Subversion Repositories Code-Repo

import java.nio.ByteBuffer;

// Memory manager that operates on the memory pool

public class MemManager {

	private byte[] memoryPool;	// Byte array representing the memory pool

	private DoubleLinkedList emptyBlockList;	// List of free blocks

	// Constructor

	public MemManager(int poolsize) {

		// Initialize memory pool and list of free blocks

		memoryPool = new byte[poolsize];

		emptyBlockList = new DoubleLinkedList();

		// Create the first empty block of the pool size

		LinkedListEntry newEntry = new LinkedListEntry(0, poolsize - 1, poolsize);

		emptyBlockList.insert(newEntry);

	}

	// Insert a record and return its position handle.

	// space contains the record to be inserted, of length size.

	public Handle insert(byte[] space, int size) {

		LinkedListEntry start = emptyBlockList.getFirstEntry();

		if (start == null) {

			// There are no free blocks

			return null;

		}

		if ((size + 1) > start.getSize()) {

			// Size to insert is greater than size of largest free block

			return null;

		}

		while (start != null) {

			if (start.getNextBlock() == null) {

				// Current block is last block in list, insert into current block

				Handle newHandle = insertDataIntoMemPool(start, space, size);

				return newHandle;

			} else if ((size + 1) > start.getNextBlock().getSize()) {

				// Best fit block found, insert into current block

				Handle newHandle = insertDataIntoMemPool(start, space, size);

				return newHandle;

			}

			// Otherwise keep searching for best fit block

			start = start.getNextBlock();

		}

		return null;

	}

	// Free a block at address. Merge adjacent blocks if appropriate.

	public void remove(Handle handle) {

		short size = getDataBlockSize(handle.getAddress());

		// Needs to create a new empty block at the specified address

		LinkedListEntry newEntry = new LinkedListEntry(handle.getAddress(), handle.getAddress() + size, size + 1);

		emptyBlockList.insert(newEntry);

	}

	// Return the record with handle posHandle, up to size bytes.

	// Data to be returned is copied to space.

	public void get(byte[] space, Handle handle, int size) {

		short shSize = getDataBlockSize(handle.getAddress());

		// Find max number of bytes to copy to byte array

		int toRead;

		if (size < shSize) {

			toRead = size;

		} else {

			toRead = shSize;

		}

		// Copy bytes from memory pool to byte array

		ByteBuffer memPool = ByteBuffer.wrap(memoryPool, handle.getAddress() + 1, toRead);

		ByteBuffer dest = ByteBuffer.wrap(space);

		dest.put(memPool);

	}

	// Dump a printout of the freeblock list

	public void dump() {

		LinkedListEntry head = emptyBlockList.getFirstEntry();

		while (head != null) {

			System.out.printf("Empty block at address %d of size %d\n", head.getStartAddress(), head.getSize());

			head = head.getNextBlock();

		}

	}

	// Returns the value of the first byte for the data entry (size)

	private short getDataBlockSize(int address) {

		byte[] shortArr = new byte[2];

		ByteBuffer shortBuffer = ByteBuffer.wrap(shortArr, 1, 1);

		shortBuffer.put(memoryPool[address]);

		shortBuffer = ByteBuffer.wrap(shortArr);

		short size = shortBuffer.getShort();

		return size;

	}

	// Copies the passed byte array into a free block in the memory pool

	private Handle insertDataIntoMemPool(LinkedListEntry entry, byte[] space, int size) {

		// Insert the data at the address of the given free block

		ByteBuffer memBuffer = ByteBuffer.wrap(memoryPool, entry.getStartAddress(), size + 1);

		memBuffer.put((byte)size);

		memBuffer.put(space);

		// Create a new free block with remaining free space

		if (entry.getSize() - (size + 1) != 0) {

			int startAddress = entry.getStartAddress() + size + 1;

			int newSize = entry.getSize() - (size + 1);

			int endAddress = startAddress + newSize - 1;

			LinkedListEntry newEntry = new LinkedListEntry(startAddress, endAddress, newSize);

			emptyBlockList.remove(entry.getStartAddress());

			emptyBlockList.insert(newEntry);

		} else {

			emptyBlockList.remove(entry.getStartAddress());

		}

		Handle newHandle = new Handle(entry.getStartAddress());

		return newHandle;

	}

}