Quelles sont les techniques d'allocation de mémoire et de statistiques d'utilisation de Redis ?

Plus précisément :

Si la bibliothèque TC_MALLOC de Google existe dans le système, utilisez la famille de fonctions tc_malloc pour remplacer la famille de fonctions malloc d'origine.

　 Si le système actuel est un système Mac, utilisez la fonction d'allocation de mémoire.

　Dans d'autres cas, un champ supplémentaire de longueur fixe est alloué au début de chaque espace alloué pour enregistrer la taille de l'espace alloué.

　 Les codes sources sont respectivement dans config.h et zmalloc.c :

　 /* config.h */

　 #if défini(USE_TCMALLOC)

　 #include

　 #if TC_VERSION_MAJOR >= 1 && TC_VERSION_ MINEUR > = 6

　#define HAVE_MALLOC_SIZE 1

　MALLOC_SIZE 1

　#define redis_malloc_size(p) malloc_size (p)

　　#endif

　　/* zmalloc.c */

　　#ifdef HAVE_MALLOC_SIZE

　　#define PREFIX_SIZE (0)

　　#else

　　#if défini(__sun)

　　#définir PREFIX_SIZE (sizeof(long long))

　#else

　#define PREFIX_SIZE (sizeof(size_t))

　tc_malloc_size et malloc_size), donc il n'y a pas il faut allouer un espace séparé pour enregistrer la taille. Pour les plateformes Linux et Sun, la taille de l'espace alloué doit être enregistrée. Pour Linux, utilisez l'enregistrement de champ de longueur fixe sizeof(size_t) ; pour Sun OS, utilisez l'enregistrement de champ de longueur fixe sizeof(long long). Il s'agit de la macro PREFIX_SIZE dans le code source ci-dessus.

Réexprimez cette phrase : Le but de cet enregistrement est de calculer la quantité de mémoire occupée par le processus en cours. Dans zmalloc.c, il existe une telle variable statique :

　static size_t used_memory = 0;

　Elle enregistre la quantité totale de mémoire actuellement occupée par le processus. Chaque fois que de la mémoire est allouée ou libérée, cette variable doit être mise à jour. Parce que lors de l'allocation de mémoire, vous pouvez clairement savoir combien de mémoire allouer. Mais lors de la libération de mémoire (pour les plates-formes qui ne fournissent pas la fonction malloc_size), vous ne pouvez pas savoir combien d'espace est libéré simplement en pointant sur le pointeur vers la mémoire à libérer. Dans ce cas, le champ de longueur fixe spécifié par PREFIX_SIZE entre en jeu et la taille de l'espace peut être obtenue à partir des informations qui y sont enregistrées. La fonction zmalloc est la suivante (en supprimant le code non pertinent) :

void *zmalloc(size_t size) {

void *ptr = malloc(size+PREFIX_SIZE);

if (!ptr) zmalloc_oom(size);

* ((size_t *) ptr) = size;

update_zmalloc_stat_alloc (size + prefix_size, size);

return (char *) ptr + prefix_size;

# endif

}

œuvre et statistiques d'utilisation

Lors de l'allocation de l'espace, faites attention à ajouter PREFIX_SIZE à la taille de l'espace. Lors de l'exécution sur un système Mac ou de l'utilisation de tc_malloc, la valeur de PREFIX_SIZE est zéro. Ensuite, les premiers octets size_t du bloc mémoire pointés par le pointeur ptr seront utilisés pour enregistrer la taille allouée du bloc mémoire. La dernière chose renvoyée est le pointeur au-delà de la zone d'enregistrement. La fonction zfree est similaire (en supprimant le code non pertinent) :

　void zfree(void *ptr) {

　void *realptr;

　size_t oldsize;

🎜　if (ptr == NULL) return;🎜🎜　realptr = (char* )ptr -PREFIX_SIZE;🎜🎜　oldsize = *((size_t*)realptr);🎜🎜　update_zmalloc_stat_free(oldsize+PREFIX_SIZE);🎜🎜　free(realptr);🎜🎜　#endif🎜🎜　}🎜🎜　Déplacez PREFIX_SIZE, puis obtenez la longueur d'espace économisé lors de l'allocation de l'espace. Enfin, libérez tout l’espace. 🎜🎜　 Update_zmalloc_stat_alloc(__n,__size) et update_zmalloc_stat_free(__n) Ces deux macros sont chargées de mettre à jour la variable used_memory lors de l'allocation ou de la libération de mémoire. Le définir comme une macro est principalement dû à des considérations d’efficacité. Restaurez-le dans une fonction, cela ressemble à ceci : 🎜🎜　void update_zmalloc_stat_alloc(__n,__size)🎜🎜　{🎜🎜　do {🎜🎜　size_t _n = (__n);🎜

　size_t _stat_slot = (__size < ZMALLOC_MAX_ALLOC_STAT) __size : ZMALLOC_MAX_ALLOC_STAT; ​if (_n&(sizeof(long)-1)) _n += sizeof(long)-(_n&(sizeof(long)-1)); si (zmalloc_thread_safe) { ​pthread_mutex_lock(&used_memory_mutex); ​used_memory += _n; ​zmalloc_allocations[_stat_slot]++; ​pthread_mutex_unlock(&used_memory_mutex); } autre { ​used_memory += _n; ​zmalloc_allocations[_stat_slot]++; } } pendant que(0) } annuler update_zmalloc_stat_free(__n) { faire { taille_t _n = (__n); ​if (_n&(sizeof(long)-1)) _n += sizeof(long)-(_n&(sizeof(long)-1)); si (zmalloc_thread_safe) { ​pthread_mutex_lock(&used_memory_mutex); ​used_memory -= _n; ​pthread_mutex_unlock(&used_memory_mutex); } autre { ​used_memory -= _n; } } pendant que(0) } En plus de mettre à jour la variable used_memory dans le code, il y a plusieurs autres choses à prendre en compte : Tout d'abord, les bits de poids faible de _n sont arrondis, et enfin _n devient un multiple de sizeof(long). Par exemple, pour un système 32 bits, sizeof(long) == 100 (binaire). vers le haut, les deux bits de poids faible deviennent 0. S'il y a plusieurs threads dans le processus, les verrous doivent être verrouillés lors de la mise à jour des variables. Il y a une autre statistique à mettre à jour dans la fonction zmalloc : zmalloc_allocations[]. Dans zmalloc.c, zmalloc_allocations est défini comme suit : size_t zmalloc_allocations[ZMALLOC_MAX_ALLOC_STAT+1]; Sa fonction est de compter le nombre de requêtes pour différentes tailles d'espace lorsque le programme alloue de la mémoire. L'espace statistique va de 1 octet à 256 octets, et l'espace supérieur à 256 octets est compté pour 256. Les résultats statistiques sont renvoyés en appelant la fonction zmalloc_allocations_for_size : size_t zmalloc_allocations_for_size(size_t taille) { if (size >

　size_t um; return

　}

　 De plus, zmalloc.c est également implémenté pour différents systèmes La fonction zmalloc_get_rss est installée. Dans le système Linux, l'utilisation de la mémoire des statistiques du système est obtenue en lisant le /proc /$pid/statfichier.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!