source: tests/concurrent/mutexstmt/locks.cfa@ 4ecc35a

#include <mutex_stmt.hfa>
#include <locks.hfa>
#include <stats.hfa>

const unsigned int num_times = 10000;

Duration default_preemption() { return 0; }

single_acquisition_lock m1, m2, m3, m4, m5;

thread T_Mutex {};
bool insideFlag = false;
int count = 0;

void main( T_Mutex & this ) {
        for (unsigned int i = 0; i < num_times; i++) {
                mutex ( m1 ) count++;
                mutex ( m1 ) { 
                        assert(!insideFlag);
                        insideFlag = true;
                        assert(insideFlag);
                        insideFlag = false;
                }
        }
}

void refTest( single_acquisition_lock & m ) {
        mutex ( m ) {
                assert(!insideFlag);
                insideFlag = true;
                assert(insideFlag);
                insideFlag = false;
        }
}

thread T_Multi {};

void main( T_Multi & this ) {
        for (unsigned int i = 0; i < num_times; i++) {
                refTest( m1 );
                mutex ( m1 ) {
                        assert(!insideFlag);
                        insideFlag = true;
                        assert(insideFlag);
                        insideFlag = false;
                }
                mutex ( m1, m2, m3, m4, m5 ) {
                        assert(!insideFlag);
                        insideFlag = true;
                        assert(insideFlag);
                        insideFlag = false;
                }
                mutex ( m3, m1 ) {
                        assert(!insideFlag);
                        insideFlag = true;
                        assert(insideFlag);
                        insideFlag = false;
                }
                mutex ( m1, m2, m4 ) {
                        assert(!insideFlag);
                        insideFlag = true;
                        assert(insideFlag);
                        insideFlag = false;
                }
                mutex ( m1, m3, m4, m5 ) {
                        assert(!insideFlag);
                        insideFlag = true;
                        assert(insideFlag);
                        insideFlag = false;
                }
        }
}

single_acquisition_lock l1;
linear_backoff_then_block_lock l2;
owner_lock l3;

thread T_Multi_Poly {};

void main( T_Multi_Poly & this ) {
        for (unsigned int i = 0; i < num_times; i++) {
                refTest( l1 );
                mutex ( l1 ) {
                        assert(!insideFlag);
                        insideFlag = true;
                        assert(insideFlag);
                        insideFlag = false;
                }
                mutex ( l1, l2, l3 ) {
                        assert(!insideFlag);
                        insideFlag = true;
                        assert(insideFlag);
                        insideFlag = false;
                }
                mutex ( l3, l1 ) {
                        assert(!insideFlag);
                        insideFlag = true;
                        assert(insideFlag);
                        insideFlag = false;
                }
                mutex ( l1, l2 ) {
                        assert(!insideFlag);
                        insideFlag = true;
                        assert(insideFlag);
                        insideFlag = false;
                }
        }
}

int num_tasks = 10;
int main() {
        processor p[num_tasks - 1];

        printf("Start Test: single lock mutual exclusion\n");
        {
                T_Mutex t[num_tasks];
        }
        assert(count == num_tasks * num_times);
        printf("End Test: single lock mutual exclusion\n");
        printf("Start Test: multi lock deadlock/mutual exclusion\n");
        {
                T_Multi t[num_tasks];
        }
        printf("End Test: multi lock deadlock/mutual exclusion\n");
        printf("Start Test: multi polymorphic lock deadlock/mutual exclusion\n");
        {
                T_Multi_Poly t[num_tasks];
        }
        printf("End Test: multi polymorphic lock deadlock/mutual exclusion\n");
}