Changeset b738974 for benchmark/readyQ/yield.cpp

Timestamp:

May 4, 2022, 2:27:25 PM (4 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, ast-experimental, master, pthread-emulation, qualifiedEnum

Children:

f6737ae1

Parents:

5695645 (diff), 3b5dcfa (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:

• benchmark/readyQ/yield.cpp (modified) (1 diff)

benchmark/readyQ/yield.cpp

@@ -1 @@
-#include <cassert>
-#include <cstdlib>
-#include <cstdio>
-#include <cstring>
-#include <climits>
-
-extern "C" {
-        #include <locale.h>
-        #include <getopt.h>
-}
-
-#include <unistd.h>
-
-#include <chrono>
-
-using Clock = std::chrono::high_resolution_clock;
-using duration_t = std::chrono::duration<double>;
-using std::chrono::nanoseconds;
-
-
-template<typename Ratio, typename T>
-T duration_cast(T seconds) {
-        return std::chrono::duration_cast<std::chrono::duration<T, Ratio>>(std::chrono::duration<T>(seconds)).count();
-}
+#include "rq_bench.hpp"
+#include <libfibre/fibre.h>
 
 volatile bool run = false;
 volatile unsigned long long global_counter;
 
-#include "libfibre/fibre.h"
 
-FredBarrier * barrier;
-struct __attribute__((aligned(128))) counter_t {
-        int value = 0;
-};
+void fibre_main() {
+        fibre_park();
+        unsigned long long count = 0;
+        for(;;) {
+                Fibre::forceYield();
+                count++;
+                if( clock_mode && stop) break;
+                if(!clock_mode && count >= stop_count) break;
+        }
 
-void fibre_main( counter_t * counter ) {
-        barrier->wait();
-        // /* paranoid */ assert( true == __atomic_load_n(&run, __ATOMIC_RELAXED) );
-
-        while(__atomic_load_n(&run, __ATOMIC_RELAXED)) {
-                Fibre::forceYield();
-                // fibre_yield();
-                counter->value++;
-        }
-        __atomic_fetch_add(&global_counter, counter->value, __ATOMIC_SEQ_CST);
+        __atomic_fetch_add(&global_counter, count, __ATOMIC_SEQ_CST);
+        __atomic_fetch_add(&threads_left, -1, __ATOMIC_SEQ_CST);
 }
 
 int main(int argc, char * argv[]) {
-        double duration = 5;
-        int nprocs = 1;
-        int nthreads = 1;
-
-        std::cout.imbue(std::locale(""));
-        setlocale(LC_ALL, "");
-
-        for(;;) {
-                static struct option options[] = {
-                        {"duration",  required_argument, 0, 'd'},
-                        {"nprocs",    required_argument, 0, 'p'},
-                        {"nthreads",  required_argument, 0, 't'},
-                        {0, 0, 0, 0}
-                };
-
-                int idx = 0;
-                int opt = getopt_long(argc, argv, "d:p:t:", options, &idx);
-
-                const char * arg = optarg ? optarg : "";
-                char * end;
-                switch(opt) {
-                        case -1:
-                                goto run;
-                        // Numeric Arguments
-                        case 'd':
-                                duration = strtod(arg, &end);
-                                if(*end != '\0') {
-                                        fprintf(stderr, "Duration must be a valid double, was %s\n", arg);
-                                        goto usage;
-                                }
-                                break;
-                        case 't':
-                                nthreads = strtoul(arg, &end, 10);
-                                if(*end != '\0' || nthreads < 1) {
-                                        fprintf(stderr, "Number of threads must be a positive integer, was %s\n", arg);
-                                        goto usage;
-                                }
-                                break;
-                        case 'p':
-                                nprocs = strtoul(arg, &end, 10);
-                                if(*end != '\0' || nprocs < 1) {
-                                        fprintf(stderr, "Number of processors must be a positive integer, was %s\n", arg);
-                                        goto usage;
-                                }
-                                break;
-                        // Other cases
-                        default: /* ? */
-                                fprintf( stderr, "Unkown option '%c'\n", opt);
-                        usage:
-                                fprintf( stderr, "Usage: %s [options]\n", argv[0]);
-                                fprintf( stderr, "\n" );
-                                fprintf( stderr, "  -d, --duration=DURATION  Duration of the experiment, in seconds\n" );
-                                fprintf( stderr, "  -t, --nthreads=NTHREADS  Number of kernel threads\n" );
-                                fprintf( stderr, "  -q, --nqueues=NQUEUES    Number of queues per threads\n" );
-                                exit(1);
-                }
-        }
-        run:
+        option_t opt[] = {
+                BENCH_OPT
+        };
+        BENCH_OPT_PARSE("libfibre yield benchmark");
 
         {
                 printf("Running %d threads on %d processors for %lf seconds\n", nthreads, nprocs, duration);
 
-                FibreInit();
-                barrier = new FredBarrier(nthreads + 1);
+                FibreInit(1, nprocs);
+                uint64_t start, end;
                 {
-                        Context::CurrCluster().addWorkers(nprocs);
-                        {
-                                counter_t counters[nthreads];
-                                Fibre threads[nthreads];
-                                for(int i = 0; i < nthreads; i++) {
-                                        threads[i].run(fibre_main, &counters[i]);
-                                }
-                                printf("Starting\n");
-                                bool is_tty = isatty(STDOUT_FILENO);
-                                auto before = Clock::now();
-                                run = true;
+                        threads_left = nthreads;
+                        Fibre * threads[nthreads];
+                        for(unsigned i = 0; i < nthreads; i++) {
+                                threads[i] = new Fibre( reinterpret_cast<void (*)(void *)>(fibre_main), nullptr );
+                        }
+                        printf("Starting\n");
+                        bool is_tty = isatty(STDOUT_FILENO);
+                        start = timeHiRes();
 
-                                barrier->wait();
-                                for(;;) {
-                                        usleep(500'000);
-                                        auto now = Clock::now();
-                                        duration_t durr = now - before;
-                                        if( durr.count() > duration ) {
-                                                break;
-                                        }
-                                        if(is_tty) {
-                                                std::cout << "\r" << std::setprecision(4) << durr.count();
-                                                std::cout.flush();
-                                        }
-                                }
+                        for(unsigned i = 0; i < nthreads; i++ ) {
+                                fibre_unpark( threads[i] );
+                        }
+                        wait<Fibre>(start, is_tty);
 
-                                auto after = Clock::now();
-                                duration_t durr = after - before;
-                                duration = durr.count();
-                                run = false;
-                                printf("\nDone\n");
-                                for(auto & thread : threads) {
-                                        thread.join();
-                                }
-
-                                // for(const auto & counter : counters) {
-                                //      std::cout << counter.value << std::endl;
-                                // }
+                        stop = true;
+                        end = timeHiRes();
+                        for(unsigned i = 0; i < nthreads; i++ ) {
+                                fibre_join( threads[i], nullptr );
                         }
                 }
 
-                auto dur_nano = duration_cast<std::nano>(duration);
-                auto dur_dms  = duration_cast<std::milli>(duration);
-
-                printf("Duration (ms)       : %'.2lf\n", dur_dms );
-                printf("Total yields        : %'15llu\n", global_counter );
-                printf("Yields per procs    : %'15llu\n", global_counter / nprocs );
-                printf("Yields per second   : %'18.2lf\n", ((double)global_counter) / duration );
-                printf("Yields/sec/procs    : %'18.2lf\n", (((double)global_counter) / nprocs) / duration );
-                printf("ns per yields       : %'18.2lf\n", dur_nano / global_counter );
-                printf("ns per yields/procs : %'18.2lf\n", dur_nano / (global_counter / nprocs) );
-
+                printf("Duration (ms)        : %'ld\n", to_miliseconds(end - start));
+                printf("Number of processors : %'d\n", nprocs);
+                printf("Number of threads    : %'d\n", nthreads);
+                printf("Total Operations(ops): %'15llu\n", global_counter);
+                printf("Ops per second       : %'18.2lf\n", ((double)global_counter) / to_fseconds(end - start));
+                printf("ns per ops           : %'18.2lf\n", ((double)(end - start)) / global_counter);
+                printf("Ops per threads      : %'15llu\n", global_counter / nthreads);
+                printf("Ops per procs        : %'15llu\n", global_counter / nprocs);
+                printf("Ops/sec/procs        : %'18.2lf\n", (((double)global_counter) / nprocs) / to_fseconds(end - start));
+                printf("ns per ops/procs     : %'18.2lf\n", ((double)(end - start)) / (global_counter / nprocs));
+                fflush(stdout);
         }
 }