How is malloc() implemented internally? [duplicate]

by

The sbrksystem call moves the “border” of the data segment. This means it moves a border of an area in which a program may read/write data (letting it grow or shrink, although AFAIK no malloc really gives memory segments back to the kernel with that method). Aside from that, there’s also mmap which is used to map files into memory but is also used to allocate memory (if you need to allocate shared memory, mmap is how you do it).

So you have two methods of getting more memory from the kernel: sbrk and mmap. There are various strategies on how to organize the memory that you’ve got from the kernel.

One naive way is to partition it into zones, often called “buckets”, which are dedicated to certain structure sizes. For example, a malloc implementation could create buckets for 16, 64, 256 and 1024 byte structures. If you ask malloc to give you memory of a given size it rounds that number up to the next bucket size and then gives you an element from that bucket. If you need a bigger area malloc could use mmap to allocate directly with the kernel. If the bucket of a certain size is empty malloc could use sbrk to get more space for a new bucket.

There are various malloc designs and there is propably no one true way of implementing malloc as you need to make a compromise between speed, overhead and avoiding fragmentation/space effectiveness. For example, if a bucket runs out of elements an implementation might get an element from a bigger bucket, split it up and add it to the bucket that ran out of elements. This would be quite space efficient but would not be possible with every design. If you just get another bucket via sbrk/mmap that might be faster and even easier, but not as space efficient. Also, the design must of course take into account that “free” needs to make space available to malloc again somehow. You don’t just hand out memory without reusing it.

If you’re interested, the OpenSER/Kamailio SIP proxy has two malloc implementations (they need their own because they make heavy use of shared memory and the system malloc doesn’t support shared memory). See: https://github.com/OpenSIPS/opensips/tree/master/mem

Then you could also have a look at the GNU libc malloc implementation, but that one is very complicated, IIRC.

More Related Contents:

  1. How do free and malloc work in C?
  2. Can I rely on malloc returning NULL?
  3. malloc(sizeof(int)) vs malloc(sizeof(int *)) vs (int *)malloc(sizeof(int))
  4. If free() knows the length of my array, why can’t I ask for it in my own code?
  5. Malloc vs custom allocator: Malloc has a lot of overhead. Why?
  6. Why exactly should I not call free() on variables not allocated by malloc()?
  7. Syscall alternative for printf()? [closed]
  8. Write a C program to swap content of memory blocks of size 32 bytes
  9. Do I cast the result of malloc?
  10. What’s the difference between a VLA and dynamic memory allocation via malloc?
  11. When and why to use malloc?
  12. What does malloc(0) return? [duplicate]
  13. Will a `char` always-always-always have 8 bits?
  14. In C, do braces act as a stack frame?
  15. What is a contiguous memory block?
  16. How do I get a thread ID from an arbitrary pthread_t?
  17. L1 memory bandwidth: 50% drop in efficiency using addresses which differ by 4096+64 bytes
  18. How to handle realloc when it fails due to memory?
  19. how could I intercept linux sys calls?
  20. Why, or when, do you need to dynamically allocate memory in C?
  21. How big can a malloc be in C?
  22. Why do you specify the size when using malloc in C?
  23. How garbage values are assigned to variables in c
  24. difference between and
  25. What happens if I try to access memory beyond a malloc()’d region?
  26. How are we able to access the pointer after deallocating the memory?
  27. Minimizing the amount of malloc() calls improves performance?
  28. How to know if a Linux system call is restartable or not?
  29. Malloc and array index confusion in C
  30. zero size malloc [duplicate]

Leave a Comment