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 recordSize = 0;

	private int cacheHit = 0;

	private int cacheMiss = 0;

	private int diskReads = 0;

	private int diskWrites = 0;

	private String dataFile;

	private String statFile;

	private int bufferSize;

	private BufferBlock bufferHead;

	private RandomAccessFile file;

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

		this.dataFile = datafile;

		this.statFile = statfile;

		this.bufferSize = size;

		this.blockSize = blocksize;

		this.recordSize = recordsize;

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

		} catch (FileNotFoundException e) {

			e.printStackTrace();

		}

	}

	// Returns recordSize number of bytes to out from record # pos

	public boolean getBytes(byte[] out, long pos) {

		BufferBlock cur = bufferHead;

		// Calculate the address of record

		long address = pos * recordSize;

		// Check if address is already in a buffer block

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

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

				// Address is in block, get data

				cacheHit++;

				cur.getBytes(out, (int)address % blockSize, recordSize);

				// Bring current block to front of list

				bringToFront(cur);

				return true;

			}

			cur = cur.getNext();

		}

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

		cacheMiss++;

		BufferBlock newBlock = readFromDisk(address);

		// Get requested bytes from block

		newBlock.getBytes(out, (int)address % blockSize, recordSize);

		insertToFront(newBlock);

		return false;

	}

	// Puts recordSize number of bytes from in to record # pos

	public boolean putBytes(byte[] in, long pos) {

		BufferBlock cur = bufferHead;

		// Calculate the address of record

		long address = pos * recordSize;

		// Check if address is already in a buffer block

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

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

				// Address is in block, put data

				cacheHit++;

				cur.setBytes(in, (int)address % blockSize, recordSize);

				cur.setDirtyBit(true);

				// Bring current block to front of list

				bringToFront(cur);

				return true;

			}

			cur = cur.getNext();

		}

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

		cacheMiss++;

		BufferBlock newBlock = readFromDisk(address);

		// Put passed bytes into block

		newBlock.setBytes(in, (int)address % blockSize, recordSize);

		newBlock.setDirtyBit(true);

		insertToFront(newBlock);

		return false;

	}

	// 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, 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, 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();

		}

	}

}