source: tests/concurrent/semaphore.cfa @ cc56283

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

enum { num_blockers = 17, num_unblockers = 13 };

void thrash() {
        unsigned t[100];
        for(i; 100) {
                t[i] = 0xDEADBEEF;
        }
}

ThreadBenaphore ben;

// const unsigned int num_blocks = 25000;
const unsigned int num_blocks = 5;

thread Blocker {
        size_t sum;
};

void main(Blocker & this) {
        thread$ * me = active_thread();
        this.sum = 0;
        for(num_blocks) {
                this.sum += (unsigned)me;
                thrash();
                P(ben);
                if(((thread&)this).seqable.next != 0p) mutex(sout) sout | "Link not invalidated";
                thrash();
        }
}

thread Unblocker {
        size_t sum;
};

void main(Unblocker & this) {
        this.sum = 0;
        LOOP: for() {
                waitfor( ^?{} : this) {
                        break LOOP;
                }
                or else {}

                thread$ * t = V(ben, false);
                if(t) {
                        this.sum += (unsigned)t;
                        unpark(t);
                }
                yield(random(10));
        }
}

int main() {
        size_t usum = 0;
        size_t bsum = 0;

        sout | "Starting";
        {
                Blocker   blockers  [num_blockers  ];
                Unblocker unblockers[num_unblockers];

                for(i;num_blockers) {
                        bsum += join(blockers[i]).sum;
                }

                sout | "Done!";

                for(i;num_unblockers) {
                        usum += join(unblockers[i]).sum;
                }
        }
        if(bsum == usum) sout | "Match!";
        else sout | "No Match!" | usum | "!=" | bsum;
}