Guide PHP : Optimisation des Performances avec la Mémoïsation

Comprendre la Mémoïsation en PHP

La mémoïsation est une technique d'optimisation qui consiste à mettre en cache les résultats des appels de fonction. Au lieu de recalculer le même résultat plusieurs fois, nous le stockons en mémoire pour une réutilisation ultérieure. Cette approche est particulièrement efficace pour :

• Les fonctions avec des calculs intensifs
• Les opérations récursives
• Les appels d'API
• Les transformations de données complexes

Implémentation de Base de la Mémoïsation

Commençons par une implémentation simple et sécurisée :

php
1<?php
2
3/**
4 * Classe de base pour la mémoïsation
5 */
6class Memoizer
7{
8    private array $cache = [];
9    private array $timestamps = [];
10
11    /**
12     * Mémoïse une fonction
13     *
14     * @param callable $fn La fonction à mémoïser
15     * @return callable La fonction mémoïsée
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 pour la clé : $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("Nouveau calcul pour la clé : $key");
31
32            return $result;
33        };
34    }
35
36    /**
37     * Génère une clé de cache unique
38     */
39    private function generateCacheKey(array $args): string
40    {
41        return md5(serialize($args));
42    }
43
44    /**
45     * Vérifie si une entrée de cache est valide
46     */
47    private function hasValidCacheEntry(string $key): bool
48    {
49        return isset($this->cache[$key]);
50    }
51
52    /**
53     * Vide le cache
54     */
55    public function clearCache(): void
56    {
57        $this->cache = [];
58        $this->timestamps = [];
59    }
60}

Implémentation Avancée avec Configuration

php
1<?php
2
3/**
4 * Configuration pour la mémoïsation avancée
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 * Statistiques de 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 * Mémoïsation avancée avec gestion complète du 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            // Gestion de la taille du 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}

Exemples Pratiques

1. Calcul de Suite de 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// Utilisation
10echo $fibonacci(30); // Beaucoup plus rapide avec la mémoïsation

2. Requêtes API Mémoïsées

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 minutes
12            cacheKeyGenerator: fn($args) => $args[0] // Utilise l'ID comme clé
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("Échec de la récupération de l'utilisateur");
22            }
23            return json_decode($response, true);
24        });
25
26        return $fetchUserData($userId);
27    }
28}

3. Transformation de Données avec Validation

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            // Logique de transformation complexe...
21            return json_encode($data);
22        });
23
24        return $transformData($data, $options);
25    }
26}

Surveillance des Performances

php
1<?php
2
3/**
4 * Wrapper pour la surveillance des performances
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}

Conclusion

La mémoïsation en PHP est une technique puissante qui peut grandement améliorer les performances de vos applications. Ces implémentations offrent :

• Une gestion efficace de la mémoire
• Des performances optimisées
• Une configuration flexible
• Des mécanismes de surveillance

Points Clés à Retenir

• Utilisez la mémoïsation pour les opérations coûteuses
• Configurez judicieusement la taille du cache
• Implémentez une stratégie d'expiration adaptée
• Surveillez les performances et l'utilisation du cache

La mémoïsation, combinée à une bonne gestion du cache, vous permet d'optimiser vos applications PHP tout en maintenant un code propre et maintenable ! 💪