The memory allocation problem

1. The memory allocation problem • Define the memory allocation problem • Memory organization and memory allocation schemes.

2. Up to this point: Process management provides the illusion of an infinite number of CPUs • On a single processor machine • Memory management provides a different set of illusions • Protected memory • Infinite amount of memory

3. Memory allocation problem • A sub-problem in memory management. • A large block of memory (e.g. physical memory), say N bytes. • Requests for sub-blocks come in an unpredictable fashion (e.g. processes start and need memory). • Each request may ask for 1 to N bytes. • Allocate continuous memory to a request when available. The memory block is in use for a while and is then returned to the system (free). • Goal: to satisfy as many requests as possible • constraints: CPU and memory overheads should be low.

4. Memory allocation problem • Example • 10KB memory to be managed • r1 = req(1K); • r2 = req (2K); • r3 = req(4k); • free(r2); • free(r1); • r4 = req(4k); • How to do it makes a difference!! • Internal fragment: unused memory within a block • Asking for 100 bytes and get a 512 bytes block • External fragment: unused memory between blocks • Even when the total available memory is more than a request, the request cannot be satisfied as in the example.

5. Variations of the memory allocation problem occur in different situations. • Disk space management • heap management • new and delete in C++ • malloc and free in C.

6. Two issues in the memory allocation problem: • Memory organization: how to divide the memory into blocks for allocation? • Static method: divide the memory once before the memory are allocated. • Dynamic method: divide it up as the memory is allocated. • Memory allocation: select which piece of memory for a request. • Memory organization and memory allocation are close related.

7. Static memory organization: • Statically divide memory into fixed size subblocks, each for a request. • Advantages: • easy to implement. • Good when the sizes for memory requests are fixed. • Can be extended for handle memory requests for different sizes known a prior. • Example: 500, 000 bytes, each request for either 50,000 or 200,000. Two 50,000 bytes blocks, Two 200,000 byte blocks. • Data structure: a linked list for each type of blocks.

8. Static memory organization: Worst case complexity: new and free O(1) for both Disadvantage: cannot handle variable-size requests effectively. Might need to use a large block to satisfy a request for small size. Internal fragmentation

9. Buddy system: • Allow to use larger blocks to satisfy smaller requests without wasting more than half of the block. • Maintain a free block list for each power of two size. • E.g. memory has 512K bytes. • The system will maintain free block list for blocks of 512K, 256K, 128K, 64K, 32K, 16K, 8K, 4K, 2K, 1K, 512bytes, 256 bytes, 128bytes, 64bytes, 32bytes, 16bytes, 8bytes, 4 bytes, 2bytes, 1bytes. • All free lists start off empty except for the free block list for the largest block which contains one free block.

10. Buddy system: • When receiving a request, round it up to the next power of two and look for that list. If that block list is empty, look for the next larger power of two and divide a free block there into two blocks (buddy). Ifstill fail, keep going up until you find one. • When freeing a block, look whether its buddy is free, if yes, merge them, otherwise, insert the free block into the appropriate free block list.

11. Example: • memory = 32 bytes, free block list for 32, 16, 8, 4, 2, 1 bytes. • Initial state of the free block list? • What is the memory state after the sequence: request 1( 1 byte), free (request 1), request 2 (4 bytes), request 3 (8 bytes), free request 2, request 4 (1 byte), request 5 (2 bytes), free request 3.

12. Buddy system is a semi-dynamic method • keeps the simplicity of the statically allocated blocks and handles the difficult cases of different request sizes. • Worst case complexity? • Drawback: • Can still have internal fragments

13. Dynamic memory allocation: • Grant only the size requested (different from static memory allocation and buddy system). • Example: total 512 bytes: allocate(r1, 100), allocate(r2, 200), allocate(r3, 200), free(r2), allocate(r4, 10), free(r1), allocate(r5, 200) • Fragmentation: memory is divided up into small blocks that none of them can be used to satisfy any requests. • Static allocation -- internal fragment. • dynamic allocation -- external fragment.

14. Issues in dynamic memory allocation. • Where are the free memory blocks? • How to keep track of the free/used memory blocks • Which memory blocks to allocate? • There may exist multiple free memory blocks that can satisfy a request. Which block to use? • Fragments must be reduced.

15. Keeping track of the blocks: the list method. • Keep a link list of all blocks of memory(block list). • Example: total 512 bytes: allocate(r1, 100), allocate(r2, 200), allocate(r3, 200), free(r2), allocate(r4, 10), free(r1), allocate(r5, 200) • How to do the allocation operation? • How to do the free operation? • What information is to be kept in the list node?

16. What is the information to be kept in the list node? • Address: Block start address • size: size of the block. • Allocated: whether the block is free or allocated. Struct list_node { int address; int size; int allocated; struct list_node *next; struct list_node *prev; };

17. Do we have to keep track of allocated block in the list? • Not necessary. • What is good and bad about keeping the allocated blocks information? • Can check invalid free operations. • Where to keep the block list? • Reserving space for the block list at the beginning of the memory. • Limited number of block list nodes, constant space overhead (memory space taken away for memory management). • Use space within each block. Each block has a header for block_list node.

18. Keeping track of the memory blocks: the bitmap method. • Memory is divided into blocks, use one bit to represent whether one block is allocated or not. • A bitmap is a string of bits. • E.g 4Mbytes memory, each block has 1 byte. How many bits are needed to keep track of the status of the memory? How about each block has 1KB? • How to allocate? • How to free? • Commonly used in disk.

19. Comparing the list method and bitmap method: list method(block header) bitmap method space: # of blocks fixed static time finding free blocks? O(B) string matching free a block? O(B) O(1)

20. Which free block to allocate? • First fit: search from the beginning, use the first free block. • next fit: search from the current position, use the first free block. • best fit: use the smallest block that can fit. • worst fit: use the largest block that can fit. • Which algorithm is faster? Which is slower? • Which one is the best (satisfies most requests)? • Depend the programs

21. One question • What would be a simple and effective heap management scheme for most applications? • Hints: most applications do not use heap that much!!!