C++ (Cpp) rvm_init Examples

Example #1

File: basic9.c Project: Machiry/AOS

/* proc1 writes some data, commits it, then exits */
void proc1() 
{
     rvm_t rvm;
     trans_t trans;
     char* segs[1];
     
     rvm = rvm_init(__FILE__ ".d");
     rvm_destroy(rvm, "testseg");
     segs[0] = (char *) rvm_map(rvm, "testseg", 10000);

     trans = rvm_begin_trans(rvm, 1, (void **) segs);
     rvm_about_to_modify(trans, segs[0], 0, 100);
     sprintf(segs[0], "one");
     rvm_commit_trans(trans);

     trans = rvm_begin_trans(rvm, 1, (void **) segs);
     rvm_about_to_modify(trans, segs[0], 0, 100);
     sprintf(segs[0], "two");
     rvm_abort_trans(trans);

     trans = rvm_begin_trans(rvm, 1, (void **) segs);
     rvm_about_to_modify(trans, segs[0], 0, 100);
     sprintf(segs[0], "foo");
     rvm_commit_trans(trans);

     abort();
}

Example #2

File: rvm_test4.c Project: dkrinos/rvm_tests

/* proc2 opens the segments and reads from them */
void proc2() {
	char* segs[2];
	rvm_t rvm;
     
	rvm = rvm_init("rvm_segments");

	segs[0] = (char *) rvm_map(rvm, "testseg", 10000);
	if(!strcmp(segs[0], "hello, world")) {
		fprintf(stderr, 
		"A second process found aborted changes committed.\n");
		fprintf(stderr, "found %s\n", segs[0]);
    		exit(2);
  	}
  	if(!strcmp(segs[0]+1000, "hello, world")) {
    		fprintf(stderr, 
		"A second process found aborted changes committed.\n");
		fprintf(stderr, "found %s\n", segs[0]+1000);
    		exit(3);
  	}

	segs[1] = (char *) rvm_map(rvm, "anotherseg", 10000);
	if(!strcmp(segs[1], "hello, world")) {
		fprintf(stderr, 
		"A second process found aborted changes committed.\n");
		fprintf(stderr, "found %s\n", segs[0]);
    		exit(4);
  	}
  	if(!strcmp(segs[1]+1000, "hello, world")) {
    		fprintf(stderr, 
		"A second process found aborted changes committed.\n");
		fprintf(stderr, "found %s\n", segs[0]+1000);
    		exit(5);
  	}
}

Example #3

File: rvm_main.c Project: wanchen1112/CS6210_Lab_4

void proc1() 
{
     rvm_t rvm;
     char* segs[2];
     trans_t trans;
     
     printf(">>> proc1()\n");

     rvm = rvm_init("rvm_segments");

     rvm_destroy(rvm, SEGNAME0);
     rvm_destroy(rvm, SEGNAME1);

     segs[0] = (char*) rvm_map(rvm, SEGNAME0, 1000);
     segs[1] = (char*) rvm_map(rvm, SEGNAME1, 1000);

     segs[0] = (char*) rvm_map(rvm, SEGNAME0, 300);

     trans = rvm_begin_trans(rvm, 2, (void **)segs);

     rvm_about_to_modify(trans, segs[0], OFFSET0, 100);
     strcpy(segs[0]+OFFSET0, STRING0);
     rvm_about_to_modify(trans, segs[1], OFFSET1, 100);
     strcpy(segs[1]+OFFSET1, STRING1);

     rvm_commit_trans(trans);

     abort();
}

Example #4

File: test3.c Project: gajayraghav/VRM

/* proc1 writes some data, commits it, then exits */
void proc1() 
{		 
     rvm_t rvm;
     trans_t trans;
     char* segs[1];
     
     rvm = rvm_init("rvm_segments");
     rvm_destroy(rvm, "testseg");
     segs[0] = (char *) rvm_map(rvm, "testseg", 1000);

     
     trans = rvm_begin_trans(rvm, 1, (void **) segs);
     
     rvm_about_to_modify(trans, segs[0], 0, 1000);
     char * currChar = segs[0];
     for (int counter= 0; counter < 1000; counter++){
       *currChar = '!';
       currChar++;
     }
     
     rvm_commit_trans(trans);
     
     

     abort();
}

Example #5

File: test_deception.c Project: kszr/recoverable-vm

/* proc1 writes some data, commits it, then exits */
void proc1() 
{
     rvm_t rvm;
     trans_t trans;
     char* segs[1];
     
     rvm = rvm_init("rvm_segments");
     rvm_destroy(rvm, "testseg");
     segs[0] = (char *) rvm_map(rvm, "testseg", 10000);

     
     trans = rvm_begin_trans(rvm, 1, (void **) segs);
     
    //  rvm_about_to_modify(trans, segs[0], 0, 100);
    //  sprintf(segs[0], TEST_STRING);
    //  printf("Segment Data %s\n", segs[0]);
     rvm_about_to_modify(trans, segs[0], OFFSET2, 100);
     sprintf(segs[0]+OFFSET2, TEST_STRING);
     sprintf(segs[0], BAD_STRING);
     printf("Segment Data %s\n", segs[0]);
     
     rvm_commit_trans(trans);

     abort();
}

Example #6

File: test01.c Project: dmanatunga/cs6210-project4

int main(int argc, char** argv) {
  rvm_t rvm;
  trans_t trans;
  char* segs[1];

  rvm = rvm_init("rvm_segments");
  rvm_destroy(rvm, "testseg01");
  segs[0] = (char*) rvm_map(rvm, "testseg01", 10000);

  trans = rvm_begin_trans(rvm, 1, (void**) segs);

  rvm_about_to_modify(trans, segs[0], 0, 100);
  sprintf(segs[0], TEST_STRING);

  rvm_about_to_modify(trans, segs[0], OFFSET2, 100);
  sprintf(segs[0] + OFFSET2, TEST_STRING);

  rvm_commit_trans(trans);

  // This should fail
  rvm_destroy(rvm, "testseg01");

  rvm_unmap(rvm, segs[0]);

  rvm_truncate_log(rvm);

  if (file_exists("rvm_segments/seg_testseg01.rvm")) {
    printf("OK\n");
  } else {
    printf("ERROR: Segment file no longer present");
  }

  return 0;
}

Example #7

File: multi-trans.c Project: kandycs/lrvm

void proc1() 
{
     rvm_t rvm;
     char* segs[2];
     trans_t trans[2];
     
     rvm = rvm_init("rvm_segments");

     rvm_destroy(rvm, SEGNAME0);
     rvm_destroy(rvm, SEGNAME1);

     segs[0] = (char*) rvm_map(rvm, SEGNAME0, 1000);
     segs[1] = (char*) rvm_map(rvm, SEGNAME1, 1000);

     trans[0] = rvm_begin_trans(rvm, 1, &segs[0]);
     trans[1] = rvm_begin_trans(rvm, 1, &segs[1]);

     rvm_about_to_modify(trans[0], segs[0], OFFSET0, 100);
     strcpy(segs[0]+OFFSET0, STRING0);
     rvm_about_to_modify(trans[1], segs[1], OFFSET1, 100);
     strcpy(segs[1]+OFFSET1, STRING1);

     rvm_commit_trans(trans[0]);
     rvm_commit_trans(trans[1]);
	
	 rvm_unmap(rvm, segs[0]);
	 rvm_unmap(rvm, segs[1]);
}

Example #8

File: segfault.c Project: Goldensunboy/cs4210-proj4

void proc1() 
{
     rvm_t rvm;
     char* segs[2];
     trans_t trans;
     
     rvm = rvm_init("rvm_segments");

     rvm_destroy(rvm, SEGNAME0);
     rvm_destroy(rvm, SEGNAME1);

     segs[0] = (char*) rvm_map(rvm, SEGNAME0, 1000);
     segs[1] = (char*) rvm_map(rvm, SEGNAME1, 1000);

     trans = rvm_begin_trans(rvm, 2, (void **)segs);

     rvm_about_to_modify(trans, segs[0], OFFSET0, 100);
     strcpy(segs[0]+OFFSET0, STRING0);
     rvm_about_to_modify(trans, segs[1], OFFSET1, 100);
     strcpy(segs[1]+OFFSET1, STRING1);

     rvm_commit_trans(trans);

	 char *str;
     (str = strdup("foo"))[3] = '\n';
     printf("Length of foo: %d\n", strlen(str));
}

Example #9

File: rvm_test4.c Project: dkrinos/rvm_tests

/* proc1 writes some data, commits it, then exits */
void proc1() {
	rvm_t rvm;
	trans_t trans;
	char* segs[2];

	rvm = rvm_init("rvm_segments");
	segs[0] = (char *) rvm_map(rvm, "testseg", 10000);
	segs[1] = (char *) rvm_map(rvm, "anotherseg", 10000);
     
	trans = rvm_begin_trans(rvm, 2, (void **) segs);
     
	rvm_about_to_modify(trans, segs[0], 0, 100);
	sprintf(segs[0], "hello, world");
     
	rvm_about_to_modify(trans, segs[0], 1000, 100);
	sprintf(segs[0]+1000, "hello, world");

	rvm_about_to_modify(trans, segs[1], 0, 100);
	sprintf(segs[1], "hello, world");
     
	rvm_about_to_modify(trans, segs[1], 1000, 100);
	sprintf(segs[1]+1000, "hello, world");
   
	rvm_abort_trans(trans);

	abort();
}

Example #10

File: test_init.c Project: kszr/recoverable-vm

int main(int argc, char **argv) 
{
     rvm_t rvm;
     rvm = rvm_init("rvm_segments");
     printf("\nTesting directory creation:\n");
     system("ls -l rvm_segments");

     return 0;
}

Example #11

File: test_multi1.c Project: Machiry/AOS

void proc1() 
{
     rvm_t rvm;
     char* segs[2];
     trans_t trans;
     char** segnames;
     int i;
     int numSegments = 100;

     rvm = rvm_init(__FILE__ ".d");
     
     // Allocate some memory
     segnames = (char **)malloc(numSegments * sizeof(char *));
     
    for(i = 0; i < numSegments; i++) {
      segnames[i] = (char *)malloc(MAX_SEGMENT_NAME_LEN);   
      sprintf(segnames[i],"testseg%i",i);
      rvm_destroy(rvm, segnames[i]);
    }

    
    //all segments contain the first string (aa)
    for(i = 0; i < numSegments; i++) {
      
      segs[0] = (char *) rvm_map(rvm, segnames[i], 3);
      trans = rvm_begin_trans(rvm, 1, (void **) segs);
      rvm_about_to_modify(trans, segs[0], 0, 3); 
      sprintf(segs[0],"aa");
      rvm_commit_trans(trans);
      rvm_unmap(rvm,segs[0]);
    }

    
    //only even segments contain the second string (modify aa to ab)
    for(i = 0; i < numSegments; i++) {
      segs[0] = (char *) rvm_map(rvm, segnames[i], 3);
      trans = rvm_begin_trans(rvm, 1, (void **) segs);
      rvm_about_to_modify(trans, segs[0], 1, 1); 
      segs[0][1]='b';
      assert(strcmp("ab", segs[0]) == 0);
      if(i%2==0){ //the modulus is 1, we are even
	rvm_commit_trans(trans);
      }
    }
    

    // Free memory
    for(i = 0; i < numSegments; i++) {
      free(segnames[i]);
    }
    free(segnames);
}

Example #12

File: abort.c Project: j3gb3rt/CS4210Proj4

int main(int argc, char **argv)
{
     rvm_t rvm;
     char *seg;
     void *segs[1];
     trans_t trans;
     
     rvm = rvm_init("rvm_segments");
     
     rvm_destroy(rvm, "testseg");
     
     seg = (char *) rvm_map(rvm, "testseg", 10000);
	 segs[0] = seg;

     /* write some data and commit it */
     trans = rvm_begin_trans(rvm, 1, segs);
     rvm_about_to_modify(trans, seg, 0, 100);
     sprintf(seg, TEST_STRING1);
     
     rvm_about_to_modify(trans, seg, OFFSET2, 100);
     sprintf(seg+OFFSET2, TEST_STRING1);
     
     rvm_commit_trans(trans);

     /* start writing some different data, but abort */
     trans = rvm_begin_trans(rvm, 1, segs);
     rvm_about_to_modify(trans, seg, 0, 100);
     sprintf(seg, TEST_STRING2);
     
     rvm_about_to_modify(trans, seg, OFFSET2, 100);
     sprintf(seg+OFFSET2, TEST_STRING2);

	 rvm_abort_trans(trans);

     /* test that the data was restored */
     if(strcmp(seg+OFFSET2, TEST_STRING1)) {
	  printf("ERROR: second hello is incorrect (%s)\n",
		 seg+OFFSET2);
	  exit(2);
     }

     if(strcmp(seg, TEST_STRING1)) {
	  printf("ERROR: first hello is incorrect (%s)\n",
		 seg);
	  exit(2);
     }
     

     rvm_unmap(rvm, seg);
     printf("OK\n");
     exit(0);
}

Example #13

File: basic9.c Project: Machiry/AOS

/* proc2 opens the segments and reads from them */
void proc2() 
{
     char* segs[1];
     rvm_t rvm;

     rvm = rvm_init(__FILE__ ".d");

     segs[0] = (char *) rvm_map(rvm, "testseg", 10000);
     assert(strcmp(segs[0], "foo") == 0);

     printf("OK\n");
     exit(0);
}

Example #14

File: map-twice.cpp Project: xjiang67/os_project4

int main()
{
    rvm_t rvm = rvm_init("rvm_segments");
    char* segs[2];
    segs[0] = (char *) rvm_map(rvm, "testseg", 10000);
    segs[1] = (char *) rvm_map(rvm, "testseg", 10000);
    if(segs[1]==NULL){
        cout<<"OK"<<endl;
    }else{
        cout<<"ERROR: DID NOT DETECT MAP TWICE CASE!"<<endl;
    }
    return 0;
}

Example #15

File: test03.c Project: dmanatunga/cs6210-project4

void proc1() {
  rvm_t rvm;
  char* segs[1] = { 0 };

  rvm = rvm_init("rvm_segments");

  // this should fail
  rvm_unmap(rvm, segs[0]);

  printf("ERROR: Unmap() before mapping\n");
  segs[0] = (char*) rvm_map(rvm, "testseg03", 10000);

  return;
}

Example #16

File: test.cpp Project: xjiang67/os_project4

int main()
{
    rvm_verbose(0);
    rvm_t rvm = rvm_init("bak");
    std::cout << rvm->directory << std::endl;
    char* segs[1];
    segs[0] = (char *) rvm_map(rvm, "testseg", 10000);
    rvm_map(rvm, "testseg", 10000);
    rvm_unmap(rvm, segs[0]);
    segs[0] = (char *) rvm_map(rvm, "testseg", 10000);
    rvm_verbose(1);
    rvm_unmap(rvm, segs[0]);
    rvm_destroy(rvm,"testseg");
    return 0;
}

Example #17

File: truncate.c Project: Goldensunboy/cs4210-proj4

int main(int argc, char **argv) 
{
     rvm_t rvm;

     printf("Before Truncation:\n");
     system("ls -l rvm_segments");
     
     rvm = rvm_init("rvm_segments");
     rvm_truncate_log(rvm);

     printf("\nAfter Truncation:\n");
     system("ls -l rvm_segments");

     return 0;
}

Example #18

File: test06.c Project: dmanatunga/cs6210-project4

void proc1() {
  rvm_t rvm;
  trans_t trans = 0;
  char* segs[1];

  rvm = rvm_init("rvm_segments");
  rvm_destroy(rvm, "testseg");
  segs[0] = (char*) rvm_map(rvm, "testseg", 10000);

  // this should exit
  rvm_about_to_modify(trans, segs[0], 0, 100);

  fprintf(stderr, "ERROR: This should not be printed\n");

  abort();
}

Example #19

File: semantics_02.c Project: abhishekjain1991/Light_Weight_Recoverable_Virtual_Memory

/* test the resulting segment */
void test() 
{
     char* segs[1];
     rvm_t rvm;

     // rvm = rvm_init(__FILE__ ".d");
     rvm = rvm_init("rvm_segments");

     segs[0] = (char *) rvm_map(rvm, "testseg", 10);

     /* ensure originals */
     assert(strcmp(segs[0] + 0, "foo") == 0);
     assert(strcmp(segs[0] + 4, "bar") == 0);

     printf("OK\n");
     exit(0);
}

Example #20

File: test_multi1.c Project: Machiry/AOS

void proc2() 
{
     rvm_t rvm;
     char *segs[2];
     char** segnames;
     int i;
     int numSegments = 100;

     // Allocate some memory
     segnames = (char **)malloc(numSegments * sizeof(char *));
     
     for(i = 0; i < numSegments; i++) {
      segnames[i] = (char *)malloc(MAX_SEGMENT_NAME_LEN);   
      sprintf(segnames[i],"testseg%i",i);
     }
     rvm = rvm_init(__FILE__ ".d");
     
     for(i = 0; i < numSegments; i++) {
      
       segs[0] = (char *) rvm_map(rvm, segnames[i], 3);
       if(i%2==0){
	 if(strcmp(segs[0], "ab")) { 
	   printf("ERROR in segment %i, string should be ab, but it is (%s)\n",
		  i,segs[0]);
	   exit(2);
	 } 
       } else {
	 if(strcmp(segs[0], "aa")) { 
	   printf("ERROR in segment %i, string should be aa, but it is (%s)\n",
		  i,segs[0]);
	   exit(2);
	 } 
       }
       rvm_unmap(rvm,segs[0]);
     }
     

     printf("OK\n");

     // Free memory
     for(i = 0; i < numSegments; i++) {
       free(segnames[i]);
     }
     free(segnames);
}

Example #21

File: test08.c Project: dmanatunga/cs6210-project4

void proc1() {
  rvm_t rvm;
  trans_t trans = 0;
  char *segs1[2], *segs2[1];

  rvm = rvm_init("rvm_segments");
  rvm_destroy(rvm, "testseg");
  segs1[0] = (char*) rvm_map(rvm, "testseg", 10000);
  segs2[0] = (char*) rvm_map(rvm, "testseg02", 10000);

  trans = rvm_begin_trans(rvm, 1, (void**) segs1);

  // this should exit
  rvm_about_to_modify(trans, segs2[0], 0, 100);

  fprintf(stderr, "ERROR: Segment mapped is not the one being modified\n");

  abort();
}

Example #22

File: test3.c Project: gajayraghav/VRM

/* proc2 opens the segments and reads from them */
void proc2() 
{
     char* segs[1];
     rvm_t rvm;
     
     rvm = rvm_init("rvm_segments");
     char * currChar;
     segs[0] = (char *) rvm_map(rvm, "testseg", 1000 + 1000);
     currChar = segs[0];
     for (int counter = 0; counter < 1000; counter++){
       if (*currChar !='!'){
	 fprintf(stderr, "ERROR %c instead of !", *currChar);
       }
       
     }

     printf("OK\n");
     exit(0);
}

Example #23

File: test_deception.c Project: kszr/recoverable-vm

/* proc2 opens the segments and reads from them */
void proc2() 
{
     char* segs[1];
     rvm_t rvm;
     
     rvm = rvm_init("rvm_segments");

     segs[0] = (char *) rvm_map(rvm, "testseg", 10000);
     if(!strcmp(segs[0], BAD_STRING)) {
	  printf("ERROR: illegal change got recorded in segment 1: %s\n", segs[0]);
	  exit(2);
     }
     if(strcmp(segs[0]+OFFSET2, TEST_STRING)) {
	  printf("ERROR: hello not present in segment 2\n");
	  exit(2);
     }

     printf("OK\n");
     exit(0);
}

Example #24

File: basic.c Project: indianburger/aosp4

/* proc2 opens the segments and reads from them */
void proc2() 
{
     char* segs[1];
     rvm_t rvm;
     
     rvm = rvm_init("rvm_segments");

     segs[0] = (char *) rvm_map(rvm, "testseg", 10000);
     if(strcmp(segs[0], TEST_STRING)) {
	  printf("ERROR: first hello not present\n");
	  exit(2);
     }
     if(strcmp(segs[0]+OFFSET2, TEST_STRING)) {
	  printf("ERROR: second hello not present\n");
	  exit(2);
     }

     printf("OK\n");
     exit(0);
}

Example #25

File: semantics_02.c Project: abhishekjain1991/Light_Weight_Recoverable_Virtual_Memory

/* create the scenario */
void create() 
{
     
  // rvm_t rvm = rvm_init(__FILE__ ".d");
  rvm_t rvm = rvm_init("rvm_segments");
     rvm_destroy(rvm, "testseg");
     char* segs[1];


     /*-- without unmapping (first half of segment) --*/
     segs[0] = (char *) rvm_map(rvm, "testseg", 10);
     trans_t tid = rvm_begin_trans(rvm, 1, (void **) segs);
     rvm_about_to_modify(tid, segs[0], 0, 5);
     sprintf(segs[0], "foo"); /* write "foo" */
     rvm_commit_trans(tid);

     tid = rvm_begin_trans(rvm, 1, (void **) segs);
     segs[0][0] = 'b'; /* change to boo without logging */
     assert(strcmp(segs[0], "boo") == 0); /* ensure change */
     rvm_commit_trans(tid);



     /*-- unmap and remap (second half of segment) --*/
     tid = rvm_begin_trans(rvm, 1, (void **) segs);
     rvm_about_to_modify(tid, segs[0], 4, 5);
     sprintf(segs[0] + 4, "bar"); /* write "bar" */
     rvm_commit_trans(tid);
     rvm_unmap(rvm, segs[0]);

     segs[0] = (char *) rvm_map(rvm, "testseg", 10);
     tid = rvm_begin_trans(rvm, 1, (void **) segs);
     segs[0][6] = 'z'; /* change to baz without logging */
     assert(strcmp(segs[0] + 4, "baz") == 0); /* ensure change */
     rvm_commit_trans(tid);



     abort();
}

Example #26

File: test6.c Project: gajayraghav/VRM

/* proc2 opens the segments and reads from them */
void proc2() {
	char* segs[1];
	char *seg;
	rvm_t rvm;

	rvm = rvm_init("rvm_segments");
	segs[0] = (char *) rvm_map(rvm, "testseg", 10000);
	seg = segs[0];

	if (strcmp(seg + OFFSET2, TEST_STRING2)) {
		printf("ERROR: blew is incorrect (%s)\n", seg + OFFSET2);
		exit(2);
	}

	if (strcmp(seg, TEST_STRING1)) {
		printf("ERROR: first hello is incorrect (%s)\n", seg);
		exit(2);
	}

	printf("OK\n");
	exit(0);
}

Example #27

File: abouttomodify2.c Project: netrakenkarey/RVM

int main(int argc, char **argv)
{
     rvm_t rvm;
     char* segs[2];
     char* badsegs;
     trans_t trans;

     /* initialize */
     rvm = rvm_init("rvm_segments");

     rvm_destroy(rvm, SEGNAME0);
     rvm_destroy(rvm, SEGNAME1);
     rvm_destroy(rvm, SEGNAME2);

     segs[0] = (char*) rvm_map(rvm, SEGNAME0, 1000);
     segs[1] = (char*) rvm_map(rvm, SEGNAME1, 1000);
     badsegs = (char*) rvm_map(rvm, SEGNAME2, 1000);


     /* write in some initial data */
     trans = rvm_begin_trans(rvm, 2, (void **) segs);

     rvm_about_to_modify(trans, segs[0], OFFSET0, 100);
     strcpy(segs[0]+OFFSET0, GOOD_STRING);
     rvm_about_to_modify(trans, badsegs, OFFSET0, 100);
     strcpy(badsegs+OFFSET0, GOOD_STRING);

     rvm_commit_trans(trans);

     /* test the strings */
     if(strcmp(badsegs + OFFSET0, GOOD_STRING)) {
	  printf("ERROR segment not mentioned in rvm_begin_trans yet modifications made (%s)\n",
		 badsegs+OFFSET0);
	  exit(2);
     }

     printf("OK\n");
     return 0;
}

Example #28

File: segfault.c Project: Goldensunboy/cs4210-proj4

void proc2() 
{
     rvm_t rvm;
     char *segs[2];

     rvm = rvm_init("rvm_segments");
     segs[0] = (char*) rvm_map(rvm, SEGNAME0, 1000);
     segs[1] = (char*) rvm_map(rvm, SEGNAME1, 1000);

     if(strcmp(segs[0] + OFFSET0, STRING0)) {
	  printf("ERROR in segment 0 (%s)\n",
		 segs[0]+OFFSET0);
	  exit(2);
     }
     if(strcmp(segs[1] + OFFSET1, STRING1)) {
	  printf("ERROR in segment 1 (%s)\n",
		 segs[1]+OFFSET1);
	  exit(2);
     }

     printf("OK\n");
}

Example #29

File: test5.c Project: hchawla/CS6210-RVM

/* proc2 opens the segments and reads from them */
void proc2() {
	char* segs[5];
	rvm_t rvm;

	rvm = rvm_init("rvm_segments");

	segs[0] = (char *) rvm_map(rvm, "page0", 10000);
	segs[1] = (char *) rvm_map(rvm, "page1", 10100);
	segs[2] = (char *) rvm_map(rvm, "page2", 10200);
	segs[3] = (char *) rvm_map(rvm, "page3", 10300);
	segs[4] = (char *) rvm_map(rvm, "page4", 10400);

	for (int i = 0; i < 5; i++) {
		if (strcmp(segs[i] + OFFSET1 * i, TEST_STRING)) {
			printf("ERROR: hello not present @ %d\n", i);
			exit(2);
		}
	}

	printf("OK\n");
	exit(0);
}

Example #30

File: rvm_main.c Project: wanchen1112/CS6210_Lab_4

int main(int argc, char **argv) 
{
#if 1
     int pid;

     pid = fork();
     if(pid < 0) {
	  perror("fork");
	  exit(2);
     }
     if(pid == 0) {
	  proc1();
	  exit(0);
     }

     waitpid(pid, NULL, 0);

     proc2();
#else 
     /* truncate test */

     proc1();

     rvm_t rvm;

     printf("Before Truncation:\n");
     system("ls -l rvm_segments");
     
     rvm = rvm_init("rvm_segments");
     rvm_truncate_log(rvm);

     printf("\nAfter Truncation:\n");
     system("ls -l rvm_segments");

#endif
     return 0;

}