Changes in / [e699eb6:7ed1d8f]

Files:

• benchmark/benchcltr.hfa (modified) (4 diffs)
• benchmark/io/readv-posix.c (added)
• benchmark/io/readv.cfa (modified) (3 diffs)
• benchmark/readyQ/yield.cfa (modified) (2 diffs)
• libcfa/src/concurrency/io.cfa (modified) (2 diffs)

benchmark/benchcltr.hfa

@@ -1 +1 @@
 #pragma once
+#include <assert.h>
+#include <stdint.h>
 
-#include <assert.h>
-#include <kernel.hfa>
-#include <thread.hfa>
-#include <stats.hfa>
+#ifdef __cforall
+        #include <kernel.hfa>
+        #include <thread.hfa>
+        #include <stats.hfa>
+#else
+#include <time.h>                                                                               // timespec
+#include <sys/time.h>                                                                   // timeval
+
+enum { TIMEGRAN = 1000000000LL };                                       // nanosecond granularity, except for timeval
+#endif
 
 #define BENCH_OPT_SHORT "d:p:t:SPV"
@@ -55 +63 @@
 bool procstats = false;
 bool viewhalts = false;
+
+#ifdef __cforall
 struct cluster * the_benchmark_cluster = 0p;
 struct BenchCluster {
@@ -60 +70 @@
 };
 
-void ?{}( BenchCluster & this, int flags, int stats ) {
-        (this.self){ "Benchmark Cluster", flags };
+void ?{}( BenchCluster & this, int num_io, const io_context_params & io_params, int stats ) {
+        (this.self){ "Benchmark Cluster", num_io, io_params };
 
         assert( the_benchmark_cluster == 0p );
@@ -105 +115 @@
         }
 }
+#else
+uint64_t getTimeNsec() {
+        timespec curr;
+        clock_gettime( CLOCK_REALTIME, &curr );
+        return (int64_t)curr.tv_sec * TIMEGRAN + curr.tv_nsec;
+}
+
+uint64_t to_miliseconds( uint64_t durtn ) { return durtn / (TIMEGRAN / 1000LL); }
+double to_fseconds(uint64_t durtn ) { return durtn / (double)TIMEGRAN; }
+uint64_t from_fseconds(double sec) { return sec * TIMEGRAN; }
+
+
+void wait_duration(double duration, uint64_t & start, uint64_t & end, bool is_tty) {
+        for(;;) {
+                usleep(100000);
+                end = getTimeNsec();
+                uint64_t delta = end - start;
+                /*if(is_tty)*/ {
+                        printf(" %.1f\r", to_fseconds(delta));
+                        fflush(stdout);
+                }
+                if( delta >= from_fseconds(duration) ) {
+                        break;
+                }
+        }
+}
+#endif
+
 
 void bench_usage( char * argv [] ) {

benchmark/io/readv.cfa

@@ -40 +40 @@
 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;
+        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;
@@ -130 +136 @@
                                 bench_usage( argv );
                                 fprintf( stderr, "  -b, --buflen=SIZE        Number of bytes to read per request\n" );
-                                fprintf( stderr, "  -u, --userthread         If set, cluster uses user-thread to poll I/O\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" );
@@ -139 +144 @@
                 }
         }
+
+        if(params.poll_submit  ) fixed_file = true;
+        if(params.poll_complete) file_flags |= O_DIRECT;
 
         int lfd = open(__FILE__, file_flags);

benchmark/readyQ/yield.cfa

@@ -44 +44 @@
 int main(int argc, char * argv[]) {
         BENCH_DECL
+        unsigned num_io = 1;
+        io_context_params params;
 
         for(;;) {
@@ -73 +75 @@
 
                 Time start, end;
-                BenchCluster cl = { 0, CFA_STATS_READY_Q };
+                BenchCluster cl = { num_io, params, CFA_STATS_READY_Q };
                 {
                         BenchProc procs[nprocs];

libcfa/src/concurrency/io.cfa

@@ -359 +359 @@
 
                         // We got the lock
+                        // Collect the submissions
                         unsigned to_submit = __collect_submitions( ring );
+
+                        // Release the lock now so syscalls can overlap
+                        unlock(ring.submit_q.lock);
+
+                        // Actually submit
                         int ret = __io_uring_enter( ring, to_submit, false );
-                        if( ret < 0 ) {
-                                unlock(ring.submit_q.lock);
-                                return;
-                        }
-
-                        /* paranoid */ verify( ret > 0 || to_submit == 0 || (ring.ring_flags & IORING_SETUP_SQPOLL) );
+                        if( ret < 0 ) return;
 
                         // Release the consumed SQEs
@@ -372 +373 @@
 
                         // update statistics
-                        __STATS__( true,
+                        __STATS__( false,
                                 io.submit_q.submit_avg.rdy += to_submit;
                                 io.submit_q.submit_avg.csm += ret;
                                 io.submit_q.submit_avg.cnt += 1;
                         )
-
-                        unlock(ring.submit_q.lock);
                 }
                 else {