From: Brian Norris <banorris@uci.edu>
Date: Wed, 2 Jan 2013 23:43:54 +0000 (-0800)
Subject: fixup style
X-Git-Tag: oopsla2013~399
X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=6e5c0bb2359b9fba6160957ffa88974233ba18ac;p=model-checker.git

fixup style
---

diff --git a/clockvector.cc b/clockvector.cc
index 6cd943b..14bb809 100644
--- a/clockvector.cc
+++ b/clockvector.cc
@@ -43,7 +43,7 @@ void ClockVector::merge(const ClockVector *cv)
 
 	if (cv->num_threads > num_threads) {
 		clock = (modelclock_t *)snapshot_realloc(clock, cv->num_threads * sizeof(modelclock_t));
-		for (int i= num_threads; i < cv->num_threads; i++)
+		for (int i = num_threads; i < cv->num_threads; i++)
 			clock[i] = 0;
 		num_threads = cv->num_threads;
 	}
diff --git a/common.cc b/common.cc
index e6c6cce..b71c00a 100644
--- a/common.cc
+++ b/common.cc
@@ -47,7 +47,7 @@ void model_print_summary(void)
 
 void assert_hook(void)
 {
-	model_print("Add breakpoint to line %u in file %s.\n",__LINE__,__FILE__);
+	model_print("Add breakpoint to line %u in file %s.\n", __LINE__, __FILE__);
 }
 
 void model_assert(bool expr, const char *file, int line)
diff --git a/cyclegraph.cc b/cyclegraph.cc
index 51066c9..2eaec36 100644
--- a/cyclegraph.cc
+++ b/cyclegraph.cc
@@ -155,12 +155,12 @@ void CycleGraph::dumpNodes(FILE *file)
 void CycleGraph::dumpGraphToFile(const char *filename)
 {
 	char buffer[200];
-	sprintf(buffer, "%s.dot",filename);
+	sprintf(buffer, "%s.dot", filename);
 	FILE *file = fopen(buffer, "w");
-	fprintf(file, "digraph %s {\n",filename);
+	fprintf(file, "digraph %s {\n", filename);
 	dumpNodes(file);
-	fprintf(file,"}\n");
-	fclose(file);	
+	fprintf(file, "}\n");
+	fclose(file);
 }
 #endif
 
@@ -189,7 +189,7 @@ bool CycleGraph::checkReachable(const ModelAction *from, const ModelAction *to)
  */
 bool CycleGraph::checkReachable(CycleNode *from, CycleNode *to)
 {
-	std::vector<CycleNode *, ModelAlloc<CycleNode *> > queue;
+	std::vector< CycleNode *, ModelAlloc<CycleNode *> > queue;
 	discovered->reset();
 
 	queue.push_back(from);
@@ -203,7 +203,7 @@ bool CycleGraph::checkReachable(CycleNode *from, CycleNode *to)
 		for (unsigned int i = 0; i < node->getNumEdges(); i++) {
 			CycleNode *next = node->getEdge(i);
 			if (!discovered->contains(next)) {
-				discovered->put(next,next);
+				discovered->put(next, next);
 				queue.push_back(next);
 			}
 		}
@@ -213,7 +213,7 @@ bool CycleGraph::checkReachable(CycleNode *from, CycleNode *to)
 
 bool CycleGraph::checkPromise(const ModelAction *fromact, Promise *promise)
 {
-	std::vector<CycleNode *, ModelAlloc<CycleNode *> > queue;
+	std::vector< CycleNode *, ModelAlloc<CycleNode *> > queue;
 	discovered->reset();
 	CycleNode *from = actionToNode.get(fromact);
 
@@ -230,7 +230,7 @@ bool CycleGraph::checkPromise(const ModelAction *fromact, Promise *promise)
 		for (unsigned int i = 0; i < node->getNumEdges(); i++) {
 			CycleNode *next = node->getEdge(i);
 			if (!discovered->contains(next)) {
-				discovered->put(next,next);
+				discovered->put(next, next);
 				queue.push_back(next);
 			}
 		}
diff --git a/librace.cc b/librace.cc
index 95b97aa..5e775f3 100644
--- a/librace.cc
+++ b/librace.cc
@@ -10,8 +10,8 @@
 void store_8(void *addr, uint8_t val)
 {
 	DEBUG("addr = %p, val = %" PRIu8 "\n", addr, val);
-	thread_id_t tid=thread_current()->get_id();
-	ClockVector * cv=model->get_cv(tid);
+	thread_id_t tid = thread_current()->get_id();
+	ClockVector *cv = model->get_cv(tid);
 	raceCheckWrite(tid, addr, cv);
 	(*(uint8_t *)addr) = val;
 }
@@ -19,46 +19,46 @@ void store_8(void *addr, uint8_t val)
 void store_16(void *addr, uint16_t val)
 {
 	DEBUG("addr = %p, val = %" PRIu16 "\n", addr, val);
-	thread_id_t tid=thread_current()->get_id();
-	ClockVector * cv=model->get_cv(tid);
+	thread_id_t tid = thread_current()->get_id();
+	ClockVector *cv = model->get_cv(tid);
 	raceCheckWrite(tid, addr, cv);
-	raceCheckWrite(tid, (void *)(((uintptr_t)addr)+1), cv);
+	raceCheckWrite(tid, (void *)(((uintptr_t)addr) + 1), cv);
 	(*(uint16_t *)addr) = val;
 }
 
 void store_32(void *addr, uint32_t val)
 {
 	DEBUG("addr = %p, val = %" PRIu32 "\n", addr, val);
-	thread_id_t tid=thread_current()->get_id();
-	ClockVector * cv=model->get_cv(tid);
+	thread_id_t tid = thread_current()->get_id();
+	ClockVector *cv = model->get_cv(tid);
 	raceCheckWrite(tid, addr, cv);
-	raceCheckWrite(tid, (void *)(((uintptr_t)addr)+1), cv);
-	raceCheckWrite(tid, (void *)(((uintptr_t)addr)+2), cv);
-	raceCheckWrite(tid, (void *)(((uintptr_t)addr)+3), cv);
+	raceCheckWrite(tid, (void *)(((uintptr_t)addr) + 1), cv);
+	raceCheckWrite(tid, (void *)(((uintptr_t)addr) + 2), cv);
+	raceCheckWrite(tid, (void *)(((uintptr_t)addr) + 3), cv);
 	(*(uint32_t *)addr) = val;
 }
 
 void store_64(void *addr, uint64_t val)
 {
 	DEBUG("addr = %p, val = %" PRIu64 "\n", addr, val);
-	thread_id_t tid=thread_current()->get_id();
-	ClockVector * cv=model->get_cv(tid);
+	thread_id_t tid = thread_current()->get_id();
+	ClockVector *cv = model->get_cv(tid);
 	raceCheckWrite(tid, addr, cv);
-	raceCheckWrite(tid, (void *)(((uintptr_t)addr)+1), cv);
-	raceCheckWrite(tid, (void *)(((uintptr_t)addr)+2), cv);
-	raceCheckWrite(tid, (void *)(((uintptr_t)addr)+3), cv);
-	raceCheckWrite(tid, (void *)(((uintptr_t)addr)+4), cv);
-	raceCheckWrite(tid, (void *)(((uintptr_t)addr)+5), cv);
-	raceCheckWrite(tid, (void *)(((uintptr_t)addr)+6), cv);
-	raceCheckWrite(tid, (void *)(((uintptr_t)addr)+7), cv);
+	raceCheckWrite(tid, (void *)(((uintptr_t)addr) + 1), cv);
+	raceCheckWrite(tid, (void *)(((uintptr_t)addr) + 2), cv);
+	raceCheckWrite(tid, (void *)(((uintptr_t)addr) + 3), cv);
+	raceCheckWrite(tid, (void *)(((uintptr_t)addr) + 4), cv);
+	raceCheckWrite(tid, (void *)(((uintptr_t)addr) + 5), cv);
+	raceCheckWrite(tid, (void *)(((uintptr_t)addr) + 6), cv);
+	raceCheckWrite(tid, (void *)(((uintptr_t)addr) + 7), cv);
 	(*(uint64_t *)addr) = val;
 }
 
 uint8_t load_8(const void *addr)
 {
 	DEBUG("addr = %p\n", addr);
-	thread_id_t tid=thread_current()->get_id();
-	ClockVector * cv=model->get_cv(tid);
+	thread_id_t tid = thread_current()->get_id();
+	ClockVector *cv = model->get_cv(tid);
 	raceCheckRead(tid, addr, cv);
 	return *((uint8_t *)addr);
 }
@@ -66,37 +66,37 @@ uint8_t load_8(const void *addr)
 uint16_t load_16(const void *addr)
 {
 	DEBUG("addr = %p\n", addr);
-	thread_id_t tid=thread_current()->get_id();
-	ClockVector * cv=model->get_cv(tid);
+	thread_id_t tid = thread_current()->get_id();
+	ClockVector *cv = model->get_cv(tid);
 	raceCheckRead(tid, addr, cv);
-	raceCheckRead(tid, (const void *)(((uintptr_t)addr)+1), cv);
+	raceCheckRead(tid, (const void *)(((uintptr_t)addr) + 1), cv);
 	return *((uint16_t *)addr);
 }
 
 uint32_t load_32(const void *addr)
 {
 	DEBUG("addr = %p\n", addr);
-	thread_id_t tid=thread_current()->get_id();
-	ClockVector * cv=model->get_cv(tid);
+	thread_id_t tid = thread_current()->get_id();
+	ClockVector *cv = model->get_cv(tid);
 	raceCheckRead(tid, addr, cv);
-	raceCheckRead(tid, (const void *)(((uintptr_t)addr)+1), cv);
-	raceCheckRead(tid, (const void *)(((uintptr_t)addr)+2), cv);
-	raceCheckRead(tid, (const void *)(((uintptr_t)addr)+3), cv);
+	raceCheckRead(tid, (const void *)(((uintptr_t)addr) + 1), cv);
+	raceCheckRead(tid, (const void *)(((uintptr_t)addr) + 2), cv);
+	raceCheckRead(tid, (const void *)(((uintptr_t)addr) + 3), cv);
 	return *((uint32_t *)addr);
 }
 
 uint64_t load_64(const void *addr)
 {
 	DEBUG("addr = %p\n", addr);
-	thread_id_t tid=thread_current()->get_id();
-	ClockVector * cv=model->get_cv(tid);
+	thread_id_t tid = thread_current()->get_id();
+	ClockVector *cv = model->get_cv(tid);
 	raceCheckRead(tid, addr, cv);
-	raceCheckRead(tid, (const void *)(((uintptr_t)addr)+1), cv);
-	raceCheckRead(tid, (const void *)(((uintptr_t)addr)+2), cv);
-	raceCheckRead(tid, (const void *)(((uintptr_t)addr)+3), cv);
-	raceCheckRead(tid, (const void *)(((uintptr_t)addr)+4), cv);
-	raceCheckRead(tid, (const void *)(((uintptr_t)addr)+5), cv);
-	raceCheckRead(tid, (const void *)(((uintptr_t)addr)+6), cv);
-	raceCheckRead(tid, (const void *)(((uintptr_t)addr)+7), cv);
+	raceCheckRead(tid, (const void *)(((uintptr_t)addr) + 1), cv);
+	raceCheckRead(tid, (const void *)(((uintptr_t)addr) + 2), cv);
+	raceCheckRead(tid, (const void *)(((uintptr_t)addr) + 3), cv);
+	raceCheckRead(tid, (const void *)(((uintptr_t)addr) + 4), cv);
+	raceCheckRead(tid, (const void *)(((uintptr_t)addr) + 5), cv);
+	raceCheckRead(tid, (const void *)(((uintptr_t)addr) + 6), cv);
+	raceCheckRead(tid, (const void *)(((uintptr_t)addr) + 7), cv);
 	return *((uint64_t *)addr);
 }
diff --git a/mymemory.cc b/mymemory.cc
index e05cb78..a15a13d 100644
--- a/mymemory.cc
+++ b/mymemory.cc
@@ -12,7 +12,7 @@
 
 #define REQUESTS_BEFORE_ALLOC 1024
 
-size_t allocatedReqs[ REQUESTS_BEFORE_ALLOC ] = { 0 };
+size_t allocatedReqs[REQUESTS_BEFORE_ALLOC] = { 0 };
 int nextRequest = 0;
 int howManyFreed = 0;
 #if !USE_MPROTECT_SNAPSHOT
@@ -38,11 +38,10 @@ void *model_calloc(size_t count, size_t size)
 	ptr = callocp(count, size);
 	return ptr;
 #else
-	if (!snapshotrecord) {
+	if (!snapshotrecord)
 		createSharedMemory();
-	}
-	if (NULL == sStaticSpace)
-		sStaticSpace = create_mspace_with_base(( void *)( snapshotrecord->mSharedMemoryBase), SHARED_MEMORY_DEFAULT -sizeof(struct SnapShot), 1);
+	if (!sStaticSpace)
+		sStaticSpace = create_mspace_with_base((void *)(snapshotrecord->mSharedMemoryBase), SHARED_MEMORY_DEFAULT - sizeof(struct SnapShot), 1);
 	return mspace_calloc(sStaticSpace, count, size);
 #endif
 }
@@ -66,11 +65,10 @@ void *model_malloc(size_t size)
 	ptr = mallocp(size);
 	return ptr;
 #else
-	if (!snapshotrecord) {
+	if (!snapshotrecord)
 		createSharedMemory();
-	}
-	if (NULL == sStaticSpace)
-		sStaticSpace = create_mspace_with_base(( void *)( snapshotrecord->mSharedMemoryBase), SHARED_MEMORY_DEFAULT -sizeof(struct SnapShot), 1);
+	if (!sStaticSpace)
+		sStaticSpace = create_mspace_with_base((void *)(snapshotrecord->mSharedMemoryBase), SHARED_MEMORY_DEFAULT - sizeof(struct SnapShot), 1);
 	return mspace_malloc(sStaticSpace, size);
 #endif
 }
@@ -114,7 +112,7 @@ void model_free(void *ptr)
 
 	/* get address of libc free */
 	if (!freep) {
-		freep = ( void  ( * )( void *))dlsym(RTLD_NEXT, "free");
+		freep = (void (*)(void *))dlsym(RTLD_NEXT, "free");
 		if ((error = dlerror()) != NULL) {
 			fputs(error, stderr);
 			exit(EXIT_FAILURE);
@@ -126,9 +124,8 @@ void model_free(void *ptr)
 #endif
 }
 
-/** Bootstrap allocation.  Problem is that the dynamic linker calls
- *  require calloc to work and calloc requires the dynamic linker to
- *	work.  */
+/** Bootstrap allocation. Problem is that the dynamic linker calls require
+ *  calloc to work and calloc requires the dynamic linker to work. */
 
 #define BOOTSTRAPBYTES 4096
 char bootstrapmemory[BOOTSTRAPBYTES];
@@ -144,7 +141,7 @@ void * HandleEarlyAllocationRequest(size_t sz)
 		exit(EXIT_FAILURE);
 	}
 
-	void *pointer= (void *)&bootstrapmemory[offset];
+	void *pointer = (void *)&bootstrapmemory[offset];
 	offset += sz;
 	return pointer;
 }
diff --git a/snapshot-interface.cc b/snapshot-interface.cc
index c8afa8f..974e436 100644
--- a/snapshot-interface.cc
+++ b/snapshot-interface.cc
@@ -20,13 +20,14 @@ SnapshotStack * snapshotObject;
  *	that may contain globals and then configures the snapshotting
  *	library to snapshot them.
  */
-static void SnapshotGlobalSegments(){
+static void SnapshotGlobalSegments()
+{
 	int pid = getpid();
 	char buf[9000], execname[100];
 	FILE *map;
 
 	sprintf(execname, "vmmap -interleaved %d", pid);
-	map=popen(execname, "r");
+	map = popen(execname, "r");
 
 	if (!map) {
 		perror("popen");
@@ -49,7 +50,7 @@ static void SnapshotGlobalSegments(){
 		void *begin, *end;
 
 		//Skip out at the end of the section
-		if (buf[0]=='\n')
+		if (buf[0] == '\n')
 			break;
 
 		sscanf(buf, "%22s %p-%p [%5dK] %c%c%c/%c%c%c SM=%3s %200s\n", type, &begin, &end, &size, &r, &w, &x, &mr, &mw, &mx, smstr, regionname);
@@ -76,7 +77,8 @@ static void get_binary_name(char *buf, size_t len)
  *	that may contain globals and then configures the snapshotting
  *	library to snapshot them.
  */
-static void SnapshotGlobalSegments(){
+static void SnapshotGlobalSegments()
+{
 	char buf[9000];
 	char binary_name[800];
 	FILE *map;
@@ -104,12 +106,14 @@ static void SnapshotGlobalSegments(){
 }
 #endif
 
-SnapshotStack::SnapshotStack(){
+SnapshotStack::SnapshotStack()
+{
 	SnapshotGlobalSegments();
-	stack=NULL;
+	stack = NULL;
 }
 
-SnapshotStack::~SnapshotStack(){
+SnapshotStack::~SnapshotStack()
+{
 }
 
 
@@ -119,24 +123,26 @@ SnapshotStack::~SnapshotStack(){
  * @param seqindex is the sequence number to rollback before.
  * @return is the sequence number we actually rolled back to.
  */
-int SnapshotStack::backTrackBeforeStep(int seqindex) {
-	while(true) {
-		if (stack->index<=seqindex) {
+int SnapshotStack::backTrackBeforeStep(int seqindex)
+{
+	while (true) {
+		if (stack->index <= seqindex) {
 			//have right entry
 			rollBack(stack->snapshotid);
 			return stack->index;
 		}
-		struct stackEntry *tmp=stack;
-		stack=stack->next;
+		struct stackEntry *tmp = stack;
+		stack = stack->next;
 		model_free(tmp);
 	}
 }
 
 /** This method takes a snapshot at the given sequence number. */
-void SnapshotStack::snapshotStep(int seqindex) {
-	struct stackEntry *tmp=(struct stackEntry *)model_malloc(sizeof(struct stackEntry));
-	tmp->next=stack;
-	tmp->index=seqindex;
-	tmp->snapshotid=takeSnapshot();
-	stack=tmp;
+void SnapshotStack::snapshotStep(int seqindex)
+{
+	struct stackEntry *tmp = (struct stackEntry *)model_malloc(sizeof(struct stackEntry));
+	tmp->next = stack;
+	tmp->index = seqindex;
+	tmp->snapshotid = takeSnapshot();
+	stack = tmp;
 }
diff --git a/snapshot-interface.h b/snapshot-interface.h
index c0db0d0..ecc60ec 100644
--- a/snapshot-interface.h
+++ b/snapshot-interface.h
@@ -15,25 +15,25 @@ void initSnapshotLibrary(unsigned int numbackingpages,
 		unsigned int numheappages, VoidFuncPtr entryPoint);
 
 struct stackEntry {
-  struct stackEntry *next;
-  snapshot_id snapshotid;
-  int index;
+	struct stackEntry *next;
+	snapshot_id snapshotid;
+	int index;
 };
 
 class SnapshotStack {
  public:
-  MEMALLOC
-  SnapshotStack( );
-  ~SnapshotStack();
-  int backTrackBeforeStep(int seq_index);
-  void snapshotStep(int seq_index);
+	SnapshotStack();
+	~SnapshotStack();
+	int backTrackBeforeStep(int seq_index);
+	void snapshotStep(int seq_index);
 
+	MEMALLOC
  private:
-  struct stackEntry * stack;
+	struct stackEntry *stack;
 };
 
 /* Not sure what it even means to have more than one snapshot object,
    so let's just make a global reference to it.*/
 
-extern SnapshotStack * snapshotObject;
+extern SnapshotStack *snapshotObject;
 #endif
diff --git a/snapshot.cc b/snapshot.cc
index 8bc685c..5ac9b46 100644
--- a/snapshot.cc
+++ b/snapshot.cc
@@ -14,7 +14,7 @@
 #include "mymemory.h"
 #include "common.h"
 
-#define FAILURE(mesg) { model_print("failed in the API: %s with errno relative message: %s\n", mesg, strerror( errno ) ); exit(EXIT_FAILURE); }
+#define FAILURE(mesg) { model_print("failed in the API: %s with errno relative message: %s\n", mesg, strerror(errno)); exit(EXIT_FAILURE); }
 
 #ifdef CONFIG_SSDEBUG
 #define SSDEBUG		model_print
@@ -23,13 +23,14 @@
 #endif
 
 /* extern declaration definition */
-struct SnapShot * snapshotrecord = NULL;
+struct SnapShot *snapshotrecord = NULL;
 
 /** PageAlignedAdressUpdate return a page aligned address for the
  * address being added as a side effect the numBytes are also changed.
  */
-static void * PageAlignAddressUpward(void * addr) {
-	return (void *)((((uintptr_t)addr)+PAGESIZE-1)&~(PAGESIZE-1));
+static void * PageAlignAddressUpward(void *addr)
+{
+	return (void *)((((uintptr_t)addr) + PAGESIZE - 1) & ~(PAGESIZE - 1));
 }
 
 #if !USE_MPROTECT_SNAPSHOT
@@ -53,54 +54,57 @@ static snapshot_id snapshotid = 0;
 /** ReturnPageAlignedAddress returns a page aligned address for the
  * address being added as a side effect the numBytes are also changed.
  */
-static void * ReturnPageAlignedAddress(void * addr) {
-	return (void *)(((uintptr_t)addr)&~(PAGESIZE-1));
+static void * ReturnPageAlignedAddress(void *addr)
+{
+	return (void *)(((uintptr_t)addr) & ~(PAGESIZE - 1));
 }
 
 /** The initSnapShotRecord method initialized the snapshotting data
  *  structures for the mprotect based snapshot.
  */
-static void initSnapShotRecord(unsigned int numbackingpages, unsigned int numsnapshots, unsigned int nummemoryregions) {
-	snapshotrecord=( struct SnapShot * )model_malloc(sizeof(struct SnapShot));
-	snapshotrecord->regionsToSnapShot=( struct MemoryRegion * )model_malloc(sizeof(struct MemoryRegion)*nummemoryregions);
-	snapshotrecord->backingStoreBasePtr= ( struct SnapShotPage * )model_malloc( sizeof( struct SnapShotPage ) * (numbackingpages + 1) );
+static void initSnapShotRecord(unsigned int numbackingpages, unsigned int numsnapshots, unsigned int nummemoryregions)
+{
+	snapshotrecord = (struct SnapShot *)model_malloc(sizeof(struct SnapShot));
+	snapshotrecord->regionsToSnapShot = (struct MemoryRegion *)model_malloc(sizeof(struct MemoryRegion) * nummemoryregions);
+	snapshotrecord->backingStoreBasePtr = (struct SnapShotPage *)model_malloc(sizeof(struct SnapShotPage) * (numbackingpages + 1));
 	//Page align the backingstorepages
-	snapshotrecord->backingStore=( struct SnapShotPage * )PageAlignAddressUpward(snapshotrecord->backingStoreBasePtr);
-	snapshotrecord->backingRecords=( struct BackingPageRecord * )model_malloc(sizeof(struct BackingPageRecord)*numbackingpages);
-	snapshotrecord->snapShots= ( struct SnapShotRecord * )model_malloc(sizeof(struct SnapShotRecord)*numsnapshots);
-	snapshotrecord->lastSnapShot=0;
-	snapshotrecord->lastBackingPage=0;
-	snapshotrecord->lastRegion=0;
-	snapshotrecord->maxRegions=nummemoryregions;
-	snapshotrecord->maxBackingPages=numbackingpages;
-	snapshotrecord->maxSnapShots=numsnapshots;
+	snapshotrecord->backingStore = (struct SnapShotPage *)PageAlignAddressUpward(snapshotrecord->backingStoreBasePtr);
+	snapshotrecord->backingRecords = (struct BackingPageRecord *)model_malloc(sizeof(struct BackingPageRecord) * numbackingpages);
+	snapshotrecord->snapShots = (struct SnapShotRecord *)model_malloc(sizeof(struct SnapShotRecord) * numsnapshots);
+	snapshotrecord->lastSnapShot = 0;
+	snapshotrecord->lastBackingPage = 0;
+	snapshotrecord->lastRegion = 0;
+	snapshotrecord->maxRegions = nummemoryregions;
+	snapshotrecord->maxBackingPages = numbackingpages;
+	snapshotrecord->maxSnapShots = numsnapshots;
 }
 
 /** HandlePF is the page fault handler for mprotect based snapshotting
  * algorithm.
  */
-static void HandlePF( int sig, siginfo_t *si, void * unused){
-	if( si->si_code == SEGV_MAPERR ){
+static void HandlePF(int sig, siginfo_t *si, void *unused)
+{
+	if (si->si_code == SEGV_MAPERR) {
 		model_print("Real Fault at %p\n", si->si_addr);
 		print_trace();
 		model_print("For debugging, place breakpoint at: %s:%d\n",
 				__FILE__, __LINE__);
-		exit( EXIT_FAILURE );
+		exit(EXIT_FAILURE);
 	}
 	void* addr = ReturnPageAlignedAddress(si->si_addr);
 
-	unsigned int backingpage=snapshotrecord->lastBackingPage++; //Could run out of pages...
-	if (backingpage==snapshotrecord->maxBackingPages) {
+	unsigned int backingpage = snapshotrecord->lastBackingPage++; //Could run out of pages...
+	if (backingpage == snapshotrecord->maxBackingPages) {
 		model_print("Out of backing pages at %p\n", si->si_addr);
-		exit( EXIT_FAILURE );
+		exit(EXIT_FAILURE);
 	}
 
 	//copy page
 	memcpy(&(snapshotrecord->backingStore[backingpage]), addr, sizeof(struct SnapShotPage));
 	//remember where to copy page back to
-	snapshotrecord->backingRecords[backingpage].basePtrOfPage=addr;
+	snapshotrecord->backingRecords[backingpage].basePtrOfPage = addr;
 	//set protection to read/write
-	if (mprotect( addr, sizeof(struct SnapShotPage), PROT_READ | PROT_WRITE )) {
+	if (mprotect(addr, sizeof(struct SnapShotPage), PROT_READ | PROT_WRITE)) {
 		perror("mprotect");
 		// Handle error by quitting?
 	}
@@ -108,14 +112,15 @@ static void HandlePF( int sig, siginfo_t *si, void * unused){
 #endif /* USE_MPROTECT_SNAPSHOT */
 
 #if !USE_MPROTECT_SNAPSHOT
-void createSharedMemory(){
+void createSharedMemory()
+{
 	//step 1. create shared memory.
-	void * memMapBase = mmap( 0, SHARED_MEMORY_DEFAULT + STACK_SIZE_DEFAULT, PROT_READ | PROT_WRITE, MAP_SHARED|MAP_ANON, -1, 0 );
-	if( MAP_FAILED == memMapBase )
+	void *memMapBase = mmap(0, SHARED_MEMORY_DEFAULT + STACK_SIZE_DEFAULT, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
+	if (MAP_FAILED == memMapBase)
 		FAILURE("mmap");
 
 	//Setup snapshot record at top of free region
-	snapshotrecord = ( struct SnapShot * )memMapBase;
+	snapshotrecord = (struct SnapShot *)memMapBase;
 	snapshotrecord->mSharedMemoryBase = (void *)((uintptr_t)memMapBase + sizeof(struct SnapShot));
 	snapshotrecord->mStackBase = (void *)((uintptr_t)memMapBase + SHARED_MEMORY_DEFAULT);
 	snapshotrecord->mStackSize = STACK_SIZE_DEFAULT;
@@ -132,25 +137,26 @@ void createSharedMemory(){
 
 void initSnapshotLibrary(unsigned int numbackingpages,
 		unsigned int numsnapshots, unsigned int nummemoryregions,
-		unsigned int numheappages, VoidFuncPtr entryPoint) {
+		unsigned int numheappages, VoidFuncPtr entryPoint)
+{
 	/* Setup a stack for our signal handler....  */
 	stack_t ss;
-	ss.ss_sp = PageAlignAddressUpward(model_malloc(SIGSTACKSIZE+PAGESIZE-1));
+	ss.ss_sp = PageAlignAddressUpward(model_malloc(SIGSTACKSIZE + PAGESIZE - 1));
 	ss.ss_size = SIGSTACKSIZE;
 	ss.ss_flags = 0;
 	sigaltstack(&ss, NULL);
 
 	struct sigaction sa;
 	sa.sa_flags = SA_SIGINFO | SA_NODEFER | SA_RESTART | SA_ONSTACK;
-	sigemptyset( &sa.sa_mask );
+	sigemptyset(&sa.sa_mask);
 	sa.sa_sigaction = HandlePF;
 #ifdef MAC
-	if( sigaction( SIGBUS, &sa, NULL ) == -1 ){
+	if (sigaction(SIGBUS, &sa, NULL) == -1) {
 		model_print("SIGACTION CANNOT BE INSTALLED\n");
 		exit(EXIT_FAILURE);
 	}
 #endif
-	if( sigaction( SIGSEGV, &sa, NULL ) == -1 ){
+	if (sigaction(SIGSEGV, &sa, NULL) == -1) {
 		model_print("SIGACTION CANNOT BE INSTALLED\n");
 		exit(EXIT_FAILURE);
 	}
@@ -163,12 +169,12 @@ void initSnapshotLibrary(unsigned int numbackingpages,
 
 	siginfo_t si;
 	memset(&si, 0, sizeof(si));
-	si.si_addr=ss.ss_sp;
+	si.si_addr = ss.ss_sp;
 	HandlePF(SIGSEGV, &si, NULL);
 	snapshotrecord->lastBackingPage--; //remove the fake page we copied
 
-	void *basemySpace = model_malloc((numheappages+1)*PAGESIZE);
-	void * pagealignedbase=PageAlignAddressUpward(basemySpace);
+	void *basemySpace = model_malloc((numheappages + 1) * PAGESIZE);
+	void *pagealignedbase = PageAlignAddressUpward(basemySpace);
 	user_snapshot_space = create_mspace_with_base(pagealignedbase, numheappages * PAGESIZE, 1);
 	addMemoryRegionToSnapShot(pagealignedbase, numheappages);
 
@@ -182,7 +188,8 @@ void initSnapshotLibrary(unsigned int numbackingpages,
 #else
 void initSnapshotLibrary(unsigned int numbackingpages,
 		unsigned int numsnapshots, unsigned int nummemoryregions,
-		unsigned int numheappages, VoidFuncPtr entryPoint) {
+		unsigned int numheappages, VoidFuncPtr entryPoint)
+{
 	if (!snapshotrecord)
 		createSharedMemory();
 
@@ -192,10 +199,10 @@ void initSnapshotLibrary(unsigned int numbackingpages,
 
 	//step 2 setup the stack context.
 	ucontext_t newContext;
-	getcontext( &newContext );
+	getcontext(&newContext);
 	newContext.uc_stack.ss_sp = snapshotrecord->mStackBase;
 	newContext.uc_stack.ss_size = STACK_SIZE_DEFAULT;
-	makecontext( &newContext, entryPoint, 0 );
+	makecontext(&newContext, entryPoint, 0);
 	/* switch to a new entryPoint context, on a new stack */
 	swapcontext(&savedSnapshotContext, &newContext);
 
@@ -206,32 +213,32 @@ void initSnapshotLibrary(unsigned int numbackingpages,
 		 as the id to which the rollback needs to occur */
 
 	bool rollback = false;
-	while( true ){
-		snapshotrecord->currSnapShotID=snapshotid+1;
+	while (true) {
+		snapshotrecord->currSnapShotID = snapshotid + 1;
 		forkedID = fork();
 
-		if( 0 == forkedID ){
+		if (0 == forkedID) {
 			/* If the rollback bool is set, switch to the context we need to
 				 return to during a rollback. */
-			if( rollback) {
-				setcontext( &( snapshotrecord->mContextToRollback ) );
+			if (rollback) {
+				setcontext(&(snapshotrecord->mContextToRollback));
 			} else {
 				/*Child process which is forked as a result of takesnapshot
 					call should switch back to the takesnapshot context*/
-				setcontext( &savedUserSnapshotContext );
+				setcontext(&savedUserSnapshotContext);
 			}
 		} else {
 			int status;
 			int retVal;
 
 			SSDEBUG("The process id of child is %d and the process id of this process is %d and snapshot id is %d\n",
-			        forkedID, getpid(), snapshotid );
+			        forkedID, getpid(), snapshotid);
 
 			do {
-				retVal=waitpid( forkedID, &status, 0 );
-			} while( -1 == retVal && errno == EINTR );
+				retVal = waitpid(forkedID, &status, 0);
+			} while (-1 == retVal && errno == EINTR);
 
-			if( snapshotrecord->mIDToRollback != snapshotid ) {
+			if (snapshotrecord->mIDToRollback != snapshotid) {
 				exit(EXIT_SUCCESS);
 			}
 			rollback = true;
@@ -242,41 +249,43 @@ void initSnapshotLibrary(unsigned int numbackingpages,
 
 /** The addMemoryRegionToSnapShot function assumes that addr is page aligned.
  */
-void addMemoryRegionToSnapShot( void * addr, unsigned int numPages) {
+void addMemoryRegionToSnapShot(void *addr, unsigned int numPages)
+{
 #if USE_MPROTECT_SNAPSHOT
-	unsigned int memoryregion=snapshotrecord->lastRegion++;
-	if (memoryregion==snapshotrecord->maxRegions) {
+	unsigned int memoryregion = snapshotrecord->lastRegion++;
+	if (memoryregion == snapshotrecord->maxRegions) {
 		model_print("Exceeded supported number of memory regions!\n");
 		exit(EXIT_FAILURE);
 	}
 
-	snapshotrecord->regionsToSnapShot[ memoryregion ].basePtr=addr;
-	snapshotrecord->regionsToSnapShot[ memoryregion ].sizeInPages=numPages;
+	snapshotrecord->regionsToSnapShot[memoryregion].basePtr = addr;
+	snapshotrecord->regionsToSnapShot[memoryregion].sizeInPages = numPages;
 #endif //NOT REQUIRED IN THE CASE OF FORK BASED SNAPSHOTS.
 }
 
 /** The takeSnapshot function takes a snapshot.
  * @return The snapshot identifier.
  */
-snapshot_id takeSnapshot( ){
+snapshot_id takeSnapshot()
+{
 #if USE_MPROTECT_SNAPSHOT
-	for(unsigned int region=0; region<snapshotrecord->lastRegion;region++) {
-		if( mprotect(snapshotrecord->regionsToSnapShot[region].basePtr, snapshotrecord->regionsToSnapShot[region].sizeInPages*sizeof(struct SnapShotPage), PROT_READ ) == -1 ){
+	for (unsigned int region = 0; region < snapshotrecord->lastRegion; region++) {
+		if (mprotect(snapshotrecord->regionsToSnapShot[region].basePtr, snapshotrecord->regionsToSnapShot[region].sizeInPages * sizeof(struct SnapShotPage), PROT_READ) == -1) {
 			perror("mprotect");
 			model_print("Failed to mprotect inside of takeSnapShot\n");
 			exit(EXIT_FAILURE);
 		}
 	}
-	unsigned int snapshot=snapshotrecord->lastSnapShot++;
-	if (snapshot==snapshotrecord->maxSnapShots) {
+	unsigned int snapshot = snapshotrecord->lastSnapShot++;
+	if (snapshot == snapshotrecord->maxSnapShots) {
 		model_print("Out of snapshots\n");
 		exit(EXIT_FAILURE);
 	}
-	snapshotrecord->snapShots[snapshot].firstBackingPage=snapshotrecord->lastBackingPage;
+	snapshotrecord->snapShots[snapshot].firstBackingPage = snapshotrecord->lastBackingPage;
 
 	return snapshot;
 #else
-	swapcontext( &savedUserSnapshotContext, &savedSnapshotContext );
+	swapcontext(&savedUserSnapshotContext, &savedSnapshotContext);
 	SSDEBUG("TAKESNAPSHOT RETURN\n");
 	return snapshotid;
 #endif
@@ -285,10 +294,11 @@ snapshot_id takeSnapshot( ){
 /** The rollBack function rollback to the given snapshot identifier.
  *  @param theID is the snapshot identifier to rollback to.
  */
-void rollBack( snapshot_id theID ){
-#if USE_MPROTECT_SNAPSHOT==2
-	if (snapshotrecord->lastSnapShot==(theID+1)) {
-		for(unsigned int page=snapshotrecord->snapShots[theID].firstBackingPage; page<snapshotrecord->lastBackingPage; page++) {
+void rollBack(snapshot_id theID)
+{
+#if USE_MPROTECT_SNAPSHOT == 2
+	if (snapshotrecord->lastSnapShot == (theID + 1)) {
+		for (unsigned int page = snapshotrecord->snapShots[theID].firstBackingPage; page < snapshotrecord->lastBackingPage; page++) {
 			memcpy(snapshotrecord->backingRecords[page].basePtrOfPage, &snapshotrecord->backingStore[page], sizeof(struct SnapShotPage));
 		}
 		return;
@@ -297,42 +307,40 @@ void rollBack( snapshot_id theID ){
 
 #if USE_MPROTECT_SNAPSHOT
 	HashTable< void *, bool, uintptr_t, 4, model_malloc, model_calloc, model_free> duplicateMap;
-	for(unsigned int region=0; region<snapshotrecord->lastRegion;region++) {
-		if( mprotect(snapshotrecord->regionsToSnapShot[region].basePtr, snapshotrecord->regionsToSnapShot[region].sizeInPages*sizeof(struct SnapShotPage), PROT_READ | PROT_WRITE ) == -1 ){
+	for (unsigned int region = 0; region < snapshotrecord->lastRegion; region++) {
+		if (mprotect(snapshotrecord->regionsToSnapShot[region].basePtr, snapshotrecord->regionsToSnapShot[region].sizeInPages * sizeof(struct SnapShotPage), PROT_READ | PROT_WRITE) == -1) {
 			perror("mprotect");
 			model_print("Failed to mprotect inside of takeSnapShot\n");
 			exit(EXIT_FAILURE);
 		}
 	}
-	for(unsigned int page=snapshotrecord->snapShots[theID].firstBackingPage; page<snapshotrecord->lastBackingPage; page++) {
-		if( !duplicateMap.contains(snapshotrecord->backingRecords[page].basePtrOfPage )) {
+	for (unsigned int page = snapshotrecord->snapShots[theID].firstBackingPage; page < snapshotrecord->lastBackingPage; page++) {
+		if (!duplicateMap.contains(snapshotrecord->backingRecords[page].basePtrOfPage)) {
 			duplicateMap.put(snapshotrecord->backingRecords[page].basePtrOfPage, true);
 			memcpy(snapshotrecord->backingRecords[page].basePtrOfPage, &snapshotrecord->backingStore[page], sizeof(struct SnapShotPage));
 		}
 	}
-	snapshotrecord->lastSnapShot=theID;
-	snapshotrecord->lastBackingPage=snapshotrecord->snapShots[theID].firstBackingPage;
+	snapshotrecord->lastSnapShot = theID;
+	snapshotrecord->lastBackingPage = snapshotrecord->snapShots[theID].firstBackingPage;
 	takeSnapshot(); //Make sure current snapshot is still good...All later ones are cleared
 #else
 	snapshotrecord->mIDToRollback = theID;
 	volatile int sTemp = 0;
-	getcontext( &snapshotrecord->mContextToRollback );
+	getcontext(&snapshotrecord->mContextToRollback);
 	/*
 	 * This is used to quit the process on rollback, so that the process
 	 * which needs to rollback can quit allowing the process whose
 	 * snapshotid matches the rollbackid to switch to this context and
 	 * continue....
 	 */
-	if( !sTemp ){
+	if (!sTemp) {
 		sTemp = 1;
 		SSDEBUG("Invoked rollback\n");
 		exit(EXIT_SUCCESS);
 	}
 	/*
 	 * This fix obviates the need for a finalize call. hence less dependences for model-checker....
-	 *
 	 */
 	snapshotrecord->mIDToRollback = -1;
 #endif
 }
-
diff --git a/snapshot.h b/snapshot.h
index f899592..76d63ac 100644
--- a/snapshot.h
+++ b/snapshot.h
@@ -8,9 +8,9 @@
 #include "snapshot-interface.h"
 #include "config.h"
 
-void addMemoryRegionToSnapShot( void * ptr, unsigned int numPages );
-snapshot_id takeSnapshot( );
-void rollBack( snapshot_id theSnapShot );
+void addMemoryRegionToSnapShot(void *ptr, unsigned int numPages);
+snapshot_id takeSnapshot();
+void rollBack(snapshot_id theSnapShot);
 
 #if !USE_MPROTECT_SNAPSHOT
 void createSharedMemory();
diff --git a/snapshotimp.h b/snapshotimp.h
index 0560203..fbff35f 100644
--- a/snapshotimp.h
+++ b/snapshotimp.h
@@ -25,22 +25,22 @@ struct SnapShotPage {
 
 //List the base address of the corresponding page in the backing store so we know where to copy it to
 struct BackingPageRecord {
-	void * basePtrOfPage;
+	void *basePtrOfPage;
 };
 
 //Stuct for each memory region
 struct MemoryRegion {
-	void * basePtr; //base of memory region
+	void *basePtr; //base of memory region
 	int sizeInPages; //size of memory region in pages
 };
 
 //Primary struct for snapshotting system....
 struct SnapShot {
-	struct MemoryRegion * regionsToSnapShot; //This pointer references an array of memory regions to snapshot
-	struct SnapShotPage * backingStore; //This pointer references an array of snapshotpage's that form the backing store
-	void * backingStoreBasePtr; //This pointer references an array of snapshotpage's that form the backing store
-	struct BackingPageRecord * backingRecords; //This pointer references an array of backingpagerecord's (same number of elements as backingstore
-	struct SnapShotRecord * snapShots; //This pointer references the snapshot array
+	struct MemoryRegion *regionsToSnapShot; //This pointer references an array of memory regions to snapshot
+	struct SnapShotPage *backingStore; //This pointer references an array of snapshotpage's that form the backing store
+	void *backingStoreBasePtr; //This pointer references an array of snapshotpage's that form the backing store
+	struct BackingPageRecord *backingRecords; //This pointer references an array of backingpagerecord's (same number of elements as backingstore
+	struct SnapShotRecord *snapShots; //This pointer references the snapshot array
 
 	unsigned int lastSnapShot; //Stores the next snapshot record we should use
 	unsigned int lastBackingPage; //Stores the next backingpage we should use
@@ -66,6 +66,6 @@ struct SnapShot {
 #endif
 
 //Global reference to snapshot data structure
-extern struct SnapShot * snapshotrecord;
+extern struct SnapShot *snapshotrecord;
 
 #endif /* __SNAPSHOTIMP_H__ */