OSDev.org

Code: Select all

unsigned char *heap, *max_heap;
void *malloc(unsigned size)
{
    void *ptr = heap;
    size += 4;
    if(heap + size > max_heap)
    {
        puts("    No memory left :P\n");
      return NULL;
    }   
    heap += size;
    *ptr = size;
    ptr += (unsigned char *)4;
   return ptr;
}

void free(void *mem)
{
    int size = *(mem - 4);
    memcpy((mem - 4), ((mem - 4) + size), (heap - ((mem - 4) + size)));
    heap -= size;
}

Code: Select all

ptr += (unsigned char *)4;

Code: Select all

a+=2; //a is a char pointer

Code: Select all

a+=2; //a is a short pointer

Code: Select all

int size = (int)*((char)mem - 4);

Code: Select all

     int size = ((int*)mem)[-1];

Code: Select all

void free(void *mem)
{
    int size = ((int*)mem)[-1];
    free_spot_data temp;
    temp.nextfree = NULL;
    temp.prevfree = NULL;
    temp.size = size;
    (free_spot_data)*((int*)mem[-1]) = temp;
}

Code: Select all

struct HeapHeader
{
     unsigned int Signature;
     struct HeapHeader *NextFree;
     size_t size;
};
#define HEAPSIG    0xB0E0E0F0
byte_t *HeapCurEnd, *HeapMax;
HeapHeader *FreeList;

void InitaliseHeap()
{
    extern byte_t __bssend__;
    HeapCurEnd = &__bssend__;
    HeapMax = HeapCurEnd + 0x1000000;
}

void *malloc(size_t sz)
{
    if(!sz) return NULL;
    --sz;

    /* First Fit, very wasteful (malloc(1), firstfree = 1MB, all unused space is wasted) */
    HeapHeader *Current = FreeList;
    HeapHeader *Previous = FreeList;
    while(Current)
    {
        if(Current->size > sz)
        {
              /* Pull out of FreeList and return it */
              Previous->NextFree = Current->NextFree;
              if(Current == FreeList) FreeList = Current->NextFree;
              Current->NextFree = NULL;
              return (void*) ++Current;
        }
        Previous = Current;
        Current = Current->NextFree;
    }

    /* No free entries, see if we can create one */
    ++sz;
    if(HeapCurEnd + sz + sizeof(HeapHeader) > HeapMax)
         return NULL;

    /* Create a new block */
    Current = (HeapHeader*)HeapCurEnd;
    Current->Signature = HEAPSIG;
    Current->size = sz;
    Current->NextFree = NULL;

    /* Modify the heap pointer and return */
    HeapCurEnd += sz + sizeof(HeapHeader);
    return (void*) ++Current;
}

void free(void *ptr)
{
    HeapHeader *hh = (HeapHeader*)ptr;
    --hh;

    /* Check signature */
    if(hh->Signature != HEAPSIG)
         return;

    /* Insert into FreeList */
    if(FreeList == NULL)
         FreeList = hh;
    else
    {
         hh->NextFree = FreeList->NextFree;
         FreeList->NextFree = hh;
    }
}