source: benchmark/io/readv.cfa@ 7f6e9eb

#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( __cfaabi_dbg_ctx );
        /* 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[]) {
        BENCH_DECL
        unsigned num_io = 1;
        io_context_params params;
        int file_flags = 0;
        unsigned sublen = 16;

        arg_loop:
        for(;;) {
                static struct option options[] = {
                        BENCH_OPT_LONG
                        {"bufsize",       required_argument, 0, 'b'},
                        {"submitthread",  no_argument      , 0, 's'},
                        {"eagersubmit",   no_argument      , 0, 'e'},
                        {"kpollsubmit",   no_argument      , 0, 'k'},
                        {"kpollcomplete", no_argument      , 0, 'i'},
                        {"fixed-files",   no_argument      , 0, 'f'},
                        {"open-direct",   no_argument      , 0, 'o'},
                        {"submitlength",  required_argument, 0, 'l'},
                        {0, 0, 0, 0}
                };

                int idx = 0;
                int opt = getopt_long(argc, argv, BENCH_OPT_SHORT "b:sekil:", options, &idx);

                const char * arg = optarg ? optarg : "";
                char * end;
                switch(opt) {
                        // Exit Case
                        case -1:
                                break arg_loop;
                        BENCH_OPT_CASE
                        case 'b':
                                buflen = strtoul(arg, &end, 10);
                                if(*end != '\0' && buflen < 10) {
                                        fprintf(stderr, "Buffer size must be at least 10, was %s\n", arg);
                                        goto usage;
                                }
                                break;
                        case 's':
                                params.poller_submits = true;
                                break;
                        case 'e':
                                params.eager_submits = true;
                                break;
                        case 'k':
                                params.poll_submit = true;
                        case 'f':
                                fixed_file = true;
                                break;
                        case 'i':
                                params.poll_complete = true;
                        case 'o':
                                file_flags |= O_DIRECT;
                                break;
                        case 'l':
                                sublen = strtoul(arg, &end, 10);
                                if(*end != '\0' && sublen < 16) {
                                        fprintf(stderr, "Submit length must be at least 16, was %s\n", arg);
                                        goto usage;
                                }
                                // flags |= (sublen << CFA_CLUSTER_IO_BUFFLEN_OFFSET);
                                break;
                        default: /* ? */
                                fprintf(stderr, "%d\n", opt);
                        usage:
                                bench_usage( argv );
                                fprintf( stderr, "  -b, --buflen=SIZE        Number of bytes to read per request\n" );
                                fprintf( stderr, "  -s, --submitthread       If set, cluster uses polling thread to submit I/O\n" );
                                fprintf( stderr, "  -e, --eagersubmit        If set, cluster submits I/O eagerly but still aggregates submits\n" );
                                fprintf( stderr, "  -k, --kpollsubmit        If set, cluster uses IORING_SETUP_SQPOLL\n" );
                                fprintf( stderr, "  -i, --kpollcomplete      If set, cluster uses IORING_SETUP_IOPOLL\n" );
                                fprintf( stderr, "  -l, --submitlength=LEN   Max number of submitions that can be submitted together\n" );
                                exit(EXIT_FAILURE);
                }
        }

        if(params.poll_submit  ) fixed_file = true;
        if(params.poll_complete) 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 = getTimeNsec();
                                run = true;

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

                                run = false;
                                end = getTimeNsec();
                                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);
}