source: benchmark/io/readv.cfa @ 0335620

ADTarm-ehast-experimentalenumforall-pointer-decayjacob/cs343-translationnew-astnew-ast-unique-exprpthread-emulationqualifiedEnum
Last change on this file since 0335620 was 0335620, checked in by Thierry Delisle <tdelisle@…>, 4 years ago

Some minor tweaking to increase performance

  • Property mode set to 100644
File size: 4.4 KB
Line 
1#include <stdlib.h>
2#include <stdio.h>
3#include <string.h>
4
5extern "C" {
6        #include <locale.h>
7        #include <getopt.h>
8        #include <fcntl.h>
9        #include <sys/uio.h>
10}
11
12#include <unistd.h>
13
14#include <clock.hfa>
15#include <kernel.hfa>
16#include <thread.hfa>
17#include <time.hfa>
18
19extern bool traceHeapOn();
20extern ssize_t cfa_preadv2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags);
21
22int fd;
23volatile bool run = false;
24volatile size_t count = 0;
25
26unsigned long int buflen = 50;
27
28cluster * the_cluster;
29
30thread Reader {};
31void ?{}( Reader & this ) {
32        ((thread&)this){ "Reader Thread", *the_cluster };
33}
34
35struct my_processor {
36        processor p;
37};
38
39void ?{}( my_processor & this ) {
40        (this.p){ "I/O Processor", *the_cluster };
41}
42
43void main( Reader & ) {
44        while(!__atomic_load_n(&run, __ATOMIC_RELAXED)) yield();
45
46        char data[buflen];
47        struct iovec iov = { data, buflen };
48
49        while(__atomic_load_n(&run, __ATOMIC_RELAXED)) {
50                int r = cfa_preadv2(fd, &iov, 1, 0, 0);
51                if(r < 0) abort("%s\n", strerror(-r));
52
53                __atomic_fetch_add( &count, 1, __ATOMIC_SEQ_CST );
54        }
55}
56
57int main(int argc, char * argv[]) {
58        double duration   = 5.0;
59        unsigned long int nthreads = 2;
60        unsigned long int nprocs   = 1;
61        int flags = 0;
62
63        arg_loop:
64        for(;;) {
65                static struct option options[] = {
66                        {"duration",     required_argument, 0, 'd'},
67                        {"nthreads",     required_argument, 0, 't'},
68                        {"nprocs",       required_argument, 0, 'p'},
69                        {"bufsize",      required_argument, 0, 'b'},
70                        {"userthread",   no_argument      , 0, 'u'},
71                        {"submitthread", no_argument      , 0, 's'},
72                        {0, 0, 0, 0}
73                };
74
75                int idx = 0;
76                int opt = getopt_long(argc, argv, "d:t:p:b:us", options, &idx);
77
78                const char * arg = optarg ? optarg : "";
79                char * end;
80                switch(opt) {
81                        // Exit Case
82                        case -1:
83                                break arg_loop;
84                        // Numeric Arguments
85                        case 'd':
86                                duration = strtod(arg, &end);
87                                if(*end != '\0') {
88                                        fprintf(stderr, "Duration must be a valid double, was %s\n", arg);
89                                        goto usage;
90                                }
91                                break;
92                        case 't':
93                                nthreads = strtoul(arg, &end, 10);
94                                if(*end != '\0' || nthreads < 1) {
95                                        fprintf(stderr, "Number of threads must be a positive integer, was %s\n", arg);
96                                        goto usage;
97                                }
98                                break;
99                        case 'p':
100                                nprocs = strtoul(arg, &end, 10);
101                                if(*end != '\0' || nprocs < 1) {
102                                        fprintf(stderr, "Number of processors must be a positive integer, was %s\n", arg);
103                                        goto usage;
104                                }
105                                break;
106                        case 'b':
107                                buflen = strtoul(arg, &end, 10);
108                                if(*end != '\0' && buflen < 10) {
109                                        fprintf(stderr, "Buffer size must be at least 10, was %s\n", arg);
110                                        goto usage;
111                                }
112                                break;
113                        case 'u':
114                                flags |= CFA_CLUSTER_IO_POLLER_USER_THREAD;
115                                break;
116                        case 's':
117                                flags |= CFA_CLUSTER_IO_POLLER_THREAD_SUBMITS;
118                                break;
119                        // Other cases
120                        default: /* ? */
121                                fprintf(stderr, "%d\n", opt);
122                        usage:
123                                fprintf(stderr, "Usage: %s : [options]\n", argv[0]);
124                                fprintf(stderr, "\n");
125                                fprintf(stderr, "  -d, --duration=DURATION  Duration of the experiment, in seconds\n");
126                                fprintf(stderr, "  -t, --nthreads=NTHREADS  Number of user threads\n");
127                                fprintf(stderr, "  -p, --nprocs=NPROCS      Number of kernel threads\n");
128                                fprintf(stderr, "  -b, --buflen=SIZE        Number of bytes to read per request\n");
129                                fprintf(stderr, "  -u, --userthread         If set, cluster uses user-thread to poll I/O\n");
130                                fprintf(stderr, "  -s, --submitthread       If set, cluster uses polling thread to submit I/O\n");
131                                exit(EXIT_FAILURE);
132                }
133        }
134
135        fd = open(__FILE__, 0);
136        if(fd < 0) {
137                fprintf(stderr, "Could not open source file\n");
138                exit(EXIT_FAILURE);
139        }
140
141        printf("Running %lu threads, reading %lu bytes each, over %lu processors for %lf seconds\n", nthreads, buflen, nprocs, duration);
142
143        {
144                Time start, end;
145                cluster cl = { "IO Cluster", flags };
146                the_cluster = &cl;
147                #if !defined(__CFA_NO_STATISTICS__)
148                        print_stats_at_exit( cl );
149                #endif
150                {
151                        my_processor procs[nprocs];
152                        {
153                                Reader threads[nthreads];
154
155                                printf("Starting\n");
156                                start = getTime();
157                                run = true;
158                                do {
159                                        sleep(500`ms);
160                                        end = getTime();
161                                } while( (end - start) < duration`s );
162                                run = false;
163                                end = getTime();
164                                printf("Done\n");
165                        }
166                }
167                printf("Took %'ld ms\n", (end - start)`ms);
168                printf("Total reads      : %'15zu\n", count);
169                printf("Reads per second : %'18.2lf\n", ((double)count) / (end - start)`s);
170                printf("Total read size  : %'15zu\n", buflen * count);
171                printf("Bytes per second : %'18.2lf\n", ((double)count * buflen) / (end - start)`s);
172        }
173
174        close(fd);
175}
Note: See TracBrowser for help on using the repository browser.