Optimisation des expulseurs

Si vous utilisez les expulseurs de plug-in, ces derniers ne sont actifs que si vous les créez et les associez à une mappe de sauvegarde. Les meilleures pratiques suivantes améliorent les performances des expulseurs LFU (least frequently used) et LRU (least recently used).

Expulseur le moins fréquemment utilisé (LFU)

Le concept d'un expulseur LFU consiste à supprimer les entrées d'une mappe qui ne sont pas utilisées fréquemment. Les entrées de la mappe sont réparties sur une quantité définie de segments de mémoire binaires. Lorsqu'une entrée de cache est de plus en plus sollicitée, elle est placée plus haut dans le segment de mémoire. Lorsque l'expulseur tente d'effectuer un ensemble d'expulsions, il supprime uniquement les entrées de cache situées en dessous d'un point spécifique du segment de mémoire binaire. Par conséquent, les entrées les moins fréquemment utilisées sont expulsées.

Expulseur le moins récemment utilisé (LRU)

L'expulseur LRU suit les mêmes concepts que l'expulseur LFU à quelques différentes près. Il diffère principalement en ce qu'il utilise une file d'attente premier entré, premier sorti et non un ensemble de segments de mémoire binaires. A chaque accès à une entrée de cache, il remonte en tête de la file d'attente. Par conséquent, le début de la file d'attente contient les entrées de mappe les plus récemment utilisées et la fin de la file d'attente contient les entrées de mappe les moins récemment utilisés. Par exemple, l'entrée de cache A est utilisée 50 fois et l'entrée de cache B est utilisée une seule fois juste après l'entrée de cache A. Dans ce cas, l'entrée de cache B est en tête de la file d'attente car elle a été utilisée en dernier alors que l'entrée de cache A se trouve à la fin de la file d'attente. L'expulseur LRU expulse les entrées de cache situées à la fin de la file d'attente car ce sont les entrées les moins récemment utilisées.

Propriétés LFU et LRU et meilleures pratiques pour améliorer les performances

Nombre de segments de mémoire

Lors de l'utilisation de l'expulseur LFU, toutes les entrées de cache d'une mappe donnée sont organisées en fonction du nombre de segments de mémoire spécifié, ce qui contribue à améliorer considérablement les performances et à réduire toutes les expulsions résultant de la synchronisation sur un segment de mémoire binaire qui contient toutes les organisations de la mappe. Une quantité supérieure de segments de mémoire accélère le temps requis pour réorganiser les segments de mémoire car chaque segment de mémoire dispose de moins d'entrées. Le nombre de segments de mémoire doit représenter 10 % du nombre total d'entrées de votre mappe de base.

Nombre de files d'attente

Lors de l'utilisation de l'expulseur LRU, toutes les entrées de cache d'une mappe donnée sont organisées en fonction du nombre de files d'attente LRU, ce qui contribue à améliorer considérablement les performances et à réduire toutes les expulsions résultant de la synchronisation sur une file d'attente qui contient toutes les organisations de la mappe. Le nombre de files d'attente doit représenter 10 % du nombre total d'entrées de votre mappe de base.

Propriété MaxSize

Lorsqu'un expulseur LFU ou LRU commence à expulser des entrées, il utilise la propriété MaxSize pour déterminer le nombre de segments de mémoire binaires ou de files d'attente LRU à expulser. Par exemple, supposons que les segments de mémoire ou files d'attente comportent 10 entrées de mappe dans chaque file d'attente de mappe. Si la propriété MaxSize est définie sur 7, l'expulseur expulse 3 entrées de chaque segment de mémoire ou de file d'attente pour ramener le nombre de segments de mémoire ou de files d'attente à 7. L'expulseur expulse uniquement les entrées de mappe d'un segment de mémoire ou d'une file d'attente lorsque ce dernier ou cette dernière contient un nombre d'éléments supérieur à la valeur de la propriété MaxSize. La valeur de la propriété MaxSize doit représenter 70 % de la taille de votre segment de mémoire ou de votre file d'attente. Pour cet exemple, la valeur est définie sur 7. Vous pouvez calculer la taille approximative de chaque segment de mémoire ou file d'attente en divisant le nombre d'entrées de la mappe de base par le nombre de segments de mémoire ou files d'attente utilisés.

Propriété SleepTime

Un expulseur ne supprime pas constamment les entrées de la mappe. En revanche, il est en veille pendant un intervalle de temps déterminé et ne vérifie la mappe que toutes les n secondes où n se réfère à la propriété SleepTime. Cette propriété influe également sur les performances de manière positive : une analyse d'expulsion trop fréquente réduit les performances en raison de l'utilisation des ressources nécessaires à cette opération. Toutefois, une utilisation trop rare de l'expulseur peut entraîner la présence d'entrées superflues dans la mappe. Une mappe saturée d'entrées inutiles peut nuire à la configuration requise pour la mémoire et aux ressources de traitement nécessaires pour la mappe. Il est recommandé de définir un intervalle d'analyse d'expulsion de quinze secondes pour la plupart des mappes. Si l'écriture de la mappe est trop fréquente et si le taux de transactions est trop élevé, pensez à réduire cette valeur. En revanche, si l'accès à la mappe n'est pas fréquent, vous pouvez augmenter la valeur.

Exemple

L'exemple suivant définit une mappe, crée un expulseur LFU, définit les propriétés de l'expulseur et définit la mappe pour utiliser l'expulseur :

//Utilisez ObjectGridManager pour créer/obtenir la grille d'objets. Voir 
// la section ObjectGridManager
ObjectGrid objGrid = ObjectGridManager.create............
BackingMap bMap = objGrid.defineMap("SomeMap");

//Définissez les propriétés sur la base de 50 000 entrées de mappe
LFUEvictor someEvictor = new LFUEvictor();
someEvictor.setNumberOfHeaps(5000);
someEvictor.setMaxSize(7);
someEvictor.setSleepTime(15);
bMap.setEvictor(someEvictor);

L'utilisation de l'expulseur LRU s'apparente à celle d'un expulseur LFU. Voici un exemple :

ObjectGrid objGrid = new ObjectGrid;
BackingMap bMap = objGrid.defineMap("SomeMap");

//Définissez les propriétés sur la base de 50 000 entrées de mappe
LRUEvictor someEvictor = new LRUEvictor();
someEvictor.setNumberOfLRUQueues(5000);
someEvictor.setMaxSize(7);
someEvictor.setSleepTime(15);
bMap.setEvictor(someEvictor);

Notez que seulement deux lignes sont différentes de l'exemple LFUEvictor.