Code malloc en C

Question

J'ai un bloc de code qui semble être le code derrière malloc. Mais comme je passe par le code, je reçois le sentiment que certaines parties du code sont manquants. Est-ce que quelqu'un sait s'il y a une partie de la fonction qui manque? Est-ce que malloc se combinent toujours des morceaux adjacents?

int heap[10000];
void* malloc(int size) {
int sz = (size + 3) / 4;
int chunk = 0;
if(heap[chunk] > sz) {
    int my_size = heap[chunk];
    if (my_size < 0) {
      my_size = -my_size
    }
    chunk = chunk + my_size + 2;
    if (chunk == heap_size) { 
      return 0;
    }
}

Answer 1

Le code derrière malloc est certainement beaucoup plus complexe que cela. Il existe plusieurs stratégies. Un code de la bibliothèque populaire est dlmalloc . A une plus simple est décrit dans le K & R.

Answer 2

Le code est manifestement incomplet (pas tous les chemins renvoient une valeur). Mais en tout cas, ce n'est pas un malloc « réel ». Ceci est probablement une tentative de mettre en œuvre un « modèle » très simplifié de « malloc ». L'approche choisie par l'auteur du code ne peut pas vraiment mener à une mise en œuvre pratique utile.

(Et BTW, standard « paramètre de malloc est de type 'size_t', pas 'int').

Answer 3

Eh bien, une erreur dans ce code est qu'il ne retourne pas un pointeur vers les données.

Je soupçonne que la meilleure approche à ce code est [supprimer].

Answer 4

Lorsque cela est possible, je pense que malloc va essayer de mettre différentes demandes proches les uns des autres, car il aura un bloc de code qui est disponible pour malloc, jusqu'à ce qu'il doit obtenir un nouveau bloc.

Mais, cela dépend aussi des exigences imposées par le système d'exploitation et l'architecture matérielle. Si vous êtes seulement autorisé à demander une certaine taille minimum de code, puis il se peut que chaque allocation ne sera pas près de l'autre.

Comme d'autres ont mentionné, il y a des problèmes avec l'extrait de code.

Vous pouvez trouver différents projets open source qui ont leur propre fonction malloc, et il peut être préférable de regarder un de ceux-ci, afin d'avoir une idée ce qui manque.

Answer 5

malloc est de alloués dynamiquement mémoire. Et cela implique sbrk, mmap, ou peut-être quelques autres fonctions du système pour Windows et / ou d'autres architectures. Je ne sais pas ce que votre int heap[10000] est pour, car le code est trop incomplet.

La version de Effo faire un peu plus de sens, mais il introduit une autre fonction boîte noire get_block, donc il ne nous aide pas beaucoup.

Answer 6

Le code semble être exécuté sur une machine de métal, normalement aucun mappage d'adresse virtuelle sur un tel système qui utilise seulement l'espace d'adresse physique directement.

Voir ma compréhension, sur un système 32 bits, sizeof (PTR) = 4 octets:

extern block_t *block_head; // the real heap, and its address 
                            // is >= 0x80000000, see below "my_size < 0"
extern void *get_block(int index); // get a block from the heap 
                                   // (lead by block_head)
int heap[10000]; // just the indicators, not the real heap

void* malloc(int size) 
{
    int sz = (size + 3) / 4; // make the size aligns with 4 bytes,
                             // you know, allocated size would be aligned.
    int chunk = 0; // the first check point
    if(heap[chunk] > sz) { // the value is either a valid free-block size 
                           // which meets my requirement, or an 
                           // address of an allocated block
        int my_size = heap[chunk]; // verify size or address
        if (my_size < 0) { // it is an address, say a 32-bit value which 
                           // is >0x8000...., not a size. 
              my_size = -my_size // the algo, convert it
        }
        chunk = chunk + my_size + 2; // the algo too, get available 
                                     // block index
        if (chunk == heap_size) { // no free chunks left
           return NULL; // Out of Memory
        }
        void *block = get_block(chunk);
        heap[chunk] = (int)block;
        return block;
    }
    // my blocks is too small initially, none of the blocks 
    // will meet the requirement
    return NULL;
}

EDIT: Quelqu'un pourrait-il aider à expliquer l'algo, qui, adresse de conversion -> my_size -> Bouchées? vous savez, quand récupération d'appel, dire libre (void * addr), il utilisera cette adresse -> my_size -.> Bouchées algo aussi, mettre à jour le tas [de morceau] en conséquence revenir après le bloc au tas

Answer 7

Pour petits pour être ensemble la mise en œuvre de malloc

Jetez un oeil dans les sources de la bibliothèque C de Visual Studio 6.0, vous y trouverez la mise en œuvre de malloc si je me souviens bien