[73abe95] | 1 | #include <fstream.hfa> |
---|
[096a2ff] | 2 | #include <kernel.hfa> |
---|
[73abe95] | 3 | #include <monitor.hfa> |
---|
| 4 | #include <thread.hfa> |
---|
| 5 | #include <time.hfa> |
---|
[303406a] | 6 | |
---|
[dc8511c] | 7 | #include "long_tests.hfa" |
---|
[7bdcac1] | 8 | |
---|
[cd99ef1] | 9 | #ifndef PREEMPTION_RATE |
---|
[8ad6533] | 10 | #define PREEMPTION_RATE 10`ms |
---|
[e1c1829] | 11 | #endif |
---|
[5ea06d6] | 12 | |
---|
[8ad6533] | 13 | Duration default_preemption() { |
---|
[cd99ef1] | 14 | return PREEMPTION_RATE; |
---|
| 15 | } |
---|
| 16 | |
---|
[7bdcac1] | 17 | #ifdef TEST_LONG |
---|
[b9da9585] | 18 | static const unsigned long N = 300_000ul; |
---|
| 19 | #else |
---|
| 20 | static const unsigned long N = 10_000ul; |
---|
| 21 | #endif |
---|
| 22 | |
---|
[102a58b] | 23 | enum state_t { WAIT, SIGNAL, BARGE }; |
---|
| 24 | |
---|
| 25 | monitor global_t {}; |
---|
| 26 | global_t mut; |
---|
| 27 | |
---|
| 28 | monitor global_data_t; |
---|
[2afec66] | 29 | void ?{}( global_data_t & this ); |
---|
[8638cef] | 30 | void ^?{} ( global_data_t & mutex this ); |
---|
[102a58b] | 31 | |
---|
| 32 | monitor global_data_t { |
---|
| 33 | int counter; |
---|
| 34 | state_t state; |
---|
| 35 | } data; |
---|
[5ea06d6] | 36 | |
---|
| 37 | condition cond; |
---|
| 38 | |
---|
[102a58b] | 39 | volatile bool all_done; |
---|
[5ea06d6] | 40 | |
---|
[2afec66] | 41 | void ?{}( global_data_t & this ) { |
---|
| 42 | this.counter == 0; |
---|
| 43 | this.state = BARGE; |
---|
[5ea06d6] | 44 | } |
---|
| 45 | |
---|
[8638cef] | 46 | void ^?{} ( global_data_t & mutex this ) {} |
---|
[5ea06d6] | 47 | |
---|
[102a58b] | 48 | //------------------------------------------------------------------------------ |
---|
| 49 | // Barging logic |
---|
[83a071f9] | 50 | void barge( global_data_t & mutex d ) { |
---|
| 51 | d.state = BARGE; |
---|
[5ea06d6] | 52 | } |
---|
| 53 | |
---|
[102a58b] | 54 | thread Barger {}; |
---|
[ab8a023] | 55 | void ?{}( Barger & this ) { |
---|
| 56 | ((thread&)this){ "Barger Thread" }; |
---|
| 57 | } |
---|
[5ea06d6] | 58 | |
---|
[83a071f9] | 59 | void main( Barger & this ) { |
---|
[0322865c] | 60 | while( !all_done ) { |
---|
[83a071f9] | 61 | barge( data ); |
---|
[0322865c] | 62 | yield(); |
---|
[102a58b] | 63 | } |
---|
[5ea06d6] | 64 | } |
---|
| 65 | |
---|
[102a58b] | 66 | //------------------------------------------------------------------------------ |
---|
| 67 | // Waiting logic |
---|
[83a071f9] | 68 | bool wait( global_t & mutex m, global_data_t & mutex d ) { |
---|
[4cedd9f] | 69 | wait( cond ); |
---|
[83a071f9] | 70 | if( d.state != SIGNAL ) { |
---|
[200fcb3] | 71 | sout | "ERROR barging!"; |
---|
[102a58b] | 72 | } |
---|
| 73 | |
---|
[ef952d7] | 74 | #if !defined(TEST_FOREVER) |
---|
| 75 | d.counter++; |
---|
[200fcb3] | 76 | if( (d.counter % 1000) == 0 ) sout | d.counter; |
---|
[ef952d7] | 77 | #endif |
---|
[102a58b] | 78 | |
---|
[7bdcac1] | 79 | return TEST(d.counter < N); |
---|
[5ea06d6] | 80 | } |
---|
| 81 | |
---|
[102a58b] | 82 | thread Waiter {}; |
---|
[ab8a023] | 83 | void ?{}( Waiter & this ) { |
---|
| 84 | ((thread&)this){ "Waiter Thread" }; |
---|
| 85 | } |
---|
[102a58b] | 86 | |
---|
[83a071f9] | 87 | void main( Waiter & this ) { |
---|
[7bdcac1] | 88 | while( wait( mut, data ) ) { KICK_WATCHDOG; yield(); } |
---|
[102a58b] | 89 | } |
---|
| 90 | |
---|
| 91 | |
---|
| 92 | //------------------------------------------------------------------------------ |
---|
| 93 | // Signalling logic |
---|
[4cedd9f] | 94 | void signal( condition & cond, global_t & mutex a, global_data_t & mutex b ) { |
---|
[83a071f9] | 95 | b.state = SIGNAL; |
---|
[102a58b] | 96 | signal( cond ); |
---|
| 97 | } |
---|
| 98 | |
---|
[83a071f9] | 99 | void logic( global_t & mutex a ) { |
---|
[4cedd9f] | 100 | signal( cond, a, data ); |
---|
[102a58b] | 101 | |
---|
[6c7b1e7] | 102 | yield( random( 10 ) ); |
---|
[5ea06d6] | 103 | |
---|
[102a58b] | 104 | //This is technically a mutual exclusion violation but the mutex monitor protects us |
---|
[7bdcac1] | 105 | bool running = TEST(data.counter < N) && data.counter > 0; |
---|
[102a58b] | 106 | if( data.state != SIGNAL && running ) { |
---|
[200fcb3] | 107 | sout | "ERROR Eager signal" | data.state; |
---|
[102a58b] | 108 | } |
---|
[5ea06d6] | 109 | } |
---|
| 110 | |
---|
[102a58b] | 111 | thread Signaller {}; |
---|
[ab8a023] | 112 | void ?{}( Signaller & this ) { |
---|
| 113 | ((thread&)this){ "Signaller Thread" }; |
---|
| 114 | } |
---|
[102a58b] | 115 | |
---|
[83a071f9] | 116 | void main( Signaller & this ) { |
---|
[0322865c] | 117 | while( !all_done ) { |
---|
[83a071f9] | 118 | logic( mut ); |
---|
[0322865c] | 119 | yield(); |
---|
[102a58b] | 120 | } |
---|
| 121 | } |
---|
| 122 | |
---|
| 123 | //------------------------------------------------------------------------------ |
---|
| 124 | // Main loop |
---|
[5ea06d6] | 125 | int main(int argc, char* argv[]) { |
---|
[54aba8d] | 126 | srandom( time( NULL ) ); |
---|
[102a58b] | 127 | all_done = false; |
---|
[5ea06d6] | 128 | processor p; |
---|
| 129 | { |
---|
[102a58b] | 130 | Signaller s; |
---|
| 131 | Barger b[17]; |
---|
| 132 | { |
---|
| 133 | Waiter w[4]; |
---|
| 134 | } |
---|
[200fcb3] | 135 | sout | "All waiter done"; |
---|
[102a58b] | 136 | all_done = true; |
---|
[0322865c] | 137 | } |
---|
[2afec66] | 138 | } |
---|