Memory Allocators 101 - Write A Simple Memory Allocator > 자유게시판

• 목록
• 답변
• 글쓰기
• 게시판 리스트 옵션
  • 수정
  • 삭제

We will implement malloc(), calloc(), realloc() and free(). This is a beginner degree article, Memory Wave Workshop so I cannot spell out every detail. This memory allocator will not be quick and efficient, we won't modify allotted memory to align to a web page boundary, however we are going to build a memory allocator that works. If you wish to have a look on the code in full, check out my github repo memalloc. Earlier than we get into constructing the memory allocator, you should be acquainted with the memory format of a program. A course of runs within its personal virtual handle house that’s distinct from the virtual address areas of other processes. As you'll be able to see in the picture, the stack and the heap develop in the other instructions. That is, brk factors to the tip of the heap. Now if we want to allocate extra memory within the heap, we have to request the system to increment brk.

Similarly, to launch memory we have to request the system to decrement brk. Assuming we run Linux (or a Unix-like system), we could make use of sbrk() system call that lets us manipulate this system break. Calling sbrk(0) provides the present deal with of program break. Calling sbrk(x) with a constructive value increments brk by x bytes, in consequence allocating memory. Calling sbrk(-x) with a adverse value decrements brk by x bytes, as a result releasing memory. To be trustworthy, sbrk() just isn't our greatest buddy in 2015. There are higher alternatives like mmap() accessible as we speak. It will probably can solely develop or shrink in LIFO order. However, the glibc implementation of malloc still makes use of sbrk() for allocating Memory Wave Workshop that’s not too huge in measurement. So, we'll go forward with sbrk() for our simple memory allocator. The malloc(size) operate allocates size bytes of memory and returns a pointer to the allocated memory. In the above code, we name sbrk() with the given dimension.

On success, size bytes are allocated on the heap. That was straightforward. Wasn’t it? The difficult part is freeing this memory. The free(ptr) operate frees the memory block pointed to by ptr, which should have been returned by a earlier name to malloc(), calloc() or realloc(). But to free a block of memory, the primary order of business is to know the dimensions of the memory block to be freed. In the present scheme of things, this is not potential as the size info is not saved anyplace. So, we must find a technique to store the scale of an allocated block somewhere. Furthermore, we need to know that the heap memory the working system has offered is contiguous. So we will only launch memory which is at the top of the heap. We can’t release a block of memory in the center to the OS. Think about your heap to be one thing like an extended loaf of bread that you may stretch and shrink at one finish, but you've to maintain it in one piece.

To handle this difficulty of not having the ability to launch memory that’s not at the tip of the heap, we are going to make a distinction between freeing memory and releasing memory. From now on, freeing a block of memory doesn't essentially imply we release memory again to OS. It simply implies that we keep the block marked as free. This block marked as free may be reused on a later malloc() name. Since memory not at the top of the heap can’t be released, this is the only way ahead for us. 2. Whether a block is free or not-free? To retailer this information, we are going to add a header to each newly allocated memory block. The idea is easy. We use this memory space returned by sbrk() to fit in both the header and the actual memory block. The header is internally managed, and is stored fully hidden from the calling program. We can’t be completely certain the blocks of memory allotted by our malloc is contiguous.

Think about the calling program has a overseas sbrk(), or there’s a section of memory mmap()ed in between our memory blocks. We additionally need a method to traverse through our blocks for memory (why traverse? we are going to get to know when we look at the implementation of free()). So to keep monitor of the memory allocated by our malloc, we will put them in a linked listing. Now, let’s wrap the complete header struct in a union together with a stub variable of measurement 16 bytes. This makes the header end up on a memory deal with aligned to 16 bytes. Recall that the dimensions of a union is the bigger size of its members. So the union guarantees that the end of the header is memory aligned. The tip of the header is where the actual memory block begins and subsequently the memory supplied to the caller by the allocator will be aligned to 16 bytes.