From: Brian Demsky Date: Mon, 21 May 2012 05:54:13 +0000 (-0700) Subject: switch back to norris style spacing in changed files X-Git-Tag: pldi2013~422 X-Git-Url: http://plrg.eecs.uci.edu/git/?p=model-checker.git;a=commitdiff_plain;h=544dab66fd213c49e18e276748b3352b1063cc52 switch back to norris style spacing in changed files --- diff --git a/main.cc b/main.cc index e49acfc..967fd39 100644 --- a/main.cc +++ b/main.cc @@ -1,3 +1,5 @@ +/* -*- Mode: C; indent-tabs-mode: t -*- */ + #include "libthreads.h" #include "common.h" #include "threads.h" @@ -11,59 +13,59 @@ * Return 1 if found next thread, 0 otherwise */ static int thread_system_next(void) { - Thread *curr, *next; + Thread *curr, *next; - curr = thread_current(); - if (curr) { - if (curr->get_state() == THREAD_READY) { - model->check_current_action(); - model->scheduler->add_thread(curr); - } else if (curr->get_state() == THREAD_RUNNING) - /* Stopped while running; i.e., completed */ - curr->complete(); - else - ASSERT(false); - } - next = model->scheduler->next_thread(); - if (next) - next->set_state(THREAD_RUNNING); - DEBUG("(%d, %d)\n", curr ? curr->get_id() : -1, next ? next->get_id() : -1); - if (!next) - return 1; - return Thread::swap(model->get_system_context(), next); + curr = thread_current(); + if (curr) { + if (curr->get_state() == THREAD_READY) { + model->check_current_action(); + model->scheduler->add_thread(curr); + } else if (curr->get_state() == THREAD_RUNNING) + /* Stopped while running; i.e., completed */ + curr->complete(); + else + ASSERT(false); + } + next = model->scheduler->next_thread(); + if (next) + next->set_state(THREAD_RUNNING); + DEBUG("(%d, %d)\n", curr ? curr->get_id() : -1, next ? next->get_id() : -1); + if (!next) + return 1; + return Thread::swap(model->get_system_context(), next); } static void thread_wait_finish(void) { - DBG(); + DBG(); - while (!thread_system_next()); + while (!thread_system_next()); } void real_main() { - thrd_t user_thread; - ucontext_t main_context; + thrd_t user_thread; + ucontext_t main_context; - //Create the singleton snapshotStack object - snapshotObject = new snapshotStack(); + //Create the singleton snapshotStack object + snapshotObject = new snapshotStack(); - model = new ModelChecker(); + model = new ModelChecker(); - if (getcontext(&main_context)) - return; + if (getcontext(&main_context)) + return; - model->set_system_context(&main_context); + model->set_system_context(&main_context); - do { - /* Start user program */ - model->add_thread(new Thread(&user_thread, &user_main, NULL)); + do { + /* Start user program */ + model->add_thread(new Thread(&user_thread, &user_main, NULL)); - /* Wait for all threads to complete */ - thread_wait_finish(); - } while (model->next_execution()); + /* Wait for all threads to complete */ + thread_wait_finish(); + } while (model->next_execution()); - delete model; + delete model; - DEBUG("Exiting\n"); + DEBUG("Exiting\n"); } int main_numargs; @@ -73,10 +75,10 @@ char ** main_args; * Main system function */ int main(int numargs, char ** args) { - /* Stash this stuff in case someone wants it eventually */ - main_numargs=numargs; - main_args=args; + /* Stash this stuff in case someone wants it eventually */ + main_numargs=numargs; + main_args=args; - /* Let's jump in quickly and start running stuff */ - initSnapShotLibrary(10000 /*int numbackingpages*/, 1024 /*unsigned int numsnapshots*/, 1024 /*unsigned int nummemoryregions*/ , 1000 /*int numheappages*/, &real_main /*MyFuncPtr entryPoint*/); + /* Let's jump in quickly and start running stuff */ + initSnapShotLibrary(10000 /*int numbackingpages*/, 1024 /*unsigned int numsnapshots*/, 1024 /*unsigned int nummemoryregions*/ , 1000 /*int numheappages*/, &real_main /*MyFuncPtr entryPoint*/); } diff --git a/mymemory.cc b/mymemory.cc index 1af6109..878e6de 100644 --- a/mymemory.cc +++ b/mymemory.cc @@ -1,3 +1,4 @@ +/* -*- Mode: C; indent-tabs-mode: t -*- */ #include "mymemory.h" #include "snapshot.h" #include "snapshotimp.h" @@ -9,61 +10,61 @@ static mspace sStaticSpace = NULL; void *MYMALLOC(size_t size) { #if USE_CHECKPOINTING - static void *(*mallocp)(size_t size); - char *error; - void *ptr; - - /* get address of libc malloc */ - if (!mallocp) { - mallocp = ( void * ( * )( size_t ) )dlsym(RTLD_NEXT, "malloc"); - if ((error = dlerror()) != NULL) { - fputs(error, stderr); - exit(1); - } - } - ptr = mallocp(size); - return ptr; + static void *(*mallocp)(size_t size); + char *error; + void *ptr; + + /* get address of libc malloc */ + if (!mallocp) { + mallocp = ( void * ( * )( size_t ) )dlsym(RTLD_NEXT, "malloc"); + if ((error = dlerror()) != NULL) { + fputs(error, stderr); + exit(1); + } + } + ptr = mallocp(size); + return ptr; #else - if( !sTheRecord ){ - createSharedLibrary(); - } - if( NULL == sStaticSpace ) - sStaticSpace = create_mspace_with_base( ( void * )( sTheRecord->mSharedMemoryBase ), SHARED_MEMORY_DEFAULT -sizeof( struct Snapshot_t ), 1 ); - return mspace_malloc( sStaticSpace, size ); + if( !sTheRecord ){ + createSharedLibrary(); + } + if( NULL == sStaticSpace ) + sStaticSpace = create_mspace_with_base( ( void * )( sTheRecord->mSharedMemoryBase ), SHARED_MEMORY_DEFAULT -sizeof( struct Snapshot_t ), 1 ); + return mspace_malloc( sStaticSpace, size ); #endif } void MYFREE(void *ptr) { #if USE_CHECKPOINTING - static void (*freep)(void *); - char *error; + static void (*freep)(void *); + char *error; - /* get address of libc free */ - if (!freep) { - freep = ( void ( * )( void * ) )dlsym(RTLD_NEXT, "free"); - if ((error = dlerror()) != NULL) { - fputs(error, stderr); - exit(1); - } - } - freep(ptr); + /* get address of libc free */ + if (!freep) { + freep = ( void ( * )( void * ) )dlsym(RTLD_NEXT, "free"); + if ((error = dlerror()) != NULL) { + fputs(error, stderr); + exit(1); + } + } + freep(ptr); #else - mspace_free( sStaticSpace, ptr ); + mspace_free( sStaticSpace, ptr ); #endif } mspace mySpace = NULL; void *malloc( size_t size ) { - return mspace_malloc( mySpace, size ); + return mspace_malloc( mySpace, size ); } void free( void * ptr ){ - mspace_free( mySpace, ptr ); + mspace_free( mySpace, ptr ); } void * operator new(size_t size) throw(std::bad_alloc) { - return MYMALLOC(size); + return MYMALLOC(size); } void operator delete(void *p) throw() { - MYFREE(p); + MYFREE(p); } diff --git a/snapshot-interface.cc b/snapshot-interface.cc index 770f316..b3da9cf 100644 --- a/snapshot-interface.cc +++ b/snapshot-interface.cc @@ -1,3 +1,5 @@ +/* -*- Mode: C; indent-tabs-mode: t -*- */ + #define MYBINARYNAME "model" #define MYLIBRARYNAME "libmodel.so" #define MYALLOCNAME "libmymemory.so" @@ -19,89 +21,89 @@ snapshotStack * snapshotObject; typedef std::basic_stringstream< char, std::char_traits< char >, MyAlloc< char > > MyStringStream; std::vector< MyString, MyAlloc< MyString> > splitString( MyString input, char delim ){ - std::vector< MyString, MyAlloc< MyString > > splits; - MyStringStream ss( input ); - MyString item; - while( std::getline( ss, item, delim ) ){ - splits.push_back( item ); - } - return splits; + std::vector< MyString, MyAlloc< MyString > > splits; + MyStringStream ss( input ); + MyString item; + while( std::getline( ss, item, delim ) ){ + splits.push_back( item ); + } + return splits; } bool checkPermissions( MyString permStr ){ - return permStr.find("w") != MyString::npos; + return permStr.find("w") != MyString::npos; } static void takeSegmentSnapshot( const MyString & lineText ){ - std::vector< MyString, MyAlloc< MyString > > firstSplit = splitString( lineText, ' ' ); - if( checkPermissions( firstSplit[ 1 ] ) ){ - std::vector< MyString, MyAlloc< MyString > > secondSplit = splitString( firstSplit[ 0 ], '-' ); - size_t val1 = 0, val2 = 0; - sscanf( secondSplit[ 0 ].c_str(), "%zx", &val1 ); - sscanf( secondSplit[ 1 ].c_str(), "%zx", &val2 ); - size_t len = ( val2 - val1 ) / PAGESIZE; - if( 0 != len ){ - addMemoryRegionToSnapShot( ( void * )val1, len ); - } - } + std::vector< MyString, MyAlloc< MyString > > firstSplit = splitString( lineText, ' ' ); + if( checkPermissions( firstSplit[ 1 ] ) ){ + std::vector< MyString, MyAlloc< MyString > > secondSplit = splitString( firstSplit[ 0 ], '-' ); + size_t val1 = 0, val2 = 0; + sscanf( secondSplit[ 0 ].c_str(), "%zx", &val1 ); + sscanf( secondSplit[ 1 ].c_str(), "%zx", &val2 ); + size_t len = ( val2 - val1 ) / PAGESIZE; + if( 0 != len ){ + addMemoryRegionToSnapShot( ( void * )val1, len ); + } + } } void SnapshotGlobalSegments(){ - MyString fn = PROCNAME; - static char sProcessSize[ 12 ] = { 0 }; - std::pair< const char *, bool > dataSect[ 3 ]; - dataSect[ 0 ] = std::make_pair( MYBINARYNAME, false ); - dataSect[ 1 ] = std::make_pair( MYLIBRARYNAME, false ); - dataSect[ 2 ] = std::make_pair( MYALLOCNAME, false ); - static pid_t sProcID = 0; - if( 0 == sProcID ) { - sProcID = getpid(); - sprintf( sProcessSize, "%d", sProcID ); - } - fn.replace( REPLACEPOS, 1, sProcessSize ); - std::ifstream procName( fn.c_str() ); - if( procName.is_open() ){ - MyString line; - while( procName.good() ){ - getline( procName, line ); - int i = 0; - for( i = 0; i < 3; ++i ){ - if( MyString::npos != line.find( dataSect[ i ].first ) ) break; - } - if( i >= 3 || dataSect[ i ].second == true ) continue; - dataSect[ i ].second = true; - if( !procName.good() )return; - getline( procName, line ); - takeSegmentSnapshot( line ); - } - } + MyString fn = PROCNAME; + static char sProcessSize[ 12 ] = { 0 }; + std::pair< const char *, bool > dataSect[ 3 ]; + dataSect[ 0 ] = std::make_pair( MYBINARYNAME, false ); + dataSect[ 1 ] = std::make_pair( MYLIBRARYNAME, false ); + dataSect[ 2 ] = std::make_pair( MYALLOCNAME, false ); + static pid_t sProcID = 0; + if( 0 == sProcID ) { + sProcID = getpid(); + sprintf( sProcessSize, "%d", sProcID ); + } + fn.replace( REPLACEPOS, 1, sProcessSize ); + std::ifstream procName( fn.c_str() ); + if( procName.is_open() ){ + MyString line; + while( procName.good() ){ + getline( procName, line ); + int i = 0; + for( i = 0; i < 3; ++i ){ + if( MyString::npos != line.find( dataSect[ i ].first ) ) break; + } + if( i >= 3 || dataSect[ i ].second == true ) continue; + dataSect[ i ].second = true; + if( !procName.good() )return; + getline( procName, line ); + takeSegmentSnapshot( line ); + } + } } //class definition of snapshotStack..... //declaration of constructor.... snapshotStack::snapshotStack(){ - SnapshotGlobalSegments(); - stack=NULL; + SnapshotGlobalSegments(); + stack=NULL; } snapshotStack::~snapshotStack(){ } int snapshotStack::backTrackBeforeStep(int seqindex) { - while(true) { - if (stack->index<=seqindex) { - //have right entry - rollBack(stack->snapshotid); - return stack->index; - } - struct stackEntry *tmp=stack; - free(tmp); - stack=stack->next; - } + while(true) { + if (stack->index<=seqindex) { + //have right entry + rollBack(stack->snapshotid); + return stack->index; + } + struct stackEntry *tmp=stack; + free(tmp); + stack=stack->next; + } } void snapshotStack::snapshotStep(int seqindex) { - struct stackEntry *tmp=(struct stackEntry *)malloc(sizeof(struct stackEntry)); - tmp->next=stack; - tmp->index=seqindex; - tmp->snapshotid=takeSnapshot(); - stack=tmp; + struct stackEntry *tmp=(struct stackEntry *)malloc(sizeof(struct stackEntry)); + tmp->next=stack; + tmp->index=seqindex; + tmp->snapshotid=takeSnapshot(); + stack=tmp; } diff --git a/snapshot.cc b/snapshot.cc index b848d02..ca75884 100644 --- a/snapshot.cc +++ b/snapshot.cc @@ -1,3 +1,4 @@ +/* -*- Mode: C; indent-tabs-mode: t -*- */ #include #include #include @@ -36,17 +37,17 @@ struct timeval *starttime = NULL; #endif void DumpIntoLog( const char * filename, const char * message ){ #if SSDEBUG - static pid_t thePID = getpid(); - char newFn[ 1024 ] ={ 0 }; - sprintf( newFn,"%s-%d.txt", filename, thePID ); - FILE * myFile = fopen( newFn, "w+" ); - struct timeval theEndTime; - BeginOperation( &theEndTime ); - double elapsed = ( theEndTime.tv_sec - starttime->tv_sec ) + ( theEndTime.tv_usec - starttime->tv_usec ) / 1000000.0; - fprintf( myFile, "The timestamp %f:--> the message %s: the process id %d\n", elapsed, message, thePID ); - fflush( myFile ); - fclose( myFile ); - myFile = NULL; + static pid_t thePID = getpid(); + char newFn[ 1024 ] ={ 0 }; + sprintf( newFn,"%s-%d.txt", filename, thePID ); + FILE * myFile = fopen( newFn, "w+" ); + struct timeval theEndTime; + BeginOperation( &theEndTime ); + double elapsed = ( theEndTime.tv_sec - starttime->tv_sec ) + ( theEndTime.tv_usec - starttime->tv_usec ) / 1000000.0; + fprintf( myFile, "The timestamp %f:--> the message %s: the process id %d\n", elapsed, message, thePID ); + fflush( myFile ); + fclose( myFile ); + myFile = NULL; #endif } #if !USE_CHECKPOINTING @@ -57,233 +58,233 @@ static int snapshotid = 0; /* Initialize snapshot data structure */ #if USE_CHECKPOINTING void initSnapShotRecord(unsigned int numbackingpages, unsigned int numsnapshots, unsigned int nummemoryregions) { - snapshotrecord=( struct SnapShot * )MYMALLOC(sizeof(struct SnapShot)); - snapshotrecord->regionsToSnapShot=( struct MemoryRegion * )MYMALLOC(sizeof(struct MemoryRegion)*nummemoryregions); - snapshotrecord->backingStoreBasePtr= ( struct SnapShotPage * )MYMALLOC( sizeof( struct SnapShotPage ) * (numbackingpages + 1) ); - //Page align the backingstorepages - snapshotrecord->backingStore=( struct SnapShotPage * )ReturnPageAlignedAddress((void*) ((uintptr_t)(snapshotrecord->backingStoreBasePtr)+sizeof(struct SnapShotPage)-1)); - snapshotrecord->backingRecords=( struct BackingPageRecord * )MYMALLOC(sizeof(struct BackingPageRecord)*numbackingpages); - snapshotrecord->snapShots= ( struct SnapShotRecord * )MYMALLOC(sizeof(struct SnapShotRecord)*numsnapshots); - snapshotrecord->lastSnapShot=0; - snapshotrecord->lastBackingPage=0; - snapshotrecord->lastRegion=0; - snapshotrecord->maxRegions=nummemoryregions; - snapshotrecord->maxBackingPages=numbackingpages; - snapshotrecord->maxSnapShots=numsnapshots; + snapshotrecord=( struct SnapShot * )MYMALLOC(sizeof(struct SnapShot)); + snapshotrecord->regionsToSnapShot=( struct MemoryRegion * )MYMALLOC(sizeof(struct MemoryRegion)*nummemoryregions); + snapshotrecord->backingStoreBasePtr= ( struct SnapShotPage * )MYMALLOC( sizeof( struct SnapShotPage ) * (numbackingpages + 1) ); + //Page align the backingstorepages + snapshotrecord->backingStore=( struct SnapShotPage * )ReturnPageAlignedAddress((void*) ((uintptr_t)(snapshotrecord->backingStoreBasePtr)+sizeof(struct SnapShotPage)-1)); + snapshotrecord->backingRecords=( struct BackingPageRecord * )MYMALLOC(sizeof(struct BackingPageRecord)*numbackingpages); + snapshotrecord->snapShots= ( struct SnapShotRecord * )MYMALLOC(sizeof(struct SnapShotRecord)*numsnapshots); + snapshotrecord->lastSnapShot=0; + snapshotrecord->lastBackingPage=0; + snapshotrecord->lastRegion=0; + snapshotrecord->maxRegions=nummemoryregions; + snapshotrecord->maxBackingPages=numbackingpages; + snapshotrecord->maxSnapShots=numsnapshots; } #endif //nothing to initialize for the fork based snapshotting. void HandlePF( int sig, siginfo_t *si, void * unused){ #if USE_CHECKPOINTING - if( si->si_code == SEGV_MAPERR ){ - printf("Real Fault at %llx\n", ( long long )si->si_addr); - exit( EXIT_FAILURE ); - } - void* addr = ReturnPageAlignedAddress(si->si_addr); - unsigned int backingpage=snapshotrecord->lastBackingPage++; //Could run out of pages... - if (backingpage==snapshotrecord->maxBackingPages) { - printf("Out of backing pages at %llx\n", ( long long )si->si_addr); - exit( EXIT_FAILURE ); - } + if( si->si_code == SEGV_MAPERR ){ + printf("Real Fault at %llx\n", ( long long )si->si_addr); + exit( EXIT_FAILURE ); + } + void* addr = ReturnPageAlignedAddress(si->si_addr); + unsigned int backingpage=snapshotrecord->lastBackingPage++; //Could run out of pages... + if (backingpage==snapshotrecord->maxBackingPages) { + printf("Out of backing pages at %llx\n", ( long long )si->si_addr); + 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; - //set protection to read/write - mprotect( addr, sizeof(struct SnapShotPage), PROT_READ | PROT_WRITE ); + //copy page + memcpy(&(snapshotrecord->backingStore[backingpage]), addr, sizeof(struct SnapShotPage)); + //remember where to copy page back to + snapshotrecord->backingRecords[backingpage].basePtrOfPage=addr; + //set protection to read/write + mprotect( addr, sizeof(struct SnapShotPage), PROT_READ | PROT_WRITE ); #endif //nothing to handle for non snapshotting case. } //Return a page aligned address for the address being added //as a side effect the numBytes are also changed. void * ReturnPageAlignedAddress(void * addr) { - return (void *)(((uintptr_t)addr)&~(PAGESIZE-1)); + return (void *)(((uintptr_t)addr)&~(PAGESIZE-1)); } #ifdef __cplusplus extern "C" { #endif -void createSharedLibrary(){ + void createSharedLibrary(){ #if !USE_CHECKPOINTING - //step 1. create shared memory. - if( sTheRecord ) return; - int fd = shm_open( "/ModelChecker-Snapshotter", O_RDWR | O_CREAT, 0777 ); //universal permissions. - if( -1 == fd ) FAILURE("shm_open"); - if( -1 == ftruncate( fd, ( size_t )SHARED_MEMORY_DEFAULT + ( size_t )STACK_SIZE_DEFAULT ) ) FAILURE( "ftruncate" ); - char * memMapBase = ( char * ) mmap( 0, ( size_t )SHARED_MEMORY_DEFAULT + ( size_t )STACK_SIZE_DEFAULT, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0 ); - if( MAP_FAILED == memMapBase ) FAILURE("mmap"); - sTheRecord = ( struct Snapshot_t * )memMapBase; - sTheRecord->mSharedMemoryBase = memMapBase + sizeof( struct Snapshot_t ); - sTheRecord->mStackBase = ( char * )memMapBase + ( size_t )SHARED_MEMORY_DEFAULT; - sTheRecord->mStackSize = STACK_SIZE_DEFAULT; - sTheRecord->mIDToRollback = -1; - sTheRecord->currSnapShotID = 0; + //step 1. create shared memory. + if( sTheRecord ) return; + int fd = shm_open( "/ModelChecker-Snapshotter", O_RDWR | O_CREAT, 0777 ); //universal permissions. + if( -1 == fd ) FAILURE("shm_open"); + if( -1 == ftruncate( fd, ( size_t )SHARED_MEMORY_DEFAULT + ( size_t )STACK_SIZE_DEFAULT ) ) FAILURE( "ftruncate" ); + char * memMapBase = ( char * ) mmap( 0, ( size_t )SHARED_MEMORY_DEFAULT + ( size_t )STACK_SIZE_DEFAULT, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0 ); + if( MAP_FAILED == memMapBase ) FAILURE("mmap"); + sTheRecord = ( struct Snapshot_t * )memMapBase; + sTheRecord->mSharedMemoryBase = memMapBase + sizeof( struct Snapshot_t ); + sTheRecord->mStackBase = ( char * )memMapBase + ( size_t )SHARED_MEMORY_DEFAULT; + sTheRecord->mStackSize = STACK_SIZE_DEFAULT; + sTheRecord->mIDToRollback = -1; + sTheRecord->currSnapShotID = 0; #endif -} + } #ifdef __cplusplus } #endif void initSnapShotLibrary(unsigned int numbackingpages, unsigned int numsnapshots, unsigned int nummemoryregions, unsigned int numheappages, MyFuncPtr entryPoint){ #if USE_CHECKPOINTING - struct sigaction sa; - sa.sa_flags = SA_SIGINFO | SA_NODEFER | SA_RESTART; - sigemptyset( &sa.sa_mask ); - sa.sa_sigaction = HandlePF; - if( sigaction( SIGSEGV, &sa, NULL ) == -1 ){ - printf("SIGACTION CANNOT BE INSTALLED\n"); - exit(-1); - } - initSnapShotRecord(numbackingpages, numsnapshots, nummemoryregions); - mySpace = create_mspace( numheappages*PAGESIZE, 1 ); - addMemoryRegionToSnapShot(mySpace, numheappages); - entryPoint(); + struct sigaction sa; + sa.sa_flags = SA_SIGINFO | SA_NODEFER | SA_RESTART; + sigemptyset( &sa.sa_mask ); + sa.sa_sigaction = HandlePF; + if( sigaction( SIGSEGV, &sa, NULL ) == -1 ){ + printf("SIGACTION CANNOT BE INSTALLED\n"); + exit(-1); + } + initSnapShotRecord(numbackingpages, numsnapshots, nummemoryregions); + mySpace = create_mspace( numheappages*PAGESIZE, 1 ); + addMemoryRegionToSnapShot(mySpace, numheappages); + entryPoint(); #else - //add a signal to indicate that the process is going to terminate. - struct sigaction sa; - sa.sa_flags = SA_SIGINFO | SA_NODEFER | SA_RESTART; - sigemptyset( &sa.sa_mask ); - sa.sa_sigaction = HandlePF; - if( sigaction( SIGUSR1, &sa, NULL ) == -1 ){ - printf("SIGACTION CANNOT BE INSTALLED\n"); - exit(-1); - } - createSharedLibrary(); - #if SSDEBUG - starttime = &(sTheRecord->startTimeGlobal); - gettimeofday( starttime, NULL ); + //add a signal to indicate that the process is going to terminate. + struct sigaction sa; + sa.sa_flags = SA_SIGINFO | SA_NODEFER | SA_RESTART; + sigemptyset( &sa.sa_mask ); + sa.sa_sigaction = HandlePF; + if( sigaction( SIGUSR1, &sa, NULL ) == -1 ){ + printf("SIGACTION CANNOT BE INSTALLED\n"); + exit(-1); + } + createSharedLibrary(); +#if SSDEBUG + starttime = &(sTheRecord->startTimeGlobal); + gettimeofday( starttime, NULL ); #endif - //step 2 setup the stack context. + //step 2 setup the stack context. - int alreadySwapped = 0; - getcontext( &savedSnapshotContext ); - if( !alreadySwapped ){ - alreadySwapped = 1; - ucontext_t currentContext, swappedContext, newContext; - getcontext( &newContext ); - newContext.uc_stack.ss_sp = sTheRecord->mStackBase; - newContext.uc_stack.ss_size = STACK_SIZE_DEFAULT; - newContext.uc_link = ¤tContext; - makecontext( &newContext, entryPoint, 0 ); - swapcontext( &swappedContext, &newContext ); - } + int alreadySwapped = 0; + getcontext( &savedSnapshotContext ); + if( !alreadySwapped ){ + alreadySwapped = 1; + ucontext_t currentContext, swappedContext, newContext; + getcontext( &newContext ); + newContext.uc_stack.ss_sp = sTheRecord->mStackBase; + newContext.uc_stack.ss_size = STACK_SIZE_DEFAULT; + newContext.uc_link = ¤tContext; + makecontext( &newContext, entryPoint, 0 ); + swapcontext( &swappedContext, &newContext ); + } - //add the code to take a snapshot here... + //add the code to take a snapshot here... //to return to user process, do a second swapcontext... - pid_t forkedID = 0; - snapshotid = sTheRecord->currSnapShotID; - bool swapContext = false; - while( !sTheRecord->mbFinalize ){ - sTheRecord->currSnapShotID=snapshotid+1; - forkedID = fork(); - if( 0 == forkedID ){ - ucontext_t currentContext; + pid_t forkedID = 0; + snapshotid = sTheRecord->currSnapShotID; + bool swapContext = false; + while( !sTheRecord->mbFinalize ){ + sTheRecord->currSnapShotID=snapshotid+1; + forkedID = fork(); + if( 0 == forkedID ){ + ucontext_t currentContext; #if 0 - int dbg = 0; - while( !dbg ); + int dbg = 0; + while( !dbg ); #endif - if( swapContext ) - swapcontext( ¤tContext, &( sTheRecord->mContextToRollback ) ); + if( swapContext ) + swapcontext( ¤tContext, &( sTheRecord->mContextToRollback ) ); else{ swapcontext( ¤tContext, &savedUserSnapshotContext ); } - } else { - int status; - int retVal; + } else { + int status; + int retVal; #if SSDEBUG - char mesg[ 1024 ] = { 0 }; - sprintf( mesg, "The process id of child is %d and the process id of this process is %d and snapshot id is %d", forkedID, getpid(), snapshotid ); - DumpIntoLog( "ModelSnapshot", mesg ); + char mesg[ 1024 ] = { 0 }; + sprintf( mesg, "The process id of child is %d and the process id of this process is %d and snapshot id is %d", forkedID, getpid(), snapshotid ); + DumpIntoLog( "ModelSnapshot", mesg ); #endif - do { + do { retVal=waitpid( forkedID, &status, 0 ); - } while( -1 == retVal && errno == EINTR ); + } while( -1 == retVal && errno == EINTR ); - if( sTheRecord->mIDToRollback != snapshotid ) - exit(0); - else{ - swapContext = true; - } - } - } + if( sTheRecord->mIDToRollback != snapshotid ) + exit(0); + else{ + swapContext = true; + } + } + } #endif } /* This function assumes that addr is page aligned */ void addMemoryRegionToSnapShot( void * addr, unsigned int numPages) { #if USE_CHECKPOINTING - unsigned int memoryregion=snapshotrecord->lastRegion++; - if (memoryregion==snapshotrecord->maxRegions) { - printf("Exceeded supported number of memory regions!\n"); - exit(-1); - } + unsigned int memoryregion=snapshotrecord->lastRegion++; + if (memoryregion==snapshotrecord->maxRegions) { + printf("Exceeded supported number of memory regions!\n"); + exit(-1); + } - 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. } //take snapshot snapshot_id takeSnapshot( ){ #if USE_CHECKPOINTING - for(unsigned int region=0; regionlastRegion;region++) { - if( mprotect(snapshotrecord->regionsToSnapShot[region].basePtr, snapshotrecord->regionsToSnapShot[region].sizeInPages*sizeof(struct SnapShotPage), PROT_READ ) == -1 ){ - printf("Failed to mprotect inside of takeSnapShot\n"); - exit(-1); - } - } - unsigned int snapshot=snapshotrecord->lastSnapShot++; - if (snapshot==snapshotrecord->maxSnapShots) { - printf("Out of snapshots\n"); - exit(-1); - } - snapshotrecord->snapShots[snapshot].firstBackingPage=snapshotrecord->lastBackingPage; + for(unsigned int region=0; regionlastRegion;region++) { + if( mprotect(snapshotrecord->regionsToSnapShot[region].basePtr, snapshotrecord->regionsToSnapShot[region].sizeInPages*sizeof(struct SnapShotPage), PROT_READ ) == -1 ){ + printf("Failed to mprotect inside of takeSnapShot\n"); + exit(-1); + } + } + unsigned int snapshot=snapshotrecord->lastSnapShot++; + if (snapshot==snapshotrecord->maxSnapShots) { + printf("Out of snapshots\n"); + exit(-1); + } + snapshotrecord->snapShots[snapshot].firstBackingPage=snapshotrecord->lastBackingPage; - return snapshot; + return snapshot; #else - swapcontext( &savedUserSnapshotContext, &savedSnapshotContext ); - return snapshotid; + swapcontext( &savedUserSnapshotContext, &savedSnapshotContext ); + return snapshotid; #endif } void rollBack( snapshot_id theID ){ #if USE_CHECKPOINTING - std::map< void *, bool, std::less< void * >, MyAlloc< std::pair< const void *, bool > > > duplicateMap; - for(unsigned int region=0; regionlastRegion;region++) { - if( mprotect(snapshotrecord->regionsToSnapShot[region].basePtr, snapshotrecord->regionsToSnapShot[region].sizeInPages*sizeof(struct SnapShotPage), PROT_READ | PROT_WRITE ) == -1 ){ - printf("Failed to mprotect inside of takeSnapShot\n"); - exit(-1); - } - } - for(unsigned int page=snapshotrecord->snapShots[theID].firstBackingPage; pagelastBackingPage; page++) { - bool oldVal = false; - if( duplicateMap.find( snapshotrecord->backingRecords[page].basePtrOfPage ) != duplicateMap.end() ){ - oldVal = true; - } - else{ - duplicateMap[ snapshotrecord->backingRecords[page].basePtrOfPage ] = true; - } - if( !oldVal ){ - memcpy(snapshotrecord->backingRecords[page].basePtrOfPage, &snapshotrecord->backingStore[page], sizeof(struct SnapShotPage)); - } - } - snapshotrecord->lastSnapShot=theID; - snapshotrecord->lastBackingPage=snapshotrecord->snapShots[theID].firstBackingPage; - takeSnapshot(); //Make sure current snapshot is still good...All later ones are cleared + std::map< void *, bool, std::less< void * >, MyAlloc< std::pair< const void *, bool > > > duplicateMap; + for(unsigned int region=0; regionlastRegion;region++) { + if( mprotect(snapshotrecord->regionsToSnapShot[region].basePtr, snapshotrecord->regionsToSnapShot[region].sizeInPages*sizeof(struct SnapShotPage), PROT_READ | PROT_WRITE ) == -1 ){ + printf("Failed to mprotect inside of takeSnapShot\n"); + exit(-1); + } + } + for(unsigned int page=snapshotrecord->snapShots[theID].firstBackingPage; pagelastBackingPage; page++) { + bool oldVal = false; + if( duplicateMap.find( snapshotrecord->backingRecords[page].basePtrOfPage ) != duplicateMap.end() ){ + oldVal = true; + } + else{ + duplicateMap[ snapshotrecord->backingRecords[page].basePtrOfPage ] = true; + } + if( !oldVal ){ + memcpy(snapshotrecord->backingRecords[page].basePtrOfPage, &snapshotrecord->backingStore[page], sizeof(struct SnapShotPage)); + } + } + snapshotrecord->lastSnapShot=theID; + snapshotrecord->lastBackingPage=snapshotrecord->snapShots[theID].firstBackingPage; + takeSnapshot(); //Make sure current snapshot is still good...All later ones are cleared #else - sTheRecord->mIDToRollback = theID; - int sTemp = 0; - getcontext( &sTheRecord->mContextToRollback ); - if( !sTemp ){ - sTemp = 1; + sTheRecord->mIDToRollback = theID; + int sTemp = 0; + getcontext( &sTheRecord->mContextToRollback ); + if( !sTemp ){ + sTemp = 1; #if SSDEBUG - DumpIntoLog( "ModelSnapshot", "Invoked rollback" ); + DumpIntoLog( "ModelSnapshot", "Invoked rollback" ); #endif - exit( 0 ); - } + exit( 0 ); + } #endif } void finalize(){ #if !USE_CHECKPOINTING - sTheRecord->mbFinalize = true; + sTheRecord->mbFinalize = true; #endif }