Add source code for project.

Author: bgroff

DiskBuffer.cpp

@@ -0,0 +1,135 @@
+/*
+ * File: DiskBuffer.h
+ * Class: ICS 451
+ * Project #: 3
+ * Team Members: Bryce Groff, Brandon Grant, Emiliano Miranda
+ * Author: Bryce Groff
+ * Created Date: 04-23-09
+ * Desc: Creates a buffer created on disk that can be written to.
+ */
+#include <iostream>
+#include <fstream>
+#include <inttypes.h>
+#include <sys/mman.h>
+
+#include "DiskBuffer.h"
+
+/*!
+	\param fileName The filename that will be used to store the information.
+	\param fileSize The total size of the file to be stored.
+	\param nextSeq The starting sequence number.
+*/
+DiskBuffer::DiskBuffer(string &fileName, uint64_t fileSize, uint64_t nextSeq) 
+	: mFileName(fileName), mFileSize(fileSize), mNextSeq(nextSeq)
+{
+	// Open the file for writing
+	try {
+		mFile.open(mFileName.c_str(), fstream::out);
+	}
+	catch (ios_base::failure &e) { 
+		cerr<<"DiskBuffer [Constructor]: "<<e.what()<<endl;
+	}
+}
+
+DiskBuffer::~DiskBuffer()
+{
+	mFile.close();
+}
+
+/*!
+	\brief Adds data to the DiskBuffer. If the data is in order, the 
+	data will be added and the out of order cache will be iterated over
+	to find any data that may come next. If the data is out of order it will be
+	put in the OutOfSeqCache
+	\sa Data
+	\param &packet The packet that you wish to add to the buffer.
+    \return The amount of data saved to disk.
+*/
+uint64_t DiskBuffer::Add(Data &packet)
+{
+	uint64_t fSeqNum = packet.mSeqNum;
+	uint32_t fSize = packet.mPacketSize;
+
+	// If the sequence number is the number that we 
+	// are expecting to receive then process the data.
+	if (mNextSeq == fSeqNum) {
+		// TODO: This can probably be finner grain.
+		//mWriteLock.Lock();
+	
+		try {
+			mFile.write(packet.mData, (streamsize)fSize);
+		}
+		catch (ios_base::failure &e) {
+			cerr<<"DiskBuffer [Add]: "<<e.what()<<endl;
+		}
+	
+		// Increment the current sequence number by the size of the packet. 
+		// This should be the next sequence number. Then loop over the out 
+		// of order cache and add as much data as we have.
+		mNextSeq += fSize;
+		Data *fNext = mOutOfSeqCache.GetData(mNextSeq);
+		while (fNext != NULL) {
+			// Write the data.
+			mFile.flush();
+			mFile.write(fNext->mData, (streamsize)fNext->mPacketSize);
+			fSize += fNext->mPacketSize;
+			
+			// Increment the pointer
+			mNextSeq += fNext->mPacketSize;
+
+			// Free the memory.
+			delete [] fNext->mData;
+			delete fNext;
+
+			fNext = mOutOfSeqCache.GetData(mNextSeq);
+		}
+	
+		//mWriteLock.Unlock();
+	}
+	
+	// If the sequence number is greater than the number we are expecting
+	// then add the data to the out of order cache.
+	else if (mNextSeq < fSeqNum) {
+		// Lock so we are not adding data while trying to remove above.
+		//mWriteLock.Lock();
+		mOutOfSeqCache.Add(packet);
+		//mWriteLock.Unlock();
+		//fSize = 0;
+	}
+
+	// return how many bytes we saved to disk.
+	return fSize;
+}
+
+/*!
+	\brief Returns the next sequence number that DiskBuffer is expecting.
+    \return mNextSeq
+*/
+uint64_t DiskBuffer::GetNextSeq()
+{
+	return mNextSeq;
+}
+
+/*!
+	\brief Returns the window size to throttle back the sender.
+    \return the window size
+*/
+uint32_t DiskBuffer::GetWindowSize()
+{
+	//TODO: Make this do something useful
+	return 0xFFFFFFFF;
+}
+
+/*!
+	\brief Flushes all the data that is in memory but not yet on the disk.
+	\return Nothing
+*/
+void DiskBuffer::Flush()
+{
+	try {
+		mFile.flush();
+	}
+	catch (ios_base::failure &e) {
+		cerr<<"DiskBuffer [Flush]: "<<e.what()<<endl;
+	}
+}

DiskBuffer.h

@@ -0,0 +1,49 @@
+/*
+ * File: DiskBuffer.h
+ * Class: ICS 451
+ * Project #: 3
+ * Team Members: Bryce Groff, Brandon Grant, Emiliano Miranda
+ * Author: Bryce Groff
+ * Created Date: 04-23-09
+ * Desc: Creates a buffer created on disk that can be written to.
+ */
+#ifndef _DISKBUFFER_H_
+#define _DISKBUFFER_H_
+#include <iostream>
+#include <fstream>
+#include <inttypes.h>
+
+#include "Transmission.h"
+#include "OutOfSeqCache.h"
+#include "Mutex.h"
+
+using namespace std;
+
+/*! \class DiskBuffer
+    \brief Represents a place to store large amounts of information.
+
+   DiskBuffer opens a file on the disk and performs writes to the file.
+   Allows one to Add data, Get the sequence number of the last processed packet,
+   and has the ability to flush what is in memory to disk.
+*/
+class DiskBuffer {
+	public:
+		DiskBuffer(string &fileName, uint64_t fileSize, uint64_t nextSeq);
+		virtual ~DiskBuffer();
+		
+		uint64_t		Add(Data &);
+		uint64_t		GetNextSeq();
+		uint32_t		GetWindowSize();
+		void	 		Flush();
+		
+	private:
+		//Mutex			mWriteLock;
+		OutOfSeqCache	mOutOfSeqCache;
+		
+		fstream			mFile;
+		std::string 	mFileName;
+		uint64_t		mFileSize;
+		uint64_t		mNextSeq;
+		uint32_t		mWindowSize;
+};
+#endif

Mutex.cpp

@@ -0,0 +1,62 @@
+/*
+ * File: Mutex.cpp
+ * Class: ICS 451
+ * Project #: 3
+ * Team Members: Bryce Groff, Brandon Grant, Emiliano Miranda
+ * Author: Bryce Groff
+ * Created Date: 04-19-09
+ * Desc: Represents a Lock.
+ */
+
+#include "Mutex.h"
+
+Mutex::Mutex()
+{
+	pthread_mutex_init(&mLock, NULL);
+	pthread_cond_init(&mCond, NULL);
+}
+
+Mutex::Mutex(int type)
+{
+	pthread_mutexattr_init(&mAttr);
+	pthread_mutexattr_settype(&mAttr, type);
+	pthread_mutex_init(&mLock, &mAttr);
+	pthread_cond_init(&mCond, NULL);
+}
+
+Mutex::~Mutex()
+{
+	pthread_mutex_destroy(&mLock);
+	pthread_mutexattr_destroy(&mAttr);
+	pthread_cond_destroy(&mCond);
+}
+
+int Mutex::Lock()
+{
+	return pthread_mutex_lock(&mLock);
+}
+
+int Mutex::TryLock()
+{
+	return pthread_mutex_trylock(&mLock);
+}
+
+int Mutex::Unlock()
+{
+	return pthread_mutex_unlock(&mLock);
+}
+
+int Mutex::TimedWait(timespec &waitTime)
+{
+	return pthread_cond_timedwait(&mCond, &mLock, &waitTime);
+}
+
+int Mutex::Wait()
+{
+	return pthread_cond_wait(&mCond, &mLock);
+}
+
+int Mutex::Signal()
+{
+	return pthread_cond_signal(&mCond);
+}

Mutex.h

@@ -0,0 +1,40 @@
+/*
+ * File: Mutex.h
+ * Class: ICS 451
+ * Project #: 3
+ * Team Members: Bryce Groff, Brandon Grant, Emiliano Miranda
+ * Author: Bryce Groff
+ * Created Date: 04-19-09
+ * Desc: Represents a Lock.
+ */
+#ifndef _MUTEX_H_
+#define _MUTEX_H_
+
+#include <pthread.h>
+#include <inttypes.h>
+#include <time.h>
+
+/*! \class Mutex
+    \brief Wrapper around pthread locks.
+
+   Mutex gives a wrapper around the pthread mutual exclusion mechanism.
+*/
+class Mutex {
+	public:
+		Mutex();
+		Mutex(int type);
+		~Mutex();
+		
+		int				Lock(); //!< Locks this lock.
+		int				TryLock(); //!< Tries to lock this lock. If 0 is returned, then the lock is required; otherwise, an error number is returned.
+		int				Unlock(); //!< Unlocks this lock.
+		int		 		TimedWait(timespec &); //!< Waits for timespec amount of time then timesout
+		int				Wait(); //!< Waits until signaled
+		int				Signal(); //!< Signals the condition variable to continue.
+	
+	private:
+		pthread_mutex_t mLock;
+		pthread_cond_t	mCond;
+		pthread_mutexattr_t mAttr;
+};
+#endif

OutOfSeqCache.cpp

@@ -0,0 +1,77 @@
+/*
+ * File: OutOfSeqCache.h
+ * Class: ICS 451
+ * Project #: 3
+ * Team Members: Bryce Groff, Brandon Grant, Emiliano Miranda
+ * Author: Bryce Groff
+ * Created Date: 04-23-09
+ * Desc: Creates cache to hold out of order data.
+ */
+#include <map>
+#include <utility>
+
+#include "OutOfSeqCache.h"
+#include "Transmission.h"
+
+/*!
+	\brief Constructor does nothing.
+*/
+OutOfSeqCache::OutOfSeqCache()
+{
+}
+
+OutOfSeqCache::~OutOfSeqCache()
+{
+}
+
+/*!
+	\brief Adds data to the OutOfSeqCache. Remeber that you must free the data that 
+	gets passed in to the OutOfSeqCache.
+	\sa Data
+	\param &packet The packet that you wish to add to the buffer. The data of the packet 
+	must be on the heap.
+    \return Nothing
+*/
+void OutOfSeqCache::Add(Data packet)
+{	
+	DataMap::iterator fIter = mMap.begin();
+	fIter = mMap.find(packet.mSeqNum);
+
+	// Make sure we didn't already add this packet.
+	if (fIter == mMap.end())
+	{
+		// Make sure that we copy the data so that when the execution continues
+		// running we do not loose the data.
+		Data *fData = new Data();
+		fData->mSeqNum = packet.mSeqNum;
+		fData->mPacketSize = packet.mPacketSize;
+		fData->mData = new char[packet.mPacketSize];
+		memcpy(fData->mData, packet.mData, packet.mPacketSize);
+
+		// Add the packet to the map, use the seqNum as a lookup.
+		mMap.insert(pair<uint64_t, Data*>(packet.mSeqNum, fData));
+	}
+}
+
+/*!
+	\brief Iterates through the list of packet and either returns the 
+	packet if we can find it, or return NULL if we cannot.
+	\param &seqNum The sequence number to search for.
+    \return The packet or NULL if the data was not found.
+*/
+Data *OutOfSeqCache::GetData(uint64_t seqNum)
+{
+	Data *fVal = NULL;
+	
+	// find will return an iterator to the matching element if it is found
+	// or to the end of the map if the key is not found
+	DataMap::iterator fIter = mMap.begin();
+	fIter = mMap.find(seqNum);
+	if( fIter != mMap.end() ) {
+		fVal = fIter->second;
+		mMap.erase(fIter);
+	}
+
+	// If we fall through return NULL.
+	return fVal;
+}