source: doc/theses/colby_parsons_MMAth/benchmarks/waituntil/ucpp/future.cc@ 994030ce

#include <iostream>
using namespace std;
#include <uFuture.h>

size_t Clients = 2, Time = 10;

size_t globalTotal = 0;
Future_ISM<size_t> A, B, C;
volatile bool server_done_loop = false;
volatile bool client_done_loop = false;
volatile bool client_done = false;
volatile bool server_done = false;

volatile size_t client_count = 0;
volatile size_t client_loop_count = 0;
_Task Client {
        void main() {
                size_t i = 0;
        for(;; i++ ) {
            _Select( A ) { A(); }
            and _Select( B ) { B(); }
            or _Select( C ) { C(); }

            // needs to check after waituntil for termination synchronization
            if ( client_done ) break;
            
            // Barrier-like synch needed to reset futures safely
            if ( __atomic_add_fetch(&client_count, 1, __ATOMIC_SEQ_CST) == Clients ) {
                client_count = 0;
                A.reset();
                B.reset();
                C.reset();
                client_done_loop = true;
            }
            while( !client_done_loop ) {} // client barrier
            if ( __atomic_add_fetch( &client_loop_count, 1, __ATOMIC_SEQ_CST ) == Clients ) { 
                client_done_loop = false; // reset barrier before clients can proceed past waituntil
                server_done_loop = true; // unblock server to restart iteration
                client_loop_count = 0;
            }
        }
        __atomic_fetch_add( &globalTotal, i, __ATOMIC_SEQ_CST );
        } 
};

_Task Server {
        void main() {
                for( size_t i = 0; !server_done; i++ ) {
            if ( i % 4 == 0 ) {
                A.delivery(i);
                B.delivery(i);
            } else if ( i % 4 == 1 ) {
                A.delivery(i);
                C.delivery(i);
            } else if ( i % 4 == 2 ) {
                B.delivery(i);
                C.delivery(i);
            } else {
                C.delivery(i);
            }
            while( !server_done_loop && !server_done ) {} // server barrier
            server_done_loop = false; // reset server barrier
        }
        }
};

int main( int argc, char * argv[] ) {
        switch ( argc ) {
          case 3:
                if ( strcmp( argv[2], "d" ) != 0 ) {                    // default ?
                        Time = atoi( argv[2] );
                } // if
          case 2:
                if ( strcmp( argv[1], "d" ) != 0 ) {                    // default ?
                        Clients = atoi( argv[1] );
                        if ( Clients < 1 ) goto Usage;
                } // if
          case 1:                                                                                       // use defaults
                break;
          default:
          Usage:
                cerr << "Usage: " << argv[0]
             << " [ clients (> 0) | 'd' (default " << Clients
                         << ") ] [ time (>= 0) | 'd' (default " << Time
                         << ") ]" ;
                exit( EXIT_FAILURE );
        } // switch
    uProcessor p[Clients];

    {
        Client c[Clients];
        {
            Server s;

            uBaseTask::sleep( uDuration( Time ) );

            server_done = true;
        }
        while( A.available() || B.available() || C.available() ) {}
        client_done = true;
        C.delivery(1); // can't deliver 0 since it causes ambiguity
    }
    cout << globalTotal << endl;
} // main