Index: tests/.expect/locks.txt =================================================================== --- tests/.expect/locks.txt (revision ebd1899b4176e70de49f784d2ddec14039e251f6) +++ tests/.expect/locks.txt (revision ebd1899b4176e70de49f784d2ddec14039e251f6) @@ -0,0 +1,56 @@ +Start Test 1: multi acquisition lock and condition variable single wait/notify +Done Test 1 +Start Test 2: multi acquisition lock and condition variable 3 wait/notify all +Done Test 2 +Start Test 3: single acquisition lock and condition variable single wait/notify +Done Test 3 +Start Test 4: single acquisition lock and condition variable 3 wait/notify all +Done Test 4 +Start Test 5: owner lock and condition variable single wait/notify +Done Test 5 +Start Test 6: owner lock and condition variable 3 wait/notify all +Done Test 6 +Start Test 7: multi acquisiton lock and condition variable multiple acquire and wait/notify +Done Test 7 +Start Test 8: owner lock and condition variable multiple acquire and wait/notify +Done Test 8 +Start Test 9: no lock condition variable wait/notify +Done Test 9 +Start Test 10: locked condition variable wait/notify with front() +Done Test 10 +Start Test 11: unlocked condition variable delay wait +Iteration: 0 +Iteration: 1000 +Iteration: 2000 +Iteration: 3000 +Iteration: 4000 +Iteration: 5000 +Iteration: 6000 +Iteration: 7000 +Iteration: 8000 +Iteration: 9000 +Done Test 11 +Start Test 12: locked condition variable delay wait with unlocked signal +Iteration: 0 +Iteration: 1000 +Iteration: 2000 +Iteration: 3000 +Iteration: 4000 +Iteration: 5000 +Iteration: 6000 +Iteration: 7000 +Iteration: 8000 +Iteration: 9000 +Done Test 12 +Start Test 13: locked condition variable delay wait with locked signal +Iteration: 0 +Iteration: 1000 +Iteration: 2000 +Iteration: 3000 +Iteration: 4000 +Iteration: 5000 +Iteration: 6000 +Iteration: 7000 +Iteration: 8000 +Iteration: 9000 +Done Test 13 Index: tests/.expect/timeout_lock.txt =================================================================== --- tests/.expect/timeout_lock.txt (revision ebd1899b4176e70de49f784d2ddec14039e251f6) +++ tests/.expect/timeout_lock.txt (revision ebd1899b4176e70de49f784d2ddec14039e251f6) @@ -0,0 +1,4 @@ +Start Test 1: surface testing condition variable timeout routines +Done Test 1 +Start Test 2: testing timeout vs signalling with varying timeout durations +Done Test 2 Index: tests/locks.cfa =================================================================== --- tests/locks.cfa (revision 636d45f56226edeb5a8a2a493e16d073c385b52e) +++ (revision ) @@ -1,303 +1,0 @@ -#include -#include "locks.hfa" -#include -#include - -const unsigned int num_times = 50000; - -multiple_acquisition_lock m; -condition_variable( multiple_acquisition_lock ) c_m; - -single_acquisition_lock s; -condition_variable( single_acquisition_lock ) c_s; - -owner_lock o; -condition_variable( owner_lock ) c_o; - -thread T_C_M_WS1 {}; - -void main( T_C_M_WS1 & this ) { - for (unsigned int i = 0; i < num_times; i++) { - lock(m); - if(empty(c_m) && i != num_times - 1) { - wait(c_m,m); - }else{ - notify_one(c_m); - } - unlock(m); - } -} - -thread T_C_M_WB1 {}; - -void main( T_C_M_WB1 & this ) { - for (unsigned int i = 0; i < num_times; i++) { - lock(m); - if(counter(c_m) == 3 || i == num_times - 1) { - notify_all(c_m); - }else{ - wait(c_m,m); - } - unlock(m); - } -} - -thread T_C_S_WS1 {}; - -void main( T_C_S_WS1 & this ) { - for (unsigned int i = 0; i < num_times; i++) { - lock(s); - if(empty(c_s) && i != num_times - 1) { - wait(c_s,s); - }else{ - notify_one(c_s); - } - unlock(s); - } -} - -thread T_C_S_WB1 {}; - -void main( T_C_S_WB1 & this ) { - for (unsigned int i = 0; i < num_times; i++) { - lock(s); - if(counter(c_s) == 3 || i == num_times - 1) { - notify_all(c_s); - }else{ - wait(c_s,s); - } - unlock(s); - } -} - -thread T_C_O_WS1 {}; - -void main( T_C_O_WS1 & this ) { - for (unsigned int i = 0; i < num_times; i++) { - lock(o); - if(empty(c_o) && i != num_times - 1) { - wait(c_o,o); - }else{ - notify_one(c_o); - } - unlock(o); - } -} - -thread T_C_O_WB1 {}; - -void main( T_C_O_WB1 & this ) { - for (unsigned int i = 0; i < num_times; i++) { - lock(o); - if(counter(c_o) == 3 || i == num_times - 1) { - notify_all(c_o); - }else{ - wait(c_o,o); - } - unlock(o); - } -} - -thread T_C_M_WS2 {}; - -void main( T_C_M_WS2 & this ) { - for (unsigned int i = 0; i < num_times; i++) { - lock(m); - lock(m); - lock(m); - if(empty(c_m) && i != num_times - 1) { - wait(c_m,m); - }else{ - notify_one(c_m); - } - unlock(m); - unlock(m); - unlock(m); - } -} - -thread T_C_O_WS2 {}; - -void main( T_C_O_WS2 & this ) { - for (unsigned int i = 0; i < num_times; i++) { - lock(o); - lock(o); - lock(o); - if(empty(c_o) && i != num_times - 1) { - wait(c_o,o); - }else{ - notify_one(c_o); - } - unlock(o); - unlock(o); - unlock(o); - } -} - -thread T_C_NLW {}; - -void main( T_C_NLW & this ) { - for (unsigned int i = 0; i < num_times; i++) { - wait(c_o); - } -} - -thread T_C_NLS {}; - -void main( T_C_NLS & this ) { - for (unsigned int i = 0; i < num_times; i++) { - while (empty(c_o)) { } - notify_one(c_o); - } -} - -thread T_C_S_WNF {}; - -void main( T_C_S_WNF & this ) { - for (unsigned int i = 0; i < num_times; i++) { - lock(s); - if(empty(c_s) && i != num_times - 1) { - wait(c_s, s, 10); - }else{ - if(!empty(c_s)) assert(front(c_s) == 10); - notify_one(c_s); - } - unlock(s); - } -} - -bool done = false; - -thread T_C_NLWD {}; - -void main( T_C_NLWD & this ) { - done = false; - for (unsigned int i = 0; i < num_times/5; i++) { - if (i % 1000 == 0) printf("Iteration: %d\n", i); - wait(c_s, 1`ns); - } - done = true; -} - -thread T_C_WDS {}; - -void main( T_C_WDS & this ) { - for (unsigned int i = 0; i < num_times; i++) { - while (empty(c_s) && !done) { } - notify_one(c_s); - sleep(1`ns); - if(done) break; - } -} - -thread T_C_LWD {}; - -void main( T_C_LWD & this ) { - done = false; - for (unsigned int i = 0; i < num_times/5; i++) { - if (i % 1000 == 0) printf("Iteration: %d\n", i); - lock(s); - wait(c_s, s, 1`ns); - unlock(s); - } - done = true; -} - -thread T_C_LWDS {}; - -void main( T_C_LWDS & this ) { - for (unsigned int i = 0; i < num_times; i++) { - while (empty(c_s) && !done) { } - lock(s); - notify_one(c_s); - unlock(s); - sleep(1`ns); - if(done) break; - } -} - -int main() { - processor p[2]; - wait( c_s, 1`ns ); - printf("Start Test 1: multi acquisition lock and condition variable single wait/notify\n"); - { - T_C_M_WS1 t1[2]; - } - printf("Done Test 1\n"); - - printf("Start Test 2: multi acquisition lock and condition variable 3 wait/notify all\n"); - { - T_C_M_WB1 t1[4]; - } - printf("Done Test 2\n"); - - printf("Start Test 3: single acquisition lock and condition variable single wait/notify\n"); - { - T_C_S_WS1 t1[2]; - } - printf("Done Test 3\n"); - - printf("Start Test 4: single acquisition lock and condition variable 3 wait/notify all\n"); - { - T_C_S_WB1 t1[4]; - } - printf("Done Test 4\n"); - - printf("Start Test 5: owner lock and condition variable single wait/notify\n"); - { - T_C_O_WS1 t1[2]; - } - printf("Done Test 5\n"); - - printf("Start Test 6: owner lock and condition variable 3 wait/notify all\n"); - { - T_C_O_WB1 t1[4]; - } - printf("Done Test 6\n"); - - printf("Start Test 7: multi acquisiton lock and condition variable multiple acquire and wait/notify\n"); - { - T_C_M_WS2 t1[2]; - } - printf("Done Test 7\n"); - - printf("Start Test 8: owner lock and condition variable multiple acquire and wait/notify\n"); - { - T_C_O_WS2 t1[2]; - } - printf("Done Test 8\n"); - - printf("Start Test 9: no lock condition variable wait/notify\n"); - { - T_C_NLW t1; - T_C_NLS t2; - } - printf("Done Test 9\n"); - - printf("Start Test 10: locked condition variable wait/notify with front()\n"); - { - T_C_S_WNF t1[2]; - } - printf("Done Test 10\n"); - - printf("Start Test 11: unlocked condition variable delay wait\n"); - { - T_C_NLWD t1; - T_C_WDS t2; - } - printf("Done Test 11\n"); - - printf("Start Test 12: locked condition variable delay wait with unlocked signal\n"); - { - T_C_LWD t1; - T_C_WDS t2; - } - printf("Done Test 12\n"); - - printf("Start Test 13: locked condition variable delay wait with locked signal\n"); - { - T_C_LWD t1; - T_C_LWDS t2; - } - printf("Done Test 13\n"); -} Index: tests/timeout_lock.cfa =================================================================== --- tests/timeout_lock.cfa (revision 636d45f56226edeb5a8a2a493e16d073c385b52e) +++ (revision ) @@ -1,92 +1,0 @@ -#include -#include "locks.hfa" -#include "alarm.hfa" -#include -#include -#include "kernel.cfa" - -multiple_acquisition_lock m; -condition_variable( multiple_acquisition_lock ) c_m; - -semaphore s; // used for barrier like behaviour - -const unsigned int NoOfTimes = 20; - -void block() { - if (s.count == 0) { - P(s); - } else { - V(s); - } -} - -thread T1 {}; - -void main( T1 & this ) { - lock(m); - wait( c_m, m, 1`s ); - printf("Thread: %p timedout\n", active_thread()); - - block(); - - // Test calls which occur increasingly close to timeout value. - - for ( unsigned int i = 0; i < NoOfTimes + 3; i += 1 ) { - if ( wait( c_m, m, 1`s ) ) { - printf("Thread: %p signalled\n", active_thread()); - } else { - printf("Thread: %p timedout\n", active_thread()); - } // if - - block(); - } // for -} - - -thread T2 {}; - -void main( T2 & this ) { - block(); - - // Test calls which occur increasingly close to timeout value. - - sleep( 100000000`ns ); - notify_one(c_m); - block(); - - sleep( 500000000`ns ); - notify_one(c_m); - block(); - - sleep( 900000000`ns ); - notify_one(c_m); - block(); - - for ( unsigned int i = 0; i < NoOfTimes; i += 1 ) { - sleep( 999700000`ns ); - notify_one(c_m); - block(); - } // for -} - -int main() { - processor p[2]; - printf("Start Test 1: surface testing condition variable timeout routines\n"); - wait( c_m, 1`ns ); // bool wait( condition_variable(L) & this, Duration duration ); - wait( c_m, 10, 1`ns ); // bool wait( condition_variable(L) & this, uintptr_t info, Duration duration ); - wait( c_m, __kernel_get_time() + 1`ns ); // bool wait( condition_variable(L) & this, Time time ); - wait( c_m, 10, __kernel_get_time() + 1`ns ); // bool wait( condition_variable(L) & this, uintptr_t info, Time time ); - lock(m); wait( c_m, m, 1`ns ); unlock(m); // bool wait( condition_variable(L) & this, L & l, Duration duration ); - lock(m); wait( c_m, m, 10, 1`ns ); unlock(m); // bool wait( condition_variable(L) & this, L & l, uintptr_t info, Duration duration ); - lock(m); wait( c_m, m, __kernel_get_time() + 1`ns ); unlock(m); // bool wait( condition_variable(L) & this, L & l, Time time ); - lock(m); wait( c_m, m, 10, __kernel_get_time() + 1`ns ); unlock(m); // bool wait( condition_variable(L) & this, L & l, uintptr_t info, Time time ); - printf("Done Test 1\n"); - - printf("Start Test 2: testing timeout vs signalling with varying timeout durations\n"); - s{ 0 }; - { - T1 t1; - T2 t2; - } - printf("Done Test 2\n"); -} Index: tests/unified_locking/locks.cfa =================================================================== --- tests/unified_locking/locks.cfa (revision ebd1899b4176e70de49f784d2ddec14039e251f6) +++ tests/unified_locking/locks.cfa (revision ebd1899b4176e70de49f784d2ddec14039e251f6) @@ -0,0 +1,303 @@ +#include +#include "locks.hfa" +#include +#include + +const unsigned int num_times = 50000; + +multiple_acquisition_lock m; +condition_variable( multiple_acquisition_lock ) c_m; + +single_acquisition_lock s; +condition_variable( single_acquisition_lock ) c_s; + +owner_lock o; +condition_variable( owner_lock ) c_o; + +thread T_C_M_WS1 {}; + +void main( T_C_M_WS1 & this ) { + for (unsigned int i = 0; i < num_times; i++) { + lock(m); + if(empty(c_m) && i != num_times - 1) { + wait(c_m,m); + }else{ + notify_one(c_m); + } + unlock(m); + } +} + +thread T_C_M_WB1 {}; + +void main( T_C_M_WB1 & this ) { + for (unsigned int i = 0; i < num_times; i++) { + lock(m); + if(counter(c_m) == 3 || i == num_times - 1) { + notify_all(c_m); + }else{ + wait(c_m,m); + } + unlock(m); + } +} + +thread T_C_S_WS1 {}; + +void main( T_C_S_WS1 & this ) { + for (unsigned int i = 0; i < num_times; i++) { + lock(s); + if(empty(c_s) && i != num_times - 1) { + wait(c_s,s); + }else{ + notify_one(c_s); + } + unlock(s); + } +} + +thread T_C_S_WB1 {}; + +void main( T_C_S_WB1 & this ) { + for (unsigned int i = 0; i < num_times; i++) { + lock(s); + if(counter(c_s) == 3 || i == num_times - 1) { + notify_all(c_s); + }else{ + wait(c_s,s); + } + unlock(s); + } +} + +thread T_C_O_WS1 {}; + +void main( T_C_O_WS1 & this ) { + for (unsigned int i = 0; i < num_times; i++) { + lock(o); + if(empty(c_o) && i != num_times - 1) { + wait(c_o,o); + }else{ + notify_one(c_o); + } + unlock(o); + } +} + +thread T_C_O_WB1 {}; + +void main( T_C_O_WB1 & this ) { + for (unsigned int i = 0; i < num_times; i++) { + lock(o); + if(counter(c_o) == 3 || i == num_times - 1) { + notify_all(c_o); + }else{ + wait(c_o,o); + } + unlock(o); + } +} + +thread T_C_M_WS2 {}; + +void main( T_C_M_WS2 & this ) { + for (unsigned int i = 0; i < num_times; i++) { + lock(m); + lock(m); + lock(m); + if(empty(c_m) && i != num_times - 1) { + wait(c_m,m); + }else{ + notify_one(c_m); + } + unlock(m); + unlock(m); + unlock(m); + } +} + +thread T_C_O_WS2 {}; + +void main( T_C_O_WS2 & this ) { + for (unsigned int i = 0; i < num_times; i++) { + lock(o); + lock(o); + lock(o); + if(empty(c_o) && i != num_times - 1) { + wait(c_o,o); + }else{ + notify_one(c_o); + } + unlock(o); + unlock(o); + unlock(o); + } +} + +thread T_C_NLW {}; + +void main( T_C_NLW & this ) { + for (unsigned int i = 0; i < num_times; i++) { + wait(c_o); + } +} + +thread T_C_NLS {}; + +void main( T_C_NLS & this ) { + for (unsigned int i = 0; i < num_times; i++) { + while (empty(c_o)) { } + notify_one(c_o); + } +} + +thread T_C_S_WNF {}; + +void main( T_C_S_WNF & this ) { + for (unsigned int i = 0; i < num_times; i++) { + lock(s); + if(empty(c_s) && i != num_times - 1) { + wait(c_s, s, 10); + }else{ + if(!empty(c_s)) assert(front(c_s) == 10); + notify_one(c_s); + } + unlock(s); + } +} + +bool done = false; + +thread T_C_NLWD {}; + +void main( T_C_NLWD & this ) { + done = false; + for (unsigned int i = 0; i < num_times/5; i++) { + if (i % 1000 == 0) printf("Iteration: %d\n", i); + wait(c_s, 1`ns); + } + done = true; +} + +thread T_C_WDS {}; + +void main( T_C_WDS & this ) { + for (unsigned int i = 0; i < num_times; i++) { + while (empty(c_s) && !done) { } + notify_one(c_s); + sleep(1`ns); + if(done) break; + } +} + +thread T_C_LWD {}; + +void main( T_C_LWD & this ) { + done = false; + for (unsigned int i = 0; i < num_times/5; i++) { + if (i % 1000 == 0) printf("Iteration: %d\n", i); + lock(s); + wait(c_s, s, 1`ns); + unlock(s); + } + done = true; +} + +thread T_C_LWDS {}; + +void main( T_C_LWDS & this ) { + for (unsigned int i = 0; i < num_times; i++) { + while (empty(c_s) && !done) { } + lock(s); + notify_one(c_s); + unlock(s); + sleep(1`ns); + if(done) break; + } +} + +int main() { + processor p[2]; + wait( c_s, 1`ns ); + printf("Start Test 1: multi acquisition lock and condition variable single wait/notify\n"); + { + T_C_M_WS1 t1[2]; + } + printf("Done Test 1\n"); + + printf("Start Test 2: multi acquisition lock and condition variable 3 wait/notify all\n"); + { + T_C_M_WB1 t1[4]; + } + printf("Done Test 2\n"); + + printf("Start Test 3: single acquisition lock and condition variable single wait/notify\n"); + { + T_C_S_WS1 t1[2]; + } + printf("Done Test 3\n"); + + printf("Start Test 4: single acquisition lock and condition variable 3 wait/notify all\n"); + { + T_C_S_WB1 t1[4]; + } + printf("Done Test 4\n"); + + printf("Start Test 5: owner lock and condition variable single wait/notify\n"); + { + T_C_O_WS1 t1[2]; + } + printf("Done Test 5\n"); + + printf("Start Test 6: owner lock and condition variable 3 wait/notify all\n"); + { + T_C_O_WB1 t1[4]; + } + printf("Done Test 6\n"); + + printf("Start Test 7: multi acquisiton lock and condition variable multiple acquire and wait/notify\n"); + { + T_C_M_WS2 t1[2]; + } + printf("Done Test 7\n"); + + printf("Start Test 8: owner lock and condition variable multiple acquire and wait/notify\n"); + { + T_C_O_WS2 t1[2]; + } + printf("Done Test 8\n"); + + printf("Start Test 9: no lock condition variable wait/notify\n"); + { + T_C_NLW t1; + T_C_NLS t2; + } + printf("Done Test 9\n"); + + printf("Start Test 10: locked condition variable wait/notify with front()\n"); + { + T_C_S_WNF t1[2]; + } + printf("Done Test 10\n"); + + printf("Start Test 11: unlocked condition variable delay wait\n"); + { + T_C_NLWD t1; + T_C_WDS t2; + } + printf("Done Test 11\n"); + + printf("Start Test 12: locked condition variable delay wait with unlocked signal\n"); + { + T_C_LWD t1; + T_C_WDS t2; + } + printf("Done Test 12\n"); + + printf("Start Test 13: locked condition variable delay wait with locked signal\n"); + { + T_C_LWD t1; + T_C_LWDS t2; + } + printf("Done Test 13\n"); +} Index: tests/unified_locking/timeout_lock.cfa =================================================================== --- tests/unified_locking/timeout_lock.cfa (revision ebd1899b4176e70de49f784d2ddec14039e251f6) +++ tests/unified_locking/timeout_lock.cfa (revision ebd1899b4176e70de49f784d2ddec14039e251f6) @@ -0,0 +1,92 @@ +#include +#include "locks.hfa" +#include "alarm.hfa" +#include +#include +#include "kernel.cfa" + +multiple_acquisition_lock m; +condition_variable( multiple_acquisition_lock ) c_m; + +semaphore s; // used for barrier like behaviour + +const unsigned int NoOfTimes = 20; + +void block() { + if (s.count == 0) { + P(s); + } else { + V(s); + } +} + +thread T1 {}; + +void main( T1 & this ) { + lock(m); + wait( c_m, m, 1`s ); + // printf("Thread: %p timedout\n", active_thread()); // removed since can't expect non deterministic output + + block(); + + // Test calls which occur increasingly close to timeout value. + + for ( unsigned int i = 0; i < NoOfTimes + 3; i += 1 ) { + if ( wait( c_m, m, 1`s ) ) { + // printf("Thread: %p signalled\n", active_thread()); // removed since can't expect non deterministic output + } else { + // printf("Thread: %p timedout\n", active_thread()); // removed since can't expect non deterministic output + } // if + + block(); + } // for +} + + +thread T2 {}; + +void main( T2 & this ) { + block(); + + // Test calls which occur increasingly close to timeout value. + + sleep( 100000000`ns ); + notify_one(c_m); + block(); + + sleep( 500000000`ns ); + notify_one(c_m); + block(); + + sleep( 900000000`ns ); + notify_one(c_m); + block(); + + for ( unsigned int i = 0; i < NoOfTimes; i += 1 ) { + sleep( 999700000`ns ); + notify_one(c_m); + block(); + } // for +} + +int main() { + processor p[2]; + printf("Start Test 1: surface testing condition variable timeout routines\n"); + wait( c_m, 1`ns ); // bool wait( condition_variable(L) & this, Duration duration ); + wait( c_m, 10, 1`ns ); // bool wait( condition_variable(L) & this, uintptr_t info, Duration duration ); + wait( c_m, __kernel_get_time() + 1`ns ); // bool wait( condition_variable(L) & this, Time time ); + wait( c_m, 10, __kernel_get_time() + 1`ns ); // bool wait( condition_variable(L) & this, uintptr_t info, Time time ); + lock(m); wait( c_m, m, 1`ns ); unlock(m); // bool wait( condition_variable(L) & this, L & l, Duration duration ); + lock(m); wait( c_m, m, 10, 1`ns ); unlock(m); // bool wait( condition_variable(L) & this, L & l, uintptr_t info, Duration duration ); + lock(m); wait( c_m, m, __kernel_get_time() + 1`ns ); unlock(m); // bool wait( condition_variable(L) & this, L & l, Time time ); + lock(m); wait( c_m, m, 10, __kernel_get_time() + 1`ns ); unlock(m); // bool wait( condition_variable(L) & this, L & l, uintptr_t info, Time time ); + printf("Done Test 1\n"); + + printf("Start Test 2: testing timeout vs signalling with varying timeout durations\n"); + s{ 0 }; + { + T1 t1; + T2 t2; + } + printf("Done Test 2\n"); +}