malloc Code in C

Question

ich einen Codeblock haben, dass der Code hinter malloc zu sein scheint. Aber wie ich durch den Code gehen, habe ich das Gefühl, dass Teile des Codes fehlen. Hat jemand wissen, ob es ein Teil der Funktion, die vermisst? Hat malloc immer miteinander kombiniert benachbarte Brocken?

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

Der Code hinter malloc ist sicherlich sehr viel komplexer als das. Es gibt verschiedene Strategien. Ein beliebter Code ist die dlmalloc Bibliothek. Ein einfacher man in K & R beschrieben.

Answer 2

Der Code ist offensichtlich unvollständig (nicht alle Pfade geben einen Wert zurück). Aber in jedem Fall ist dies nicht ein „echter“ malloc. Dies ist wahrscheinlich ein Versuch, ein stark vereinfachte „Modell“ von ‚malloc‘ zu implementieren. Der Ansatz des Autor des Codes gewählt kann wirklich nicht zu einer nützlichen praktischen Umsetzung führen.

(Und BTW, Standard ‚malloc der Parameter hat Typ 'size_t', nicht 'int').

Answer 3

Nun, ein Fehler in diesem Code ist, dass es nicht einen Zeiger auf die Daten zurückgibt.

Ich vermute, dass der beste Ansatz zu diesem Code wird [Löschen].

Answer 4

Wenn möglich, erwarte ich, dass malloc wird versuchen, unterschiedliche Anforderungen zu stellen nahe beieinander, als es einen Code-Block hat, die für malloc zur Verfügung steht, bis er einen neuen Block erhalten hat.

Aber das hängt auch von den Anforderungen durch das Betriebssystem und Hardware-Architektur eingeführt. Wenn Sie nur erlauben eine gewisse Mindestgröße von Codes erforderlich ist, dann kann es sein, dass jede Zuordnung nicht in der Nähe von mir sein wird.

Wie andere schon erwähnt, gibt es Probleme mit dem Code-Schnipsel.

Sie können verschiedene Open-Source-Projekte finden, die ihre eigene malloc Funktion hat, und es kann am besten sein bei einem von denen zu suchen, um eine Vorstellung zu bekommen, was fehlt.

Answer 5

malloc ist für dynamisch zugewiesen Speicher. Und das beinhaltet sbrk, mmap, oder vielleicht einige andere Systemfunktionen für Windows und / oder andere Architekturen. Ich bin nicht sicher, was Ihre int heap[10000] ist, da der Code auch unvollständig ist.

Effo Version macht ein wenig mehr Sinn bisschen, aber dann einführte andere Black-Box-Funktion get_block, so dass es nicht viel hilft.

Answer 6

Der Code scheint auf einem Metall Maschine ausgeführt werden, in der Regel keine virtuelle Adresse Mapping auf einem solchen System, das nur direkt physikalischen Adressraum verwenden.

Sehen Sie mein Verständnis, auf einem 32-Bit-System, sizeof (ptr) = 4 Bytes:

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: Könnte jemand helfen, die algo zu erklären, das heißt, Adresse Umwandlung -> my_size -> Brocken? Sie wissen, wenn ein Anruf reclaim, gratis (void * addr) sagen, es diese Adresse verwenden werden -> my_size. -> Chunk algo auch entsprechend nach der Heap [chunk], um den Block zu dem Heap zurückkehren zu aktualisieren

Answer 7

Um kleine eine ganze malloc Implementierung zu sein

Werfen Sie einen Blick in den Quellen der C-Bibliothek von Visual Studio 6.0, dort werden Sie die Implementierung von malloc finden, wenn ich es richtig erinnere