source: benchmark/readyQ/rq_bench.hfa @ d1c47c2

#include <clock.hfa>
#include <kernel.hfa>
#include <parseargs.hfa>
#include <stdio.h>
#include <stdlib.hfa>
#include <stats.hfa>
#include <thread.hfa>
#include <time.hfa>
#include <unistd.h>

volatile bool stop = false;
bool clock_mode;
double duration = -1;
unsigned long long stop_count = 0;
unsigned nprocs = 1;
unsigned nthreads = 1;

volatile unsigned long long threads_left;

#define thread_loop for(this.count = 0;; this.count++)

#define BENCH_OPT \
        {'d', "duration",  "Duration of the experiments in seconds", duration }, \
        {'i', "iterations",  "Number of iterations of the experiments", stop_count }, \
        {'t', "nthreads",  "Number of threads to use", nthreads }, \
        {'p', "nprocs",    "Number of processors to use", nprocs }

#define BENCH_OPT_PARSE(name) \
        { \
                int opt_cnt = sizeof(opt) / sizeof(cfa_option); \
                char **left; \
                parse_args( argc, argv, opt, opt_cnt, "[OPTIONS]...\n" name, left ); \
                if(duration > 0 && stop_count > 0) { \
                        fprintf(stderr, "--duration and --iterations cannot be used together\n"); \
                        print_args_usage(argc, argv, opt, opt_cnt, "[OPTIONS]...\n" name, true); \
                } else if(duration > 0) { \
                        clock_mode = true; \
                        stop_count = 0xFFFFFFFFFFFFFFFF; \
                        printf("Running for %lf seconds\n", duration); \
                } else if(stop_count > 0) { \
                        clock_mode = false; \
                        printf("Running for %llu iterations\n", stop_count); \
                } else { \
                        duration = 5; clock_mode = true;\
                        printf("Running for %lf seconds\n", duration); \
                } \
        }

struct cluster & bench_cluster;

struct BenchCluster {
        cluster cl;
        processor * procs;
        unsigned nprocs;
};

void ?{}( BenchCluster & this, unsigned nprocs ) {
        (this.cl){ "Benchmark Cluster" };
        &bench_cluster = &this.cl;
        this.nprocs = nprocs;
        this.procs  = alloc( this.nprocs );
        for(i; this.nprocs){
                processor * p = &this.procs[i];
                (*p){ "Benchmark Processor", this.cl };
        }
        #if !defined(__CFA_NO_STATISTICS__)
                print_stats_at_exit( this.cl, CFA_STATS_READY_Q );
        #endif
}

void ^?{}( BenchCluster & this ) {
        adelete( this.procs );
        ^(this.cl){};
}

void wait(const Time & start, bool is_tty) {
        for() {
                sleep(100`ms);
                Time end = timeHiRes();
                Duration delta = end - start;
                if(is_tty) {
                        printf(" %.1f\r", delta`ds);
                        fflush(stdout);
                }
                if( clock_mode && delta >= duration`s ) {
                        break;
                }
                else if( !clock_mode && threads_left == 0 ) {
                        break;
                }
        }
}

struct __attribute__((aligned(128))) bench_sem {
        struct thread$ * volatile ptr;
};

static inline {
        void  ?{}(bench_sem & this) {
                this.ptr = 0p;
        }

        void ^?{}(bench_sem & this) {}

        bool wait(bench_sem & this) {
                for() {
                        struct thread$ * expected = this.ptr;
                        if(expected == 1p) {
                                if(__atomic_compare_exchange_n(&this.ptr, &expected, 0p, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
                                        return false;
                                }
                        }
                        else {
                                /* paranoid */ verify( expected == 0p );
                                if(__atomic_compare_exchange_n(&this.ptr, &expected, active_thread(), false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
                                        park();
                                        return true;
                                }
                        }

                }
        }

        bool post(bench_sem & this) {
                for() {
                        struct thread$ * expected = this.ptr;
                        if(expected == 1p) return false;
                        if(expected == 0p) {
                                if(__atomic_compare_exchange_n(&this.ptr, &expected, 1p, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
                                        return false;
                                }
                        }
                        else {
                                if(__atomic_compare_exchange_n(&this.ptr, &expected, 0p, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
                                        unpark( expected );
                                        return true;
                                }
                        }
                }
        }
}