/*------------------------------------------------------------------------ * xsh_memstat - Print statistics about memory use and dump the free list *------------------------------------------------------------------------ */ shellcmd xsh_memstat(int nargs, char *args[]) { /* For argument '--help', emit help about the 'memstat' command */ if (nargs == 2 && strncmp(args[1], "--help", 7) == 0) { printf("use: %s \n\n", args[0]); printf("Description:\n"); printf("\tDisplays the current memory use and prints the\n"); printf("\tfree list.\n"); printf("Options:\n"); printf("\t--help\t\tdisplay this help and exit\n"); return 0; } /* Check for valid number of arguments */ if (nargs > 1) { fprintf(stderr, "%s: too many arguments\n", args[0]); fprintf(stderr, "Try '%s --help' for more information\n", args[0]); return 1; } printMemUse(); printFreeList(); return 0; }
short RemoveFreeByColor(FreeList *fl, int v, int color, Table *table){ TableCell *tcell; if (IsFreeColor(v, color, *fl)){ tcell = &table->matrix[v][color]; RemoveFreeIntern(&fl->f[v], &color, tcell->cPointer, tcell); printf("\nRemoveFree(%d, %d):", v, color); /* apagar*/ printFreeList(*fl); /* apagar */ return TRUE; } return FALSE; }
// allocate x memory blocks, then start freeing every mod y of them // in case we dont see issues because we are too even or multiples of // even void allocXfreeModY(int x, int y){ int i; struct memHeader* ahdr; char* kaddresses[MAXADDR]; for (i=1; i< x; i++){ kaddresses[i] = (char*)kmalloc(i*2); freeMemListOK(); memHeaderOK( (struct memHeader*)hdrFromUsrPtr(kaddresses[i])); ahdr = (struct memHeader*) hdrFromUsrPtr(kaddresses[i]); kprintf("\t%d, user address=0x%x, hdr addres=0x%x, size=0x%x, sanity=0x%x, prev=%x, next= %x\n", i,kaddresses[i],ahdr,ahdr->size,ahdr->sanityCheck, ahdr->prev, ahdr->next ); } for (i=1; i<x;i++){ if (i%y) kfree(kaddresses[i]); freeMemListOK(); } printFreeList(); sleep(5); }
/** * @ingroup shell * * Shell command (gpiostat) provides memory use and free list information. * @param nargs number of arguments in args array * @param args array of arguments * @return non-zero value on error */ shellcmd xsh_memstat(int nargs, char *args[]) { int i; tid_typ tid; /* thread to dump memlist of */ char print; /* print region free/alloc lists */ print = PRINT_DEFAULT; /* Output help, if '--help' argument was supplied */ if (nargs == 2 && strcmp(args[1], "--help") == 0) { usage(args[0]); return 0; } tid = BADTID; for (i = 1; i < nargs; i++) { if (0 == strcmp(args[i], "-t")) { if (i + 1 < nargs) { /* Get thread id to display freelist of */ print |= PRINT_THREAD; tid = atoi(args[i + 1]); } else { usage(args[0]); return 1; } } else if (0 == strcmp(args[i], "-r")) { print |= PRINT_REGION; } else if (0 == strcmp(args[i], "-k")) { print |= PRINT_KERNEL; } else if (0 == strcmp(args[i], "-q")) { print &= ~(PRINT_DEFAULT); } } if (print & PRINT_DEFAULT) { printMemUsage(); } if (print & PRINT_REGION) { printRegAllocList(); printRegFreeList(); } if (print & PRINT_KERNEL) { printFreeList(&memlist, "kernel"); } if (print & PRINT_THREAD) { if (isbadtid(tid)) { fprintf(stderr, "Invalid thread id: %d\n", tid); } else { printFreeList(&(thrtab[tid].memlist), thrtab[tid].name); } } return 0; }
int main () { FreeList *FL_START = NULL, *FL_END = NULL; char tempBuffer[80]; char *inputCommand, *tempBuffer2; unsigned int inputArgument; // Number of bytes requested by the user printf ("********** IMPORTANT **********\n"); printf ("This program implements a Linked List to store the allocated and de-allocated memory.. ..\n"); printf ("The size of LinkedList Structure == %lu (bytes)\n\n", sizeof (FreeList)); printf ("***** Made By: GURSIMRAN SINGH __ 2014041 *****\n\n"); printf ("Enter one of the following (without quotes) to operate\n"); printf ("\t\"malloc\" <int>\t\tTo allocate <int> bytes\n"); printf ("\t\"free\" <int>\t\tTo free the entry at <int> in the list\n"); printf ("\t\"printlist\"\t\tTo print the FreeList\n"); printf ("\t\"exit\"\t\t\tTo quit\n\n"); while (1) { fgets (tempBuffer, 80, stdin); tempBuffer [strlen (tempBuffer) -1] = '\0'; inputCommand = strtok (tempBuffer, " "); tempBuffer2 = strtok (NULL, " "); if (tempBuffer2 != NULL) inputArgument = atoi (tempBuffer2); else inputArgument = -1; // printf ("%s %d\n", inputCommand, inputArgument); if (!strcmp (inputCommand, "malloc")) { if (inputArgument > 0) insertAtEnd (&FL_START, &FL_END, inputArgument); continue; } else if (!strcmp (inputCommand, "free")) { deleteFromPosition (&FL_START, &FL_END, inputArgument); continue; } else if (!strcmp (inputCommand, "printlist")) { if (inputArgument == -1) printFreeList (FL_START, FL_END); continue; } else if (!strcmp (inputCommand, "exit")) { _exit_ (&FL_START, &FL_END); } else { printf ("INVALID_COMMAND: Enter one of the following (without quotes)\n"); printf ("\t\"malloc\" <int>\t\tTo allocate <int> bytes\n"); printf ("\t\"free\" <int>\t\tTo free the entry at <int> in the list\n"); printf ("\t\"printlist\"\t\tTo print the FreeList\n\n"); } } return 0; }
// basic sanity check is automated by memHeaderOK and freememListOK // failure on sanity conditions will halt system. // manual inspection is only required to verify values, not consistency or sanity void testkmalloc(void){ TRACE //test allocating a single block int request = 1; char* abyte = (char*)kmalloc (request); showAllocatedHeader(abyte); memHeaderOK((struct memHeader*) (abyte-sizeof(struct memHeader))); kprintf("*******************TESTKMALLOC***************\n"); kprintf("1. kmalloc(0x%x) returned address %x\n", request, abyte ); kassert(((struct memHeader*)hdrFromUsrPtr(abyte))->size=16); printFreeList(); freeMemListOK(); sleep (10); // size of new smaller free block is correct // 32bytes for user data and 16 bytes for extra header = 48 bytes (0x30 size reduction) // test allocating a second block request+=1; abyte = (char*)kmalloc (request); showAllocatedHeader(abyte); memHeaderOK((struct memHeader*) (abyte-sizeof(struct memHeader))); kprintf("2. kmalloc(0x%x) returned address %x\n", request, abyte ); kassert(((struct memHeader*)hdrFromUsrPtr(abyte))->size=16); printFreeList(); freeMemListOK(); sleep(5); // test allocating a single block size = pagesize request=16; abyte = (char*)kmalloc (request); showAllocatedHeader(abyte); kassert(((struct memHeader*)hdrFromUsrPtr(abyte))->size=16); memHeaderOK((struct memHeader*) (abyte-sizeof(struct memHeader))); kprintf("3. kmalloc(0x%x) returned address %x\n", request, abyte ); printFreeList(); freeMemListOK(); sleep(5); // ask for size larger than in first memory block request=0x98650; abyte = (char*)kmalloc (request); showAllocatedHeader(abyte); kassert(((struct memHeader*)hdrFromUsrPtr(abyte))->size>=request); memHeaderOK((struct memHeader*) (abyte-sizeof(struct memHeader))); kprintf("4. kmalloc(0x%x) returned address %x\n", request, abyte ); printFreeList(); freeMemListOK(); sleep(5); // ask for size larger than largest block request = 0x1d20000; abyte = (char*)kmalloc (request); kassert(abyte==0); kprintf("5. kmalloc(0x%x) returned address %x\n", request, abyte ); printFreeList(); freeMemListOK(); sleep(5); // ask for size just smaller than full memory block (leave less than 32 bytes) request = 0x980b1; abyte = (char*)kmalloc (request); showAllocatedHeader(abyte); kassert(((struct memHeader*)hdrFromUsrPtr(abyte))->size>request); memHeaderOK((struct memHeader*) (abyte-sizeof(struct memHeader))); kprintf("6. kmalloc(0x%x) returned address %x\n", request, abyte ); printFreeList(); freeMemListOK(); sleep(5); }
void testkfree(void){ int i =0; int testno=0; char* addresses[16] ; struct memHeader* ahdr; // starting with ABCDE all allocated, test sequence will be // // free(A), which tested return first memblock, // free(B), return 2nd memblock - coallesce left // free(d), return a block that requires linking left and right // free(c), return a block that requires coallescing left and right // free(e), return a block that requires coallescing left and right to restore all free kprintf("TEST %d ===================\n",++testno); kprintf("kfree test freememABCDE free A----------------\n"); kprintf(" --setting up for test 1\n"); for (i =0; i<5 ;i++) { addresses[i] = (char*)kmalloc(1); memHeaderOK((struct memHeader*)hdrFromUsrPtr(addresses[i])); freeMemListOK(); } kprintf("TEST %d === Allocated User Memory==============\n", testno); for (i = 0; i< 5; i++){ ahdr = (struct memHeader*) hdrFromUsrPtr(addresses[i]); kprintf("\t%d, user address=0x%x, hdr addres=0x%x, size=0x%x, sanity=0x%x, prev=%x, next=%x\n", i,addresses[i],ahdr,ahdr->size,ahdr->sanityCheck,ahdr->prev, ahdr->next ); } kprintf("TEST %d --freelist before test\n", testno); printFreeList(); sleep(5); kprintf("TEST %d --freeing first memHeader\n", testno); for (i =0; i<5 ;i++) memHeaderOK((struct memHeader*)hdrFromUsrPtr(addresses[i])); kprintf("TEST %d -- before test\n", testno); showAllocatedHeader(addresses[0]); printFreeList(); sleep(5); kfree(addresses[0]); for (i =0; i<5 ;i++) memHeaderOK((struct memHeader*)hdrFromUsrPtr(addresses[i])); kprintf(" TEST %d --after test\n", testno); printFreeList(); freeMemListOK(); sleep(5); //free pattern freememFBCDE free B kprintf("TEST %d ===================\n",++testno); kprintf("TEST %d -- freelist inherited from last test\n", testno); kprintf("TEST %d --freeing B freememFBCDE free B - coallesce left\n", testno); memHeaderOK((struct memHeader*)hdrFromUsrPtr(addresses[1])); kprintf("TEST %d -- before test\n", testno); showAllocatedHeader(addresses[1]); printFreeList(); sleep (10); kfree(addresses[1]); //memHeaderOK((struct memHeader*)hdrFromUsrPtr(addresses[1])); // should no longer be valid header coallese into A, kprintf("TEST %d -- after test\n", testno); printFreeList(); freeMemListOK(); kprintf("TEST %d --result should have first memblock at head of freelist\n", testno); sleep(5); //free pattern freememFFCDE free D kprintf("TEST %d ===================\n",++testno); kprintf("TEST %d --freeing D freememFFCDE - link in middle \n", testno); memHeaderOK((struct memHeader*)hdrFromUsrPtr(addresses[3])); kprintf("TEST %d -- before test\n", testno); showAllocatedHeader(addresses[3]); sleep(5); kfree(addresses[3]); kprintf("TEST %d -- after test\n", testno); memHeaderOK((struct memHeader*)hdrFromUsrPtr(addresses[3])); printFreeList(); freeMemListOK(); kprintf("TEST %d --result should have first memblock at head of freelist\n", testno); sleep(5); //free pattern freememFFCFE free C kprintf("TEST %d ===================\n",++testno); kprintf(" TEST %d --freeing C freememFFCFE - coallesce (prev targ next)\n", testno); memHeaderOK((struct memHeader*)hdrFromUsrPtr(addresses[2])); kprintf(" TEST %d -- before test\n", testno); showAllocatedHeader(addresses[2]); printFreeList(); sleep(5); kfree(addresses[2]); //memHeaderOK((struct memHeader*)hdrFromUsrPtr(addresses[2])); //coallesce no longer valid header kprintf("TEST %d -- after test\n", testno); printFreeList(); freeMemListOK(); kprintf("TEST %d --result should have first memblock at head of freelist\n", testno); sleep(5); //free pattern freememFFFFE free E kprintf("TEST %d ===================\n",++testno); kprintf("TEST %d --freeing E freememFFFFE - coallesce (prev, target, next) n", testno); kprintf("TEST %d -- before test\n", testno); showAllocatedHeader(addresses[4]); printFreeList(); sleep(5); kfree(addresses[4]); kprintf("TEST %d --after test\n", testno); printFreeList(); freeMemListOK(); kprintf(" --result should have first memblock at head of freelist\n"); sleep(5); // completed batch one of free tests //all of addreses are already free, kprintf("TEST %d ===================\n",++testno); kprintf("TEST %d -- free addresses that are already free\n", testno); kprintf("TEST %d -- before test\n",testno); printFreeList(); sleep(5); for(i=0;i<5;i++){ kprintf("%d %x ", i, addresses[i]); kfree(addresses[i]); freeMemListOK(); } kprintf("TEST %d -- after test\n", testno); printFreeList(); sleep(5); //free pattern freememAFCDE free A kprintf("TEST %d ===================\n",++testno); kprintf("TEST %d -- kfree test freememAFCDE free A---link in returning first memory block-------------\n", testno); kprintf("TEST %d --setting up for test2\n", testno); freeMemListOK(); for(i=0;i<5;i++) { addresses[i] = (char*)kmalloc(1); freeMemListOK(); memHeaderOK( (struct memHeader*)hdrFromUsrPtr(addresses[i])); } kfree(addresses[1]); kprintf("TEST %d -- before test\n", testno); showAllocatedHeader(addresses[1]); printFreeList(); sleep(5); kfree(addresses[0]); kprintf("TEST %d -- after test\n", testno); printFreeList(); freeMemListOK(); sleep (10); // cleanup - release rest kfree(addresses[2]); kfree(addresses[3]); kfree(addresses[4]); kprintf("=== setting up for next test: Allocated User Memory\n"); for (i = 0; i< 5; i++){ addresses[i]=(char*)kmalloc(1); ahdr = (struct memHeader*) hdrFromUsrPtr(addresses[i]); //kprintf("\t%d, user address=0x%x, hdr addres=0x%x, size=0x%x, sanity=0x%x\n", //i,addresses[i],ahdr,ahdr->size,ahdr->sanityCheck ); } kprintf(" --second address should be part of free list (not adj to freemem)\n"); kfree(addresses[1]); kprintf("TEST %d ===================\n",++testno); kprintf("TEST %d --test freeing A - freememAFCDE - coallese right, inert head freememlist\n", testno); kprintf("TEST %d -- before test\n", testno); showAllocatedHeader(addresses[0]); printFreeList(); sleep(5); kfree(addresses[0]); kprintf("TEST %d -- after test\n", testno); printFreeList(); kprintf(" TEST %d --result should have first memblock at head of freelist, size 30\n", testno); sleep(5); //cleanup kfree(addresses[2]); kfree(addresses[3]); kfree(addresses[4]); ////free pattern AFCFE free C for 3way coallesc kprintf("TEST %d ===================\n",++testno); kprintf("TEST %d --kfree test AFCFE free b for 3way coallesc----------------\n", testno); kprintf("TEST %d --setting up for test 3\n", testno); for(i=0;i<5;i++) addresses[i] = (char*)kmalloc(1); kfree(addresses[1]); kfree(addresses[3]); kprintf("TEST %d --should now have AFCFE \n", testno); kprintf("TEST %d -- Allocated User Memory\n", testno); for (i = 0; i< 5; i++){ ahdr = (struct memHeader*) hdrFromUsrPtr(addresses[i]); kprintf("\t%d, user address=0x%x, hdr addres=0x%x, size=0x%x, sanity=0x%x\n", i,addresses[i],ahdr,ahdr->size,ahdr->sanityCheck ); } kprintf("TEST %d --test: freeing C in AFCFE : coalles prev and next\n", testno); kprintf("TEST %d -- before test\n", testno); showAllocatedHeader(addresses[2]); printFreeList(); sleep(5); kfree(addresses[2]); kprintf("TEST %d -- after test\n", testno); kprintf("TEST %d -- verify correct updating of Allocated User Memory blocks\n", testno); for (i = 0; i< 5; i++){ ahdr = (struct memHeader*) hdrFromUsrPtr(addresses[i]); kprintf("\t%d, user address=0x%x, hdr addres=0x%x, size=0x%x, sanity=0x%x\n", i,addresses[i],ahdr,ahdr->size,ahdr->sanityCheck ); } printFreeList(); kprintf("TEST %d --result should have first memblock at head of freelist, not adjacent to freemem, size 50\n", testno); sleep(5); // cleanup kfree(addresses[0]); kfree(addresses[4]); //free pattern AFBC free b for left coallesc kprintf("TEST %d ===================\n",++testno); kprintf(" TEST %d --kfree test AFBC free b for left coallesc----------------\n", testno); for(i=0;i<5;i++) { addresses[i] = (char*)kmalloc(1); freeMemListOK(); memHeaderOK( (struct memHeader*)hdrFromUsrPtr(addresses[i])); } showAllocatedHeader(addresses[1]); kfree(addresses[1]); kprintf("TEST %d -- test setup : Allocated User Memory\n", testno); for (i = 0; i< 5; i++){ ahdr = (struct memHeader*) hdrFromUsrPtr(addresses[i]); kprintf("\t%d, user address=0x%x, hdr addres=0x%x, size=0x%x, sanity=0x%x, prev=%x, next= %x\n", i,addresses[i],ahdr,ahdr->size,ahdr->sanityCheck, ahdr->prev, ahdr->next ); } kprintf(" TEST %d --before test\n", testno); printFreeList(); kprintf(" TEST %d -- test AFBC, freeing B - coallesc left\n", testno); showAllocatedHeader(addresses[2]); sleep(5); kfree(addresses[2]); kprintf(" TEST %d -- after test\n", testno); printFreeList(); freeMemListOK(); sleep(5); //free pattern ABFC free b for right coallesc kprintf("TEST %d ===================\n",++testno); kprintf(" -- kfree test ABFC free b for right coallesc----------------\n"); for(i=0;i<5;i++) { addresses[i] = (char*)kmalloc(1); freeMemListOK(); memHeaderOK( (struct memHeader*)hdrFromUsrPtr(addresses[i])); } kfree(addresses[2]); kprintf(" --before test\n"); printFreeList(); showAllocatedHeader(addresses[1]); sleep(5); kfree(addresses[1]); kprintf(" --after test\n"); printFreeList(); freeMemListOK(); sleep(5); //free pattern AFCDEF free d for all linking kprintf("TEST %d ===================\n",++testno); kprintf(" -- kfree test AFCDEF free d for all linking----------------\n"); for(i=0;i<6;i++) { addresses[i] = (char*)kmalloc(1); freeMemListOK(); memHeaderOK( (struct memHeader*)hdrFromUsrPtr(addresses[i])); } kfree(addresses[1]); kfree(addresses[5]); kprintf(" -- before test\n"); showAllocatedHeader(addresses[3]); printFreeList(); sleep(5); kfree(addresses[3]); kprintf(" -- after test\n"); printFreeList(); freeMemListOK(); sleep(5); kprintf("TEST %d ===================\n",++testno); kprintf(" allocate 1000 memory blocks, deallocate 1000\n"); kprintf(" also run with variants of size, and dealloc every mod 2"); kprintf(" mod 3, mod 5"); allocXfreeModY(1000, 3); }