Index: libcfa/src/concurrency/invoke.h =================================================================== --- libcfa/src/concurrency/invoke.h (revision e43aa144c4c08d30a277b5cafc1979cd08ae40af) +++ libcfa/src/concurrency/invoke.h (revision c131a027b25acccd0ac9645890d8369d04c0a782) @@ -18,4 +18,5 @@ #include "bits/locks.hfa" #include "kernel/fwd.hfa" +#include #ifdef __cforall @@ -189,4 +190,10 @@ struct __monitor_group_t monitors; + // used to put threads on user data structures + struct { + struct $thread * next; + struct $thread * back; + } seqable; + struct { struct $thread * next; @@ -218,4 +225,16 @@ } + static inline $thread *& Back( $thread * this ) __attribute__((const)) { + return this->seqable.back; + } + + static inline $thread *& Next( $thread * this ) __attribute__((const)) { + return this->seqable.next; + } + + static inline bool listed( $thread * this ) { + return this->seqable.next != 0p; + } + static inline void ?{}(__monitor_group_t & this) { (this.data){0p}; Index: libcfa/src/concurrency/locks.cfa =================================================================== --- libcfa/src/concurrency/locks.cfa (revision e43aa144c4c08d30a277b5cafc1979cd08ae40af) +++ libcfa/src/concurrency/locks.cfa (revision c131a027b25acccd0ac9645890d8369d04c0a782) @@ -29,4 +29,16 @@ void ^?{}( info_thread(L) & this ){ } + + info_thread(L) *& Back( info_thread(L) * this ) { + return (info_thread(L) *)Back( (Seqable *)this ); + } + + info_thread(L) *& Next( info_thread(L) * this ) { + return (info_thread(L) *)Next( (Colable *)this ); + } + + bool listed( info_thread(L) * this ) { + return Next( (Colable *)this ) != 0p; + } } @@ -58,5 +70,5 @@ abort("A single acquisition lock holder attempted to reacquire the lock resulting in a deadlock."); } else if ( owner != 0p && owner != active_thread() ) { - append( blocked_threads, active_thread() ); + addTail( blocked_threads, *active_thread() ); wait_count++; unlock( lock ); @@ -96,5 +108,5 @@ void pop_and_set_new_owner( blocking_lock & this ) with( this ) { - $thread * t = pop_head( blocked_threads ); + $thread * t = &dropHead( blocked_threads ); owner = t; recursion_count = ( t ? 1 : 0 ); @@ -128,5 +140,5 @@ lock( lock __cfaabi_dbg_ctx2 ); if ( owner != 0p ) { - append( blocked_threads, t ); + addTail( blocked_threads, *t ); wait_count++; unlock( lock ); @@ -257,5 +269,4 @@ size_t recursion_count = 0; if (i->lock) { - i->t->link.next = 1p; recursion_count = get_recursion_count(*i->lock); remove_( *i->lock ); @@ -353,2 +364,281 @@ } } + +// 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 ) { +// fprintf(stderr, "start of thd main listed: %d\n", listed(active_thread()) ); +// fprintf(stderr, "thread colable next ptr in start of thd main %p\n", Next( (Colable *)active_thread() ) ); +// 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; 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; i++) { +// if (i % 500 == 0) printf("!! %d\n", i); +// lock(s); +// wait(c_s, s, 1`ns); +// unlock(s); +// } +// done = true; +// } + +// int main() { +// processor p[2]; +// printf("Start Test 1: multi acquisition lock and condition variable single wait/notify\n"); +// { +// T_C_M_WS1 t1; +// } +// 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\n"); +// // { +// // T_C_LWD t1; +// // T_C_WDS t2; +// // } +// // printf("Done Test 12\n"); +// } Index: libcfa/src/concurrency/locks.hfa =================================================================== --- libcfa/src/concurrency/locks.hfa (revision e43aa144c4c08d30a277b5cafc1979cd08ae40af) +++ libcfa/src/concurrency/locks.hfa (revision c131a027b25acccd0ac9645890d8369d04c0a782) @@ -43,4 +43,8 @@ void ?{}( info_thread(L) & this, $thread * t, uintptr_t info ); void ^?{}( info_thread(L) & this ); + + info_thread(L) *& Back( info_thread(L) * this ); + info_thread(L) *& Next( info_thread(L) * this ); + bool listed( info_thread(L) * this ); } @@ -64,5 +68,5 @@ // List of blocked threads - __queue_t( $thread ) blocked_threads; + Sequence( $thread ) blocked_threads; // Count of current blocked threads Index: libcfa/src/concurrency/thread.cfa =================================================================== --- libcfa/src/concurrency/thread.cfa (revision e43aa144c4c08d30a277b5cafc1979cd08ae40af) +++ libcfa/src/concurrency/thread.cfa (revision c131a027b25acccd0ac9645890d8369d04c0a782) @@ -43,4 +43,7 @@ canary = 0x0D15EA5E0D15EA5Ep; #endif + + seqable.next = 0p; + seqable.back = 0p; node.next = 0p;