Guida PHP: Ottimizzazione delle Prestazioni con la Memoizzazione

Comprendere la Memoizzazione in PHP

La memoizzazione è una tecnica di ottimizzazione che consiste nel memorizzare nella cache i risultati delle chiamate di funzione. Invece di ricalcolare lo stesso risultato più volte, lo memorizziamo per un utilizzo successivo. Questo approccio è particolarmente efficace per:

• Funzioni con calcoli intensivi
• Operazioni ricorsive
• Chiamate API
• Trasformazioni di dati complesse

Implementazione Base della Memoizzazione

Iniziamo con un'implementazione semplice e sicura:

php
1<?php
2
3/**
4 * Classe base per la memoizzazione
5 */
6class Memoizer
7{
8    private array $cache = [];
9    private array $timestamps = [];
10
11    /**
12     * Memoizza una funzione
13     *
14     * @param callable $fn La funzione da memoizzare
15     * @return callable La funzione memoizzata
16     */
17    public function memoize(callable $fn): callable
18    {
19        return function (...$args) use ($fn) {
20            $key = $this->generateCacheKey($args);
21
22            if ($this->hasValidCacheEntry($key)) {
23                error_log("Cache hit per la chiave: $key");
24                return $this->cache[$key];
25            }
26
27            $result = $fn(...$args);
28            $this->cache[$key] = $result;
29            $this->timestamps[$key] = time();
30            error_log("Nuovo calcolo per la chiave: $key");
31
32            return $result;
33        };
34    }
35
36    /**
37     * Genera una chiave cache unica
38     */
39    private function generateCacheKey(array $args): string
40    {
41        return md5(serialize($args));
42    }
43
44    /**
45     * Verifica se una voce della cache è valida
46     */
47    private function hasValidCacheEntry(string $key): bool
48    {
49        return isset($this->cache[$key]);
50    }
51
52    /**
53     * Svuota la cache
54     */
55    public function clearCache(): void
56    {
57        $this->cache = [];
58        $this->timestamps = [];
59    }
60}

Implementazione Avanzata con Configurazione

php
1<?php
2
3/**
4 * Configurazione per la memoizzazione avanzata
5 */
6class MemoizeConfig
7{
8    public function __construct(
9        public readonly int $maxCacheSize = 1000,
10        public readonly int $ttl = PHP_INT_MAX,
11        public readonly ?callable $cacheKeyGenerator = null
12    ) {}
13}
14
15/**
16 * Statistiche della cache
17 */
18class CacheStats
19{
20    public function __construct(
21        public int $hits = 0,
22        public int $misses = 0,
23        public float $totalAccessTime = 0,
24        public int $accessCount = 0
25    ) {}
26
27    public function getAverageAccessTime(): float
28    {
29        return $this->accessCount > 0 ? $this->totalAccessTime / $this->accessCount : 0;
30    }
31}
32
33/**
34 * Memoizzazione avanzata con gestione completa della cache
35 */
36class AdvancedMemoizer
37{
38    private array $cache = [];
39    private array $timestamps = [];
40    private CacheStats $stats;
41
42    public function __construct(private readonly MemoizeConfig $config = new MemoizeConfig())
43    {
44        $this->stats = new CacheStats();
45    }
46
47    public function memoize(callable $fn): callable
48    {
49        return function (...$args) use ($fn) {
50            $startTime = microtime(true);
51            $key = $this->generateCacheKey($args);
52            $now = time();
53
54            if ($this->hasValidCacheEntry($key, $now)) {
55                $this->updateStats(true, $startTime);
56                return $this->cache[$key];
57            }
58
59            // Gestione della dimensione della cache
60            if (count($this->cache) >= $this->config->maxCacheSize) {
61                $this->removeOldestEntry();
62            }
63
64            $result = $fn(...$args);
65            $this->cache[$key] = $result;
66            $this->timestamps[$key] = $now;
67            $this->updateStats(false, $startTime);
68
69            return $result;
70        };
71    }
72
73    private function generateCacheKey(array $args): string
74    {
75        if ($this->config->cacheKeyGenerator) {
76            return ($this->config->cacheKeyGenerator)($args);
77        }
78        return md5(serialize($args));
79    }
80
81    private function hasValidCacheEntry(string $key, int $now): bool
82    {
83        return isset($this->cache[$key]) &&
84               ($now - $this->timestamps[$key] <= $this->config->ttl);
85    }
86
87    private function updateStats(bool $isHit, float $startTime): void
88    {
89        $accessTime = microtime(true) - $startTime;
90        $this->stats->totalAccessTime += $accessTime;
91        $this->stats->accessCount++;
92
93        if ($isHit) {
94            $this->stats->hits++;
95        } else {
96            $this->stats->misses++;
97        }
98    }
99
100    private function removeOldestEntry(): void
101    {
102        $oldestKey = array_key_first($this->timestamps);
103        unset($this->cache[$oldestKey], $this->timestamps[$oldestKey]);
104    }
105
106    public function getStats(): array
107    {
108        return [
109            'hits' => $this->stats->hits,
110            'misses' => $this->stats->misses,
111            'size' => count($this->cache),
112            'averageAccessTime' => $this->stats->getAverageAccessTime()
113        ];
114    }
115
116    public function clearCache(): void
117    {
118        $this->cache = [];
119        $this->timestamps = [];
120    }
121}

Esempi Pratici

1. Calcolo della Sequenza di Fibonacci

php
1<?php
2
3$memoizer = new Memoizer();
4$fibonacci = $memoizer->memoize(function (int $n) use (&$fibonacci): int {
5    if ($n <= 1) return $n;
6    return $fibonacci($n - 1) + $fibonacci($n - 2);
7});
8
9// Utilizzo
10echo $fibonacci(30); // Molto più veloce con la memoizzazione

2. Richieste API Memoizzate

php
1<?php
2
3class UserAPI
4{
5    private AdvancedMemoizer $memoizer;
6
7    public function __construct()
8    {
9        $this->memoizer = new AdvancedMemoizer(new MemoizeConfig(
10            maxCacheSize: 100,
11            ttl: 300, // 5 minuti
12            cacheKeyGenerator: fn($args) => $args[0] // Usa l'ID come chiave
13        ));
14    }
15
16    public function fetchUser(string $userId): array
17    {
18        $fetchUserData = $this->memoizer->memoize(function (string $userId) {
19            $response = file_get_contents("https://api.example.com/users/{$userId}");
20            if ($response === false) {
21                throw new RuntimeException("Errore nel recupero dell'utente");
22            }
23            return json_decode($response, true);
24        });
25
26        return $fetchUserData($userId);
27    }
28}

3. Trasformazione dei Dati con Validazione

php
1<?php
2
3class DataTransformer
4{
5    private AdvancedMemoizer $memoizer;
6
7    public function __construct()
8    {
9        $this->memoizer = new AdvancedMemoizer(new MemoizeConfig(
10            cacheKeyGenerator: function($args) {
11                [$data, $options] = $args;
12                return md5(json_encode($data) . '-' . $options['format'] . '-' . $options['version']);
13            }
14        ));
15    }
16
17    public function transform(array $data, array $options): string
18    {
19        $transformData = $this->memoizer->memoize(function (array $data, array $options) {
20            // Logica di trasformazione complessa...
21            return json_encode($data);
22        });
23
24        return $transformData($data, $options);
25    }
26}

Monitoraggio delle Prestazioni

php
1<?php
2
3/**
4 * Wrapper per il monitoraggio delle prestazioni
5 */
6class PerformanceMonitor
7{
8    private int $calls = 0;
9    private float $totalTime = 0;
10    private int $cacheHits = 0;
11
12    public function wrap(callable $fn): callable
13    {
14        return function (...$args) use ($fn) {
15            $start = microtime(true);
16            $result = $fn(...$args);
17            $this->totalTime += microtime(true) - $start;
18            $this->calls++;
19
20            return $result;
21        };
22    }
23
24    public function getMetrics(): array
25    {
26        return [
27            'totalCalls' => $this->calls,
28            'averageExecutionTime' => $this->calls > 0 ? $this->totalTime / $this->calls : 0,
29            'cacheEfficiency' => $this->calls > 0 ? $this->cacheHits / $this->calls : 0
30        ];
31    }
32}

Conclusione

La memoizzazione in PHP è una tecnica potente che può migliorare notevolmente le prestazioni delle tue applicazioni. Queste implementazioni offrono:

• Una gestione efficiente della memoria
• Prestazioni ottimizzate
• Configurazione flessibile
• Meccanismi di monitoraggio

Punti Chiave da Ricordare

• Utilizza la memoizzazione per le operazioni costose
• Configura saggiamente la dimensione della cache
• Implementa una strategia di scadenza adeguata
• Monitora le prestazioni e l'utilizzo della cache

La memoizzazione, combinata con una buona gestione della cache, ti permette di ottimizzare le tue applicazioni PHP mantenendo un codice pulito e manutenibile! 💪