Subversion Repositories Code-Repo

import java.io.BufferedWriter;

import java.io.FileNotFoundException;

import java.io.FileWriter;

import java.io.IOException;

import java.io.RandomAccessFile;

public class LRUBuffer {

	private int blockSize = 0;

	private int cacheHit = 0;

	private int cacheMiss = 0;

	private int diskReads = 0;

	private int diskWrites = 0;

	private String dataFile;

	private String statFile;

	private BufferBlock bufferHead;

	private RandomAccessFile file;

	public LRUBuffer(String datafile, String statfile, int size, int blocksize) {

		this.dataFile = datafile;

		this.statFile = statfile;

		this.blockSize = blocksize;

		// Allocates a new doubly linked list of BufferBlocks

		// The buffer will have at least one block

		bufferHead = new BufferBlock(blockSize);

		BufferBlock cur = bufferHead;

		for (int i = 0; i < size-1; i++) {

			BufferBlock newBlock = new BufferBlock(blockSize);

			cur.setNext(newBlock);

			newBlock.setPrev(cur);

			cur = newBlock;

		}

		// Open access to the datafile

		try {

			file = new RandomAccessFile(dataFile, "rw");

			file.setLength(0);

		} catch (FileNotFoundException e) {

			e.printStackTrace();

		} catch (IOException e) {

			e.printStackTrace();

		}

	}

	/** Recursive function to copy length number of bytes from file at startAddress

	 * to offset position in out

	 * 

	 * @param out Destination array to copy bytes to

	 * @param offset Offset of position to write to in the destination array

	 * @param startAddress Starting address on disk to copy bytes from

	 * @param length Number of bytes to copy to the destination array

	 * @return

	 */

	public boolean getBytes(byte[] out, int offset, long startAddress, int length) {

		BufferBlock cur = bufferHead;

		// If the requested length doesnt extends to the next block

		if (startAddress % blockSize + length < blockSize) {

			// Check if address is already in a buffer block

			while (cur != null && cur.getStartAddress() != -1) {

				if (startAddress >= cur.getStartAddress() && startAddress < cur.getStartAddress() + blockSize) {

					// Address is in block

					cacheHit++;

					// Bring current block to front of list

					bringToFront(cur);

					// Get data

					cur.getBytes(out, offset, (int)startAddress % blockSize, length);

					return true;

				}

				cur = cur.getNext();

			}

			// Address is not in buffer, read new block from disk

			cacheMiss++;

			cur = readFromDisk(startAddress);

			insertToFront(cur);

			// Get data from block

			cur.getBytes(out, offset, (int)startAddress % blockSize, length);

			return true;

		// If the requested length extends to the next block

		} else {

			int bytesToRead = 0;

			// Check if address is already in a buffer block

			while (cur != null && cur.getStartAddress() != -1) {

				if (startAddress >= cur.getStartAddress() && startAddress < cur.getStartAddress() + blockSize) {

					// Address is in block

					cacheHit++;

					// Bring current block to front of list

					bringToFront(cur);

					// Read in from address to end of block

					bytesToRead = blockSize - (int)startAddress % blockSize;

					cur.getBytes(out, offset, (int)startAddress % blockSize, bytesToRead);

					offset += bytesToRead;

					// Get data from the next consecutive block

					getBytes(out, offset, startAddress + bytesToRead, length - bytesToRead);

					return true;

				}

				cur = cur.getNext();

			}

			// Address is not in buffer, read new block from disk

			cacheMiss++;

			cur = readFromDisk(startAddress);

			insertToFront(cur);

			// Read in from address to end of block

			bytesToRead = blockSize - (int)startAddress % blockSize;

			cur.getBytes(out, offset, (int)startAddress % blockSize, bytesToRead);

			offset += bytesToRead;

			// Get data from the next consecutive block

			getBytes(out, offset, startAddress + bytesToRead, length - bytesToRead);

			return true;

		}

	}

	/** Recursive function to copy length number of bytes from in to file at startAddress

	 * 

	 * @param in Input array to copy bytes from

	 * @param startAddress Starting address on disk to copy bytes to

	 * @param length Number of bytes to copy from in to disk

	 * @return

	 */

	public boolean putBytes(byte[] in, int offset, long startAddress, int length) {

		BufferBlock cur = bufferHead;

		// If the requested length doesnt extends to the next block

		if (startAddress % blockSize + length <= blockSize) {

			// Check if address is already in a buffer block

			while (cur != null && cur.getStartAddress() != -1) {

				if (startAddress >= cur.getStartAddress() && startAddress < cur.getStartAddress() + blockSize) {

					// Address is in block

					cacheHit++;

					// Bring current block to front of list

					bringToFront(cur);

					// Put data into block

					cur.setBytes(in, offset, (int)startAddress % blockSize, length);

					cur.setDirtyBit(true);

					return true;

				}

				cur = cur.getNext();

			}

			// Address is not in buffer, read new block from disk

			cacheMiss++;

			cur = readFromDisk(startAddress);

			insertToFront(cur);

			// Put data into block

			cur.setBytes(in, offset, (int)startAddress % blockSize, length);

			cur.setDirtyBit(true);

			return true;

		// If the requested length extends to the next block

		} else {

			int bytesToWrite = 0;

			// Check if address is already in a buffer block

			while (cur != null && cur.getStartAddress() != -1) {

				if (startAddress >= cur.getStartAddress() && startAddress < cur.getStartAddress() + blockSize) {

					// Address is in block

					cacheHit++;

					// Bring current block to front of list

					bringToFront(cur);

					// Put in data until end of block

					bytesToWrite = blockSize - (int)startAddress % blockSize;

					cur.setBytes(in, offset, (int)startAddress % blockSize, bytesToWrite);

					cur.setDirtyBit(true);

					startAddress += bytesToWrite;

					// Put remaining data into the next consecutive block

					putBytes(in, offset + bytesToWrite, startAddress, length - bytesToWrite);

					return true;

				}

				cur = cur.getNext();

			}

			// Address is not in buffer, read new block from disk

			cacheMiss++;

			cur = readFromDisk(startAddress);

			insertToFront(cur);

			// Put in data until end of block

			bytesToWrite = blockSize - (int)startAddress % blockSize;

			cur.setBytes(in, offset, (int)startAddress % blockSize, bytesToWrite);

			cur.setDirtyBit(true);

			startAddress += bytesToWrite;

			// Put remaining data into the next consecutive block

			putBytes(in, offset + bytesToWrite, startAddress, length - bytesToWrite);

			return true;

		}

	}

	/** Brings a block currently in the list to the front of the list */

	private void bringToFront(BufferBlock block) {

		// If block is already in front, return

		if (block == bufferHead)

			return;

		if (block.getPrev() != null)

			block.getPrev().setNext(block.getNext());

		if (block.getNext() != null)

			block.getNext().setPrev(block.getPrev());

		block.setPrev(null);

		bufferHead.setPrev(block);

		block.setNext(bufferHead);

		bufferHead = block;

	}

	/** Inserts a new block into the front of the list */

	private void insertToFront(BufferBlock block) {

		// Set head as current block

		block.setPrev(null);

		bufferHead.setPrev(block);

		block.setNext(bufferHead);

		bufferHead = block;

		// Write last block in list to disk if dirty bit is set

		// Last block is also removed

		BufferBlock cur = bufferHead;

		while (cur.getNext() != null) {

			cur = cur.getNext();

		}

		cur.getPrev().setNext(null);

		if (cur.isDirtyBit()) {

			writeToDisk(cur);

		}

	}

	/** Reads a new block from disk given an address */

	private BufferBlock readFromDisk(long address) {

		diskReads++;

		byte[] data = new byte[blockSize];

		long offset = address / blockSize;

		offset = offset * blockSize;

		try {

			file.seek(offset);

			file.read(data);

		} catch (IOException e) {

			e.printStackTrace();

		}

		// Pass read block into a new block

		BufferBlock newBlock = new BufferBlock(blockSize);

		newBlock.setBytes(data, 0, 0, blockSize);

		newBlock.setStartAddress(offset);

		return newBlock;

	}

	/** Writes the specified block to disk */

	private void writeToDisk(BufferBlock block) {

		diskWrites++;

		byte[] data = new byte[blockSize];

		block.getBytes(data, 0, 0, blockSize);

		try {

			file.seek(block.getStartAddress());

			file.write(data);

		} catch (IOException e) {

			e.printStackTrace();

		}

	}

	/** Flush the buffer by writing all blocks in buffer to disk */

	public void flushBuffer() {

		BufferBlock cur = bufferHead;

		while (cur != null) {

			if (cur.isDirtyBit()) {

				writeToDisk(cur);

			}

			cur = cur.getNext();

		}

		try {

			file.close();

		} catch (IOException e) {

			e.printStackTrace();

		}

	}

	/** Write stats to stat file */

	public void writeStats(long time) {

		try {

			BufferedWriter out = new BufferedWriter(new FileWriter(statFile, true));

			StringBuilder str = new StringBuilder();

			str.append("Datafile: " + dataFile + " | ");

			str.append("Cache Hits: " + cacheHit + " | ");

			str.append("Cache Misses: " + cacheMiss + " | ");

			str.append("Disk Reads: " + diskReads + " | ");

			str.append("Disk Writes: " + diskWrites + " | ");

			str.append("Time to Sort: " + time + "\n");

			out.write(str.toString());

			out.close();

		} catch (IOException e) {

			e.printStackTrace();

		}

	}

	public void printBlockIDs() {

		BufferBlock cur = bufferHead;

		System.out.print("Buffer Pool Blocks: ");

		while (cur != null && cur.getStartAddress() != -1) {

//			System.out.print(cur.getStartAddress() + " ; ");

			System.out.print(cur.getStartAddress() / blockSize + " ; ");

			cur = cur.getNext();

		}

		System.out.print("\n");

	}

}