0,0 → 1,117 |
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; |
} |
} |