예제 #1
0
파일: freetests.c 프로젝트: gzachv/ece354
int main()
{
  /* Create memory space */
  assert(Mem_Init(MEM_SIZE) == 0);
  printf("Memory Space requested with size: %d\n",MEM_SIZE);   
  Mem_Dump();  

  /* Ask for simple memory allocation */
  void* ptr = Mem_Alloc(ALLOC_SIZE);
  printf("\nRequest memory block of size: %d\n",ALLOC_SIZE);
  Mem_Dump();
 
  /* Free memory */
  assert(Mem_Free(ptr) == 0);
  printf("\nFree memory space");
  Mem_Dump();
  
  /* Request memory again*/
  ptr = Mem_Alloc(ALLOC_SIZE);
  printf("\nRequest memory block of size: %d\n",ALLOC_SIZE);
  Mem_Dump();
    
  /* Corrupt pointer */
  ptr = NULL;

  /* Attemp to free memory with bad pointer */
  int result = Mem_Free(ptr);
  printf("Attempted to free memory pointed to by pointer (ptr = %p)\n",ptr);
  printf("Result from Mem_Free(ptr) = %d\n",result);
  Mem_Dump();

  exit(0);
}
예제 #2
0
int main() {
   assert(Mem_Init(4096) == 0);
   void * ptr[4];

   ptr[0] = Mem_Alloc(800);
   assert(ptr[0] != NULL);

   ptr[1] = Mem_Alloc(800);
   assert(ptr[1] != NULL);

   ptr[2] = Mem_Alloc(800);
   assert(ptr[2] != NULL);

   ptr[3] = Mem_Alloc(800);
   assert(ptr[3] != NULL);

   while (Mem_Alloc(800) != NULL)
      ;

	 Mem_Dump();
   assert(m_error == E_NO_SPACE);

   assert(Mem_Free(ptr[1]) == 0);
	 Mem_Dump();
   assert(Mem_Free(ptr[3]) == 0);
	 Mem_Dump();
   assert(Mem_Free(ptr[2]) == 0);
	 Mem_Dump();

   ptr[2] = Mem_Alloc(2400);
   assert(ptr[2] != NULL);

	 Mem_Dump();
   exit(0);
}
예제 #3
0
int main() {
   assert(Mem_Init(4096) == 0);
   void* ptr = Mem_Alloc(8);
   Mem_Dump();
   assert(ptr != NULL);
   assert(Mem_Free(ptr) == 0);
   printf("\nEND\n");
   Mem_Dump();
   exit(0);
}
예제 #4
0
파일: nospace.c 프로젝트: ethanz/OS-3
int main() {
   assert(Mem_Init(4096) == 0);
   Mem_Dump();
   assert(Mem_Alloc(2048, FIRSTFIT) != NULL);
   Mem_Dump();
   assert(Mem_Alloc(2049, FIRSTFIT) == NULL);
   Mem_Dump();
   assert(m_error == E_NO_SPACE);

   exit(0);
}
예제 #5
0
파일: alloc2.c 프로젝트: gzachv/ece354
int main() {
   assert(Mem_Init(4096) == 0);
   assert(Mem_Alloc(4) != NULL);
   Mem_Dump();
   assert(Mem_Alloc(8) != NULL);
   Mem_Dump();
   assert(Mem_Alloc(16) != NULL);
   Mem_Dump();
   assert(Mem_Alloc(4) != NULL);
   Mem_Dump();
   exit(0);
}
예제 #6
0
int main(int argc, char *argv[]) {
  void *space = Mem_Init(4096);
  assert(space != NULL);
  printf("Got space %p\n", space);
  int *x = Mem_Alloc(sizeof(int));
  //int *y = Mem_Alloc(sizeof(int));
  //assert(x != NULL && y != NULL);

  //printf("pre x = %p\n", x);
  //printf("pre y = %p\n", y);

  // use x and y
  *x = 123;
  //*y = 456;

  //printf("post x = %p\n", x);
  //printf("post y = %p\n", y);

  //Mem_Free(x);
  //Mem_Free(y);

  //int64_t *x;
  // should loop forever
  
  while ((x = Mem_Alloc(sizeof(int))) != NULL) {
    printf("x = %p\n", x);
    //Mem_Free(x);
    //Mem_Dump();
  }

  Mem_Dump();
  return 0;
}
예제 #7
0
int main() {
   assert(Mem_Init(4096) == 0);
   void* ptr = Mem_Alloc(8);
   assert(ptr != NULL);
    Mem_Dump();
   exit(0);
    
}
예제 #8
0
파일: bestfit2.c 프로젝트: ethanz/OS-3
int main() {
   assert(Mem_Init(4096) == 0);
   void *ptr[4];
   void *first, *best, *worst;

   assert(Mem_Alloc(8, FIRSTFIT) != NULL);
   ptr[0] = Mem_Alloc(40, FIRSTFIT);
   assert(Mem_Alloc(8, FIRSTFIT) != NULL);
   ptr[1] = Mem_Alloc(56, FIRSTFIT);
   assert(Mem_Alloc(8, FIRSTFIT) != NULL);
   first = Mem_Alloc(256, FIRSTFIT);
   assert(Mem_Alloc(8, FIRSTFIT) != NULL);
   best = Mem_Alloc(128, FIRSTFIT);
   assert(Mem_Alloc(8, FIRSTFIT) != NULL);
   ptr[2] = Mem_Alloc(32, FIRSTFIT);
   assert(Mem_Alloc(8, FIRSTFIT) != NULL);
   worst = Mem_Alloc(512, FIRSTFIT);
   assert(Mem_Alloc(8, FIRSTFIT) != NULL);
   ptr[3] = Mem_Alloc(32, FIRSTFIT);
   Mem_Dump();
   int count = 0;
   while(Mem_Alloc(128, FIRSTFIT) != NULL)
   {
	   printf("%d\n", count);
	   count++;
   	Mem_Dump();
   }
   assert(m_error == E_NO_SPACE);

   assert(Mem_Free(ptr[2]) == 0);
   assert(Mem_Free(ptr[3]) == 0);
   Mem_Dump();
   assert(Mem_Free(first) == 0);
   Mem_Dump();
   assert(Mem_Free(best) == 0);
   Mem_Dump();
   assert(Mem_Free(ptr[1]) == 0);
   Mem_Dump();
   assert(Mem_Free(worst) == 0);
   Mem_Dump();
   assert(Mem_Free(ptr[0]) == 0);
   Mem_Dump();

   assert(Mem_Alloc(128, BESTFIT) == best);
   Mem_Dump();

   exit(0);
}
예제 #9
0
int main() {
  /* Make sure the memory initializes correctly */
  assert(Mem_Init(memsize) == 0);

  printf("Allocating %d from initialized memory.\n\n", allocation);
  /* Make an allocation, get a pointer, and print memory usage */
  ptr = Mem_Alloc(allocation);
  Mem_Dump();

  printf("Freeing %d from initialized memory.\n", allocation);
  /* Free the memory and make sure it exits with status 0 */
  assert(Mem_Free(ptr) == 0);
  Mem_Dump();
  puts("Checking if Mem_Free() handles bad pointers...");
  /* Check exit status for NULL and bad pointers */
  ptr = NULL;
  assert(Mem_Free(ptr) == -1);
  ptr = (int *)5;
  assert(Mem_Free(ptr) == -1);
  puts("...done.");
}   
예제 #10
0
int main() {
   assert(Mem_Init(4096) == 0);
   void * ptr[9];
   ptr[0] = Mem_Alloc(1);
   ptr[1] = (Mem_Alloc(5));
   ptr[2] = (Mem_Alloc(14));
   ptr[3] = (Mem_Alloc(8));
   assert(ptr[0] != NULL);
   assert(ptr[1] != NULL);
   assert(ptr[2] != NULL);
   assert(ptr[3] != NULL);

   assert(Mem_Free(ptr[1]) == 0);
   assert(Mem_Free(ptr[0]) == 0);
   assert(Mem_Free(ptr[3]) == 0);
   Mem_Dump();
   ptr[4] = (Mem_Alloc(1));
   ptr[5] = (Mem_Alloc(4));
   assert(ptr[4] != NULL);
   assert(ptr[5] != NULL);

   assert(Mem_Free(ptr[5]) == 0);

   ptr[6] = (Mem_Alloc(9));
   ptr[7] = (Mem_Alloc(33));
   assert(ptr[6] != NULL);
   assert(ptr[7] != NULL);

   assert(Mem_Free(ptr[4]) == 0);

   ptr[8] = (Mem_Alloc(55));
   assert(ptr[8] != NULL);

   assert(Mem_Free(ptr[2]) == 0);
   assert(Mem_Free(ptr[7]) == 0);
   assert(Mem_Free(ptr[8]) == 0);
   assert(Mem_Free(ptr[6]) == 0);
   Mem_Dump();
   exit(0);
}
예제 #11
0
int main() {
   assert(Mem_Init(4096) == 0);
   void * ptr[6];

   ptr[0] = Mem_Alloc(400, BESTFIT);
   assert(ptr[0] != NULL);

   ptr[1] = Mem_Alloc(400, BESTFIT);
   assert(ptr[1] != NULL);

   ptr[2] = Mem_Alloc(1000, BESTFIT);
   assert(ptr[2] != NULL);

   ptr[3] = Mem_Alloc(1000, BESTFIT);
   assert(ptr[3] != NULL);

   ptr[4] = Mem_Alloc(400, BESTFIT);
   assert(ptr[4] != NULL);

   ptr[5] = Mem_Alloc(400, BESTFIT);
   assert(ptr[5] != NULL);
   Mem_Dump();
   
   assert(Mem_Free(ptr[0]) == 0);
   ptr[0] = NULL;
   Mem_Dump();
   
   assert(Mem_Free(ptr[2]) == 0);
   ptr[2] = NULL;
   Mem_Dump();

   assert(Mem_Free(ptr[4]) == 0);
   ptr[4] = NULL;
   Mem_Dump();
   
   ptr[0] = Mem_Alloc(360, BESTFIT);
   assert(ptr[0] != NULL);
   Mem_Dump();
   
   ptr[2] = Mem_Alloc(360, BESTFIT);
   assert(ptr[2] != NULL);
   Mem_Dump();
   
   ptr[4] = Mem_Alloc(960, BESTFIT);
   assert(ptr[4] != NULL);

   exit(0);
}
예제 #12
0
int main() {
   printf("Starting mem testing...");
   /*
   int result = Mem_Init(6012);
   printf("Called Mem_Init... result=%i\r\n",result);
   if (result == 0) printf("Successfully called Mem_Init()!\r\n");
   int *ptr = Mem_Alloc(2);
   int *ptr2 = Mem_Alloc(14);
   int *ptr3 = Mem_Alloc(32);
   printf("Got allocated memory @%p!\r\n",ptr);
   result = Mem_Free(ptr);
   Mem_Dump();
   if (result == 0) printf("Successfully called Mem_Free()!\r\n");
   Mem_Free(ptr2);
   Mem_Free(ptr3);
   printf("Calling Mem_Dump()... ");
   printf("finishing up testing program.........\r\n");
   printf("---------------------------------------------------------\r\n");
   */
   printf("taking apart free2\r\n"); 

   Mem_Init(4096);
   void *ptr[4];
   ptr[0] = Mem_Alloc(800);
   ptr[1] = Mem_Alloc(800);
   ptr[2] = Mem_Alloc(800);
   ptr[3] = Mem_Alloc(800);
   Mem_Free(ptr[1]);
   Mem_Free(ptr[2]);
   ptr[2] = Mem_Alloc(1600);
   

   Mem_Dump();



   return 0;
}
예제 #13
0
파일: mem.c 프로젝트: samgooi4189/cs537
int main(int argc, char **argv) {
   // psudeo-random seed
   unsigned int seed = atoi(argv[1]);

   // number of operations to perform
   long long n = atoll(argv[2]);

   // if true, write data into allocated memory
   bool writeData = atoi(argv[3]);

   // maximum number of concurrent allocations to track
   int max_allocs = 1000;

   // size for allocation request
   int min_alloc_size = 1;
   int max_alloc_size = 128;

   // allowed constant overhead
   int slack = 32;

   // max header size per allocation
   int header_size = 32;

   // request size up to 64+32, header up to 32 bytes
   int max_chunk_size = max_alloc_size + header_size;

   // most possible space, no more than max_allocs+1 unusable free chunks
   int region_size = max_allocs * max_chunk_size * 2 + max_chunk_size;

   void** ptr = calloc(sizeof(void*), max_allocs);
   int* size = calloc(sizeof(int), max_allocs);
   void** shadow = calloc(sizeof(void*), max_allocs);

   /*******************************************************************
   Please note that random() gives psudeo-random, not true random data.
   If the seed is set to the same value, the sequence generated by
   random() will be the same. Using psuedo-random number generators is
   a common testing technique.
   *******************************************************************/
   srandom(seed);

   assert(Mem_Init(region_size + slack) == 0);

   int slot;
   bool doAlloc;
   bool doWrite;

   long long i;


   for (i=0; i<n; i++) {
      slot = random() % max_allocs;
      doAlloc = random() % 4;
      doWrite = writeData;

      if (!doAlloc || ptr[slot] != NULL) {
         assert(Mem_Free(ptr[slot], 1) == 0);
         free(shadow[slot]);
         ptr[slot] = NULL;
         shadow[slot] = NULL;
      }

		Mem_Dump();
      if (doAlloc) {
         size[slot] = min_alloc_size +
            (random() % (max_alloc_size - min_alloc_size + 1));
         ptr[slot] = Mem_Alloc(size[slot]);
         assert(ptr[slot] != NULL);
         if (doWrite) {
            shadow[slot] = malloc(size[slot]);
            int j;
            for (j=0; j<size[slot]; j++) {
               char data = random();
               *((char*)(ptr[slot] + j)) = data;
               *((char*)(shadow[slot] + j)) = data;
            }
         }
      }
   }

   if (writeData) {
      for (slot=0; slot<max_allocs; slot++) {
         if (ptr[slot] != NULL) {
            assert(memcmp(ptr[slot], shadow[slot], size[slot]) == 0);
         }
      }
   }


exit(0);

	return 0;
} // END OF MAIN
예제 #14
0
파일: mem.c 프로젝트: samgooi4189/cs537
int Mem_Free(void *ptr, int coalesce) {

    printf("Freeing: %p \n", &ptr);
    Mem_Dump();
    if(ptr == NULL) {
        return 0;
    }

    //void * new_block_ptr = ptr - sizeof(struct node_block);
    struct node_block *ptr_header;
    struct node_block *cur_block;
    //struct node_block *prev = free_block_head;

    // point to block header
    ptr_header = (struct node_block*) (ptr - sizeof(struct node_block));


    // cur block points to free list header
    cur_block = free_block_head;

    // if the allocated memory comes before the free list
    if( (uintptr_t *) ptr_header < (uintptr_t *) cur_block ) {
        free_block_head->prev = ptr_header;
        ptr_header->next = free_block_head;
        ptr_header->prev = NULL;
        free_block_head = ptr_header;
    } else if(ptr_header != free_block_head) { // comes after free list

        while(cur_block->next != NULL) {
            if( (uintptr_t *) cur_block->next > (uintptr_t *) ptr_header ) {
                break;
            }
            cur_block = cur_block->next;
        }
        if(cur_block == free_block_head) { // in front of list
            ptr_header->prev = cur_block;
            ptr_header->next = cur_block->next;
            if(ptr_header->next != NULL) ptr_header->next->prev = ptr_header;
            cur_block->next = ptr_header;
        } else if (cur_block->next == NULL) { // end of list
            ptr_header->prev = cur_block;
            if(ptr_header->next != NULL) ptr_header->prev->next = ptr_header;
            ptr_header->next = cur_block->next;
            cur_block->next = ptr_header;
        } else if (cur_block != free_block_head) { // middle
            ptr_header->prev = cur_block;
            ptr_header->next = cur_block->next;
            cur_block->next = ptr_header;
            if(ptr_header->next != NULL) ptr_header->next->prev = ptr_header;
        }

    }

    // check whether need to coalesce
    if(coalesce != 0) {
        //cur_block = ptr_header;
        cur_block = free_block_head;


        /*// check for left coalesce
        if( (ptr_header->prev != NULL) && ((void *) ptr_header->prev == (void *) ptr_header - ptr_header->prev->size - sizeof(struct node_block)) ) {
        	ptr_header->prev->size += (ptr_header->size + sizeof(struct node_block)); // update size
        	ptr_header->prev->next = ptr_header->next;
        	if(ptr_header->next != NULL) ptr_header->next->prev = ptr_header->prev;
        	ptr_header = ptr_header->prev;
        }


        // check for right coalesce
        if( ptr_header->next != NULL && (void *) ptr_header->next == (void *) ptr_header + ptr_header->next->size + sizeof(struct node_block)) {
        	ptr_header->size += (ptr_header->next->size + sizeof(struct node_block)); // update size
        	if(ptr_header->next->next != NULL) ptr_header->next->next->prev = ptr_header;
        	ptr_header->next = ptr_header->next->next; // update the next
        }*/


        while(cur_block != NULL && cur_block->next != NULL) {
            if((void *) cur_block + sizeof(struct node_block) + cur_block->size == (void *) cur_block->next) {

                // update the size to include the adjacent block and header
                cur_block->size += (cur_block->next->size + sizeof(struct node_block));

                // remove the adjacent block from the link
                cur_block->next = cur_block->next->next;
            } else {
                cur_block = cur_block->next;
            }
        }


    }

    return 0;

} // END OF MEM_FREE
예제 #15
0
int main() {
   assert(Mem_Init(4096) == 0);
   void* ptr[9];
   void* test;

   ptr[0] = Mem_Alloc(300);
   assert(ptr[0] != NULL);

   ptr[1] = Mem_Alloc(200);
   assert(ptr[1] != NULL);

   ptr[2] = Mem_Alloc(200);
   assert(ptr[2] != NULL);

   ptr[3] = Mem_Alloc(100);
   assert(ptr[3] != NULL);

   ptr[4] = Mem_Alloc(200);
   assert(ptr[4] != NULL);

   ptr[5] = Mem_Alloc(800);
   assert(ptr[5] != NULL);

   ptr[6] = Mem_Alloc(500);
   assert(ptr[6] != NULL);

   ptr[7] = Mem_Alloc(700);
   assert(ptr[7] != NULL);

   ptr[8] = Mem_Alloc(300);
   assert(ptr[8] != NULL);
   Mem_Dump();
   assert(Mem_Free(ptr[1]) == 0);
   assert(Mem_Free(ptr[3]) == 0);
   assert(Mem_Free(ptr[5]) == 0);
   assert(Mem_Free(ptr[7]) == 0);
   Mem_Dump();
   test = Mem_Alloc(50);
   Mem_Dump();
   assert(
           (!(
             (
               ((unsigned long int)test >= (unsigned long int)ptr[3])
               &&
               ((unsigned long int)test < (unsigned long int)ptr[4])
             )
             ||
             (
               ((unsigned long int)test >= (unsigned long int)ptr[3])
               &&
               ((unsigned long int)test < (unsigned long int)ptr[2])
             )
           ))
           &&
           (!(
             (
               ((unsigned long int)test >= (unsigned long int)ptr[5])
               &&
               ((unsigned long int)test < (unsigned long int)ptr[6])
             )
             ||
             (
               ((unsigned long int)test >= (unsigned long int)ptr[5])
               &&
               ((unsigned long int)test < (unsigned long int)ptr[4])
             )
           ))
         );
   exit(0);
}