Dynamic memory allocator (heap)

Question

My goal is to create my own "malloc" and "free" functions. I'm only doing this for practice so I'm not interested in speed/performance. Instead I would go for a an easy approach so I can understand easier.

Where can I get started with this? Can you give me some pointers as to how to do it or tell me what I need to use to create these functions?

do you mean creating your own _true functions from scratch_ or writing wrapper functions around them? — Binayaka Chakraborty, Apr 12 '13 at 06:05
Try http://stackoverflow.com/questions/5422061/malloc-implementation and http://g.oswego.edu/dl/html/malloc.html — Patashu, Apr 12 '13 at 06:05
Here's how the GNU people do it: http://www.eglibc.org/cgi-bin/viewvc.cgi/branches/eglibc-2_17/libc/malloc/malloc.c?view=markup Overview: http://www.eglibc.org/cgi-bin/viewvc.cgi/branches/eglibc-2_17/libc/malloc/ — alk, Apr 12 '13 at 06:10

score 2 · Answer 1 · edited May 23 '17 at 10:25

2

The answer is more of a redirection to previous questions

For Malloc making your own malloc function in C

For Free C - Design your own free( ) function

And one blog http://www.dreamincode.net/forums/topic/178691-creating-a-custom-malloc-and-free-in-c/

edited May 23 '17 at 10:25

Community

1
1

answered Apr 12 '13 at 06:05

AurA

12,135
7
46
63

score 1 · Accepted Answer · answered Apr 12 '13 at 06:11

Below is the solution. This code helped me, I got it from IBM Developers.

/* Include the sbrk function */ 
#include <unistd.h> 

int has_initialized = 0; 
void *managed_memory_start; 
void *last_valid_address; 

void malloc_init() 
 { 
   /* grab the last valid address from the OS */ 
   last_valid_address = sbrk(0); 

 /* we don't have any memory to manage yet, so 
  *just set the beginning to be last_valid_address 
  */ 
  managed_memory_start = last_valid_address; 

  /* Okay, we're initialized and ready to go */ 
  has_initialized = 1; 
} 

 struct mem_control_block { 
  int is_available; 
  int size; 
 };  

 void free(void *firstbyte) { 
   struct mem_control_block *mcb; 

  /* Backup from the given pointer to find the 
  * mem_control_block 
   */ 
    mcb = firstbyte - sizeof(struct mem_control_block); 
   /* Mark the block as being available */ 
    mcb->is_available = 1; 
   /* That's It! We're done. */ 
   return; 
  } 

 void *malloc(long numbytes) { 
     /* Holds where we are looking in memory */ 
     void *current_location; 

    /* This is the same as current_location, but cast to a 
    * memory_control_block 
    */ 
    struct mem_control_block *current_location_mcb; 

    /* This is the memory location we will return. It will 
    * be set to 0 until we find something suitable 
    */ 
      void *memory_location; 

/* Initialize if we haven't already done so */ 
if(! has_initialized) { 
malloc_init(); 
} 

/* The memory we search for has to include the memory 
* control block, but the user of malloc doesn't need 
* to know this, so we'll just add it in for them. 
*/ 
numbytes = numbytes + sizeof(struct mem_control_block); 

/* Set memory_location to 0 until we find a suitable 
*
 location 
*/ 
memory_location = 0; 

/* Begin searching at the start of managed memory */ 
current_location = managed_memory_start; 

/* Keep going until we have searched all allocated space */ 
while(current_location != last_valid_address) 
{ 
/* current_location and current_location_mcb point 
* to the same address. However, current_location_mcb 
* is of the correct type so we can use it as a struct. 
* current_location is a void pointer so we can use it 
* to calculate addresses. 
*/ 
current_location_mcb = 
(struct mem_control_block *)current_location; 

if(current_location_mcb->is_available) 
{

if(current_location_mcb->size >= numbytes) 
{ 
/* Woohoo! We've found an open, 
* appropriately-size location. 
*/ 

/* It is no longer available */ 
current_location_mcb->is_available = 0; 

/* We own it */ 
memory_location = current_location; 

/* Leave the loop */ 
break; 
} 
} 

/* If we made it here, it's because the Current memory 
* block not suitable, move to the next one 
*/ 
current_location = current_location + 
current_location_mcb->size; 
} 

/* If we still don't have a valid location, we'll 
* have to ask the operating system for more memory 
*/ 
if(! memory_location) 
{ 
/* Move the program break numbytes further */ 
sbrk(numbytes); 

/* The new memory will be where the last valid 
* address left off 
*/ 
memory_location = last_valid_address; 

/* We'll move the last valid address forward 
* numbytes 
*/ 
last_valid_address = last_valid_address + numbytes; 

/* We need to initialize the mem_control_block */ 
current_location_mcb = memory_location; 
current_location_mcb->is_available = 0; 
current_location_mcb->size = numbytes; 
} 

/* Now, no matter what (well, except for error conditions), 
* memory_location has the address of the memory, including 
* the mem_control_block 
*/ 

/* Move the pointer past the mem_control_block */ 
memory_location = memory_location + sizeof(struct mem_control_block); 

/* Return the pointer */ 
return memory_location; 
}

Hope it helps...

This may get handy... http://stackoverflow.com/questions/13764711/making-your-own-malloc-function-in-c

I don't understand how this works :(. How can you treat memory like it was a struct..."current_location_mcb->is_available" how can this work ? — Silviu., Apr 13 '13 at 12:02

score 1 · Answer 3 · answered Apr 12 '13 at 06:22

jemalloc is a free, open-source, thread-safe replacement for the libc malloc(). Its code is fairly simple, and studying it you will find everything you need to know about creating your own replacement for malloc and other libc functions including:

How to make the compiler use your malloc instead of the native libc's for everything, including the malloc() calls in the inner guts of the libc functions;
How to make it thread-safe;
How to make it compilable and functional in every platform.

Notice NetBSD and FreeBSD already use jemalloc as default memory allocator.

Dynamic memory allocator (heap)

3 Answers3