The memory allocation problem - PowerPoint PPT Presentation


PPT – The memory allocation problem PowerPoint presentation | free to download - id: 3c61ee-MGY2M


The Adobe Flash plugin is needed to view this content

Get the plugin now

View by Category
About This Presentation

The memory allocation problem


The memory allocation problem Define the memory allocation problem Memory organization and memory allocation schemes. * * * * * * * * * * Up to this point: Process ... – PowerPoint PPT presentation

Number of Views:28
Avg rating:3.0/5.0
Slides: 22
Provided by: csFsuEdu
Learn more at:


Write a Comment
User Comments (0)
Transcript and Presenter's Notes

Title: The memory allocation problem

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

  • 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
  • Protected memory
  • Infinite amount of memory

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

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.

  • 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.

  • 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
  • Memory allocation select which piece of memory
    for a request.
  • Memory organization and memory allocation are
    close related.

  • 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
  • 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

  • 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

  • Buddy system
  • Allow to use larger blocks to satisfy smaller
    requests without wasting more than half of the
  • Maintain a free block list for each power of two
  • 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.

  • 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.

  • 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.

  • 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

  • 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.

  • 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.

  • Keeping track of the blocks the list method.
  • Keep a link list of all blocks of memory(block
  • 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?

  • What is the information to be kept in the list
  • Address Block start address
  • size size of the block.
  • Allocated whether the block is free or
  • Struct list_node
  • int address
  • int size
  • int allocated
  • struct list_node next
  • struct list_node prev

  • 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.

  • Keeping track of the memory blocks the bitmap
  • 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.

  • 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)

  • 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

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