8/3/2019 Lab 09 - Doubly Linked List

1/1

Punjab University College Of Information Technology Page 1 of1

Data Structures and AlgorithmsSpecial ClassLAB-09Dated: January 04, 2012

Objective: Understanding of doubly linked list.

Free Space Management with Doubly Linked Lists

Have you ever wondered how the new operator, which is used to create an object in C, C++ and Java which supportdynamic allocation of memory. One of the responsibilities ofnew is to allocate memory space for the newly-created

object. Java uses a memory manager to keep track of the memory space (the free space pool) available for creating

new objects. The memory manager needs to have mechanisms for allocating space from the free space pool and also

for returning space to the pool when an object is no longer being used. In today's lab, we will look at one way of

implementing the free space pool, by using a doubly linked list.

Your task is to implement a memory manager that is responsible for allocating and de-allocating the blocks of

memory.

The memory manager is responsible for handling two types of request:

1. MemoryBlock allocate(int size); // allocate a memory block of the given size2. void free(MemoryBlock block); // free a given memory block; that is, return it to the free list

Every memory block has the following structure.

public class MemoryBlock

{

private int address;

private int length;

MemoryBlock *prev;

MemoryBlock *next;

}

The basic strategy in the allocate method is to scan the free block list to find the first free block which is large enoughto satisfy the request. (This is called the "first fit" strategy). If the length of the free block is exactly the same as the

requested size, the block is simply removed from the free list and returned to the caller. If the first-fit block is larger

than the requested size, it is split into two parts. One part, the same size as the requested size, is returned to the caller.

The remainder of that block (with its size appropriately reduced) is left on the free list. If the free list does not contain

any block of sufficient size to satisfy the request, allocate should return null.

The list should be ordered by address. The free method starts by scanning the free list to find the place where the block

being freed belongs. The block should be returned to the free list, combining it with adjacent free blocks if possible.

(Two blocks b1 and b2 are adjacent if b1.address + b1.length == b2.address.) The rationale for this is that we want to

keep the free blocks as large as possible to handle future allocate requests; otherwise, fragmentation occurs. That is,

the free space is split into smaller and smaller blocks until they are too small to be of any use.

In programming the free method, there are four possible cases:

1. The block can be combined with the preceding block. In that case, we can simply add the length of the freeblock to the preceding block.

2. The block can be combined with the succeeding block. Add it to the succeeding block by adjusting both thesize and the address of the succeeding block.

3. The block can be combined with both the preceding block and the succeeding block. Combine all three byadding the lengths of the block and the succeeding block to the length of the preceding block, then deleting

the succeeding block.

4. The block cannot be combined with either block. Add it to the free list between the predecessor andsuccessor.