/*------------------------------------------------------------------------
* 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);
}
