source: tests/concurrency/futures/select_future.cfa@ baad96e

#include <thread.hfa>
#include <future.hfa>
#include <concurrency/barrier.hfa>

enum {NFUTURES = 10};

thread Server {
        int pending, done, iteration;
        future(int) * request;
};

void ?{}( Server & this ) {
        ((thread&)this){"Server Thread"};
        this.pending = 0;
        this.done = 0;
        this.iteration = 0;
        this.request = 0p;
}

void ^?{}( Server & mutex this ) {
        assert(this.pending == 0);
        this.request = 0p;
}

void init( Server & this , future(int) * f ) {
        this.request = f;
}

void call( Server & mutex this ) {
        this.pending++;
}

void finish( Server & mutex this ) {
        this.done++;
}

void main( Server & this ) {
        MAIN_LOOP:
        for() {
                waitfor( ^?{} : this ) {
                        break;
                }
                or waitfor( call: this ) {
                        if (this.pending != NFUTURES) { continue MAIN_LOOP; }

                        this.pending = 0;
                        fulfil( *this.request, this.iteration );
                        this.iteration++;

                        for(NFUTURES) {
                                waitfor( finish: this );
                        }

                        reset( *this.request );
                        this.done = 0;
                }
        }

}

Server * the_server;
thread Worker {};
void ?{}(Worker & this) {
        ((thread&)this){"Worker Thread"};
}

future(int) * shared_future;

void thrash(void) {
        volatile int locals[250];
        for(i; 250) {
                locals[i] = 0xdeadbeef;
        }
}

void work(int num) {
        call( *the_server );
        int res = get( *shared_future );
        if( res != num ) abort();
        finish( *the_server );
}

void main( Worker & ) {
        for (i; 10) {
                thrash();
                work(i);
                thrash();
        }
}

thread Worker2 {};

semaphore before{0};
semaphore after_server{0};
semaphore after_worker{0};

void work2( int num ) {
    P( before );
        int res = get( *shared_future );
        if( res != num ) abort();
        V( after_server );
    P( after_worker );
}

void main( Worker2 & ) {
        for (i; 10) {
                thrash();
                work2(i);
                thrash();
        }
}

thread Server2 {};

void main( Server2 & ) {
        for (i; 10) {
                fulfil( *shared_future , i );
        V( before, NFUTURES );
        for ( i; NFUTURES ) P( after_server );
        reset( *shared_future );
        V( after_worker, NFUTURES );
        }
}

barrier bar = { NFUTURES + 1 };

thread Worker3 {};

void work3( int num ) {
    [int, bool] tt;
    do {
        tt = try_get( *shared_future );
    } while ( ! tt.1 );
        if( tt.0 != num ) abort();
        V( after_server );
    block(bar);
}

void main( Worker3 & ) {
        for (i; 10) {
                thrash();
                work3(i);
                thrash();
        }
}

thread Server3 {};

void main( Server3 & ) {
        for (i; 10) {
                fulfil( *shared_future , i );
        for ( i; NFUTURES ) P( after_server );
        reset( *shared_future );
        block(bar);
        }
}

int main() {
        printf( "start 1: blocking path future test\n" );
        processor procs[11];
        shared_future = new();
        {
                Server server;
                the_server = &server;
                init(server, shared_future);
                {
                        Worker workers[NFUTURES];
                }
        }
        delete( shared_future );
        printf( "done 1\n" );

    printf( "start 2: nonblocking path future test\n" );
    shared_future = new();

    {
        Server2 server;
                {
                        Worker2 workers[NFUTURES];
                }
        }

    delete( shared_future );
        printf( "done 2\n" );

    printf( "start 3: try_get future test\n" );
    shared_future = new();

    {
        Worker3 workers[NFUTURES];
                {
                        Server3 server;
                }
        }

    delete( shared_future );
        printf( "done 3\n" );
}