source: tests/concurrent/spinaphore.cfa@ a3769cc

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

enum { num_blockers = 17, num_unblockers = 13 };

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

Semaphore0nary sem;

const unsigned int num_blocks = 1625;

thread Blocker {
        size_t sum;
};
void main(Blocker & this);

Blocker * from_thread(thread$ * t) {
        Blocker & nullb = *(Blocker*)0p;
        thread$ & nullt = (thread&)nullb;
        uintptr_t offset  = (uintptr_t)&nullt;
        uintptr_t address = ((uintptr_t)t) - offset;
        return (Blocker*)address;
}

void main(Blocker & this) {
        thread$ * me = active_thread();
        Blocker * me1 = &this;
        Blocker * me2 = from_thread(me);
        if( me1 != me2 ) sout | "Bad casting!" | me1 | "vs" | me2;
        this.sum = 0;
        for(num_blocks) {
                P(sem);
                if(((thread&)this).seqable.next != 0p) sout | "Link not invalidated";
        }
}

const unsigned int num_unblocks = 2125;

thread Unblocker {
        size_t sum;
};

void main(Unblocker & this) {
        this.sum = 0;
        unsigned me = (unsigned)(uintptr_t)&this;
        for(num_unblocks) {
                thread$ * t = V(sem, false);
                Blocker * b = from_thread(t);
                b->sum += me;
                this.sum += (unsigned)(uintptr_t)b;
                unpark(t);
                yield(random(10));
        }
}

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

        if((num_unblocks * num_unblockers) != (num_blocks * num_blockers)) sout | "Mismatched Operations: " | (num_unblocks * num_unblockers) | "vs" | (num_blocks * num_blockers);

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

                for(i;num_blockers) {
                        for(num_blocks)
                                usum += (unsigned)(uintptr_t)&blockers[i];
                }

                for(i;num_unblockers) {
                        for(num_unblocks)
                                bsum += (unsigned)(uintptr_t)&unblockers[i];
                }

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

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