Welche Techniken gibt es für die Speicherzuweisung und Nutzungsstatistik von Redis?

Konkret:

Wenn die TC_MALLOC-Bibliothek von Google im System vorhanden ist, verwenden Sie die tc_malloc-Funktionsfamilie anstelle der ursprünglichen malloc-Funktionsfamilie.

Wenn das aktuelle System ein Mac-System ist, verwenden Sie die Speicherzuweisungsfunktion.

In anderen Fällen wird am Anfang jedes zugewiesenen Speicherplatzes ein zusätzliches Feld fester Länge zugewiesen, um die Größe des zugewiesenen Speicherplatzes aufzuzeichnen.

Die Quellcodes befinden sich in config.h bzw. zmalloc.c:

/* config.h */

#if definiert(USE_TCMALLOC )

　#include

　#if TC_VERSION_MAJOR >= 1 && TC_VERSION_MINOR >= 6

　#define HAVE_MALLOC_SIZE. 1 # 🎜🎜##🎜 🎜 #　#define redis_malloc_size(p) tc_malloc_size(p)

　#endif

　#elif define(__APPLE__)

　#include# 🎜🎜# # 🎜🎜#　#define HAVE_MALLOC_SIZE 1

　#define redis_malloc_size(p) malloc_size(p)

　#endif

　/* z malloc.c * /

　#ifdef HAVE_MALLOC_SIZE

　#define PREFIX_SIZE (0)

　#else

un)# 🎜🎜#

　#define PREFIX_SIZE (sizeof(long long))

　#else

　#define PREFIX_SIZE (sizeof(size_t))

#🎜 🎜#　# endif

　#endif

　Da tc_malloc und die malloc-Funktionsfamilie unter der Mac-Plattform Funktionen zum Berechnen der Größe des zugewiesenen Speicherplatzes (tc_malloc_size bzw. malloc_size) bereitstellen, gibt es keine Sie müssen einen separaten Speicherplatz zuweisen, um die Größe aufzuzeichnen. Für Linux- und Sun-Plattformen muss die Größe des zugewiesenen Speicherplatzes aufgezeichnet werden. Verwenden Sie für Linux sizeof(size_t) Felddatensätze mit fester Länge; für Sun-Betriebssysteme verwenden Sie sizeof(long long) Felddatensätze mit fester Länge. Das ist das PREFIX_SIZE-Makro im obigen Quellcode.

Drücken Sie diesen Satz noch einmal aus: Der Zweck dieses Datensatzes besteht darin, zu berechnen, wie viel Speicher vom aktuellen Prozess belegt ist. In zmalloc.c gibt es eine solche statische Variable:

static size_t used_memory = 0;

Sie zeichnet die Gesamtmenge an Speicher auf, die derzeit vom Prozess belegt wird. Immer wenn Speicher zugewiesen oder freigegeben wird, muss diese Variable aktualisiert werden. Denn wenn Sie Speicher zuweisen, wissen Sie genau, wie viel Speicher Sie zuweisen müssen. Wenn Sie jedoch Speicher freigeben (für Plattformen, die die Funktion malloc_size nicht bereitstellen), können Sie nicht wissen, wie viel Speicherplatz freigegeben wird, indem Sie einfach auf den Zeiger auf den freizugebenden Speicher zeigen. In diesem Fall kommt das durch PREFIX_SIZE angegebene Feld mit fester Länge ins Spiel, und die Größe des Speicherplatzes kann aus den darin aufgezeichneten Informationen ermittelt werden. Die zmalloc-Funktion lautet wie folgt (Entfernen irrelevanten Codes):

void *zmalloc(size_t size) {

void *ptr = malloc(size+PREFIX_SIZE);#🎜🎜 ##🎜 🎜# if (!ptr) zmalloc_oom(size);

*((size_t*)ptr) = size; 🎜#

Return (char*)ptr+PREFIX_SIZE;# 🎜🎜#

#endif

　}

Was sind einige Tipps?

Achten Sie beim Zuweisen von Speicherplatz darauf, PREFIX_SIZE hinzuzufügen Raumgröße. Bei der Ausführung auf einem Mac-System oder bei Verwendung von tc_malloc ist der Wert von PREFIX_SIZE Null. Als nächstes werden die ersten size_t Bytes des Speicherblocks, auf den der Zeiger ptr zeigt, verwendet, um die zugewiesene Größe des Speicherblocks aufzuzeichnen. Als letztes wird der Zeiger über den Datensatzbereich hinaus zurückgegeben. Die zfree-Funktion ist ähnlich (entfernt irrelevanten Code):

void zfree(void *ptr) {

void *realptr;

size_t oldsize; #🎜 🎜#

　if (ptr == NULL) return;

Realptr = (char*)ptr-PREFIX_SIZE;

);

# 🎜🎜# update_zmalloc_stat_free(oldsize+PREFIX_SIZE);

free(realptr); }# 🎜🎜#

Bewegen Sie zuerst den Zeiger nach vorne PREFIX_SIZE und nehmen Sie dann die beim Zuweisen von Speicherplatz gespeicherte Speicherplatzlänge heraus . Geben Sie abschließend den gesamten Speicherplatz frei.

Die beiden Makros update_zmalloc_stat_alloc(__n,__size) und update_zmalloc_stat_free(__n) sind für die Aktualisierung der used_memory-Variablen beim Zuweisen oder Freigeben von Speicher verantwortlich. Die Definition als Makro erfolgt hauptsächlich aus Effizienzgründen. Stellen Sie es wie unten gezeigt in einer Funktion wieder her:

void update_zmalloc_stat_alloc(__n,__size)

🎜🎜#　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)); ​if (zmalloc_thread_safe) { ​pthread_mutex_lock(&used_memory_mutex); ​used_memory += _n; ​zmalloc_allocations[_stat_slot]++; ​pthread_mutex_unlock(&used_memory_mutex); } anders { ​used_memory += _n; ​zmalloc_allocations[_stat_slot]++; } } while(0) } void update_zmalloc_stat_free(__n) { Tun { size_t _n = (__n); ​if (_n&(sizeof(long)-1)) _n += sizeof(long)-(_n&(sizeof(long)-1)); ​if (zmalloc_thread_safe) { ​pthread_mutex_lock(&used_memory_mutex); ​used_memory -= _n; ​pthread_mutex_unlock(&used_memory_mutex); } anders { ​used_memory -= _n; } } while(0) } Neben der Aktualisierung der used_memory-Variablen im Code gibt es noch einige andere Dinge zu beachten: Zuerst werden die niederwertigen Bits von _n aufgerundet, und schließlich wird _n zu einem Vielfachen von sizeof(long). Für ein 32-Bit-System ist beispielsweise sizeof(long) == 100 (binär). Nach oben werden die beiden niederwertigen Bits zu 0. Wenn im Prozess mehrere Threads vorhanden sind, müssen Sperren beim Aktualisieren von Variablen gesperrt werden. In der zmalloc-Funktion muss eine weitere Statistik aktualisiert werden: zmalloc_allocations[]. In zmalloc.c ist zmalloc_allocations wie folgt definiert: size_t zmalloc_allocations[ZMALLOC_MAX_ALLOC_STAT+1]; Seine Funktion besteht darin, die Anzahl der Anforderungen für unterschiedliche Speicherplatzgrößen zu zählen, wenn das Programm Speicher zuweist. Der statistische Speicherplatz reicht von 1 Byte bis 256 Byte, und der Speicherplatz, der größer als 256 Byte ist, wird als 256 gezählt. Statistische Ergebnisse werden durch Aufrufen der Funktion zmalloc_allocations_for_size zurückgegeben: size_t zmalloc_allocations_for_size(size_t size) { if (size >

　size_t um; return

　}

　 Darüber hinaus ist zmalloc.c auch für verschiedene Systeme implementiert. Die Funktion zmalloc_get_rss ist installiert. In Linux-Systemen werden Systemstatistiken der Speichernutzung durch Lesen von /proc/$pid abgerufen /stat-Datei.

Das obige ist der detaillierte Inhalt vonWelche Techniken gibt es für die Speicherzuweisung und Nutzungsstatistik von Redis?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!