source: benchmark/io/readv.cfa @ 08e0d65

#define _GNU_SOURCE

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

extern "C" {
        #include <locale.h>
        #include <getopt.h>
        #include <fcntl.h>
        #include <sys/uio.h>
}

#include <errno.h>
#include <unistd.h>

#include <clock.hfa>
#include <iofwd.hfa>
#include <kernel.hfa>
#include <thread.hfa>
#include <time.hfa>
#include <stats.hfa>

#include "../benchcltr.hfa"

extern bool traceHeapOn();

int fd;
volatile bool run = false;
volatile size_t count = 0;

unsigned long int buflen = 512;
bool fixed_file = false;

thread __attribute__((aligned(128))) Reader {};
void ?{}( Reader & this ) {
        ((thread&)this){ "Reader Thread", *the_benchmark_cluster };
}

int do_read(int fd, struct iovec * iov) {
        // extern ssize_t cfa_preadv2(int, const struct iovec *, int, off_t, int, int = 0, Duration = -1`s, io_cancellation * = 0p, io_context * = 0p);
        int sflags = 0
        #if defined(CFA_HAVE_IOSQE_ASYNC)
                | CFA_IO_ASYNC
        #else
        #warning no CFA_IO_ASYNC support
        #endif
        ;
        if(fixed_file) {
                sflags |= CFA_IO_FIXED_FD1;
        }
        return cfa_preadv2(fd, iov, 1, 0, 0, sflags, -1`s, 0p, 0p);
}

void main( Reader & ) {
        park();
        /* paranoid */ assert( true == __atomic_load_n(&run, __ATOMIC_RELAXED) );

        __attribute__((aligned(512)))  char data[buflen];
        struct iovec iov = { data, buflen };

        while(__atomic_load_n(&run, __ATOMIC_RELAXED)) {
                int r = do_read(fd, &iov);
                if(r < 0) abort("%s\n", strerror(errno));

                __atomic_fetch_add( &count, 1, __ATOMIC_SEQ_CST );
        }
}

int main(int argc, char * argv[]) {
        int file_flags = 0;
        unsigned num_io = 1;
        unsigned sublen = 16;
        unsigned nentries = 0;

        bool subthrd = false;
        bool subeagr = false;
        bool odirect = false;
        bool kpollsb = false;
        bool kpollcp = false;

        cfa_option opt[] = {
                BENCH_OPT_CFA
                {'b', "bufsize",       "Number of bytes to read per request", buflen},
                {'s', "submitthread",  "If set, cluster uses polling thread to submit I/O", subthrd, parse_settrue},
                {'e', "eagersubmit",   "If set, cluster submits I/O eagerly but still aggregates submits", subeagr, parse_settrue},
                {'f', "fixed-files",   "Pre-register files with the io_contexts", fixed_file, parse_settrue},
                {'o', "open-direct",   "Open files with O_DIRECT flag, bypassing the file cache", odirect, parse_settrue},
                {'k', "kpollsubmit",   "If set, cluster uses an in kernel thread to poll submission, implies -f, requires elevated permissions", kpollsb, parse_settrue},
                {'i', "kpollcomplete", "If set, cluster polls fds for completions instead of relying on interrupts to get notifications, implies -o", kpollcp, parse_settrue},
                {'l', "submitlength",  "Size of the buffer that stores ready submissions", sublen},
                {'r', "numentries",    "Number of entries each of the io_context have", nentries},
                {'n', "numcontexts",   "Number of io_contexts to the cluster", num_io},
        };
        int opt_cnt = sizeof(opt) / sizeof(cfa_option);

        char **left;
        parse_args( opt, opt_cnt, "[OPTIONS]...\ncforall readv benchmark", left );

        if(kpollcp || odirect) {
                if( (buflen % 512) != 0 ) {
                        fprintf(stderr, "Buffer length must be a multiple of 512 when using O_DIRECT, was %lu\n\n", buflen);
                        print_args_usage(opt, opt_cnt, "[OPTIONS]...\ncforall readv benchmark", true);
                }
        }

        io_context_params params;

        if( subthrd ) params.poller_submits = true;
        if( subeagr ) params.eager_submits  = true;
        if( kpollsb ) params.poll_submit    = true;
        if( kpollcp ) params.poll_complete  = true;

        if(params.poll_submit  ) fixed_file = true;
        if(params.poll_complete) odirect    = true;

        params.num_ready = sublen;
        params.num_entries = nentries;

        if(odirect) file_flags |= O_DIRECT;

        int lfd = open(__FILE__, file_flags);
        if(lfd < 0) {
                fprintf(stderr, "Could not open source file\n");
                exit(EXIT_FAILURE);
        }

        printf("Running %d threads, reading %lu bytes each, over %d processors for %f seconds\n", nthreads, buflen, nprocs, duration);

        {
                Time start, end;
                BenchCluster cl = { num_io, params, CFA_STATS_READY_Q | CFA_STATS_IO };

                if(fixed_file) {
                        fd = 0;
                        register_fixed_files( cl.self, &lfd, 1 );
                }
                else {
                        fd = lfd;
                }

                {
                        BenchProc procs[nprocs];
                        {
                                Reader threads[nthreads];

                                printf("Starting\n");
                                bool is_tty = isatty(STDOUT_FILENO);
                                start = timeHiRes();
                                run = true;

                                for(i; nthreads) {
                                        unpark( threads[i] );
                                }
                                wait(duration, start, end, is_tty);

                                run = false;
                                end = timeHiRes();
                                printf("\nDone\n");
                        }
                        printf("Readers closed\n");
                }
                printf("Took %'ld ms\n", (end - start)`ms);
                printf("Total reads      : %'15zu\n", count);
                printf("Reads per second : %'18.2lf\n", ((double)count) / (end - start)`s);
                printf("Total read size  : %'15zu\n", buflen * count);
                printf("Bytes per second : %'18.2lf\n", ((double)count * buflen) / (end - start)`s);
        }

        close(lfd);
}