Index: tests/unified_locking/.expect/block_spin_lock.txt =================================================================== --- tests/unified_locking/.expect/block_spin_lock.txt (revision aa45b15307ca8d731f3261767f737e6cc52ec994) +++ (revision ) @@ -1,3 +1,0 @@ -Starting -Done! -Match! Index: tests/unified_locking/.expect/clh.txt =================================================================== --- tests/unified_locking/.expect/clh.txt (revision aa45b15307ca8d731f3261767f737e6cc52ec994) +++ (revision ) @@ -1,3 +1,0 @@ -Starting -Done! -Match! Index: tests/unified_locking/.expect/exp_backoff.txt =================================================================== --- tests/unified_locking/.expect/exp_backoff.txt (revision aa45b15307ca8d731f3261767f737e6cc52ec994) +++ (revision ) @@ -1,3 +1,0 @@ -Starting -Done! -Match! Index: tests/unified_locking/.expect/fast_block_lock.txt =================================================================== --- tests/unified_locking/.expect/fast_block_lock.txt (revision aa45b15307ca8d731f3261767f737e6cc52ec994) +++ (revision ) @@ -1,3 +1,0 @@ -Starting -Done! -Match! Index: tests/unified_locking/.expect/futex_mutex.txt =================================================================== --- tests/unified_locking/.expect/futex_mutex.txt (revision aa45b15307ca8d731f3261767f737e6cc52ec994) +++ (revision ) @@ -1,3 +1,0 @@ -Starting -Done! -Match! Index: tests/unified_locking/.expect/lin_backoff.txt =================================================================== --- tests/unified_locking/.expect/lin_backoff.txt (revision aa45b15307ca8d731f3261767f737e6cc52ec994) +++ (revision ) @@ -1,3 +1,0 @@ -Starting -Done! -Match! Index: tests/unified_locking/.expect/locks.txt =================================================================== --- tests/unified_locking/.expect/locks.txt (revision aa45b15307ca8d731f3261767f737e6cc52ec994) +++ (revision ) @@ -1,26 +1,0 @@ -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: linear backoff lock and condition variable single wait/notify -Done Test 7 -Start Test 8: linear backoff lock and condition variable 3 wait/notify all -Done Test 8 -Start Test 9: multi acquisiton lock and condition variable multiple acquire and wait/notify -Done Test 9 -Start Test 10: owner lock and condition variable multiple acquire and wait/notify -Done Test 10 -Start Test 11: no lock condition variable wait/notify -Done Test 11 -Start Test 12: locked condition variable wait/notify with front() -Done Test 12 -Start Test 13: fast block lock and fast cond var single wait/notify -Done Test 13 Index: tests/unified_locking/.expect/mcs.txt =================================================================== --- tests/unified_locking/.expect/mcs.txt (revision aa45b15307ca8d731f3261767f737e6cc52ec994) +++ (revision ) @@ -1,3 +1,0 @@ -Starting -Done! -Match! Index: tests/unified_locking/.expect/mcs_block_spin_lock.txt =================================================================== --- tests/unified_locking/.expect/mcs_block_spin_lock.txt (revision aa45b15307ca8d731f3261767f737e6cc52ec994) +++ (revision ) @@ -1,3 +1,0 @@ -Starting -Done! -Match! Index: tests/unified_locking/.expect/mcs_spin.txt =================================================================== --- tests/unified_locking/.expect/mcs_spin.txt (revision aa45b15307ca8d731f3261767f737e6cc52ec994) +++ (revision ) @@ -1,3 +1,0 @@ -Starting -Done! -Match! Index: tests/unified_locking/.expect/pthread_locks.txt =================================================================== --- tests/unified_locking/.expect/pthread_locks.txt (revision aa45b15307ca8d731f3261767f737e6cc52ec994) +++ (revision ) @@ -1,8 +1,0 @@ -Start Test 1: lock and condition variable single wait/notify -Done Test 1 -Start Test 2: lock and condition variable 3 wait/notify all -Done Test 2 -Start Test 3: lock and condition variable multiple acquire and wait/notify -Done Test 3 -Start Test 4: lock and condition variable single timed wait/notify -Done Test 4 Index: tests/unified_locking/.expect/simple_owner_lock.txt =================================================================== --- tests/unified_locking/.expect/simple_owner_lock.txt (revision aa45b15307ca8d731f3261767f737e6cc52ec994) +++ (revision ) @@ -1,3 +1,0 @@ -Starting -Done! -Match! Index: tests/unified_locking/.expect/spin_queue_lock.txt =================================================================== --- tests/unified_locking/.expect/spin_queue_lock.txt (revision aa45b15307ca8d731f3261767f737e6cc52ec994) +++ (revision ) @@ -1,3 +1,0 @@ -Starting -Done! -Match! Index: tests/unified_locking/.expect/timeout_lock.txt =================================================================== --- tests/unified_locking/.expect/timeout_lock.txt (revision aa45b15307ca8d731f3261767f737e6cc52ec994) +++ (revision ) @@ -1,4 +1,0 @@ -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/unified_locking/block_spin_lock.cfa =================================================================== --- tests/unified_locking/block_spin_lock.cfa (revision aa45b15307ca8d731f3261767f737e6cc52ec994) +++ (revision ) @@ -1,8 +1,0 @@ -#include - -#define LOCK block_spin_lock -#include "mutex_test.hfa" - -int main() { - test(); -} Index: tests/unified_locking/clh.cfa =================================================================== --- tests/unified_locking/clh.cfa (revision aa45b15307ca8d731f3261767f737e6cc52ec994) +++ (revision ) @@ -1,8 +1,0 @@ -#include - -#define LOCK clh_lock -#include "mutex_test.hfa" - -int main() { - test(); -} Index: tests/unified_locking/exp_backoff.cfa =================================================================== --- tests/unified_locking/exp_backoff.cfa (revision aa45b15307ca8d731f3261767f737e6cc52ec994) +++ (revision ) @@ -1,8 +1,0 @@ -#include - -#define LOCK exp_backoff_then_block_lock -#include "mutex_test.hfa" - -int main() { - test(); -} Index: tests/unified_locking/fast_block_lock.cfa =================================================================== --- tests/unified_locking/fast_block_lock.cfa (revision aa45b15307ca8d731f3261767f737e6cc52ec994) +++ (revision ) @@ -1,8 +1,0 @@ -#include - -#define LOCK fast_block_lock -#include "mutex_test.hfa" - -int main() { - test(); -} Index: tests/unified_locking/futex_mutex.cfa =================================================================== --- tests/unified_locking/futex_mutex.cfa (revision aa45b15307ca8d731f3261767f737e6cc52ec994) +++ (revision ) @@ -1,8 +1,0 @@ -#include - -#define LOCK futex_mutex -#include "mutex_test.hfa" - -int main() { - test(); -} Index: tests/unified_locking/lin_backoff.cfa =================================================================== --- tests/unified_locking/lin_backoff.cfa (revision aa45b15307ca8d731f3261767f737e6cc52ec994) +++ (revision ) @@ -1,8 +1,0 @@ -#include - -#define LOCK linear_backoff_then_block_lock -#include "mutex_test.hfa" - -int main() { - test(); -} Index: tests/unified_locking/locks.cfa =================================================================== --- tests/unified_locking/locks.cfa (revision aa45b15307ca8d731f3261767f737e6cc52ec994) +++ (revision ) @@ -1,348 +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; - -exp_backoff_then_block_lock l; -condition_variable( exp_backoff_then_block_lock ) c_l; - -fast_block_lock f; -fast_cond_var( fast_block_lock ) f_c_f; - -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_L_WS1 {}; - -void main( T_C_L_WS1 & this ) { - for (unsigned int i = 0; i < num_times; i++) { - lock(l); - if(empty(c_l) && i != num_times - 1) { - wait(c_l,l); - }else{ - notify_one(c_l); - } - unlock(l); - } -} - -thread T_C_L_WB1 {}; - -void main( T_C_L_WB1 & this ) { - for (unsigned int i = 0; i < num_times; i++) { - lock(l); - if(counter(c_l) == 3 || i == num_times - 1) { - notify_all(c_l); - }else{ - wait(c_l,l); - } - unlock(l); - } -} - -thread T_F_C_F_WS1 {}; - -void main( T_F_C_F_WS1 & this ) { - for (unsigned int i = 0; i < num_times; i++) { - lock(f); - if(empty(f_c_f) && i != num_times - 1) { - wait(f_c_f,f); - }else{ - notify_one(f_c_f); - } - unlock(f); - } -} - -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]; - 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: linear backoff lock and condition variable single wait/notify\n"); - { - T_C_L_WS1 t1[2]; - } - printf("Done Test 7\n"); - - printf("Start Test 8: linear backoff lock and condition variable 3 wait/notify all\n"); - { - T_C_L_WB1 t1[4]; - } - printf("Done Test 8\n"); - - printf("Start Test 9: multi acquisiton lock and condition variable multiple acquire and wait/notify\n"); - { - T_C_M_WS2 t1[2]; - } - printf("Done Test 9\n"); - - printf("Start Test 10: owner lock and condition variable multiple acquire and wait/notify\n"); - { - T_C_O_WS2 t1[2]; - } - printf("Done Test 10\n"); - - printf("Start Test 11: no lock condition variable wait/notify\n"); - { - T_C_NLW t1; - T_C_NLS t2; - } - printf("Done Test 11\n"); - - printf("Start Test 12: locked condition variable wait/notify with front()\n"); - { - T_C_S_WNF t1[2]; - } - printf("Done Test 12\n"); - - printf("Start Test 13: fast block lock and fast cond var single wait/notify\n"); - { - T_F_C_F_WS1 t1[2]; - } - printf("Done Test 13\n"); - -} Index: tests/unified_locking/mcs.cfa =================================================================== --- tests/unified_locking/mcs.cfa (revision aa45b15307ca8d731f3261767f737e6cc52ec994) +++ (revision ) @@ -1,66 +1,0 @@ -#include -#include -#include - -const unsigned int num_times = 50000; - -struct MutexObj { - mcs_lock l; - thread$ * id; - size_t sum; -}; - -MutexObj mo; - -void trash() { - unsigned t[100]; - for(i; 100) { - t[i] = 0xDEADBEEF; - } -} - -unsigned cs() { - thread$ * me = active_thread(); - unsigned value = (unsigned)me; - mcs_node n; - lock(mo.l, n); - { - size_t tsum = mo.sum; - mo.id = me; - yield(random(5)); - if(mo.id != me) sout | "Intruder!"; - mo.sum = tsum + value; - } - unlock(mo.l, n); - return value; -} - -thread LockCheck { - size_t sum; -}; - -void main(LockCheck & this) { - this.sum = 0; - for(num_times) { - trash(); - this.sum += cs(); - trash(); - yield(random(10)); - } -} - -int main() { - size_t sum = -32; - mo.sum = -32; - processor p[2]; - sout | "Starting"; - { - LockCheck checkers[13]; - for(i;13) { - sum += join(checkers[i]).sum; - } - } - sout | "Done!"; - if(sum == mo.sum) sout | "Match!"; - else sout | "No Match!" | sum | "vs" | mo.sum; -} Index: tests/unified_locking/mcs_block_spin_lock.cfa =================================================================== --- tests/unified_locking/mcs_block_spin_lock.cfa (revision aa45b15307ca8d731f3261767f737e6cc52ec994) +++ (revision ) @@ -1,8 +1,0 @@ -#include - -#define LOCK mcs_block_spin_lock -#include "mutex_test.hfa" - -int main() { - test(); -} Index: tests/unified_locking/mcs_spin.cfa =================================================================== --- tests/unified_locking/mcs_spin.cfa (revision aa45b15307ca8d731f3261767f737e6cc52ec994) +++ (revision ) @@ -1,78 +1,0 @@ - -#include -#include -#include - -const unsigned int num_times = 50; - -struct MutexObj { - mcs_spin_lock l; - thread$ * id; - uint32_t sum; - uint32_t cnt; -}; - -MutexObj mo; - -void trash() { - unsigned t[100]; - for(i; 100) { - t[i] = 0xDEADBEEF; - } -} - -uint32_t cs() { - thread$ * me = active_thread(); - uint32_t value; - mcs_spin_node node; - lock(mo.l, node); - { - uint32_t tsum = mo.sum; - uint32_t cnt = mo.cnt; - mo.id = me; - yield(random(5)); - value = ((uint32_t)random()) ^ ((uint32_t)me); - if(mo.id != me) sout | "Intruder!"; - mo.cnt = cnt + 1; - mo.sum = tsum + value; - } - unlock(mo.l, node); - return value; -} - -thread LockCheck { - uint32_t sum; -}; - -void main(LockCheck & this) { - this.sum = 0; - for(num_times) { - trash(); - this.sum += cs(); - trash(); - yield(random(10)); - } -} - -void test() { - uint32_t sum = -32; - mo.sum = -32; - mo.cnt = 0; - processor p[2]; - sout | "Starting"; - { - LockCheck checkers[13]; - for(i;13) { - sum += join(checkers[i]).sum; - } - } - sout | "Done!"; - if(mo.cnt != (13 * num_times)) sout | "Invalid cs count!" | mo.cnt | "vs "| (13 * num_times) | "(13 *" | num_times | ')'; - if(sum == mo.sum) sout | "Match!"; - else sout | "No Match!" | sum | "vs" | mo.sum; -} - -int main() { - test(); - return 0; -} Index: tests/unified_locking/mutex_test.hfa =================================================================== --- tests/unified_locking/mutex_test.hfa (revision aa45b15307ca8d731f3261767f737e6cc52ec994) +++ (revision ) @@ -1,79 +1,0 @@ - -#include -#include -#include - -const unsigned int num_times = 50; - -struct MutexObj { - LOCK l; - thread$ * id; - uint32_t sum; - uint32_t cnt; -}; - -MutexObj mo; - -void trash() { - unsigned t[100]; - for(i; 100) { - t[i] = 0xDEADBEEF; - } -} - -uint32_t cs(uint32_t & entries) { - thread$ * me = active_thread(); - uint32_t value; - lock(mo.l); - { - entries++; - uint32_t tsum = mo.sum; - uint32_t cnt = mo.cnt; - mo.id = me; - yield(random(5)); - value = ((uint32_t)random()) ^ ((uint32_t)me); - if(mo.id != me) sout | "Intruder!"; - mo.cnt = cnt + 1; - mo.sum = tsum + value; - } - unlock(mo.l); - return value; -} - -thread LockCheck { - uint32_t sum; - uint32_t entries; -}; - -void main(LockCheck & this) { - this.sum = 0; - this.entries = 0; - for(num_times) { - trash(); - this.sum += cs( this.entries ); - trash(); - yield(random(10)); - } -} - -void test() { - uint32_t sum = -32; - mo.sum = -32; - mo.cnt = 0; - uint32_t real_entries = 0; - processor p[2]; - sout | "Starting"; - { - LockCheck checkers[13]; - for(i;13) { - LockCheck & curr = join(checkers[i]); - sum += curr.sum; - real_entries += curr.entries; - } - } - sout | "Done!"; - if(real_entries != (13 * num_times)) sout | "Invalid real cs count!" | mo.cnt | "vs "| (13 * num_times) | "(13 *" | num_times | ')'; - if(mo.cnt != (13 * num_times)) sout | "Invalid concurrent cs count!" | mo.cnt | "vs "| (13 * num_times) | "(13 *" | num_times | ')'; - if(sum == mo.sum) sout | "Match!"; - else sout | "No Match!" | sum | "vs" | mo.sum; -} Index: tests/unified_locking/pthread_locks.cfa =================================================================== --- tests/unified_locking/pthread_locks.cfa (revision aa45b15307ca8d731f3261767f737e6cc52ec994) +++ (revision ) @@ -1,108 +1,0 @@ -#include -#include "locks.hfa" -#include -#include -#include -#include - -const unsigned int num_times = 50; - -simple_owner_lock l; -pthread_cond_var( simple_owner_lock ) c; - -owner_lock l2; -condition_variable( owner_lock ) c2; - -volatile int counter = 0; - -thread Wait_Signal_1 {}; - -void main( Wait_Signal_1 & this ) { - for (unsigned int i = 0; i < num_times; i++) { - lock(l); - if(empty(c) && i != num_times - 1) { - wait(c,l); - }else{ - notify_one(c); - } - unlock(l); - } -} - -thread Wait_3_Signal_3 {}; - -void main( Wait_3_Signal_3 & this ) { - for (unsigned int i = 0; i < num_times; i++) { - lock(l); - counter++; - if(counter == 4 || i == num_times - 1) { - counter = 0; - notify_all(c); - }else{ - wait(c,l); - } - unlock(l); - } -} - -thread Rec_Lock_Wait_Signal_1 {}; - -void main( Rec_Lock_Wait_Signal_1 & this ) { - for (unsigned int i = 0; i < num_times; i++) { - lock(l); - lock(l); - lock(l); - if(empty(c) && i != num_times - 1) { - wait(c,l); - }else{ - notify_one(c); - } - unlock(l); - unlock(l); - unlock(l); - } -} - -thread Wait_Time_Signal_1 {}; - -void main( Wait_Time_Signal_1 & this ) { - for (unsigned int i = 0; i < num_times; i++) { - lock(l); - if(empty(c) || random(10) >= 9 ) { - timespec t; - clock_gettime(CLOCK_REALTIME, &t); - timespec waitTime{0,1}; - bool woken = wait(c,l, t + waitTime); - }else{ - notify_one(c); - } - unlock(l); - } -} - -int main() { - processor p[1]; - printf("Start Test 1: lock and condition variable single wait/notify\n"); - { - Wait_Signal_1 t1[2]; - } - printf("Done Test 1\n"); - - printf("Start Test 2: lock and condition variable 3 wait/notify all\n"); - { - Wait_3_Signal_3 t1[4]; - } - printf("Done Test 2\n"); - - printf("Start Test 3: lock and condition variable multiple acquire and wait/notify\n"); - { - Rec_Lock_Wait_Signal_1 t1[2]; - } - printf("Done Test 3\n"); - - printf("Start Test 4: lock and condition variable single timed wait/notify\n"); - { - Wait_Time_Signal_1 t1[2]; - } - printf("Done Test 4\n"); -} Index: tests/unified_locking/simple_owner_lock.cfa =================================================================== --- tests/unified_locking/simple_owner_lock.cfa (revision aa45b15307ca8d731f3261767f737e6cc52ec994) +++ (revision ) @@ -1,8 +1,0 @@ -#include - -#define LOCK simple_owner_lock -#include "mutex_test.hfa" - -int main() { - test(); -} Index: tests/unified_locking/spin_queue_lock.cfa =================================================================== --- tests/unified_locking/spin_queue_lock.cfa (revision aa45b15307ca8d731f3261767f737e6cc52ec994) +++ (revision ) @@ -1,8 +1,0 @@ -#include - -#define LOCK spin_queue_lock -#include "mutex_test.hfa" - -int main() { - test(); -} Index: tests/unified_locking/thread_test.cfa =================================================================== --- tests/unified_locking/thread_test.cfa (revision aa45b15307ca8d731f3261767f737e6cc52ec994) +++ (revision ) @@ -1,108 +1,0 @@ -#include -#include "locks.hfa" -#include -#include -#include - -static unsigned int taskCount = 4; -static unsigned int threadCount = 2; -static unsigned int lockCount = 1; -static unsigned int total_times = 320000; -static unsigned int num_times; -static const int workBufferSize = 16; -static unsigned int work_unlocked = 10000; -static unsigned int work_locked = 10000; - -// taken from martin's thread_test -static inline void dowork(volatile int* buffer, unsigned int steps) { - int value = 0; - for (unsigned int i = 0; i < steps; i += 1) { - // a little more work than just a single memory access helps with stability - value += (buffer[i % workBufferSize] * 17) / 23 + 55; - } - buffer[0] += value; -} - -thread worker { - exp_backoff_then_block_lock * locks; - bool improved; -}; - -void ?{}( worker & w, exp_backoff_then_block_lock * locks, bool improved ) { - w.locks = locks; - w.improved = improved; -} - - -void main( worker & this ) with(this) { - int buffer[workBufferSize]; - for (int i = 0; i < workBufferSize; i += 1) buffer[i] = rand() % 1024; - unsigned int lck = rand() % lockCount; - exp_backoff_then_block_lock * curr_lock = &locks[lck]; - for (unsigned int i = 0; i < num_times; i++) { - dowork(buffer, work_unlocked); - if (improved) lock_improved(*curr_lock); - else lock(*curr_lock); - dowork(buffer, work_locked); - unlock(*curr_lock); - lck = rand() % lockCount; - curr_lock = &locks[lck]; - } -} - -int doOne = 0; -int main(int argc, char* argv[]) { - switch (argc) { - case 8: - doOne = atoi(argv[7]); - case 7: - work_unlocked = atoi(argv[6]); - case 6: - work_locked = atoi(argv[5]); - case 5: - total_times = atoi(argv[4]); - case 4: - lockCount = atoi(argv[3]); - case 3: - threadCount = atoi(argv[2]); - case 2: - taskCount = atoi(argv[1]); - case 1: - break; - default: - break; - } - processor p[threadCount]; - exp_backoff_then_block_lock locks[lockCount]; - worker * worker_arr[taskCount]; - num_times = total_times / taskCount; - //printf("%d\n", doOne); - // - //clock_t begin = clock(); - if (doOne == 1) { - printf("Start Test: martin lock simple %d\n", num_times); - for (unsigned int i = 0; i < taskCount; i++) { - worker_arr[i] = new( locks, false ); - } - for (unsigned int i = 0; i < taskCount; i++) { - delete( worker_arr[i] ); - } - } - //clock_t end = clock(); - //double time_spent = (double)(end - begin) / CLOCKS_PER_SEC; - //printf("norm: %f\n", time_spent); - - //printf("Start Test: martin lock improved\n"); - //begin = clock(); - if (doOne == 2) { - for (unsigned int i = 0; i < taskCount; i++) { - worker_arr[i] = new( locks, true ); - } - for (unsigned int i = 0; i < taskCount; i++) { - delete( worker_arr[i] ); - } - } - //end = clock(); - //time_spent = (double)(end - begin) / CLOCKS_PER_SEC; - //printf("improved: %f\n", time_spent); -} Index: tests/unified_locking/timeout_lock.cfa =================================================================== --- tests/unified_locking/timeout_lock.cfa (revision aa45b15307ca8d731f3261767f737e6cc52ec994) +++ (revision ) @@ -1,87 +1,0 @@ -#include -#include -#include -#include -#include -#include - -multiple_acquisition_lock m, n; -condition_variable( multiple_acquisition_lock ) c_m, c_n; - -const unsigned int NoOfTimes = 20; - -void block() { // used for barrier like behaviour - lock(n); - if (empty( c_n )) { - wait( c_n, n ); - } else { - notify_one( c_n ); - } - unlock(n); -} - -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, 1000000`ns ) ) { - // 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( 100000`ns ); - notify_one(c_m); - block(); - - sleep( 500000`ns ); - notify_one(c_m); - block(); - - sleep( 900000`ns ); - notify_one(c_m); - block(); - - for ( unsigned int i = 0; i < NoOfTimes; i += 1 ) { - sleep( 999700`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 ); - 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 ); - printf("Done Test 1\n"); - - printf("Start Test 2: testing timeout vs signalling with varying timeout durations\n"); - { - T1 t1; - T2 t2; - } - printf("Done Test 2\n"); -}