codice malloc in C

Question

Ho un blocco di codice che sembra essere il codice dietro malloc. Ma come vado attraverso il codice, ho la sensazione che parti del codice sono mancanti. Qualcuno sa se c'è una parte della funzione che manca? Ha malloc combinano sempre pezzi adiacenti insieme?

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

Il codice dietro malloc è sicuramente molto più complesso di quello. Ci sono diverse strategie. Un codice popolare è il dlmalloc biblioteca. A una più semplice è descritto in K & R.

Answer 2

Il codice è manifestamente incompleta (non tutti i percorsi restituiscono un valore). Ma in ogni caso non si tratta di una malloc "reale". Questo è probabilmente un tentativo di realizzare un "modello" altamente semplificato di 'malloc'. L'approccio scelto dall'autore del codice non può davvero portare ad un utile applicazione pratica.

(E BTW, standard 'parametro di malloc è di tipo 'size_t', non 'int').

Answer 3

Bene, un errore nel codice che è che non restituisce un puntatore ai dati.

Ho il sospetto che l'approccio migliore a quel codice è [Elimina].

Answer 4

Quando è possibile, mi aspetto che malloc cercherà di mettere le richieste di diversi vicini gli uni agli altri, in quanto avrà un blocco di codice che è disponibile per malloc, fino a quando non ha per ottenere un nuovo blocco.

Ma, che dipende anche i requisiti imposti dall'architettura del sistema operativo e l'hardware. Se vi sono solo permesso di richiedere una certa dimensione minima di codice, allora può essere che ogni allocazione non sarà vicino a vicenda.

Come altri hanno detto, ci sono problemi con il frammento di codice.

È possibile trovare vari progetti open-source che hanno la loro propria funzione malloc, e può essere meglio guardare uno di quelli, in modo da avere un'idea di ciò che manca.

Answer 5

malloc è per allocati dinamicamente memoria. E questo comporta sbrk, mmap, o forse alcune altre funzioni di sistema per Windows e / o di altre architetture. Non sono sicuro che cosa il vostro int heap[10000] è per, come il codice è troppo incompleta.

versione

di effo fare un po 'di più il senso, ma poi introdurre un'altra funzione scatola nera get_block, in modo che non aiuta molto.

Answer 6

Il codice sembra essere eseguito su una macchina metallo, normalmente alcun mapping indirizzo virtuale in un tale sistema che utilizzano solo spazio di indirizzamento fisico direttamente.

Vedere la mia comprensione, su un sistema di 32 bit, sizeof (PTR) = 4 byte:

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: Qualcuno potrebbe aiutare a spiegare l'algo, questo indirizzo è, convertendo -> my_size -> pezzo? si sa, quando la chiamata di recupero, diciamo gratis (void * addr), si userà questo indirizzo -> my_size -.> pezzo algo troppo, per aggiornare il mucchio [pezzo] di conseguenza dopo tornare il blocco al mucchio

Answer 7

Per piccola per essere un'implementazione intero malloc

Date un'occhiata nelle fonti della libreria C di Visual Studio 6.0, lì troverete l'implementazione di malloc se ricordo correttamente