Pseudocode jmalloc

Written by Maria Hernandez Rivero, March, 2024

NOTE: Whenever you need to add a specific number of bytes to a memory address pointing to a Chunk struct, you should cast this memory address to either void* or char*. This ensures that, during pointer arithmetic, the operation adds bytes rather than bytes * sizeof(Chunk). While you cannot dereference a void* pointer, performing pointer arithmetic on it treats each increment as a one-byte move.

Compiling mymalloc.c

The gradescript for jmalloc compiles mymalloc.c along with a test file named test.c (which is copied from the Gradescript-Examples directory depending on the problem number provided to the script). This compilation step produces an executable named a.out by default, as no output file name is specified in the gcc command. If the compilation is successful, the script runs a.out and captures its standard output and standard error into temporary files for analysis. The test file (corresponding to a specific problem number from the Gradescript-Examples directory) is designed to test the functionality implemented in mymalloc.c for the given problem number. In other words, you don't need to use a makefile to compile your program. Just ./gradeall or ./gradescript number, but make sure that your mymalloc.c file is in the same directory as the gradescript file.

Variable and Struct

• A free list data structure that contains all chunks of memory available to use in future my_malloc() allocations. In other words, the free list contains chunks of the heap memory allocated by sbrk, but that are available (free) to give to the user once they call my_malloc().

  Each Chunk of memory in the free list data structure contains the size of the chunk, a pointer to the next Chunk, and a pointer to the previous Chunk.

• A global variable that points to the beginning of the free list.

Functions:

1. Traverse function:

• Parameters:
  • size (number of bytes requested by the user + alignment bytes + 8 bytes for bookkeeping)
• Body: Iterates through the free list to find a chunk of memory that is large enough to fulfill the request. The size of the chunk must be at least equal to the 'size' parameter passed to the function.
• Return: The address of the suitable chunk of memory. If the function returns NULL, it indicates that there is either no free list of chunks or there is no chunk available that is large enough to satisfy the requested size.

2. Function to insert a node in the free list:

• NOTE: When we free a node (add a node to the free list), the primary action involves readjusting the next and prev pointers of certain chunks to ensure the free list remains properly linked. The size of each chunk initially remains the same. However, subsequent operations, such as coalescing contiguous free chunks, may adjust the sizes of nodes in the list to optimize memory usage and minimize fragmentation.
• Parameters: Pointer to a chunk that we want to insert to the free list.
• Body:
  • If the free list does not exist (head == NULL), create it. Like in this example provided by Dr. Plank:

  malloc_head == 0x6100 (chunk that we passed to the function)

  0x6100 (start of heap)
  8192	0x6100
  NULL	0x6104
  NULL	0x6108
  ...	...
  0x8100 (end of heap -- sbrk(0))

  Namely, point head to the chunk of memory we passed to the function.

  • If the memory address of the node I want to insert is less than the memory address of the head :
    • Point the next field of the chunk you want to insert to the current head .
    • Point the previous field of the current head to the chunk you want to insert.
    • Update the new head to be equal to the the chunk you want to insert.

  malloc_head == 0x6100 (new head - chunk that we passed to the function)

  0x6100 (start of heap)
  24	0x6100
  0x6128	0x6104
  NULL	0x6108
  0x6824abcd	0x610c
  	0x6110
  5555	0x6114
  16	0x6118
  NULL	0x611c
  0x00230000	0x6120
  0xfe??????	0x6124
  8152	0x6128 (previous head)
  NULL	0x612c
  0x6100	0x6130
  ...	...
  0x8100 (end of heap -- sbrk(0))

  I took this table from Dr. Plank's examples in the malloc 2 lecture. Only pay attention to the sections colored with red and blue and if you want to understand the whole memory layout read his Malloc Lecture #2.

  • Otherwise, loop through the list and insert the chunk in the right position in the list – list is sorted in ascending order based on memory address. In other words, the chunk should be inserted after an existing node if its memory address is greater than that node but less than the node's next chunk. You may use two variables to achieve this, one variable that holds the memory address of a given chunk in the list, and another one that holds the memory address of the next chunk.
  • Change the previous and next link accordingly. If the node you want to insert is in the middle of the list, you need to adjust four links. If the node you want to insert is at the end of the list, you just need to adjust two links.

  NOTE: Sorting the list in ascending order makes coalescing easier.

• Return: Does not return anything.

3. my_malloc():

• Parameters: Bytes the user wants to allocate (do not include alignment bytes).
• Body:
  • Perform alignment: size = (size + 7 + 8) & -8;

  Alignment Example:

  Suppose size = 13. You want to allocate at least 13 bytes plus space for bookkeeping, and align everything to a multiple of 8.

  • Add 7 to the requested size to round up to the nearest multiple of 8. This ensures that if the size is already a multiple of 8, we don't add an unnecessary full block of 8 bytes.
  • Add an additional 8 bytes for bookkeeping purposes which includes metadata such as the size of the allocation.
  • Finally, use the bitwise AND operation with -8 to round down to an exact multiple of 8. This step clears the last three bits of the size, ensuring it is a multiple of 8.

  size = 13
size + 7 = 20 (0x14)
size + 7 + 8 = 28 (0x1C)
  

  0x1C (binary: 00011100)
  -8 decimal => 0xFFFFFFF8 => binary: 1111_1111_1111_1111_1111_1111_1111_1000
  

  0x1C AND 0xFFFFFFF8 yields:
  0x18 (binary: 00011000), which is 24 in decimal.

  • Traverse the list and find a chunk big enough to fit size.
  • If the free list is empty, call sbrk with either 8192 or the size previously calculated after the alignment - whichever is greater. Typecast the memory returned by sbrk to a pointer to your chunk struct and set the fields accordingly. Then, insert this whole chunk of memory into the free list.
  • Break off a chunk of the free list to be allocated.
  • Decrease the size of the free chunk by the size calculated previously (bytes requested by the user + alignment bytes)
  • If the new size of that specific free chunk is too small to be useful for subsequent allocations (16 or less), return to the user all the original bytes of that chunk (size of that chunk before decreasing its size). This is because if the new size is too small, the chunk will be useless for subsequent allocations since it can never be re-allocated until it is coalesced – as Dr. Marz explained.
  • Otherwise, give to the user the last part of this chunk (start_chunk_address + new_chunk_size). We need to set the size of the last part of this chunk before returning the bytes to the user.
• Return: A void* pointer to the start of the memory block allocated for the user. This address is calculated as (start_chunk_address + new_chunk_size + 8 bytes of bookkeeping). It's important to note that the usable memory for the user begins 8 bytes after the start of the allocated chunk. This offset accounts for the bookkeeping information stored at the beginning of each allocated block. Therefore, the actual usable memory address provided to the user will be (start_chunk_address + new_chunk_size + 8 bytes).

4. Function to delete node:

• Parameters: Memory address of the chunk to delete.
• Body: Readjust next and previous links.

Consider Plank's implementation of the delete operation in a doubly linked list:

    void dll_delete_node(Dllist node)    /* Deletes an arbitrary item */
    {
    node->flink->blink = node->blink;
    node->blink->flink = node->flink;
    free(node);
    }
    

NOTE: In our custom memory allocator, DO NOT free() the node after readjusting the links. This is because we are only removing the node from our free list, and we want to keep the memory address valid for future allocation by my_malloc(). The memory will be returned to the user, not returned to the system.

• Return: Does not return anything.

5. my_free():

• Parameters: Memory address of the first byte of the chunk that I want to free.
• Body: Decrease this memory address by 8 bytes (to account for the bookkeeping bytes) and pass this new memory address to the function that incorporates a chunk to the free list.
• Return: Does not return anything.

6. Coalesce_free_list():

• Parameters: No parameters.
• Body: Loop through the whole list. If address_current_chunk + size_current_chunk == address_next_chunk, add the size of the next chunk to the size of the current chunk and delete the next node. Otherwise, go to the next chunk in the list.
• Return: Does not return anything.