source: tests/concurrency/unified_locking/locks.cfa @ b5e3a80

#include <stdio.h>
#include "locks.hfa"
#include <stdlib.hfa>
#include <thread.hfa>

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");
        
}