Subversion Repositories Code-Repo

import java.nio.ByteBuffer;

// Memory manager that operates on the buffer pool

public class MemManager {

	private LRUBuffer buffer;	// Buffer pool interfacing to disk

	private int blockSize = 0;	// Size of each block

	private long fileLength = 0;	// Current length of the file

	private DoubleLinkedList emptyBlockList;	// List of free blocks

	// Constructor

	public MemManager(LRUBuffer buffer, int blockSize) {

		// Initialize buffer pool and list of free blocks

		this.buffer = buffer;

		emptyBlockList = new DoubleLinkedList();

		this.blockSize = blockSize;

	}

	// Insert a record and return its position handle.

	public Handle insert(byte[] data, int length) {

		// There are no free blocks

		if (emptyBlockList.getFirstEntry() == null) {

			// Create a new free block of size blockSize

			LinkedListBlock newEntry = new LinkedListBlock(0, blockSize - 1, blockSize);

			emptyBlockList.insert(newEntry);

			fileLength = blockSize;

		}

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

		if ((length + 1) > emptyBlockList.getFirstEntry().getSize()) {

			// Calculate how many new free blocks needs to be created to hold the byte array

			int blocks = length / blockSize;

			if (length % blockSize != 0) {

				blocks++;

			}

			for (int i = 0; i < blocks; i++) {

				// Create a new free block and insert it into the list of empty block

				LinkedListBlock newEntry = new LinkedListBlock(fileLength, fileLength + blockSize - 1, blockSize);

				emptyBlockList.insert(newEntry);

				fileLength += blockSize;

			}

		}

		// Find the first free block that can hold the byte array

		LinkedListBlock start = emptyBlockList.getFirstEntry();

		while (start != null) {

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

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

				Handle newHandle = insertDataIntoMemPool(start, data, length);

				return newHandle;

			// Best fit block found, insert into current block

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

				Handle newHandle = insertDataIntoMemPool(start, data, length);

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

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

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

		emptyBlockList.insert(newEntry);

	}

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

	public void get(byte[] data, Handle handle) {

		// Get bytes from buffer

		buffer.getBytes(data, 0, handle.getAddress() + 1, getDataBlockSize(handle));

	}

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

	public short getDataBlockSize(Handle handle) {

		byte[] shortArr = new byte[2];

		// Get the first byte at the address

		buffer.getBytes(shortArr, 1, handle.getAddress(), 1);

		ByteBuffer shortBuffer = ByteBuffer.wrap(shortArr);

		short size = shortBuffer.getShort();

		return size;

	}

	// Copies the passed byte array into the buffer

	private Handle insertDataIntoMemPool(LinkedListBlock entry, byte[] data, int length) {

		// Insert the size of the array into the first byte

		byte[] size = new byte[1];

		ByteBuffer buff = ByteBuffer.wrap(size);

		buff.put((byte)length);

		buffer.putBytes(size, 0, entry.getStartAddress(), 1);

		// Insert the array

		buffer.putBytes(data, 0, entry.getStartAddress() + 1, length);

		// Create a new free block with remaining free space

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

			long startAddress = entry.getStartAddress() + length + 1;

			long newSize = entry.getSize() - (length + 1);

			long endAddress = startAddress + newSize - 1;

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

			emptyBlockList.remove(entry.getStartAddress());

			emptyBlockList.insert(newEntry);

		} else {

			emptyBlockList.remove(entry.getStartAddress());

			LinkedListBlock newEntry = new LinkedListBlock(fileLength, fileLength + blockSize - 1, blockSize);

			emptyBlockList.insert(newEntry);

			fileLength += blockSize;

		}

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

		return newHandle;

	}

	// Dump a printout of the freeblock list

	public void dump() {

		LinkedListBlock head = emptyBlockList.getFirstEntry();

		while (head != null) {

			System.out.printf("Empty block at address %d to %d\n", head.getStartAddress(), head.getStartAddress() + head.getSize() - 1);

			head = head.getNextBlock();

		}

	}

	public void printBuffer() {

		buffer.printBlockIDs();

	}

	public void clear() {

		LinkedListBlock head = emptyBlockList.getFirstEntry();

		while (head != null) {

			emptyBlockList.remove(head.getStartAddress());

			head = head.getNextBlock();

		}

		LinkedListBlock newEntry = new LinkedListBlock(0, fileLength-1, fileLength);

		emptyBlockList.insert(newEntry);

	}

}