Implémenter malloc () et libre () - diviser les gros morceaux

L'article précédent a exploré l'impact de l'ordre de réutilisation du bloc de mémoire sur la consommation de mémoire et les fonctions optimisées pour réduire les déchets. Cependant, un autre problème plus grave persiste: un énorme bloc de mémoire peut occuper plusieurs petits blocs d'espace qui auraient pu être exploités. Par exemple, allouer un grand morceau de mémoire et après la libération, allouer deux morceaux plus petits:

 <code class="c">void *ptr1 = abmalloc(128); void *ptr2 = abmalloc(8); abfree(ptr1); void *ptr3 = abmalloc(8); void *ptr4 = abmalloc(8);</code>

À l'heure actuelle, le bloc libre de 128 octets ne peut pas être utilisé par la demande de 8 octets, entraînant l'allocation de blocs de 8 octets ultérieure qui nécessite que le tas soit à nouveau élargi, entraînant une faible utilisation de la mémoire.

Une façon très efficace mais complexe de résoudre ce problème consiste à utiliser des "bacs": une liste de morceaux groupés par taille. Une autre solution plus simple consiste à diviser les gros morceaux en morceaux plus petits. Cet article adopte ce dernier.

Refactoring de code

Tout d'abord, refacteur le code légèrement. header_new() est responsable de l'allocation de la mémoire et de l'initialisation des en-têtes de bloc, qui n'est pas propice à la lisibilité et à la maintenance du code. Nous l'avons divisé en deux fonctions:

• header_plug() : insérez le bloc initialisé entre les blocs précédents et suivants.
• header_init() : initialisez les métadonnées (taille et disponibilité) du bloc.

Ils sont les suivants:

 <code class="c">void header_init(header *header, size_t size, bool available) { header->size = size; header->available = available; } void header_plug(header *header, header *previous, header *next) { header->previous = previous; if (previous != NULL) { previous->next = header; } header->next = next; if (next != NULL) { next->previous = header; } }</code>

header_new() est modifiée comme suit:

 <code class="c">header *header_new(header *previous, size_t size, bool available) { header *header = sbrk(sizeof(header) size); header_init(header, size, available); header_plug(header, previous, NULL); return header; }</code>

( last->previous->next = last; Dans abmalloc() , cette ligne peut être supprimée car header_plug() est désormais responsable de la gestion de cette logique.)

Blocs de mémoire divisés

Ensuite, implémentez header_split() . Étant donné un en-tête de bloc et la taille minimale requise, si le bloc d'origine est suffisamment grand, divisez-le en deux parties:

• blocs de taille requise;
• Le reste et ses nouveaux blocs;

Tout d'abord, vérifiez si le bloc est assez grand:

 <code class="c">header *header_split(header *header, size_t size) { size_t original_size = header->size; if (original_size >= size sizeof(header)) {</code>

S'il est assez grand, divisez le bloc. Tout d'abord, réduisez la taille du bloc actuel:

 header->size = original_size - size - sizeof(header);

Calculez le pointeur vers le nouveau bloc:

 header *new_header = (header 1) header->size; // Corrected pointer calculation

Initialisez l'en-tête d'un nouveau bloc:

 header_init(new_header, size, true);

Connectez le nouveau bloc à la liste liée:

 header_plug(new_header, header, header->next);

Si le bloc d'origine est le dernier bloc, mettez à jour last pointeur:

 if (header == last) { last = new_header; }

Retour au nouveau bloc:

 return new_header; } else { return header; } }

Mettre à jour abmalloc ()

Enfin, modifiez la fonction abmalloc() , et après avoir trouvé le bloc disponible, appelez header_split() pour l'essayer de le diviser:

 <code class="c">if (header->available && (header->size >= size)) { header = header_split(header, size); header->available = false; return (void*)(header 1); // Cast to void* for correct return type }</code>

Si le bloc peut être divisé, le nouveau bloc est retourné; Sinon, le bloc d'origine est retourné.

Notes sur la segmentation des blocs

Il convient de noter que le nouveau bloc est créé à la fin du bloc d'origine. Bien qu'il puisse également être créé au début, la création d'un nouveau bloc à la fin peut rapprocher le nouveau bloc gratuit de l'ancien bloc, améliorant l'efficacité de l'appel abmalloc() suivant.

La division de gros morceaux de mémoire est une étape vers l'amélioration de la gestion de la mémoire, mais elle peut également conduire à de petits morceaux de fragmentation de la mémoire, ce qui entraîne des demandes plus importantes qui nécessitent une expansion du tas. Le prochain article explorera comment résoudre ce problème.

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!