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

#include <fstream.hfa>
#include <locks.hfa>
#include <stdlib.hfa>
#include <thread.hfa>

const unsigned int num_times = 20_000;

multiple_acquisition_lock m;
cond_lock( multiple_acquisition_lock ) c_m;

single_acquisition_lock s;
cond_lock( single_acquisition_lock ) c_s;

owner_lock o;
cond_lock( owner_lock ) c_o;

exp_backoff_then_block_lock l;
cond_lock( 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 & ) {
        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 );
                } // for
                unlock( m );
        } // for
} // main

thread T_C_M_WB1 {};

void main( T_C_M_WB1 & ) {
        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 );
                } // if
                unlock( m );
        } // for
} // main

thread T_C_S_WS1 {};

void main( T_C_S_WS1 & ) {
        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 );
                } // if
                unlock( s );
        } // for
} // main

thread T_C_S_WB1 {};

void main( T_C_S_WB1 & ) {
        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 );
                } // if
                unlock( s );
        } // for
} // main

thread T_C_L_WS1 {};

void main( T_C_L_WS1 & ) {
        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 );
                } // if
                unlock( l );
        } // for
} // main

thread T_C_L_WB1 {};

void main( T_C_L_WB1 & ) {
        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 );
                } // if
                unlock( l );
        } // for
} // main

thread T_F_C_F_WS1 {};

void main( T_F_C_F_WS1 & ) {
        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 );
                } // if
                unlock( f );
        } // for
} // main

thread T_C_O_WS1 {};

void main( T_C_O_WS1 & ) {
        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 );
                } // if
                unlock( o );
        } // for
} // main

thread T_C_O_WB1 {};

void main( T_C_O_WB1 & ) {
        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 );
                } // if
                unlock( o );
        } // for
} // main

thread T_C_M_WS2 {};

void main( T_C_M_WS2 & ) {
        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 );
                } // if
                unlock( m );
                unlock( m );
                unlock( m );
        } // for
} // main

thread T_C_O_WS2 {};

void main( T_C_O_WS2 & ) {
        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 );
                } // if
                unlock( o );
                unlock( o );
                unlock( o );
        } // for
} // main

thread T_C_NLW {};

void main( T_C_NLW & ) {
        for ( unsigned int i = 0; i < num_times; i++ ) {
                wait( c_o );
        } // for
} // main

thread T_C_NLS {};

void main( T_C_NLS & ) {
        for ( unsigned int i = 0; i < num_times; i++ ) {
                while ( empty( c_o )) { }
                notify_one( c_o );
        } // for
} // main

thread T_C_S_WNF {};

void main( T_C_S_WNF & ) {
        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 );
                } // if
                unlock( s );
        } // for
} // main

bool done = false;

thread T_C_NLWD {};

void main( T_C_NLWD & ) {
        done = false;
        for ( unsigned int i = 0; i < num_times/5; i++ ) {
                if ( i % 1000 == 0 ) sout | "Iteration:" | i;
                wait( c_s, 1`ns );
        } // for
        done = true;
} // main

thread T_C_WDS {};

void main( T_C_WDS & ) {
        for ( unsigned int i = 0; i < num_times; i++ ) {
                while ( empty( c_s ) && !done ) { }
                notify_one( c_s );
                sleep( 1`ns );
                if ( done ) break;
        } // for
} // main

thread T_C_LWD {};

void main( T_C_LWD & ) {
        done = false;
        for ( unsigned int i = 0; i < num_times/5; i++ ) {
                if ( i % 1000 == 0 ) sout | "Iteration:" | i;
                lock( s );
                wait( c_s, s, 1`ns );
                unlock( s );
        } // for
        done = true;
} // main

thread T_C_LWDS {};

void main( T_C_LWDS & ) {
        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;
        } // for
} // main

int main() {
        processor p[2];
        sout | "Start Test 1: multi acquisition lock and condition variable single wait/notify";
        {
                T_C_M_WS1 t1[2];
        }
        sout | "Done Test 1";

        sout | "Start Test 2: multi acquisition lock and condition variable 3 wait/notify all";
        {
                T_C_M_WB1 t1[4];
        }
        sout | "Done Test 2";

        sout | "Start Test 3: single acquisition lock and condition variable single wait/notify";
        {
                T_C_S_WS1 t1[2];
        }
        sout | "Done Test 3";

        sout | "Start Test 4: single acquisition lock and condition variable 3 wait/notify all";
        {
                T_C_S_WB1 t1[4];
        }
        sout | "Done Test 4";

        sout | "Start Test 5: owner lock and condition variable single wait/notify";
        {
                T_C_O_WS1 t1[2];
        }
        sout | "Done Test 5";

        sout | "Start Test 6: owner lock and condition variable 3 wait/notify all";
        {
                T_C_O_WB1 t1[4];
        }
        sout | "Done Test 6";

        sout | "Start Test 7: linear backoff lock and condition variable single wait/notify";
        {
                T_C_L_WS1 t1[2];
        }
        sout | "Done Test 7";

        sout | "Start Test 8: linear backoff lock and condition variable 3 wait/notify all";
        {
                T_C_L_WB1 t1[4];
        }
        sout | "Done Test 8";

        sout | "Start Test 9: multi acquisiton lock and condition variable multiple acquire and wait/notify";
        {
                T_C_M_WS2 t1[2];
        }
        sout | "Done Test 9";

        sout | "Start Test 10: owner lock and condition variable multiple acquire and wait/notify";
        {
                T_C_O_WS2 t1[2];
        }
        sout | "Done Test 10";

        sout | "Start Test 11: no lock condition variable wait/notify";
        {
                T_C_NLW t1;
                T_C_NLS t2;
        }
        sout | "Done Test 11";

        sout | "Start Test 12: locked condition variable wait/notify with front()";
        {
                T_C_S_WNF t1[2];
        }
        sout | "Done Test 12";

        sout | "Start Test 13: fast block lock and fast cond var single wait/notify";
        {
                T_F_C_F_WS1 t1[2];
        }
        sout | "Done Test 13";
} // main