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