source: doc/theses/colby_parsons_MMAth/benchmarks/channels/cfa/barrier.cfa @ 4912520

#include <locks.hfa>
#include <fstream.hfa>
#include <stdio.h>
#include <channel.hfa>
#include <thread.hfa>
#include <time.hfa>
#include <string.h>

size_t total_operations = 0;
int Processors = 1, Tasks = 1, BarrierSize = 2;

typedef channel( int ) Channel;

Channel * barWait;
Channel * entryWait;
owner_lock o;

bool done = false;
size_t tasks_done = 0;

static inline void flushBarrier() {
    for ( j; BarrierSize ) {
        insert( *entryWait, -1 );
        insert( *barWait, -1 );
    }
}

static inline void initBarrier() {
    for ( j; BarrierSize )
        insert( *entryWait, j );
}

static inline void barrier() {
    int ticket = remove( *entryWait );
    if ( ticket == -1 ) {
                insert( *entryWait, -1 );
                return;
        }
    if ( ticket == BarrierSize - 1 ) {
                for ( j; BarrierSize - 1 )
            insert( *barWait, j );
        return;
        }
    ticket = remove( *barWait );
    if ( ticket == -1 ) {
                insert( *barWait, -1 );
                return;
        }

        // last one out
        if ( BarrierSize == 1 || ticket == BarrierSize - 2 ) {
                for ( j; BarrierSize )
            insert( *entryWait, j );
        }
}

thread Task {};
static inline void ?{}( Task & p, cluster & clu ) {
    ((thread &)p){ clu };
}
void main(Task & this) {
    size_t runs = 0;
    for ( ;; ) {
        if ( done ) break;
        barrier();
        runs++;
    }
    lock(o);
    total_operations += runs;
    // sout | "P: " | runs;
    unlock(o);
}


int main( int argc, char * argv[] ) {
    switch ( argc ) {
          case 3:
                if ( strcmp( argv[2], "d" ) != 0 ) {                    // default ?
                        BarrierSize = atoi( argv[2] );
            if ( Processors < 1 ) goto Usage;
                } // if
          case 2:
                if ( strcmp( argv[1], "d" ) != 0 ) {                    // default ?
                        Processors = atoi( argv[1] );
                        if ( Processors < 1 ) goto Usage;
                } // if
          case 1:                                                                                       // use defaults
                break;
          default:
          Usage:
                sout | "Usage: " | argv[0]
             | " [ processors (> 0) | 'd' (default " | Processors
                         | ") ] [ BarrierSize (> 0) | 'd' (default " | BarrierSize
                         | ") ]" ;
                exit( EXIT_FAILURE );
        } // switch
    Tasks = Processors;
    if ( Tasks < BarrierSize )
        Tasks = BarrierSize;

    size_t Clusters = 1;
    // create a cluster
    cluster clus[Clusters];
    processor * proc[Processors];
    for ( i; Processors ) {
        (*(proc[i] = malloc())){clus[i % Clusters]};
    }

    Channel entry{ 2 * BarrierSize };
    Channel wait{ 2 * BarrierSize };

    entryWait = &entry;
    barWait = &wait;

    initBarrier();
    // sout | "Processors: " | Processors | " ProdsPerChan: " | Producers | " ConsPerChan: " | Consumers | "Channels: " | Channels | " Channel Size: " | ChannelSize;

    // sout | "start";
    Task * t[Tasks];

    for ( i; Tasks ) {
        (*(t[i] = malloc())){ clus[i % Clusters] };
    }

    sleep(10`s);
    done = true;

    // sout | "sleep";

    flushBarrier();

    for ( i; Tasks ) {
        delete(t[i]);
    }
    
    sout | total_operations;
    // print_stats_now( *active_cluster(), CFA_STATS_READY_Q);

    for ( i; Processors ) {
        delete(proc[i]);
    }
    // sout | "done";
    return 0;
}