source: benchmark/io/readv.cfa @ 61dd73d

#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 <unistd.h>

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

extern bool traceHeapOn();
extern ssize_t cfa_preadv2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags);

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

unsigned long int buflen = 50;

cluster * the_cluster;

thread Reader {};
void ?{}( Reader & this ) {
        ((thread&)this){ "Reader Thread", *the_cluster };
}

struct my_processor {
        processor p;
};

void ?{}( my_processor & this ) {
        (this.p){ "I/O Processor", *the_cluster };
}

void main( Reader & ) {
        while(!__atomic_load_n(&run, __ATOMIC_RELAXED)) yield();

        char data[buflen];
        struct iovec iov = { data, buflen };

        while(__atomic_load_n(&run, __ATOMIC_RELAXED)) {
                int r = cfa_preadv2(fd, &iov, 1, 0, 0);
                if(r < 0) abort(strerror(-r));

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

int main(int argc, char * argv[]) {
        double duration   = 5.0;
        unsigned long int nthreads = 2;
        unsigned long int nprocs   = 1;

        printf("Setting local\n");
        setlocale(LC_NUMERIC, "");

        arg_loop:
        for(;;) {
                static struct option options[] = {
                        {"duration",  required_argument, 0, 'd'},
                        {"nthreads",  required_argument, 0, 't'},
                        {"nprocs",    required_argument, 0, 'p'},
                        {"bufsize",   required_argument, 0, 'b'},
                        {0, 0, 0, 0}
                };

                int idx = 0;
                int opt = getopt_long(argc, argv, "d:t:p:b:", options, &idx);

                const char * arg = optarg ? optarg : "";
                char * end;
                switch(opt) {
                        // Exit Case
                        case -1:
                                break arg_loop;
                        // 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;
                        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;
                        // Other cases
                        default: /* ? */
                                fprintf(stderr, "%d\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 user threads\n");
                                fprintf(stderr, "  -p, --nprocs=NPROCS      Number of kernel threads\n");
                                fprintf(stderr, "  -b, --buflen=SIZE        Number of bytes to read per request\n");
                                exit(EXIT_FAILURE);
                }
        }

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

        printf("Running %lu threads over %lu processors for %lf seconds\n", nthreads, nprocs, duration);

        {
                Time start, end;
                cluster cl = { "IO Cluster" };
                the_cluster = &cl;
                #if !defined(__CFA_NO_STATISTICS__)
                        print_stats_at_exit( cl );
                #endif
                {
                        my_processor procs[nprocs];
                        {
                                Reader threads[nthreads];

                                printf("Starting\n");
                                start = getTime();
                                run = true;
                                do {
                                        sleep(500`ms);
                                        end = getTime();
                                } while( (end - start) < duration`s );
                                run = false;
                                end = getTime();
                                printf("Done\n");
                        }
                }
                printf("Took %ld ms\n", (end - start)`ms);
                printf("Total reads:      %'zu\n", count);
                printf("Reads per second: %'lf\n", ((double)count) / (end - start)`s);
        }

        close(fd);
}