CS 208 s22 — Dynamic Memory Allocation: Free Lists

Implementation questions:

• freeing: how much do we free given just a pointer?
• free block organization: how to keep track of them
• placement: which free block should we choose to fulfill a request
• splitting: what do we do with the remainder of a free block after part of it is allocated
• coalescing: what do we do when a block is freed

• since block size will always be a multiple of 16 due to alignment, the four lower order bits of the size will always be 0
• we can make efficient use of the header by using these four bits to indicate if the block is allocated or free
• the block size includes the payload and any padding, and is thus an implicit pointer to the start of the next block
• we will need some special block to mark the end of the free list (e.g, allocated bit, size 0)
• implicit free list is simple, but operations are linear in the number of blocks since we have to traverse the list
• alignment combined with block format impose a minimum block size
• https://docs.google.com/spreadsheets/d/1Tj8LTKBBqLodX5K8GbqCVUSWOFur6KzXZshQhx0bF4E/edit?usp=sharing#gid=858123926
• https://docs.google.com/spreadsheets/d/1Tj8LTKBBqLodX5K8GbqCVUSWOFur6KzXZshQhx0bF4E/edit?usp=sharing#gid=1764373338

• organize free list as a doubly-linked list using the payload of free blocks (by definition unused) to store the pointers
  • now placement is linear in the number of free blocks instead of the total number of blocks
  • assuming a first-fit policy:
    • if list uses last-in first-out by inserting new free blocks at the head, freeing a block is constant time
    • better memory utilization can be achieved if free blocks are maintained in address order
• minimum block size must increase to accomodate list pointers, potentially increasing internal fragmentation
• splitting, boundary tags, coalescing are general to all allocators
  • free blocks still coalesce with those adjacent in memory
    • remove from list, reinsert at the head
  • list can hold blocks in any order, regardless of memory address

Which allocation strategy and requests remove external fragmentation in this heap?¹ B3 was the last fulfilled request.

1. best-fit: malloc(50), malloc(50)
2. first-fit: malloc(50), malloc(30)
3. next-fit: malloc(30), malloc(50)
4. next-fit: malloc(50), malloc(30)

What is the relationship between throughput and memory utilization?²

• section 9.9.12 walks through an implementation of an implicit free list
  • beware it is in 32-bit, and your will need to be in 64-bit (generally involves changing constants)
  • pay more attention to the text descriptions than the code
• use macros or helper functions like these for pointer manipulation
  • make sure you understand why these work/are necessary before you start coding

/* Round up size to the nearest multiple of 16 */
/* Basic constants and macros */
#define WSIZE       8       /* word size (bytes) */
#define DSIZE       16      /* doubleword size (bytes) */
#define CHUNKSIZE  (1<<12)  /* initial heap size (bytes) */
#define OVERHEAD    16      /* overhead of header and footer (bytes) */

/* NOTE: feel free to replace these macros with helper functions and/or
 * add new ones that will be useful for you. Just make sure you think
 * carefully about why these work the way they do
 */

/* Pack a size and allocated bit into a word */
#define PACK(size, alloc)  ((size) | (alloc))

/* Read and write a word at address p */
#define GET(p)       (*(size_t *)(p))
#define PUT(p, val)  (*(size_t *)(p) = (val))

/* Perform unscaled pointer arithmetic */
#define PADD(p, val) ((char *)(p) + (val))
#define PSUB(p, val) ((char *)(p) - (val))

/* Read the size and allocated fields from address p */
#define GET_SIZE(p)  (GET(p) & ~0xf)
#define GET_ALLOC(p) (GET(p) & 0x1)

/* Given block ptr bp, compute address of its header and footer */
#define HDRP(bp)       (PSUB(bp, WSIZE))
#define FTRP(bp)       (PADD(bp, GET_SIZE(HDRP(bp)) - DSIZE))

/* Given block ptr bp, compute address of next and previous blocks */
#define NEXT_BLKP(bp)  (PADD(bp, GET_SIZE(HDRP(bp))))
#define PREV_BLKP(bp)  (PSUB(bp, GET_SIZE((PSUB(bp, DSIZE)))))

• Allocator Policies
  • All policies offer trade-offs in fragmentation and throughput.
  • Placement policy:
    • First-fit, next-fit, best-fit
  • Splitting policy:
    • Always? Sometimes?
    • Be mindful of minimum block size—never split off a block smaller than the minimum
    • Which side of the split should the allocated block be on?
      • Left? Right? Alternate?
  • Coalescing policy:
    • Immediate vs. deferred

CSPP practice problem 9.7 (p. 852, 854)

Determine minumum block size for the following combinations of alignment requirements and block formats. Assumptions: implicit free list, zero-size payloads are not allowed, and headers and footers are stored in 4-byte words.³