void test8 ()
{
int rdA, rdC, rdE;
int wrB, wrD, wrF;
kprintf("\nTest 8: \nexpected output:\n rdA try to acquire lock 1\n rdA acquires lock 1, sleep 2s\n wrB try to acquire lock 2\n wrB acquires lock 2, sleep 2s\n rdC try to acquire lock 1\n rdC acquires lock 1\n rdC try to acquire lock 2\n wrD try to acquire lock 1\n rdE try to acquire lock 1\n wrF try to acquire lock 2\n rdA releases lock 1&3\n procA doesn't hold this lock\n wrB releases lock 2\n wrF acquires lock 2, sleep 2s\n wrF releases lock 2\n rdC acquires lock 2, sleep 2s\n rdC releases lock 1&2\n wrD acquires lock 1\n wrD try to acquire lock 2\n wrD acquires lock 2, sleep 2s\n wrD releases lock 1&2\n rdE acquires lock 1, sleep 2s\n rdE releases lock 1\n\n\n real output: \n");
kprintf("\nReal Output:\n");
lck1 = lcreate();
lck2 = lcreate();
lck3 = lcreate();
rdA = create(procAA, 2000, 20, "rdA", 1, 1);
rdC = create(procCC, 2000, 20, "rdC", 1, 1);
rdE = create(procEE, 2000, 20, "rdE", 1, 1);
wrB = create(procBB, 2000, 20, "wrB", 1, 1);
wrD = create(procDD, 2000, 20, "wrD", 1, 1);
wrF = create(procFF, 2000, 20, "wrF", 1, 1);
resume(rdA);
resume(wrB);
resume(rdC);
resume(wrD);
resume(rdE);
resume(wrF);
sleep (10);
ldelete (lck1); ldelete(lck2); ldelete(lck3);
kill(rdA);kill(rdC);kill(rdE);kill(wrB);kill(wrD);kill(wrF);
sleep(1);
}
// Lock Re-use Test -
void lock_reuse_test()
{
int i;
int lck;
int rd1, rd2, rd3, rd4;
int wr1;
kprintf("\nlock_reuse_test: Verify the following:\n"
"reader A: acquires lock\n"
"writer C: gets DELETED\n"
"reader B: gets SYSERR\n"
"reader D: acquires lock\n");
// Create original lock
lck = lcreate();
//kprintf("Original Lock: %d\t Lock Index: %d\n", lck, LOCK_INDEX(lck));
// Create processes that use original lock
rd1 = create(reader, 2000, 20, "reader", 3, "reader A", lck, 20);
rd2 = create(reader, 2000, 20, "reader", 3, "reader B", lck, 20);
wr1 = create(writer, 2000, 20, "writer", 3, "writer C", lck, 30);
// Start reader A
resume(rd1);
sleep(1);
// Start writer C. Will get returned DELETED after lock gets
// deleted.
resume(wr1);
sleep(1);
// Delete lock
ldelete(lck);
// Cycle all the way back around to get back to the original
// lock slot in the array of locks.
for (i=1; i<NLOCKS; i++) {
lck = lcreate();
ldelete(lck);
}
// Create a new lock (this lock will use same slot as original)
lck = lcreate();
// Create a new process to use the new lock spot.
rd3 = create(reader, 2000, 20, "reader", 3, "reader D", lck, 20);
//kprintf("Final Lock: %d\t Lock Index: %d\n", lck, LOCK_INDEX(lck));
// Start reader B: Should get returned SYSERR since the lock it
// uses was already deleted and a new lock is using that index
resume(rd2);
// Start reader D that uses new lock
resume(rd3);
sleep(4);
kprintf ("lock_reuse_test finished, check order of acquisition!\n");
}
void test3 ()
{
int rd1, rd2;
int wr1;
kprintf("\nTest 3: test the basic priority inheritence\n");
lck = lcreate();
lck2 = lcreate();
kprintf("lck1: %d \t lck2: %d",lck,lck2);
rd1 = create(reader3, 2000, 25, "reader3", 2, "reader A", lck);
rd2 = create(reader3, 2000, 30, "reader3", 2, "reader B", lck2);
wr1 = create(writer3, 2000, 40, "writer3", 2, "writer C", lck);
kprintf("-start reader B, then sleep 1s. reader B(prio 30) blocked on the lock\n");
resume (rd2);
sleep (1);
kprintf("-start writer, then sleep 1s. lock granted to write (prio 20)\n");
resume(wr1);
sleep (1);
kprintf("-start reader A, then sleep 1s. reader A(prio 25) blocked on the lock\n");
resume(rd1);
assert(getprio(rd2)==40);
assert(getprio(rd1)==25);
assert(getprio(wr1)==40);
sleep (8);
kprintf ("Test 3 OK\n");
/*semaphore*/
kprintf("\n\nSEMAPHORE \n\n");
kprintf("\nTest 3: test the basic priority inheritence\n");
sem = screate(2);
sem2 = screate(1);
kprintf("lck1: %d \t lck2: %d",lck,lck2);
rd1 = create(readersem3, 2000, 25, "readersem3", 2, "reader A", sem);
rd2 = create(readersem3, 2000, 30, "readersem3", 2, "reader B", sem2);
wr1 = create(writersem3, 2000, 40, "writersem3", 2, "writer C", sem);
kprintf("-start reader B, then sleep 1s. reader B(prio 30) blocked on the lock\n");
resume (rd2);
sleep (1);
kprintf("-start writer, then sleep 1s. lock granted to write (prio 20)\n");
resume(wr1);
sleep (1);
kprintf("-start reader A, then sleep 1s. reader A(prio 25) blocked on the lock\n");
resume(rd1);
assert(getprio(rd2)==40);
assert(getprio(rd1)==25);
assert(getprio(wr1)==40);
sleep (8);
kprintf ("Test 3 OK\n");
}
msg_Headers hdr_Create( void )
{
msg_Headers headers = Calloc( sizeof(struct _msg_Headers), 1 );
if( headers )
{
headers->mail = lcreate( del_Header );
headers->text = lcreate( del_Header );
}
return headers;
}
void test9 ()
{
int i;
int lastlck;
int rd1, rd2, rd3, rd4;
int wr1;
kprintf("\nTest 9:\nexpected output:\nreader A: acquired lock, sleep 3s\nwriter C: lock was DELETED\nreader B: lock returned SYSERR\nreader D: acquired lock, sleep 3s\n");
kprintf("\nReal Output:\n");
// Create original lock
lastlck = lcreate();
//kprintf("\nLcreate <%d>",lastlck);
// Create processes that use original lock
rd1 = create(reader, 2000, 20, "reader", 3, "reader A", lastlck, 20);
rd2 = create(reader, 2000, 20, "reader", 3, "reader B", lastlck, 20);
wr1 = create(writer, 2000, 20, "writer", 3, "writer C", lastlck, 30);
// Start reader A
resume(rd1);
sleep(1);
// Start writer C. Will get returned DELETED after lock gets
// deleted.
resume(wr1);
sleep(1);
// Delete lock
ldelete(lastlck);
for (i=1; i<NLOCKS; i++) {
lastlck = lcreate();
//kprintf("\nLcreate <%d>",lastlck);
ldelete(lastlck);
}
// Create a new lock (this lock will use same slot as original)
lastlck = lcreate();
//kprintf("\nFinal Lcreate <%d>",lastlck);
// Create a new process to use the new lock spot.
rd3 = create(reader, 2000, 20, "reader", 3, "reader D", lastlck, 20);
// Start reader B: Should get returned SYSERR since the lock it
// uses was already deleted and a new lock is using that index
resume(rd2);
// Start reader D that uses new lock
resume(rd3);
sleep(4);
}
void multiPriorityInterleave() {
int i,j=0;
int lck1,retval;
/*create lock*/
kprintf("Launcher %s starting\n",__func__);
lck1 = lcreate();
if(lck1 < 0) {
kprintf("Launcher %s: Unable to get lock. Return: %d. Test failed\n",__func__,lck1);
return;
}
kprintf("\n\nTest: %s\n",__func__);
resume(create(writer,2000,20,"writerK",5,'K', lck1, 24, 2, 3));
resume(create(reader,2000,20,"readerL",5,'L', lck1, 30, 9, 5));
resume(create(reader,2000,20,"readerM",5,'M', lck1, 30, 9, 5));
resume(create(reader,2000,20,"readerN",5,'N', lck1, 22, 1, 5));
resume(create(reader,2000,20,"readerO",5,'O', lck1, 24, 2, 5));
resume(create(reader,2000,20,"readerP",5,'P', lck1, 26, 3, 5));
resume(create(reader,2000,20,"readerQ",5,'Q', lck1, 28, 4, 5));
sleep(1);
resume(create(reader,2000,20,"readerR",5,'R', lck1, 24, 2, 5));
while (1) {
kprintf("Looping in launcher %s\n", __func__);
sleep(2);
j++;
if(j == 10) break;
}
sleep(150);
if(OK != (retval = ldelete(lck1) ) ) {
kprintf("Launcher %s: Delete on the lock %d failed with code %d\n",__func__,lck1,retval);
return;
}
kprintf("Launcher %s completed.\n",__func__);
}
void stressTest(){
int i,j;
int ldes[NLOCKS];
kprintf("Launcher %s starting\n",__func__);
for(i=0; i<NLOCKS; i++) {
ldes[i] = lcreate();
if(ldes[i] < 0) {
kprintf("Launcher %s: Unable to get %dth lock. Return: %d. Test failed\n",__func__,i,ldes[i]);
return;
}
}
resume(create(getAllLocks,2000,20,"procStresstestRdW",6,'W', ldes,READ, 10, 1, 3));
resume(create(getAllLocks,2000,20,"procStresstestRdX",6,'X', ldes,READ, 10, 1, 3));
resume(create(getAllLocks,2000,20,"procStresstestWrY",6,'Y', ldes,WRITE, 10, 1, 3));
resume(create(getAllLocks,2000,20,"procStresstestWrZ",6,'Z', ldes,WRITE, 10, 1, 3));
sleep(20);
kprintf("Launcher %s: Deleting all locks. All children should exit or error out now, depending on their status.\n",__func__);
for(i=0; i<NLOCKS; i++) {
int retval;
if(OK != (retval = ldelete(ldes[i]) ) ) {
kprintf("Launcher %s: Delete on the lock %d failed with code %d\n",__func__,ldes[i],retval);
}
if(i==10) sleep(3);
}
sleep(5);
kprintf("Launcher %s completed. Check messages till now for any failures.\n",__func__);
}
void test1 ()
{
int lck;
int pid1;
int pid2;
kprintf("\nTest 1: readers can share the rwlock.\n");
testval = 1;
lck = lcreate ();
assert (lck != SYSERR,"Test 1 FAILED\n");
pid1 = create(reader1, 2000, 20, "reader a", 2, "reader a", lck);
pid2 = create(reader1, 2000, 20, "reader b", 2, "reader b", lck);
resume(pid1);
sleep(1);
resume(pid2);
sleep (5);
ldelete (lck);
kill(pid1);
kill(pid2);
assert (testval == 90,"Test 1 FAILED\n");
kprintf ("Test 1 PASSED!\n");
}
/*-----------------------------------Test 5---------------------------*/
void test5 ()
{
int lck[5];
int index;
int ret;
kprintf("\nTest 5: release multiple locks simultaneously\n");
for (index = 0; index < 5; index++) {
lck[index] = lcreate ();
assert (lck[index] != SYSERR,"Test 5 FAILED\n");
ret = lock (lck[index], READ, DEFAULT_LOCK_PRIO);
assert (ret == OK,"Test 5 FAILED\n");
}
ret = releaseall (2, lck[4], lck[0]);
assert (ret == OK,"Test 5 FAILED\n");
ret = releaseall (3, lck[1], lck[3], lck[2]);
assert (ret == OK,"Test 5 FAILED\n");
for (index = 0; index < 5; index++) {
ldelete (lck[index]);
}
kprintf ("Test 5 PASSED!\n");
}
void test2 ()
{
int lck;
int pid1;
int pid2;
testval = 1;
kprintf("\nTest 2: write lock is mutual exclusive\n");
lck = lcreate ();
//kprintf("\nLcreate<%d><%d>",lck,lock_map[lck]);
assert (lck != SYSERR,"1Test 2 FAILED\n");
pid1 = create(writer2, 2000, 20, "writer2", 2, "writer", lck);
pid2 = create(reader2, 2000, 20, "reader2", 2, "reader", lck);
resume(pid1);
sleep (2);
resume(pid2);
sleep (8);
ldelete (lck);
kill(pid1);
kill(pid2);
//kprintf("\nTestval<%d>",testval);
assert (testval == 40,"Test 2 FAILED\n");
kprintf ("Test 2 PASSED!\n");
}
int main()
{
int i;
/*create lock*/
#if 1
kprintf("\n\nTEST1: Expect RRRRRRWRWRWR....\n");
lck1 = lcreate();
resume(reader1 = create(reader,2000,20,"reader1",3,'1', lck1, 100));
resume(reader2 = create(reader,2000,20,"reader2",3,'2', lck1, 100));
resume(writer1 = create(writer,2000,20,"writer1",3,'1', lck1, 94));
sleep(10);
kill (reader1);
kill (reader2);
kill (writer1);
kprintf(" Locking %d\n", lock(lck1,READ,100));
releaseall(1,lck1);
ldelete(lck1);
kprintf("\nTest Done\n");
#endif
#if 1
kprintf("\n\n Test2: Deletion test\n\n");
lck1 = lcreate();
resume(reader1 = create(del_test1, 20000, 20, "Del1", 3, '1', lck1));
resume(reader2 = create(del_test2, 20000, 20, "Del1", 3, '2', lck1));
sleep(1);
resume(writer1 = create(del_test3, 20000, 20, "Del1", 3, '3', lck1));
sleep(4);
kill (reader1);
kill (reader2);
kill (writer1);
ldelete(lck1);
kprintf("\nTest Done\n");
#endif
#if 1
kprintf("\n\n Test3: Peak Load test\n\n");
resume(reader1 = create(peak_load_test, 20000, 20, "Del1", 3, '1'));
sleep(5);
kprintf("\nTest Done\n");
#endif
while (1) {
sleep(1);
}
}
/*--------------------------------Test 0--------------------------------*/
void test0 ()
{
int lck;
kprintf("\nTest 0: create rwlock.\n");
lck = lcreate ();
assert (lck != SYSERR,"Test 0 FAILED\n");
kprintf("Test 0 PASSED!\n");
ldelete (lck);
}
int main2()
{
int lck = lcreate();
int loopProc, waitProc, waitProc2;
resume(loopProc = create(looper,2000,20,"looper",1,lck));
resume(waitProc = create(waiter,2000,50,"waiter",1,lck));
resume(waitProc2 = create(waiter2,2000,40,"waiter",1,lck));
sleep(1);
kill(waitProc);
}
// Multi Lock Test
void multi_lock_test() {
int lck1, lck2;
int rd1, rd2, rd3, rd4, rd5, rd6;
int wr1, wr2;
int rw1;
kprintf("\nMultiple Lock Test: tests releasing multiple locks at a time"
" lock acquisition is:\n"
"reader A, Lock 1\n"
"reader B, Lock 2\n"
"writer C, Lock 1\n"
"writer F, Lock 2\n"
" combo H, Lock 1\n"
"reader D, Lock 1\n"
" combo H, Lock 2\n"
"reader E, Lock 2\n");
lck1 = lcreate();
lck2 = lcreate();
rd1 = create(reader, 2000, 20, "reader", 3, "reader A", lck1, 20);
rd2 = create(reader, 2000, 20, "reader", 3, "reader B", lck2, 20);
rd3 = create(reader, 2000, 20, "reader", 3, "reader D", lck1, 20);
rd4 = create(reader, 2000, 20, "reader", 3, "reader E", lck2, 20);
wr1 = create(writer, 2000, 20, "writer", 3, "writer C", lck1, 30);
wr2 = create(writer, 2000, 20, "writer", 3, "writer F", lck2, 35);
rw1 = create( combo, 2000, 20, "writer", 5, " combo H", lck1, lck2, 20, 30);
resume(rd1);
sleep(1);
resume(wr1);
resume(rd2);
sleep(1);
resume(wr2);
resume(rw1);
resume(rd3);
resume(rd4);
sleep (12);
kprintf ("Multi Lock Test finished, check order of acquisition!\n");
}
void tooManyLocksAndSomeOtherFuncTests() {
int i,j,retval;
int ldes[NLOCKS];
kprintf("Launcher %s starting\n",__func__);
for(i=0; i<NLOCKS; i++) {
ldes[i] = lcreate();
if(ldes[i] < 0) {
kprintf("Launcher %s: Unable to get lock. Return: %d. Test failed!\n",__func__,ldes[i]);
return;
}
}
j = lcreate();
if(j != SYSERR) {
kprintf("Launcher %s: Too many locks getting created. This one should have failed. Return: %d. Test failed!\n",__func__,j);
return;
}
if(SYSERR != (retval = releaseall(1,ldes[30]) ) ) {
kprintf("Launcher %s: The release on lock %d should have failed, since we never locked it. Return: %d. Test failed!\n",__func__,ldes[30],retval);
return;
}
if(OK != (retval = ldelete(ldes[30]) ) ) {
kprintf("Launcher %s: Delete on the lock %d failed with code %d\n",__func__,ldes[30],retval);
return;
}
if(SYSERR != (retval = releaseall(1,ldes[30]) ) ) {
kprintf("Launcher %s: The release on lock %d should have failed, since we've already deleted the lock. Return: %d. Test failed!\n",__func__,ldes[30],retval);
return;
}
j = lcreate();
if(j < 0) {
kprintf("Launcher %s: A space for one lock was created. We should have got a lock now. Return: %d. Test failed!\n",__func__,j);
return;
}
ldes[30]=j;
for(i=0; i<NLOCKS; i++) {
int retval;
if(OK != (retval = ldelete(ldes[i]) ) ) {
kprintf("Launcher %s: Delete on the lock %d failed with code %d\n",__func__,ldes[i],retval);
}
}
kprintf("Launcher %s completed. Check messages till now for any failures.\n",__func__);
}
int main()
{
kprintf("\n\nTEST 1:\n Multiple readers\n ");
lck1 = lcreate();
lck2 = lcreate();
lck3 = lcreate();
resume(reader1 = create(reader,2000,20,"reader1",3,'A', lck1, 30));
resume(reader2 = create(reader,2000,20,"reader2",3,'B', lck1, 40));
resume(reader3 = create(reader,2000,20,"reader3",3,'C', lck1, 30));
sleep(5);
kprintf("\n\nTEST 2:\n Multiple writers\n");
resume(writer1 = create(writer,2000,20,"writer1",3,'A', lck1, 30));
resume(writer2 = create(writer,2000,20,"writer2",3,'B', lck1, 40));
resume(writer3 = create(writer,2000,20,"writer3",3,'C', lck1, 30));
sleep(10);
kprintf("\n\nTEST 3:\n Lock deletion\n A acquires the lock while B and C wait for the lock. A deletes the lock when it's done. B and C return DELETED!\n");
resume(writer1 = create(deletingWriter,2000,20,"writer1",3,'A', lck1, 30));
resume(writer2 = create(writer,2000,20,"writer2",3,'B', lck1, 40));
resume(writer3 = create(writer,2000,20,"writer3",3,'C', lck1, 30));
sleep(5);
kprintf("\n\nTEST 4:\n Lock deletion\n A acquires the lock while B waits for it. A deletes the lock when it's done. C uses the same lock descriptor. B returns DELETED! If B tries querying for the lock again, SYSERR will be returned.\n");
lck1 = lcreate();
resume(writer1 = create(recreatingWriter,2000,20,"writer1",3,'A', lck1, 30));
resume(writer2 = create(retryingWriter,2000,20,"writer2",3,'B', lck1, 40));
sleep(5);
resume(writer3 = create(writer,2000,20,"writer3",3,'C', lck1, 30));
sleep(5);
kprintf("\n\nTEST 5:\n Locking policy: Writer A already executing. Reader B will wait. \n");
resume(writer1 = create(writer,2000,20,"writer1",3,'A', lck1, 30));
resume(reader1 = create(reader,2000,20,"reader1",3,'B', lck1, 30));
sleep(5);
kprintf("\n\nTEST 6:\n Locking policy: Reader A already executing. Writer B with higher priority waiting. Writer D and Reader E with priority between B and C but D has more waiting time. Reader C will wait. \n");
resume(reader1 = create(reader,2000,20,"reader1",3,'A', lck1, 30));
resume(writer1 = create(writer,2000,20,"writer1",3,'B', lck1, 50));
resume(reader2 = create(reader,2000,20,"reader2",3,'C', lck1, 30));
resume(writer2 = create(writer,2000,20,"writer2",3,'D', lck1, 40));
resume(reader3 = create(reader,2000,20,"reader3",3,'E', lck1, 40));
sleep(10);
kprintf("\n\nTEST 7:\n Multiple locks acquired and released! \n");
resume(reader1 = create(multipleReader,2000,20,"reader1",5,'A', lck1, lck2, lck3, 30));
return 0;
}
/*-----------------------------------Test 3---------------------------*/
void test3 ()
{
int lck[NLOCKS];
int last_lck;
int index;
kprintf("\nTest 3: return SYSERR if no lock is available\n");
for (index = 0; index < NLOCKS; index++) {
lck[index] = lcreate ();
assert (lck[index] != SYSERR,"Test 3 FAILED\n");
}
last_lck = lcreate ();
assert (last_lck == SYSERR,"Test 3 FAILED\n");
for (index = 0; index < NLOCKS; index++) {
ldelete (lck[index]);
}
kprintf ("Test 3 PASSED!\n");
}
int peak_load_test(char c){
int lck[50];
int i;
for(i=0; i<50; i++){
lck[i] = lcreate();
if(OK != lock(lck[i], WRITE, 10)){
kprintf("Test Failed!! \n");
return;
}
}
for(i=0; i<50; i++){
if(OK == lock(lck[i], WRITE, 10)){
kprintf("Test Failed!! \n");
return;
}
}
for(i=0; i<50; i += 5){
if(OK != releaseall(5, lck[i], lck[i+1], lck[i+2], lck[i+3], lck[i+4])){
kprintf("Test Failed!! \n");
return;
}
}
for(i=0; i<50; i++){
if(OK != ldelete(lck[i])){
kprintf("Test Failed!! \n");
return;
}
}
lck[0] = lcreate();
if(OK != lock(lck[0], READ, 10)){
kprintf("Test Failed!! \n");
return;
}
releaseall(1, lck[0]);
ldelete(lck[0]);
}
// Priority Inheritance chprio test
void pinh_chprio_test() {
int lck;
int rd1;
int wr1, wr2;
int lp;
kprintf("\nBasic Priority chprio Test\n"
"Once looper process is started readers/writers will be\n"
"starved until chprio() is used to change prio of reader C\n"
"(currently waiting on lock) to 30\n"
" lock acquisition is:\n"
"writer A\n"
"writer B\n"
"reader C\n");
lck = lcreate();
// Create a process that is always ready to run at priority 15
lp = create(looper, 2000, 15, "looper", 0, NULL);
wr1 = create(writer, 2000, 10, "writer", 4, "writer A p10 l20", lck, 20, 5);
wr2 = create(writer, 2000, 11, "writer", 4, "writer B p11 l30", lck, 30, 2);
rd1 = create(reader, 2000, 12, "reader", 4, "reader C p12 l20", lck, 20, 1);
kprintf("-start writer A (pprio 10, lprio 20), then sleep 1s.\n");
resume(wr1);
sleep(1);
kprintf("-start writer B (pprio 11, lprio 30), then sleep 1s.\n");
resume(wr2);
sleep(1);
kprintf("-start reader C (pprio 12, lprio 20), then sleep 1s.\n");
resume(rd1);
sleep(1);
// This will guarantee that writer B will never get chosen unless
// we boost its priority.
kprintf("-start looper process (pprio 15), then sleep 8s.\n");
resume(lp);
sleep(8);
//chprio
kprintf("-chprio of reader C to 30 --> All readers/writers will have effective priority 30.\n");
chprio(rd1, 30);
sleep (10);
kprintf ("Test finished, verify readers/writers were hung until chprio!\n");
}
void killAndDeleteTest() {
int i,j,ldes,retval;
int pid1,pid2,pid3,pid4,pid5;
kprintf("Launcher %s starting\n",__func__);
ldes = lcreate();
if(ldes < 0) {
kprintf("Launcher %s: Unable to get lock. Return: %d. Test failed\n",__func__,ldes);
return;
}
if(OK != (retval = lock(ldes,WRITE,50) ) ) {
kprintf("Launcher %s: Unable to open lock %d. Return: %d FAIL!\n",__func__, ldes,retval);
return;
}
kprintf("Launcher %s: Holding lock %d . 1st process S should not be able to start printing, even after resuming.\n",__func__, ldes);
pid1 = create(writer,2000,20,"wrS",5,'S', ldes, 30, 1, 9);
pid2 = create(writer,2000,20,"wrT",5,'T', ldes, 30, 1, 9);
pid3 = create(writer,2000,20,"wrU",5,'U', ldes, 30, 1, 5);
pid4 = create(writer,2000,20,"wrV",5,'V', ldes, 30, 1, 5);
resume(pid1);
sleep(1);
resume(pid2);
sleep(1);
resume(pid3);
sleep(1);
resume(pid4);
kill(pid1);
if(OK != (retval = releaseall(1,ldes) ) ) {
kprintf("Launcher %s: Could not release lock %d. Return: %d !\n",__func__,ldes,retval);
return;
}
sleep(1);
kprintf("Launcher %s: Waiting kill done. Now the 2nd process T should have got the lock and started printing. Will kill it now.\n",__func__, ldes,retval);
kill(pid2);
sleep(1);
kprintf("Launcher %s: Holding kill done. Now the 3rd process U should have got the lock and started printing. Will delete lock now.\n",__func__, ldes,retval);
if(OK != (retval = ldelete(ldes) ) ) {
kprintf("Launcher %s: Delete on the lock %d failed with code %d\n",__func__,ldes,retval);
return;
}
kprintf("Launcher %s: Live and Waiting delete done. 3rd process U should fail during release with -1, and 4th process V should fail with return code of -6.\n",__func__,ldes,retval);
sleep(12);
kprintf("Launcher %s completed. Check messages till now for any failures.\n",__func__);
}
int recreatingWriter(char c, int ldes1, int prio)
{
int flag;
flag = lock(ldes1, WRITE, prio);
if(flag == SYSERR)
{
kprintf("\n%c's lock returned SYSERR!", c);
return;
}
if(flag == DELETED)
{
kprintf("\n%c's lock was deleted!", c);
return;
}
kprintf("\n%c has obtained lock %d!", c, ldes1);
sleep(2);
kprintf("\n%c is releasing lock %d!", c, ldes1);
ldelete(ldes1);
lck1 = lcreate();
}
// Basic Priority Inheritance Test (locks)
void basic_pinh_locks_test() {
int lck;
int rd1;
int wr1, wr2;
int lp;
kprintf("\nBasic Priority Inheritance Test (locks)\n"
" lock acquisition is:\n"
"writer A\n"
"writer B\n"
"reader C\n");
lck = lcreate();
// Create a process that is always ready to run at priority 15
lp = create(looper, 2000, 15, "looper", 0, NULL);
wr1 = create(writer, 2000, 20, "writer", 4, "writer A p20 l20", lck, 20, 5);
wr2 = create(writer, 2000, 10, "writer", 4, "writer B p10 l30", lck, 30, 2);
rd1 = create(reader, 2000, 40, "reader", 4, "reader C p40 l20", lck, 20, 1);
kprintf("-start writer A (pprio 20, lprio 20), then sleep 1s.\n");
resume(wr1);
sleep(1);
kprintf("-start writer B (pprio 10, lprio 30), then sleep 1s.\n");
resume(wr2);
sleep(1);
// This will guarantee that writer B will never get chosen unless
// we boost its priority.
kprintf("-start looper process (pprio 15), then sleep 1s.\n");
resume(lp);
sleep(1);
kprintf("-start reader C (pprio 40, lprio 20), then sleep 1s.\n");
resume(rd1);
sleep(1);
sleep (10);
kprintf ("Test finished, check order of acquisition!\n");
}
void samePriorityInterleave()
{
int i,j=0,retval;
int lck1;
/*create lock*/
kprintf("Launcher %s starting\n",__func__);
lck1 = lcreate();
if(lck1 < 0) {
kprintf("Launcher %s: Unable to get lock. Return: %d. Test failed\n",__func__,lck1);
return;
}
kprintf("\n\nTest: %s\n",__func__);
resume(create(writer,2000,20,"writerA",5,'A', lck1, 24, 1, 3));
resume(create(writer,2000,20,"writerB",5,'B', lck1, 24, 2, 4));
resume(create(writer,2000,20,"writerC",5,'C', lck1, 24, 1, 4));
resume(create(writer,2000,20,"writerD",5,'D', lck1, 24, 3, 4));
resume(create(reader,2000,20,"readerE",5,'E', lck1, 24, 2, 5));
sleep(1);
resume(create(reader,2000,20,"readerF",5,'F', lck1, 24, 2, 5));
sleep(1);
resume(create(reader,2000,20,"readerG",5,'G', lck1, 24, 2, 5));
sleep(1);
resume(create(reader,2000,20,"readerH",5,'H', lck1, 24, 2, 5));
sleep(1);
resume(create(reader,2000,20,"readerI",5,'I', lck1, 24, 2, 5));
sleep(1);
resume(create(reader,2000,20,"readerJ",5,'J', lck1, 24, 2, 5));
while (1) {
kprintf("Looping in launcher %s\n", __func__);
sleep(2);
j++;
if(j == 10) break;
}
sleep(150);
if(OK != (retval = ldelete(lck1) ) ) {
kprintf("Launcher %s: Delete on the lock %d failed with code %d\n",__func__,lck1,retval);
return;
}
kprintf("Launcher %s completed.\n",__func__);
}
// Priority Inheritance kill test
void pinh_kill_test() {
int lck;
int rd1;
int wr1, wr2;
int lp;
kprintf("\nPriority Inheritance kill Test\n"
" lock acquisition is:\n"
"writer A\n");
lck = lcreate();
// Create a process that is always ready to run at priority 15
lp = create(looper, 2000, 15, "looper", 0, NULL);
wr1 = create(writer, 2000, 5, "writer", 4, "writer A p5 l20", lck, 20, 10);
wr2 = create(writer, 2000, 10, "writer", 4, "writer B p10 l30", lck, 30, 2);
rd1 = create(reader, 2000, 30, "reader", 4, "reader C p30 l20", lck, 20, 1);
kprintf("-start writer A (pprio 10, lprio 20), then sleep 1s.\n");
resume(wr1);
sleep(1);
kprintf("-start writer B (pprio 11, lprio 30), then sleep 1s.\n");
resume(wr2);
sleep(1);
kprintf("-start reader C (pprio 12, lprio 20), then sleep 1s.\n");
resume(rd1);
sleep(1);
kprintf("-start looper process (pprio 15), then sleep 1s.\n");
resume(lp);
sleep(1);
kprintf("-kill reader C (pprio 30) --> All other readers/writers will starve.\n");
kill(rd1);
sleep (10);
kprintf ("Test finished, Verify only Writer A acquired lock!\n");
}
void test6 ()
{
int lck;
int rd1, rd2, rd3, rd4;
int wr1;
count7 = 0;
kprintf("\nTest 6: wait on locks with priority. Expected order of "
"lock acquisition is: reader A, reader B, reader C, writer E, reader D\n");
lck = lcreate ();
assert (lck != SYSERR,"Test 6 FAILED\n");
rd1 = create(reader6, 2000, 20, "reader6", 3, 'A', lck, 20);
rd2 = create(reader6, 2000, 20, "reader6", 3, 'B', lck, 30);
rd3 = create(reader6, 2000, 20, "reader6", 3, 'C', lck, 40);
rd4 = create(reader6, 2000, 20, "reader6", 3, 'D', lck, 20);
wr1 = create(writer6, 2000, 20, "writer6", 3, 'E', lck, 25);
//kprintf("-start reader A, then sleep 1s. lock granted to reader A\n");
resume(rd1);
sleep (1);
//kprintf("-start writer C, then sleep 1s. writer waits for the lock\n");
resume(wr1);
sleep (1);
//kprintf("-start reader B, D, E. reader B is granted lock.\n");
resume (rd2);
sleep10(1);
resume (rd3);
sleep10(1);
resume (rd4);
sleep (10);
ldelete (lck);
kill(rd1);kill(rd2);kill(rd3);kill(rd4);kill(wr1);
kprintf("Output is %s\n",output7);
}
// Priority Test - Reads wait if higher priority writer
void write_prio_test() {
int lck;
int rd1, rd2, rd3, rd4;
int wr1;
kprintf("\nwrite_prio_test: Reads wait if higher priority write exists."
" lock acquisition is:\n"
"reader A,\n"
"writer C,\n"
"reader B,\n"
"reader D,\n"
"reader E,\n");
lck = lcreate ();
rd1 = create(reader, 2000, 20, "reader", 3, "reader A", lck, 20);
rd2 = create(reader, 2000, 20, "reader", 3, "reader B", lck, 20);
rd3 = create(reader, 2000, 20, "reader", 3, "reader D", lck, 20);
rd4 = create(reader, 2000, 20, "reader", 3, "reader E", lck, 20);
wr1 = create(writer, 2000, 20, "writer", 3, "writer C", lck, 30);
kprintf("-start reader A, then sleep 1s. lock granted to reader A\n");
resume(rd1);
sleep (1);
kprintf("-start writer C, then sleep 1s. writer waits for the lock\n");
resume(wr1);
kprintf("-start reader B, D, E.\n");
resume (rd2);
resume (rd3);
resume (rd4);
sleep (10);
kprintf ("write_prio_test finished, check order of acquisition!\n");
}
// Lock Deleted Test - Verify process gets DELETED rc if lock was deleted
void lock_deleted_test()
{
int lck;
int rd1, rd2, rd3, rd4;
int wr1;
kprintf("\nlock_deleted_test: Verify procs waiting on deleted locks"
" get proper return.\n"
"reader A: gets lock\n"
"writer C: gets lock\n"
"reader B: gets DELETED\n"
"reader D: gets DELETED\n"
"reader E: gets DELETED\n");
lck = lcreate ();
rd1 = create(reader, 2000, 20, "reader", 3, "reader A", lck, 20);
rd2 = create(reader, 2000, 20, "reader", 3, "reader B", lck, 20);
rd3 = create(reader, 2000, 20, "reader", 3, "reader D", lck, 20);
rd4 = create(reader, 2000, 20, "reader", 3, "reader E", lck, 20);
wr1 = create(writer, 2000, 20, "writer", 3, "writer C", lck, 30);
kprintf("-start reader A, then sleep 1s. lock granted to reader A\n");
resume(rd1);
sleep(2);
kprintf("-start writer C, readers B, D, E\n");
resume(wr1);
resume(rd2);
resume(rd3);
resume(rd4);
sleep(2);
ldelete(lck);
sleep (10);
kprintf ("write_prio_test finished, check order of acquisition!\n");
}
void test4 ()
{
int lck;
int pid1;
int pid2;
kprintf("\nTest 4: return DELETED if lock deleted while waiting\n");
lck = lcreate ();
assert (lck != SYSERR,"Test 4 FAILED\n");
pid1 = create(writer4, 2000, 20, "writer4", 2, "writer", lck);
pid2 = create(reader4, 2000, 20, "reader4", 2, "reader", lck);
resume(pid1);
sleep (1);
resume(pid2);
sleep(1);
ldelete (lck);
sleep (5);
kill(pid1);
kill(pid2);
}
void clock_init()
{
_clocks = lcreate();
pushexit(clock_free);
}
int main()
{
int lck, lrdm, lwrl, lwrh, sem, srdm, swrl, swrh, lloop, sloop;
kprintf("Start priority inversion test with lock\n");
lck = lcreate();
lloop = create(dowait, 2000, 25, "dowait", 1, 5);
lwrh = create(lwr, 2000, 30, "writer", 4, "writer H", lck, 20, 2);
lwrl = create(lwr, 2000, 10, "writer", 4, "writer L", lck, 20, 5);
lrdm = create(lrd, 2000, 20, "reader", 4, "reader M", lck, 20, 1);
kprintf("Start Writer L, then sleep 1s\n");
resume(lwrl);
sleep(1);
kprintf("Start Writer H, then sleep 1s\n");
resume(lwrh);
sleep(1);
kprintf("Start dowait, then sleep 1s\n");
resume(lloop);
sleep(1);
sleep(10);
kprintf ("Lock test finished!\n");
kprintf("Start priority inversion test with semaphore\n");
sem = screate(1);
sloop= create(dowait, 2000, 20, "dowait", 1, 5);
swrh = create(srw, 2000, 30, "writer", 3, "writer H", sem, 5);
swrl = create(srw, 2000, 10, "writer", 3, "writer L", sem, 3);
srdm = create(srw, 2000, 40, "reader", 3, "reader M", sem, 1);
kprintf("Start Writer L, then sleep 1s\n");
resume(swrl);
sleep(1);
kprintf("Start Writer H, then sleep 1s\n");
resume(swrh);
sleep(1);
kprintf("Start dowait, then sleep 1s\n");
resume(sloop);
sleep(1);
sleep(10);
kprintf ("Semaphore test finished!\n");
return 0;
}
