static void doPotato(int mySlot)//You will want to create data structures like a ready list (for TCBs that are { int ret; int moved; int passes = 0; printf("Made it to doPotato %d\n", mySlot); while(1){ assert(alarmIsEnabled()); moved = tryMovePotato(mySlot); if(moved){ passes++; printf("%d passes potato for %d-st/nd/rd time \n", mySlot, passes); } /* * Add some yields by some threads to scramble the list */ if(mySlot > 4){ int ii; for(ii = 0; ii < mySlot - 4; ii++){ ret = ULT_Yield(ULT_ANY); assert(ULT_isOKRet(ret)); } } } }
static void hello(char *msg) { Tid ret; printf("Made it to hello() in called thread\n"); printf("Message: %s\n", msg); ret = ULT_Yield(ULT_SELF); assert(ULT_isOKRet(ret)); printf("Thread returns from first yield\n"); ret = ULT_Yield(ULT_SELF); assert(ULT_isOKRet(ret)); printf("Thread returns from second yield\n"); while(1){ ULT_Yield(ULT_ANY); } }
void grandFinale() { int ret; printf("For my grand finale, I will destroy myself\n"); printf("while my talented assistant prints Done.\n"); ret = ULT_CreateThread((void (*)(void *))finale, NULL); assert(ULT_isOKRet(ret)); ULT_DestroyThread(ULT_SELF); assert(0); }
void preemptiveTests() { static const int duration = 10; int ret; int ii; startAlarmHelper(); spin(2); interruptsQuiet(); potato[0] = 1; for(ii = 1; ii < NPOTATO; ii++){ potato[ii] = 0; } printf("Running hot potato test. This will take %d seconds\n", duration); for(ii = 0; ii < NPOTATO; ii++){ potatoTids[ii] = ULT_CreateThread((void (*)(void *))doPotato, (void *)ii); assert(ULT_isOKRet(potatoTids[ii])); } spin(duration); printf("Hot potato done. Cleaning up\n"); for(ii = 0; ii < NPOTATO; ii++){ ret = ULT_DestroyThread(ULT_ANY); assert(ULT_isOKRet(ret)); } printf("Done.\n"); }
void basicThreadTests() { Tid ret; Tid ret2; printf("Starting tests...\n"); /* * Initial thread yields */ ret = ULT_Yield(ULT_SELF); assert(ULT_isOKRet(ret)); printf("Initial thread returns from Yield(SELF)\n"); ret = ULT_Yield(0); /* See ULT.h -- initial thread must be Tid 0 */ assert(ULT_isOKRet(ret)); printf("Initial thread returns from Yield(0)\n"); ret = ULT_Yield(ULT_ANY); assert(ret == ULT_NONE); printf("Initial thread returns from Yield(ANY)\n"); ret = ULT_Yield(0xDEADBEEF); assert(ret == ULT_INVALID); printf("Initial thread returns from Yield(INVALID)\n"); ret = ULT_Yield(16); assert(ret == ULT_INVALID); printf("Initial thread returns from Yield(INVALID2)\n"); /* * Create a thread */ ret = ULT_CreateThread((void (*)(void *))hello, "World"); assert(ULT_isOKRet(ret)); ret2 = ULT_Yield(ret); assert(ret2 == ret); /* * Create 10 threads */ int ii; static const int NTHREAD = 10; Tid children[NTHREAD]; char msg[NTHREAD][1024]; for(ii = 0; ii < NTHREAD; ii++){ ret = snprintf(msg[ii], 1023, "Hello from thread %d\n", ii); assert(ret > 0); children[ii] = ULT_CreateThread((void (*)(void *))hello, msg[ii]); assert(ULT_isOKRet(children[ii])); } for(ii = 0; ii < NTHREAD; ii++){ ret = ULT_Yield(children[ii]); assert(ret == children[ii]); } /* * Destroy 11 threads we just created */ ret = ULT_DestroyThread(ret2); assert(ret == ret2); for(ii = 0; ii < NTHREAD; ii++){ ret = ULT_DestroyThread(children[ii]); assert(ret == children[ii]); } /* * Create maxthreads-1 threads */ printf("Creating %d threads\n", ULT_MAX_THREADS-1); for(ii = 0; ii < ULT_MAX_THREADS-1; ii++){ ret = ULT_CreateThread((void (*)(void *))fact, (void *)10); assert(ULT_isOKRet(ret)); } /* * Now we're out of threads. Next create should fail. */ ret = ULT_CreateThread((void (*)(void *))fact, (void *)10); assert(ret == ULT_NOMORE); /* * Now let them all run. */ printf("Running %d threads\n", ULT_MAX_THREADS-1); for(ii = 0; ii < ULT_MAX_THREADS; ii++) { ret = ULT_Yield(ii); if(ii == 0){ /* * Guaranteed that first yield will find someone. * Later ones may or may not depending on who * stub schedules on exit. */ assert(ULT_isOKRet(ret)); } } /* * They should have cleaned themselves up when * they finished running. Create maxthreads-1 threads. */ printf("Creating %d threads\n", ULT_MAX_THREADS-1); for(ii = 0; ii < ULT_MAX_THREADS-1; ii++){ ret = ULT_CreateThread((void (*)(void *))fact, (void *)10); assert(ULT_isOKRet(ret)); } /* * Now destroy some explicitly and let the others run */ printf("Destorying %d threads, running the rest\n", ULT_MAX_THREADS/2); for(ii = 0; ii < ULT_MAX_THREADS; ii+=2){ ret = ULT_DestroyThread(ULT_ANY); assert(ULT_isOKRet(ret)); } for(ii = 0; ii < ULT_MAX_THREADS; ii++){ ret = ULT_Yield(ii); } printf("Trying some destroys even though I'm the only thread\n"); ret = ULT_DestroyThread(ULT_ANY); assert(ret == ULT_NONE); ret = ULT_DestroyThread(42); assert(ret == ULT_INVALID); ret = ULT_DestroyThread(-42); assert(ret == ULT_INVALID); ret = ULT_DestroyThread(ULT_MAX_THREADS + 1000); assert(ret == ULT_INVALID); /* * Create a thread that destroys itself. * Control should come back here after * that thread runs. */ printf("Testing destroy self\n"); int flag = setFlag(0); ret = ULT_CreateThread((void (*)(void *))suicide, NULL); assert(ULT_isOKRet(ret)); ret = ULT_Yield(ret); assert(ULT_isOKRet(ret)); flag = setFlag(0); assert(flag == 1); /* Other thread ran */ /* That thread is gone now */ ret = ULT_Yield(ret); assert(ret == ULT_INVALID); }
void main() { queue* myQueue = list_new(); assert(myQueue); assert(myQueue->head->num == 0); assert(myQueue->tail->num == 0); printf("test no queue passed in\n"); int ret = list_remove_element(NULL, 9); assert (ret == ULT_INVALID); /* printf("\ntest empty list\n"); ret = list_remove_element(myQueue, 12); assert (ret == ULT_NONE); */ printf("\ntest add to invalid queue\n"); ret = list_add_element(NULL); assert (ret == ULT_FAILED); printf("\ntest add 1 element\n"); ret = list_add_element(myQueue); printf("first element after tid 0: %d\n", ret); assert (ULT_isOKRet(ret)); printf("\ninside queue, %d elements\n", myQueue->numTCB); list_print(myQueue); list_print_backwards(myQueue); printf("\ntest add another element\n"); ret = list_add_element(myQueue); printf("second element after tid 0: %d\n", ret); assert (ULT_isOKRet(ret)); printf("\ninside queue, %d elements\n", myQueue->numTCB); list_print(myQueue); list_print_backwards(myQueue); //TESTS FOR LIST_REMOVE_HEAD printf("\ntest remove first element 3 times\n"); ret = list_remove_head(myQueue); printf("element's tid: %d\n", ret); assert (ULT_isOKRet(ret)); printf("\ninside queue, %d elements\n", myQueue->numTCB); list_print(myQueue); list_print_backwards(myQueue); ret = list_remove_head(myQueue); printf("element's tid: %d\n", ret); assert (ULT_isOKRet(ret)); printf("\ninside queue, %d elements\n", myQueue->numTCB); list_print(myQueue); list_print_backwards(myQueue); ret = list_remove_head(myQueue); printf("element's tid: %d\n", ret); assert (ULT_isOKRet(ret)); printf("\ninside queue, %d elements\n", myQueue->numTCB); list_print(myQueue); list_print_backwards(myQueue); printf("\ntest add another element after emptying queue\n"); ret = list_add_element(myQueue); printf("element: %d\n", ret); assert (ULT_isOKRet(ret)); printf("\ninside queue, %d elements\n", myQueue->numTCB); list_print(myQueue); list_print_backwards(myQueue); /* //TESTS FOR LIST_REMOVE_ELEMENT printf("\ntest remove third element\n"); ret = list_remove_element(myQueue, 2); printf("element's tid: %d\n", ret); assert (ULT_isOKRet(ret)); printf("\ninside queue, %d elements\n", myQueue->numTCB); list_print(myQueue); list_print_backwards(myQueue); printf("\ntest remove second element\n"); ret = list_remove_element(myQueue, 1); printf("element's tid: %d\n", ret); assert (ULT_isOKRet(ret)); printf("\ninside queue, %d elements\n", myQueue->numTCB); list_print(myQueue); list_print_backwards(myQueue); printf("\ntest remove first element\n"); ret = list_remove_element(myQueue, 0); printf("element's tid: %d\n", ret); assert (ULT_isOKRet(ret)); printf("\ninside queue, %d elements\n", myQueue->numTCB); list_print(myQueue); list_print_backwards(myQueue); printf("\ntest remove no more elements\n"); ret = list_remove_element(myQueue, 1); printf("element's tid: %d\n", ret); assert (ret == ULT_INVALID); printf("\ntest add another element after emptying list\n"); ret = list_add_element(myQueue); printf("element: %d\n", ret); assert (ULT_isOKRet(ret)); printf("\ninside queue, %d elements\n", myQueue->numTCB); list_print(myQueue); list_print_backwards(myQueue); printf("\ntest add 2nd element after emptying list\n"); ret = list_add_element(myQueue); printf("element: %d\n", ret); assert (ULT_isOKRet(ret)); printf("\ninside queue, %d elements\n", myQueue->numTCB); list_print(myQueue); list_print_backwards(myQueue); printf("\ntest add 3rd element after emptying list\n"); ret = list_add_element(myQueue); printf("element: %d\n", ret); assert (ULT_isOKRet(ret)); printf("\ninside queue, %d elements\n", myQueue->numTCB); list_print(myQueue); list_print_backwards(myQueue); printf("\ntest remove second element AGAIN\n"); ret = list_remove_element(myQueue, 1); printf("element's tid: %d\n", ret); assert (ULT_isOKRet(ret)); printf("\ninside queue, %d elements\n", myQueue->numTCB); list_print(myQueue); list_print_backwards(myQueue); */ }