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). If still 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!!!