Changeset 04b73b6

Timestamp:

Jul 23, 2020, 3:37:05 PM (3 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

f4ec4a90

Parents:

f0c3120 (diff), e262b5e (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Files:

• benchmark/io/http/filecache.cfa (modified) (7 diffs)
• benchmark/io/http/filecache.hfa (modified) (1 diff)
• benchmark/io/http/main.cfa (modified) (8 diffs)
• benchmark/io/http/options.cfa (added)
• benchmark/io/http/options.hfa (modified) (1 diff)
• benchmark/io/http/parseargs.cfa (modified) (5 diffs)
• benchmark/io/http/parseargs.hfa (modified) (1 diff)
• benchmark/io/http/protocol.cfa (modified) (2 diffs)
• benchmark/io/http/protocol.hfa (modified) (1 diff)
• benchmark/io/http/worker.cfa (modified) (5 diffs)
• libcfa/configure (modified) (3 diffs)
• libcfa/configure.ac (modified) (1 diff)
• libcfa/prelude/defines.hfa.in (modified) (1 diff)
• libcfa/src/concurrency/io.cfa (modified) (4 diffs)
• libcfa/src/concurrency/iocall.cfa (modified) (24 diffs)
• libcfa/src/concurrency/kernel.cfa (modified) (8 diffs)
• libcfa/src/concurrency/ready_queue.cfa (modified) (5 diffs)
• libcfa/src/concurrency/snzi.hfa (modified) (1 diff)
• libcfa/src/concurrency/stats.cfa (modified) (3 diffs)
• libcfa/src/concurrency/stats.hfa (modified) (3 diffs)
• libcfa/src/heap.cfa (modified) (6 diffs)
• libcfa/src/heap.hfa (modified) (2 diffs)
• libcfa/src/iostream.cfa (modified) (3 diffs)
• libcfa/src/stdlib.cfa (modified) (2 diffs)
• libcfa/src/stdlib.hfa (modified) (5 diffs)
• src/Common/PassVisitor.proto.h (modified) (1 diff)
• src/Virtual/ExpandCasts.cc (modified) (9 diffs)
• tests/.expect/alloc.txt (modified) (1 diff)
• tests/exceptions/.expect/virtual-cast.txt (added)
• tests/exceptions/.expect/virtual-poly.txt (added)
• tests/exceptions/virtual-cast.cfa (moved) (moved from tests/zombies/virtualCast.cfa)
• tests/exceptions/virtual-poly.cfa (added)

benchmark/io/http/filecache.cfa

@@ -56 +56 @@
 }
 
+static inline [unsigned size, char unit] human_size( size_t size ) {
+        int idx = 0;
+        static char units [] = { ' ', 'K', 'M', 'G', 'T' };
+        while( size >= 1024 ) {
+                idx++;
+                size /= 1024;
+                if(idx >= 5) {
+                        abort("File too large to print\n");
+                }
+        }
+
+        return [size, units[idx]];
+}
 
 struct {
@@ -69 +82 @@
 
 [int fd, size_t size] get_file( * const char file, size_t len ) {
-        uint32_t idx = murmur3_32( (const uint8_t *)file, len, options.hash_seed ) % file_cache.size;
+        uint32_t idx = murmur3_32( (const uint8_t *)file, len, options.file_cache.hash_seed ) % file_cache.size;
 
         for(int i = 0;; i++) {
@@ -86 +99 @@
 
 int put_file( cache_line & entry ) {
-        uint32_t idx = murmur3_32( (const uint8_t *)entry.file, strlen(entry.file), options.hash_seed ) % file_cache.size;
+        uint32_t idx = murmur3_32( (const uint8_t *)entry.file, strlen(entry.file), options.file_cache.hash_seed ) % file_cache.size;
 
         int i = 0;
@@ -101 +114 @@
 void fill_cache( const char * path ) {
         int ret;
+        ret = chdir(path);
+        if(ret < 0) {
+                abort( "chdir error: (%d) %s\n", (int)errno, strerror(errno) );
+        }
+
         size_t fcount = 0;
         size_t fsize = 16;
@@ -118 +136 @@
                 raw[idx].file = strdup(fpath+2);
                 raw[idx].size = sb->st_size;
-                raw[idx].fd = open( fpath, options.open_flags );
-                if(raw[idx].fd < 0) {
-                        abort( "open file error: (%d) %s\n", (int)errno, strerror(errno) );
+                if( !options.file_cache.list ) {
+                        raw[idx].fd = open( fpath, options.file_cache.open_flags );
+                        if(raw[idx].fd < 0) {
+                                abort( "open file error: (%d) %s\n", (int)errno, strerror(errno) );
+                        }
                 }
                 return 0;
         }
 
-        ret = ftw(path, walk, 10);
+        ret = ftw(".", walk, 10);
         if(ret < 0) {
                 abort( "ftw error: (%d) %s\n", (int)errno, strerror(errno) );
@@ -135 +155 @@
 
         // Step 2 create the cache
-        file_cache.size = options.file_cache_size > 0 ? options.file_cache_size : fsize;
+        file_cache.size = options.file_cache.size > 0 ? options.file_cache.size : fsize;
         if( file_cache.size < fcount ) {
                 abort("File Cache too small\n");
         }
 
-        file_cache.entries = anew(fsize);
+        file_cache.entries = anew(file_cache.size);
 
         // Step 3 fill the cache
         int conflicts = 0;
         for(i; fcount) {
-                printf("Added file %s\n", raw[i].file);
                 conflicts += put_file( raw[i] );
         }
         printf("Filled cache from path \"%s\" with %zu files\n", path, fcount);
         if( conflicts > 0 ) {
-                printf("Found %d conflicts (seed: %u)\n", conflicts, options.hash_seed);
+                printf("Found %d conflicts (seed: %u)\n", conflicts, options.file_cache.hash_seed);
                 #if defined(REJECT_CONFLICTS)
                         abort("Conflicts found in the cache");
@@ -156 +175 @@
         }
 
+        if(options.file_cache.list) {
+                printf("Listing files and exiting\n");
+                for(i; fcount) {
+                        int s; char u;
+                        [s, u] = human_size(raw[i].size);
+                        printf("%4d%c - %s\n", s, u, raw[i].file);
+                        free(raw[i].file);
+                }
+                free(raw);
+                adelete(file_cache.size, file_cache.entries);
+                exit(0);
+        }
+
         // Step 4 clean up
         free( raw );
 }
+
+[int *, int] filefds(int extra) {
+        if(!file_cache.entries) {
+                abort("File cache not filled!\n");
+        }
+
+        return [aalloc(extra), 0];
+}
+
 
 void close_cache() {

benchmark/io/http/filecache.hfa

@@ -11 +11 @@
 [int fd, size_t size] get_file( * const char file, size_t len );
 void fill_cache( const char * path );
+[int *, int] filefds( int extra );
 void close_cache();

benchmark/io/http/main.cfa

@@ -17 +17 @@
 #include "filecache.hfa"
 #include "options.hfa"
-#include "parseargs.hfa"
 #include "worker.hfa"
 
@@ -23 +22 @@
 // Globals
 //=============================================================================================
-Options options @= {
-        0,
-        42u,
-        0,
-        false,
-        false,
-        0
-};
-
 channel & wait_connect;
 
@@ -39 +29 @@
 
 void ?{}( ServerProc & this ) {
-        /* paranoid */ assert( options.the_cluster != 0p );
-        (this.self){ "Benchmark Processor", *options.the_cluster };
+        /* paranoid */ assert( options.clopts.instance != 0p );
+        (this.self){ "Benchmark Processor", *options.clopts.instance };
 
         #if !defined(__CFA_NO_STATISTICS__)
-                if( options.procstats ) {
-                        print_stats_at_exit( this.self, options.the_cluster->print_stats );
+                if( options.clopts.procstats ) {
+                        print_stats_at_exit( this.self, options.clopts.instance->print_stats );
                 }
-                if( options.viewhalts ) {
+                if( options.clopts.viewhalts ) {
                         print_halts( this.self );
                 }
@@ -56 +46 @@
 //============================================================================================='
 int main( int argc, char * argv[] ) {
-        int port      = 8080;
-        int backlog   = 10;
-        int nprocs    = 1;
-        int nworkers  = 1;
-        int cl_flags  = 0;
-        int chan_size = 10;
-        const char * path = ".";
         //===================
         // Parse args
-        static cfa_option opt[] = {
-                {'p', "port", "Port the server will listen on", port},
-                {'c', "cpus", "Number of processors to use", nprocs},
-                {'t', "threads", "Number of worker threads to use", nworkers},
-                {'b', "accept-backlog", "Maximum number of pending accepts", backlog},
-                {'B', "channel-size", "Maximum number of accepted connection pending", chan_size}
-        };
-        int opt_cnt = sizeof(opt) / sizeof(cfa_option);
-
-        char **left;
-      parse_args( argc, argv, opt, opt_cnt, "[OPTIONS] [PATH]  -- cforall http server", left );
-
+        const char * path = parse_options(argc, argv);
 
         //===================
@@ -85 +57 @@
         //===================
         // Open Socket
-        printf("Listening on port %d\n", port);
+        printf("Listening on port %d\n", options.socket.port);
         int server_fd = socket(AF_INET, SOCK_STREAM, 0);
         if(server_fd < 0) {
@@ -97 +69 @@
         address.sin_family = AF_INET;
         address.sin_addr.s_addr = htonl(INADDR_ANY);
-        address.sin_port = htons( port );
+        address.sin_port = htons( options.socket.port );
 
         ret = bind( server_fd, (struct sockaddr *)&address, sizeof(address) );
@@ -104 +76 @@
         }
 
-        ret = listen( server_fd, backlog );
+        ret = listen( server_fd, options.socket.backlog );
         if(ret < 0) {
                 abort( "listen error: (%d) %s\n", (int)errno, strerror(errno) );
@@ -112 +84 @@
         // Run Server Cluster
         {
-                cluster cl = { "Server Cluster", cl_flags };
+                cluster cl = { "Server Cluster", options.clopts.flags };
                 #if !defined(__CFA_NO_STATISTICS__)
                         print_stats_at_exit( cl, CFA_STATS_READY_Q | CFA_STATS_IO );
                 #endif
-                options.the_cluster = &cl;
+                options.clopts.instance = &cl;
 
-                channel chan = { chan_size };
+                channel chan = { options.clopts.chan_size };
                 &wait_connect = &chan;
 
+                int pipe_cnt = options.clopts.nworkers * 2;
+                int pipe_off;
+                int * fds;
+                [fds, pipe_off] = filefds( pipe_cnt );
+                for(i; 0 ~ pipe_cnt ~ 2) {
+                        int ret = pipe(&fds[pipe_off + i]);
+                        if( ret < 0 ) { abort( "pipe error: (%d) %s\n", (int)errno, strerror(errno) ); }
+                }
+
                 {
-                        ServerProc procs[nprocs];
+                        ServerProc procs[options.clopts.nprocs];
                         {
-                                Worker workers[nworkers];
-                                printf("%d workers started on %d processors\n", nworkers, nprocs);
+                                Worker workers[options.clopts.nworkers];
+                                for(i; options.clopts.nworkers) {
+                                        if( options.file_cache.fixed_fds ) {
+                                                workers[i].pipe[0] = pipe_off + (i * 2) + 0;
+                                                workers[i].pipe[1] = pipe_off + (i * 2) + 1;
+                                        }
+                                        else {
+                                                workers[i].pipe[0] = fds[pipe_off + (i * 2) + 0];
+                                                workers[i].pipe[1] = fds[pipe_off + (i * 2) + 1];
+                                        }
+                                        unpark( workers[i] __cfaabi_dbg_ctx2 );
+                                }
+                                printf("%d workers started on %d processors\n", options.clopts.nworkers, options.clopts.nprocs);
                                 {
                                         Acceptor acceptor = { server_fd, (struct sockaddr *)&address, (socklen_t*)&addrlen, 0 };
+
+                                        char buffer[128];
+                                        while(!feof(stdin)) {
+                                                fgets(buffer, 128, stdin);
+                                        }
+
+                                        printf("Shutting Down\n");
                                 }
-                                printf("Shutting Down\n");
+                                printf("Acceptor Closed\n");
 
                                 // Clean-up the workers
-                                for(nworkers) {
+                                for(options.clopts.nworkers) {
                                         put( wait_connect, -1 );
                                 }
                         }
+                        printf("Workers Closed\n");
                 }
+
+                for(i; pipe_cnt) {
+                        ret = close( fds[pipe_off + i] );
+                        if(ret < 0) {
+                                abort( "close pipe error: (%d) %s\n", (int)errno, strerror(errno) );
+                        }
+                }
+                free(fds);
         }
 

benchmark/io/http/options.hfa

@@ -6 +6 @@
 
 struct Options {
-        int open_flags;
-        uint32_t hash_seed;
-      size_t file_cache_size;
-        bool procstats;
-        bool viewhalts;
-        cluster * the_cluster;
+        struct {
+                int open_flags;
+                uint32_t hash_seed;
+                size_t size;
+                bool list;
+                bool fixed_fds;
+        } file_cache;
+
+        struct {
+                int port;
+                int backlog;
+                int buflen;
+        } socket;
+
+        struct {
+                int nprocs;
+                int nworkers;
+                int flags;
+                int chan_size;
+                bool procstats;
+                bool viewhalts;
+                cluster * instance;
+        } clopts;
 };
 
 extern Options options;
+
+const char * parse_options( int argc, char * argv[] );

benchmark/io/http/parseargs.cfa

@@ -3 +3 @@
 // #include <stdio.h>
 // #include <stdlib.h>
+#include <errno.h>
 #include <string.h>
+#include <unistd.h>
 extern "C" {
         #include <getopt.h>
+        #include <sys/ioctl.h>
 
         struct FILE;
@@ -11 +14 @@
         extern FILE * stdout;
 
+        extern int fileno(FILE *stream);
+
         extern int fprintf ( FILE * stream, const char * format, ... );
-        extern long long int strtoll (const char* str, char** endptr, int base);
+
+        extern          long long int strtoll (const char* str, char** endptr, int base);
+        extern unsigned long long int strtoull(const char* str, char** endptr, int base);
+}
+
+#include <common.hfa>
+#include <limits.hfa>
+
+void printopt(FILE * out, int width, int max, char sn, const char * ln, const char * help) {
+        int hwidth = max - (11 + width);
+        if(hwidth <= 0) hwidth = max;
+
+        fprintf(out, "  -%c, --%-*s   %.*s\n", sn, width, ln, hwidth, help);
+        for() {
+                help += min(strlen(help), hwidth);
+                if('\0' == *help) break;
+                fprintf(out, "%*s%.*s\n", width + 11, "", hwidth, help);
+        }
 }
 
@@ -25 +47 @@
         struct option optarr[opt_count + 2];
         int width = 0;
+        int max_width = 1_000_000;
         {
                 int idx = 0;
@@ -93 +116 @@
         }
 
-        USAGE:
-        fprintf(out, "%s\n", usage);
+        USAGE:;
+        int outfd = fileno(out);
+        if(isatty(outfd)) {
+                struct winsize size;
+                int ret = ioctl(outfd, TIOCGWINSZ, &size);
+                if(ret < 0) abort( "ioctl error: (%d) %s\n", (int)errno, strerror(errno) );
+                max_width = size.ws_col;
+        }
+
+        fprintf(out, "Usage:\n  %s %s\n", argv[0], usage);
 
         for(i; opt_count) {
-                fprintf(out, "  -%c, --%-*s   %s\n", options[i].short_name, width, options[i].long_name, options[i].help);
+                printopt(out, width, max_width, options[i].short_name, options[i].long_name, options[i].help);
         }
         fprintf(out, "  -%c, --%-*s   %s\n", 'h', width, "help", "print this help message");
@@ -132 +163 @@
 }
 
+bool parse(const char * arg, unsigned & value) {
+        char * end;
+        unsigned long long int r = strtoull(arg, &end, 10);
+        if(*end != '\0') return false;
+        if(r > (unsigned)MAX) return false;
+
+        value = r;
+        return true;
+}
+
+bool parse(const char * arg, size_t & value) {
+        char * end;
+        unsigned long long int r = strtoull(arg, &end, 10);
+        if(*end != '\0') return false;
+        if(r > (size_t)MAX) return false;
+
+        value = r;
+        return true;
+}
+
 bool parse(const char * arg, int & value) {
         char * end;

benchmark/io/http/parseargs.hfa

@@ -38 +38 @@
 
 bool parse(const char *, const char * & );
+bool parse(const char *, unsigned & );
+bool parse(const char *, size_t & );
 bool parse(const char *, int & );

benchmark/io/http/protocol.cfa

@@ -25 +25 @@
 };
 
-_Static_assert( KNOWN_CODES == (sizeof(http_msgs) / sizeof(http_msgs[0])));
+_Static_assert( KNOWN_CODES == (sizeof(http_msgs ) / sizeof(http_msgs [0])));
+
+const int http_codes[] = {
+        200,
+        400,
+        404,
+        413,
+        414,
+};
+
+_Static_assert( KNOWN_CODES == (sizeof(http_codes) / sizeof(http_codes[0])));
+
+int code_val(HttpCode code) {
+        return http_codes[code];
+}
 
 static inline int answer( int fd, const char * it, int len) {
@@ -61 +75 @@
         for() {
                 int ret = cfa_read(fd, it, count);
+                if(ret == 0 ) return [OK200, true, 0p, 0];
                 if(ret < 0 ) {
-                        if( errno ) return [OK200, true, 0p, 0];
                         if( errno == EAGAIN || errno == EWOULDBLOCK) continue READ;
                         abort( "read error: (%d) %s\n", (int)errno, strerror(errno) );

benchmark/io/http/protocol.hfa

@@ -10 +10 @@
 };
 
+int code_val(HttpCode code);
+
 int answer_error( int fd, HttpCode code );
 int answer_header( int fd, size_t size );

benchmark/io/http/worker.cfa

@@ -12 +12 @@
 #include "filecache.hfa"
 
-extern "C" {
-// extern ssize_t sendfile(int out_fd, int in_fd, off_t *offset, size_t count);
-extern ssize_t splice(int fd_in, loff_t *off_in, int fd_out, loff_t *off_out, size_t len, unsigned int flags);
-}
-
-ssize_t sendfile(int out_fd, int in_fd, off_t *offset, size_t count) {
-        return splice(in_fd, offset, out_fd, 0p, count, 0);
-}
-
-
 //=============================================================================================
 // Worker Thread
 //=============================================================================================
 void ?{}( Worker & this ) {
-        ((thread&)this){ "Server Worker Thread", *options.the_cluster };
-        int ret = pipe(this.pipe);
-        if( ret < 0 ) { abort( "pipe error: (%d) %s\n", (int)errno, strerror(errno) ); }
+        ((thread&)this){ "Server Worker Thread", *options.clopts.instance };
+        this.pipe[0] = -1;
+        this.pipe[1] = -1;
 }
 
 void main( Worker & this ) {
+        park( __cfaabi_dbg_ctx );
+        /* paranoid */ assert( this.pipe[0] != -1 );
+        /* paranoid */ assert( this.pipe[1] != -1 );
+
         CONNECTION:
-        while( int fd = take(wait_connect); fd >= 0) {
-            printf("New connection, waiting for requests\n");
+        for() {
+                int fd = take(wait_connect);
+                if (fd < 0) break;
+
+                printf("New connection %d, waiting for requests\n", fd);
                 REQUEST:
                 for() {
@@ -43 +40 @@
 
                         // Read the http request
-                        size_t len = 1024;
+                        size_t len = options.socket.buflen;
                         char buffer[len];
                         printf("Reading request\n");
@@ -56 +53 @@
                         // If this wasn't a request retrun 400
                         if( code != OK200 ) {
-                                printf("Invalid Request\n");
+                                printf("Invalid Request : %d\n", code_val(code));
                                 answer_error(fd, code);
                                 continue REQUEST;
                         }
 
-                        printf("Request for file %.*s\n", name_size, file);
+                        printf("Request for file %.*s\n", (int)name_size, file);
 
                         // Get the fd from the file cache
@@ -90 +87 @@
 //=============================================================================================
 void ?{}( Acceptor & this, int sockfd, struct sockaddr * addr, socklen_t * addrlen, int flags ) {
-        ((thread&)this){ "Acceptor Thread", *options.the_cluster };
+        ((thread&)this){ "Acceptor Thread", *options.clopts.instance };
         this.sockfd  = sockfd;
         this.addr    = addr;
@@ -105 +102 @@
                 }
 
-            printf("New connection accepted\n");
+                printf("New connection accepted\n");
                 put( wait_connect, ret );
-      }
+        }
 }

libcfa/configure

@@ -2054 +2054 @@
 
 } # ac_fn_c_check_header_mongrel
+
+# ac_fn_c_check_decl LINENO SYMBOL VAR INCLUDES
+# ---------------------------------------------
+# Tests whether SYMBOL is declared in INCLUDES, setting cache variable VAR
+# accordingly.
+ac_fn_c_check_decl ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  as_decl_name=`echo $2|sed 's/ *(.*//'`
+  as_decl_use=`echo $2|sed -e 's/(/((/' -e 's/)/) 0&/' -e 's/,/) 0& (/g'`
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $as_decl_name is declared" >&5
+$as_echo_n "checking whether $as_decl_name is declared... " >&6; }
+if eval \${$3+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$4
+int
+main ()
+{
+#ifndef $as_decl_name
+#ifdef __cplusplus
+  (void) $as_decl_use;
+#else
+  (void) $as_decl_name;
+#endif
+#endif
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  eval "$3=yes"
+else
+  eval "$3=no"
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+eval ac_res=\$$3
+               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+
+} # ac_fn_c_check_decl
 cat >config.log <<_ACEOF
 This file contains any messages produced by compilers while
@@ -16962 +17008 @@
 
 
+
+
+#io_uring 5.4 and earlier uses defines
+#io_uring 5.5 uses enum values
+#io_uring 5.6 and later uses probes
+
 for ac_header in linux/io_uring.h
 do :
@@ -16969 +17021 @@
 #define HAVE_LINUX_IO_URING_H 1
 _ACEOF
+
+        $as_echo "#define CFA_HAVE_LINUX_IO_URING_H 1" >>confdefs.h
+
+        # AC_CHECK_HEADER([liburing.h], [
+        #       AC_CHECK_LIB([uring], [io_uring_get_probe])
+        # ])
+
+                ac_fn_c_check_decl "$LINENO" "IORING_OP_NOP" "ac_cv_have_decl_IORING_OP_NOP" "#include <linux/io_uring.h>
+"
+if test "x$ac_cv_have_decl_IORING_OP_NOP" = xyes; then :
+  $as_echo "#define CFA_HAVE_IORING_OP_NOP 1" >>confdefs.h
+
+fi
+
+
+                ac_fn_c_check_decl "$LINENO" "IORING_OP_READV" "ac_cv_have_decl_IORING_OP_READV" "#include <linux/io_uring.h>
+"
+if test "x$ac_cv_have_decl_IORING_OP_READV" = xyes; then :
+  $as_echo "#define CFA_HAVE_IORING_OP_READV 1" >>confdefs.h
+
+fi
+
+
+                ac_fn_c_check_decl "$LINENO" "IORING_OP_WRITEV" "ac_cv_have_decl_IORING_OP_WRITEV" "#include <linux/io_uring.h>
+"
+if test "x$ac_cv_have_decl_IORING_OP_WRITEV" = xyes; then :
+  $as_echo "#define CFA_HAVE_IORING_OP_WRITEV 1" >>confdefs.h
+
+fi
+
+
+                ac_fn_c_check_decl "$LINENO" "IORING_OP_FSYNC" "ac_cv_have_decl_IORING_OP_FSYNC" "#include <linux/io_uring.h>
+"
+if test "x$ac_cv_have_decl_IORING_OP_FSYNC" = xyes; then :
+  $as_echo "#define CFA_HAVE_IORING_OP_FSYNC 1" >>confdefs.h
+
+fi
+
+
+                ac_fn_c_check_decl "$LINENO" "IORING_OP_READ_FIXED" "ac_cv_have_decl_IORING_OP_READ_FIXED" "#include <linux/io_uring.h>
+"
+if test "x$ac_cv_have_decl_IORING_OP_READ_FIXED" = xyes; then :
+  $as_echo "#define CFA_HAVE_IORING_OP_READ_FIXED 1" >>confdefs.h
+
+fi
+
+
+                ac_fn_c_check_decl "$LINENO" "IORING_OP_WRITE_FIXED" "ac_cv_have_decl_IORING_OP_WRITE_FIXED" "#include <linux/io_uring.h>
+"
+if test "x$ac_cv_have_decl_IORING_OP_WRITE_FIXED" = xyes; then :
+  $as_echo "#define CFA_HAVE_IORING_OP_WRITE_FIXED 1" >>confdefs.h
+
+fi
+
+
+                ac_fn_c_check_decl "$LINENO" "IORING_OP_POLL_ADD" "ac_cv_have_decl_IORING_OP_POLL_ADD" "#include <linux/io_uring.h>
+"
+if test "x$ac_cv_have_decl_IORING_OP_POLL_ADD" = xyes; then :
+  $as_echo "#define CFA_HAVE_IORING_OP_POLL_ADD 1" >>confdefs.h
+
+fi
+
+
+                ac_fn_c_check_decl "$LINENO" "IORING_OP_POLL_REMOVE" "ac_cv_have_decl_IORING_OP_POLL_REMOVE" "#include <linux/io_uring.h>
+"
+if test "x$ac_cv_have_decl_IORING_OP_POLL_REMOVE" = xyes; then :
+  $as_echo "#define CFA_HAVE_IORING_OP_POLL_REMOVE 1" >>confdefs.h
+
+fi
+
+
+                ac_fn_c_check_decl "$LINENO" "IORING_OP_SYNC_FILE_RANGE" "ac_cv_have_decl_IORING_OP_SYNC_FILE_RANGE" "#include <linux/io_uring.h>
+"
+if test "x$ac_cv_have_decl_IORING_OP_SYNC_FILE_RANGE" = xyes; then :
+  $as_echo "#define CFA_HAVE_IORING_OP_SYNC_FILE_RANGE 1" >>confdefs.h
+
+fi
+
+
+                ac_fn_c_check_decl "$LINENO" "IORING_OP_SENDMSG" "ac_cv_have_decl_IORING_OP_SENDMSG" "#include <linux/io_uring.h>
+"
+if test "x$ac_cv_have_decl_IORING_OP_SENDMSG" = xyes; then :
+  $as_echo "#define CFA_HAVE_IORING_OP_SENDMSG 1" >>confdefs.h
+
+fi
+
+
+                ac_fn_c_check_decl "$LINENO" "IORING_OP_RECVMSG" "ac_cv_have_decl_IORING_OP_RECVMSG" "#include <linux/io_uring.h>
+"
+if test "x$ac_cv_have_decl_IORING_OP_RECVMSG" = xyes; then :
+  $as_echo "#define CFA_HAVE_IORING_OP_RECVMSG 1" >>confdefs.h
+
+fi
+
+
+                ac_fn_c_check_decl "$LINENO" "IORING_OP_TIMEOUT" "ac_cv_have_decl_IORING_OP_TIMEOUT" "#include <linux/io_uring.h>
+"
+if test "x$ac_cv_have_decl_IORING_OP_TIMEOUT" = xyes; then :
+  $as_echo "#define CFA_HAVE_IORING_OP_TIMEOUT 1" >>confdefs.h
+
+fi
+
+
+                ac_fn_c_check_decl "$LINENO" "IORING_OP_TIMEOUT_REMOVE" "ac_cv_have_decl_IORING_OP_TIMEOUT_REMOVE" "#include <linux/io_uring.h>
+"
+if test "x$ac_cv_have_decl_IORING_OP_TIMEOUT_REMOVE" = xyes; then :
+  $as_echo "#define CFA_HAVE_IORING_OP_TIMEOUT_REMOVE 1" >>confdefs.h
+
+fi
+
+
+                ac_fn_c_check_decl "$LINENO" "IORING_OP_ACCEPT" "ac_cv_have_decl_IORING_OP_ACCEPT" "#include <linux/io_uring.h>
+"
+if test "x$ac_cv_have_decl_IORING_OP_ACCEPT" = xyes; then :
+  $as_echo "#define CFA_HAVE_IORING_OP_ACCEPT 1" >>confdefs.h
+
+fi
+
+
+                ac_fn_c_check_decl "$LINENO" "IORING_OP_ASYNC_CANCEL" "ac_cv_have_decl_IORING_OP_ASYNC_CANCEL" "#include <linux/io_uring.h>
+"
+if test "x$ac_cv_have_decl_IORING_OP_ASYNC_CANCEL" = xyes; then :
+  $as_echo "#define CFA_HAVE_IORING_OP_ASYNC_CANCEL 1" >>confdefs.h
+
+fi
+
+
+                ac_fn_c_check_decl "$LINENO" "IORING_OP_LINK_TIMEOUT" "ac_cv_have_decl_IORING_OP_LINK_TIMEOUT" "#include <linux/io_uring.h>
+"
+if test "x$ac_cv_have_decl_IORING_OP_LINK_TIMEOUT" = xyes; then :
+  $as_echo "#define CFA_HAVE_IORING_OP_LINK_TIMEOUT 1" >>confdefs.h
+
+fi
+
+
+                ac_fn_c_check_decl "$LINENO" "IORING_OP_CONNECT" "ac_cv_have_decl_IORING_OP_CONNECT" "#include <linux/io_uring.h>
+"
+if test "x$ac_cv_have_decl_IORING_OP_CONNECT" = xyes; then :
+  $as_echo "#define CFA_HAVE_IORING_OP_CONNECT 1" >>confdefs.h
+
+fi
+
+
+                ac_fn_c_check_decl "$LINENO" "IORING_OP_FALLOCATE" "ac_cv_have_decl_IORING_OP_FALLOCATE" "#include <linux/io_uring.h>
+"
+if test "x$ac_cv_have_decl_IORING_OP_FALLOCATE" = xyes; then :
+  $as_echo "#define CFA_HAVE_IORING_OP_FALLOCATE 1" >>confdefs.h
+
+fi
+
+
+                ac_fn_c_check_decl "$LINENO" "IORING_OP_OPENAT" "ac_cv_have_decl_IORING_OP_OPENAT" "#include <linux/io_uring.h>
+"
+if test "x$ac_cv_have_decl_IORING_OP_OPENAT" = xyes; then :
+  $as_echo "#define CFA_HAVE_IORING_OP_OPENAT 1" >>confdefs.h
+
+fi
+
+
+                ac_fn_c_check_decl "$LINENO" "IORING_OP_CLOSE" "ac_cv_have_decl_IORING_OP_CLOSE" "#include <linux/io_uring.h>
+"
+if test "x$ac_cv_have_decl_IORING_OP_CLOSE" = xyes; then :
+  $as_echo "#define CFA_HAVE_IORING_OP_CLOSE 1" >>confdefs.h
+
+fi
+
+
+                ac_fn_c_check_decl "$LINENO" "IORING_OP_FILES_UPDATE" "ac_cv_have_decl_IORING_OP_FILES_UPDATE" "#include <linux/io_uring.h>
+"
+if test "x$ac_cv_have_decl_IORING_OP_FILES_UPDATE" = xyes; then :
+  $as_echo "#define CFA_HAVE_IORING_OP_FILES_UPDATE 1" >>confdefs.h
+
+fi
+
+
+                ac_fn_c_check_decl "$LINENO" "IORING_OP_STATX" "ac_cv_have_decl_IORING_OP_STATX" "#include <linux/io_uring.h>
+"
+if test "x$ac_cv_have_decl_IORING_OP_STATX" = xyes; then :
+  $as_echo "#define CFA_HAVE_IORING_OP_STATX 1" >>confdefs.h
+
+fi
+
+
+                ac_fn_c_check_decl "$LINENO" "IORING_OP_READ" "ac_cv_have_decl_IORING_OP_READ" "#include <linux/io_uring.h>
+"
+if test "x$ac_cv_have_decl_IORING_OP_READ" = xyes; then :
+  $as_echo "#define CFA_HAVE_IORING_OP_READ 1" >>confdefs.h
+
+fi
+
+
+                ac_fn_c_check_decl "$LINENO" "IORING_OP_WRITE" "ac_cv_have_decl_IORING_OP_WRITE" "#include <linux/io_uring.h>
+"
+if test "x$ac_cv_have_decl_IORING_OP_WRITE" = xyes; then :
+  $as_echo "#define CFA_HAVE_IORING_OP_WRITE 1" >>confdefs.h
+
+fi
+
+
+                ac_fn_c_check_decl "$LINENO" "IORING_OP_FADVISE" "ac_cv_have_decl_IORING_OP_FADVISE" "#include <linux/io_uring.h>
+"
+if test "x$ac_cv_have_decl_IORING_OP_FADVISE" = xyes; then :
+  $as_echo "#define CFA_HAVE_IORING_OP_FADVISE 1" >>confdefs.h
+
+fi
+
+
+                ac_fn_c_check_decl "$LINENO" "IORING_OP_MADVISE" "ac_cv_have_decl_IORING_OP_MADVISE" "#include <linux/io_uring.h>
+"
+if test "x$ac_cv_have_decl_IORING_OP_MADVISE" = xyes; then :
+  $as_echo "#define CFA_HAVE_IORING_OP_MADVISE 1" >>confdefs.h
+
+fi
+
+
+                ac_fn_c_check_decl "$LINENO" "IORING_OP_SEND" "ac_cv_have_decl_IORING_OP_SEND" "#include <linux/io_uring.h>
+"
+if test "x$ac_cv_have_decl_IORING_OP_SEND" = xyes; then :
+  $as_echo "#define CFA_HAVE_IORING_OP_SEND 1" >>confdefs.h
+
+fi
+
+
+                ac_fn_c_check_decl "$LINENO" "IORING_OP_RECV" "ac_cv_have_decl_IORING_OP_RECV" "#include <linux/io_uring.h>
+"
+if test "x$ac_cv_have_decl_IORING_OP_RECV" = xyes; then :
+  $as_echo "#define CFA_HAVE_IORING_OP_RECV 1" >>confdefs.h
+
+fi
+
+
+                ac_fn_c_check_decl "$LINENO" "IORING_OP_OPENAT2" "ac_cv_have_decl_IORING_OP_OPENAT2" "#include <linux/io_uring.h>
+"
+if test "x$ac_cv_have_decl_IORING_OP_OPENAT2" = xyes; then :
+  $as_echo "#define CFA_HAVE_IORING_OP_OPENAT2 1" >>confdefs.h
+
+fi
+
+
+                ac_fn_c_check_decl "$LINENO" "IORING_OP_EPOLL_CTL" "ac_cv_have_decl_IORING_OP_EPOLL_CTL" "#include <linux/io_uring.h>
+"
+if test "x$ac_cv_have_decl_IORING_OP_EPOLL_CTL" = xyes; then :
+  $as_echo "#define CFA_HAVE_IORING_OP_EPOLL_CTL 1" >>confdefs.h
+
+fi
+
+
+                ac_fn_c_check_decl "$LINENO" "IORING_OP_SPLICE" "ac_cv_have_decl_IORING_OP_SPLICE" "#include <linux/io_uring.h>
+"
+if test "x$ac_cv_have_decl_IORING_OP_SPLICE" = xyes; then :
+  $as_echo "#define CFA_HAVE_IORING_OP_SPLICE 1" >>confdefs.h
+
+fi
+
+
+                ac_fn_c_check_decl "$LINENO" "IORING_OP_PROVIDE_BUFFERS" "ac_cv_have_decl_IORING_OP_PROVIDE_BUFFERS" "#include <linux/io_uring.h>
+"
+if test "x$ac_cv_have_decl_IORING_OP_PROVIDE_BUFFERS" = xyes; then :
+  $as_echo "#define CFA_HAVE_IORING_OP_PROVIDE_BUFFERS 1" >>confdefs.h
+
+fi
+
+
+                ac_fn_c_check_decl "$LINENO" "IORING_OP_REMOVE_BUFFER" "ac_cv_have_decl_IORING_OP_REMOVE_BUFFER" "#include <linux/io_uring.h>
+"
+if test "x$ac_cv_have_decl_IORING_OP_REMOVE_BUFFER" = xyes; then :
+  $as_echo "#define CFA_HAVE_IORING_OP_REMOVE_BUFFER 1" >>confdefs.h
+
+fi
+
+
 
 fi

libcfa/configure.ac

@@ -123 +123 @@
 AC_PROG_MAKE_SET
 
-AC_CHECK_HEADERS([linux/io_uring.h])
+
+
+#io_uring 5.4 and earlier uses defines
+#io_uring 5.5 uses enum values
+#io_uring 5.6 and later uses probes
+
+AC_CHECK_HEADERS([linux/io_uring.h], [
+        AC_DEFINE(CFA_HAVE_LINUX_IO_URING_H)
+        # AC_CHECK_HEADER([liburing.h], [
+        #       AC_CHECK_LIB([uring], [io_uring_get_probe])
+        # ])
+        m4_foreach([op], [IORING_OP_NOP,IORING_OP_READV,IORING_OP_WRITEV,IORING_OP_FSYNC,IORING_OP_READ_FIXED,IORING_OP_WRITE_FIXED,IORING_OP_POLL_ADD,IORING_OP_POLL_REMOVE,IORING_OP_SYNC_FILE_RANGE,IORING_OP_SENDMSG,IORING_OP_RECVMSG,IORING_OP_TIMEOUT,IORING_OP_TIMEOUT_REMOVE,IORING_OP_ACCEPT,IORING_OP_ASYNC_CANCEL,IORING_OP_LINK_TIMEOUT,IORING_OP_CONNECT,IORING_OP_FALLOCATE,IORING_OP_OPENAT,IORING_OP_CLOSE,IORING_OP_FILES_UPDATE,IORING_OP_STATX,IORING_OP_READ,IORING_OP_WRITE,IORING_OP_FADVISE,IORING_OP_MADVISE,IORING_OP_SEND,IORING_OP_RECV,IORING_OP_OPENAT2,IORING_OP_EPOLL_CTL,IORING_OP_SPLICE,IORING_OP_PROVIDE_BUFFERS,IORING_OP_REMOVE_BUFFER], [
+                AC_CHECK_DECL(op, [AC_DEFINE([CFA_HAVE_]op)], [], [[#include <linux/io_uring.h>]])
+        ])
+])
 AC_CHECK_FUNCS([preadv2 pwritev2])
 

libcfa/prelude/defines.hfa.in

@@ -14 +14 @@
 //
 
-#undef HAVE_LINUX_IO_URING_H
+#undef CFA_HAVE_LINUX_IO_URING_H
+
+#undef CFA_HAVE_IORING_OP_NOP
+#undef CFA_HAVE_IORING_OP_READV
+#undef CFA_HAVE_IORING_OP_WRITEV
+#undef CFA_HAVE_IORING_OP_FSYNC
+#undef CFA_HAVE_IORING_OP_READ_FIXED
+#undef CFA_HAVE_IORING_OP_WRITE_FIXED
+#undef CFA_HAVE_IORING_OP_POLL_ADD
+#undef CFA_HAVE_IORING_OP_POLL_REMOVE
+#undef CFA_HAVE_IORING_OP_SYNC_FILE_RANGE
+#undef CFA_HAVE_IORING_OP_SENDMSG
+#undef CFA_HAVE_IORING_OP_RECVMSG
+#undef CFA_HAVE_IORING_OP_TIMEOUT
+#undef CFA_HAVE_IORING_OP_TIMEOUT_REMOVE
+#undef CFA_HAVE_IORING_OP_ACCEPT
+#undef CFA_HAVE_IORING_OP_ASYNC_CANCEL
+#undef CFA_HAVE_IORING_OP_LINK_TIMEOUT
+#undef CFA_HAVE_IORING_OP_CONNECT
+#undef CFA_HAVE_IORING_OP_FALLOCATE
+#undef CFA_HAVE_IORING_OP_OPENAT
+#undef CFA_HAVE_IORING_OP_CLOSE
+#undef CFA_HAVE_IORING_OP_FILES_UPDATE
+#undef CFA_HAVE_IORING_OP_STATX
+#undef CFA_HAVE_IORING_OP_READ
+#undef CFA_HAVE_IORING_OP_WRITE
+#undef CFA_HAVE_IORING_OP_FADVISE
+#undef CFA_HAVE_IORING_OP_MADVISE
+#undef CFA_HAVE_IORING_OP_SEND
+#undef CFA_HAVE_IORING_OP_RECV
+#undef CFA_HAVE_IORING_OP_OPENAT2
+#undef CFA_HAVE_IORING_OP_EPOLL_CTL
+#undef CFA_HAVE_IORING_OP_SPLICE
+#undef CFA_HAVE_IORING_OP_PROVIDE_BUFFERS
+#undef CFA_HAVE_IORING_OP_REMOVE_BUFFER
 
 #undef HAVE_PREADV2

libcfa/src/concurrency/io.cfa

@@ -16 +16 @@
 #if defined(__CFA_DEBUG__)
         // #define __CFA_DEBUG_PRINT_IO__
-        #define __CFA_DEBUG_PRINT_IO_CORE__
+        // #define __CFA_DEBUG_PRINT_IO_CORE__
 #endif
 
@@ -22 +22 @@
 #include "bitmanip.hfa"
 
-#if !defined(HAVE_LINUX_IO_URING_H)
+#if !defined(CFA_HAVE_LINUX_IO_URING_H)
         void __kernel_io_startup( cluster &, unsigned, bool ) {
                 // Nothing to do without io_uring
@@ -490 +490 @@
         static uint32_t __release_consumed_submission( struct __io_data & ring );
 
+        static inline void process(struct io_uring_cqe & cqe, struct __processor_id_t * id ) {
+                struct __io_user_data_t * data = (struct __io_user_data_t *)(uintptr_t)cqe.user_data;
+                __cfadbg_print_safe( io, "Kernel I/O : Syscall completed : cqe %p, result %d for %p\n", data, cqe.res, data->thrd );
+
+                data->result = cqe.res;
+                if(!id) { unpark(     data->thrd __cfaabi_dbg_ctx2 ); }
+                else  { __unpark( id, data->thrd __cfaabi_dbg_ctx2 ); }
+        }
+
         // Process a single completion message from the io_uring
         // This is NOT thread-safe
@@ -538 +547 @@
                         /* paranoid */ verify(&cqe);
 
-                        struct __io_user_data_t * data = (struct __io_user_data_t *)(uintptr_t)cqe.user_data;
-                        __cfadbg_print_safe( io, "Kernel I/O : Performed reading io cqe %p, result %d for %p\n", data, cqe.res, data->thrd );
-
-                        data->result = cqe.res;
-                        if(!mask) { unpark( data->thrd __cfaabi_dbg_ctx2 ); }
-                        else      { __unpark( &ring.poller.slow.id, data->thrd __cfaabi_dbg_ctx2 ); }
+                        process( cqe, !mask ? (struct __processor_id_t *)0p : &ring.poller.slow.id );
                 }
 

libcfa/src/concurrency/iocall.cfa

@@ -20 +20 @@
 //=============================================================================================
 
-#if defined(HAVE_LINUX_IO_URING_H)
+#if defined(CFA_HAVE_LINUX_IO_URING_H)
         #include <stdint.h>
         #include <linux/io_uring.h>
@@ -122 +122 @@
 #if defined(HAVE_PREADV2)
         ssize_t cfa_preadv2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags) {
-                #if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_READV)
+                #if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_READV)
                         return preadv2(fd, iov, iovcnt, offset, flags);
                 #else
@@ -134 +134 @@
 
         ssize_t cfa_preadv2_fixed(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags) {
-                #if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_READV)
+                #if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_READV)
                         return preadv2(fd, iov, iovcnt, offset, flags);
                 #else
@@ -149 +149 @@
 #if defined(HAVE_PWRITEV2)
         ssize_t cfa_pwritev2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags) {
-                #if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_WRITEV)
+                #if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_WRITEV)
                         return pwritev2(fd, iov, iovcnt, offset, flags);
                 #else
@@ -162 +162 @@
 
 int cfa_fsync(int fd) {
-        #if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_FSYNC)
+        #if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_FSYNC)
                 return fsync(fd);
         #else
@@ -174 +174 @@
 
 int cfa_sync_file_range(int fd, int64_t offset, int64_t nbytes, unsigned int flags) {
-        #if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_SYNC_FILE_RANGE)
+        #if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_SYNC_FILE_RANGE)
                 return sync_file_range(fd, offset, nbytes, flags);
         #else
@@ -190 +190 @@
 
 ssize_t cfa_sendmsg(int sockfd, const struct msghdr *msg, int flags) {
-        #if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_SENDMSG)
+        #if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_SENDMSG)
                 return sendmsg(sockfd, msg, flags);
         #else
@@ -203 +203 @@
 
 ssize_t cfa_recvmsg(int sockfd, struct msghdr *msg, int flags) {
-        #if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_RECVMSG)
+        #if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_RECVMSG)
                 return recvmsg(sockfd, msg, flags);
         #else
@@ -216 +216 @@
 
 ssize_t cfa_send(int sockfd, const void *buf, size_t len, int flags) {
-        #if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_SEND)
+        #if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_SEND)
                 return send( sockfd, buf, len, flags );
         #else
@@ -231 +231 @@
 
 ssize_t cfa_recv(int sockfd, void *buf, size_t len, int flags) {
-        #if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_RECV)
+        #if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_RECV)
                 return recv( sockfd, buf, len, flags );
         #else
@@ -246 +246 @@
 
 int cfa_accept4(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags) {
-        #if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_ACCEPT)
+        #if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_ACCEPT)
                 return accept4( sockfd, addr, addrlen, flags );
         #else
@@ -261 +261 @@
 
 int cfa_connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen) {
-        #if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_CONNECT)
+        #if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_CONNECT)
                 return connect( sockfd, addr, addrlen );
         #else
@@ -275 +275 @@
 
 int cfa_fallocate(int fd, int mode, uint64_t offset, uint64_t len) {
-        #if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_FALLOCATE)
+        #if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_FALLOCATE)
                 return fallocate( fd, mode, offset, len );
         #else
@@ -290 +290 @@
 
 int cfa_fadvise(int fd, uint64_t offset, uint64_t len, int advice) {
-        #if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_FADVISE)
+        #if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_FADVISE)
                 return posix_fadvise( fd, offset, len, advice );
         #else
@@ -305 +305 @@
 
 int cfa_madvise(void *addr, size_t length, int advice) {
-        #if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_MADVISE)
+        #if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_MADVISE)
                 return madvise( addr, length, advice );
         #else
@@ -320 +320 @@
 
 int cfa_openat(int dirfd, const char *pathname, int flags, mode_t mode) {
-        #if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_OPENAT)
+        #if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_OPENAT)
                 return openat( dirfd, pathname, flags, mode );
         #else
@@ -335 +335 @@
 
 int cfa_close(int fd) {
-        #if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_CLOSE)
+        #if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_CLOSE)
                 return close( fd );
         #else
@@ -349 +349 @@
 struct statx;
 int cfa_statx(int dirfd, const char *pathname, int flags, unsigned int mask, struct statx *statxbuf) {
-        #if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_STATX)
+        #if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_STATX)
                 #if defined(__NR_statx)
                         return syscall( __NR_statx, dirfd, pathname, flags, mask, statxbuf );
@@ -367 +367 @@
 
 ssize_t cfa_read(int fd, void *buf, size_t count) {
-        #if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_READ)
+        #if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_READ)
                 return read( fd, buf, count );
         #else
@@ -379 +379 @@
 
 ssize_t cfa_write(int fd, void *buf, size_t count) {
-        #if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_WRITE)
+        #if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_WRITE)
                 return read( fd, buf, count );
         #else
@@ -391 +391 @@
 
 ssize_t cfa_splice(int fd_in, loff_t *off_in, int fd_out, loff_t *off_out, size_t len, unsigned int flags) {
-        #if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_SPLICE)
+        #if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_SPLICE)
                 return splice( fd_in, off_in, fd_out, off_out, len, flags );
         #else
@@ -405 +405 @@
 }
 
+ssize_t cfa_splice(int fd_in, loff_t *off_in, int fd_out, loff_t *off_out, size_t len, unsigned int flags, int in_flags, int out_flags) {
+        #if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_SPLICE)
+                return splice( fd_in, off_in, fd_out, off_out, len, flags );
+        #else
+                __submit_prelude
+
+                (*sqe){ IORING_OP_SPLICE, fd_out, 0p, len, off_out };
+                sqe->splice_fd_in  = fd_in;
+                sqe->splice_off_in = off_in;
+                sqe->splice_flags  = flags | out_flags;
+                sqe->flags = in_flags;
+
+                __submit_wait
+        #endif
+}
+
 ssize_t cfa_tee(int fd_in, int fd_out, size_t len, unsigned int flags) {
-        #if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_TEE)
+        #if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_TEE)
                 return tee( fd_in, fd_out, len, flags );
         #else
@@ -429 +445 @@
 
 bool has_user_level_blocking( fptr_t func ) {
-        #if defined(HAVE_LINUX_IO_URING_H)
+        #if defined(CFA_HAVE_LINUX_IO_URING_H)
                 #if defined(HAVE_PREADV2)
                         if( /*func == (fptr_t)preadv2 || */
                                 func == (fptr_t)cfa_preadv2 )
-                                #define _CFA_IO_FEATURE_IORING_OP_READV ,
-                                return IS_DEFINED(IORING_OP_READV);
+                                #define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_READV ,
+                                return IS_DEFINED(CFA_HAVE_IORING_OP_READV);
                 #endif
 
@@ -440 +456 @@
                         if( /*func == (fptr_t)pwritev2 || */
                                 func == (fptr_t)cfa_pwritev2 )
-                                #define _CFA_IO_FEATURE_IORING_OP_WRITEV ,
-                                return IS_DEFINED(IORING_OP_WRITEV);
+                                #define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_WRITEV ,
+                                return IS_DEFINED(CFA_HAVE_IORING_OP_WRITEV);
                 #endif
 
                 if( /*func == (fptr_t)fsync || */
                         func == (fptr_t)cfa_fsync )
-                        #define _CFA_IO_FEATURE_IORING_OP_FSYNC ,
-                        return IS_DEFINED(IORING_OP_FSYNC);
+                        #define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_FSYNC ,
+                        return IS_DEFINED(CFA_HAVE_IORING_OP_FSYNC);
 
                 if( /*func == (fptr_t)ync_file_range || */
                         func == (fptr_t)cfa_sync_file_range )
-                        #define _CFA_IO_FEATURE_IORING_OP_SYNC_FILE_RANGE ,
-                        return IS_DEFINED(IORING_OP_SYNC_FILE_RANGE);
+                        #define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_SYNC_FILE_RANGE ,
+                        return IS_DEFINED(CFA_HAVE_IORING_OP_SYNC_FILE_RANGE);
 
                 if( /*func == (fptr_t)sendmsg || */
                         func == (fptr_t)cfa_sendmsg )
-                        #define _CFA_IO_FEATURE_IORING_OP_SENDMSG ,
-                        return IS_DEFINED(IORING_OP_SENDMSG);
+                        #define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_SENDMSG ,
+                        return IS_DEFINED(CFA_HAVE_IORING_OP_SENDMSG);
 
                 if( /*func == (fptr_t)recvmsg || */
                         func == (fptr_t)cfa_recvmsg )
-                        #define _CFA_IO_FEATURE_IORING_OP_RECVMSG ,
-                        return IS_DEFINED(IORING_OP_RECVMSG);
+                        #define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_RECVMSG ,
+                        return IS_DEFINED(CFA_HAVE_IORING_OP_RECVMSG);
 
                 if( /*func == (fptr_t)send || */
                         func == (fptr_t)cfa_send )
-                        #define _CFA_IO_FEATURE_IORING_OP_SEND ,
-                        return IS_DEFINED(IORING_OP_SEND);
+                        #define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_SEND ,
+                        return IS_DEFINED(CFA_HAVE_IORING_OP_SEND);
 
                 if( /*func == (fptr_t)recv || */
                         func == (fptr_t)cfa_recv )
-                        #define _CFA_IO_FEATURE_IORING_OP_RECV ,
-                        return IS_DEFINED(IORING_OP_RECV);
+                        #define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_RECV ,
+                        return IS_DEFINED(CFA_HAVE_IORING_OP_RECV);
 
                 if( /*func == (fptr_t)accept4 || */
                         func == (fptr_t)cfa_accept4 )
-                        #define _CFA_IO_FEATURE_IORING_OP_ACCEPT ,
-                        return IS_DEFINED(IORING_OP_ACCEPT);
+                        #define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_ACCEPT ,
+                        return IS_DEFINED(CFA_HAVE_IORING_OP_ACCEPT);
 
                 if( /*func == (fptr_t)connect || */
                         func == (fptr_t)cfa_connect )
-                        #define _CFA_IO_FEATURE_IORING_OP_CONNECT ,
-                        return IS_DEFINED(IORING_OP_CONNECT);
+                        #define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_CONNECT ,
+                        return IS_DEFINED(CFA_HAVE_IORING_OP_CONNECT);
 
                 if( /*func == (fptr_t)fallocate || */
                         func == (fptr_t)cfa_fallocate )
-                        #define _CFA_IO_FEATURE_IORING_OP_FALLOCATE ,
-                        return IS_DEFINED(IORING_OP_FALLOCATE);
+                        #define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_FALLOCATE ,
+                        return IS_DEFINED(CFA_HAVE_IORING_OP_FALLOCATE);
 
                 if( /*func == (fptr_t)posix_fadvise || */
                         func == (fptr_t)cfa_fadvise )
-                        #define _CFA_IO_FEATURE_IORING_OP_FADVISE ,
-                        return IS_DEFINED(IORING_OP_FADVISE);
+                        #define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_FADVISE ,
+                        return IS_DEFINED(CFA_HAVE_IORING_OP_FADVISE);
 
                 if( /*func == (fptr_t)madvise || */
                         func == (fptr_t)cfa_madvise )
-                        #define _CFA_IO_FEATURE_IORING_OP_MADVISE ,
-                        return IS_DEFINED(IORING_OP_MADVISE);
+                        #define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_MADVISE ,
+                        return IS_DEFINED(CFA_HAVE_IORING_OP_MADVISE);
 
                 if( /*func == (fptr_t)openat || */
                         func == (fptr_t)cfa_openat )
-                        #define _CFA_IO_FEATURE_IORING_OP_OPENAT ,
-                        return IS_DEFINED(IORING_OP_OPENAT);
+                        #define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_OPENAT ,
+                        return IS_DEFINED(CFA_HAVE_IORING_OP_OPENAT);
 
                 if( /*func == (fptr_t)close || */
                         func == (fptr_t)cfa_close )
-                        #define _CFA_IO_FEATURE_IORING_OP_CLOSE ,
-                        return IS_DEFINED(IORING_OP_CLOSE);
+                        #define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_CLOSE ,
+                        return IS_DEFINED(CFA_HAVE_IORING_OP_CLOSE);
 
                 if( /*func == (fptr_t)read || */
                         func == (fptr_t)cfa_read )
-                        #define _CFA_IO_FEATURE_IORING_OP_READ ,
-                        return IS_DEFINED(IORING_OP_READ);
+                        #define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_READ ,
+                        return IS_DEFINED(CFA_HAVE_IORING_OP_READ);
 
                 if( /*func == (fptr_t)write || */
                         func == (fptr_t)cfa_write )
-                        #define _CFA_IO_FEATURE_IORING_OP_WRITE ,
-                        return IS_DEFINED(IORING_OP_WRITE);
+                        #define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_WRITE ,
+                        return IS_DEFINED(CFA_HAVE_IORING_OP_WRITE);
 
                 if( /*func == (fptr_t)splice || */
-                        func == (fptr_t)cfa_splice )
-                        #define _CFA_IO_FEATURE_IORING_OP_SPLICE ,
-                        return IS_DEFINED(IORING_OP_SPLICE);
+                        func == (fptr_t)(ssize_t (*)(int, loff_t *, int, loff_t *, size_t, unsigned int))cfa_splice,
+                        func == (fptr_t)(ssize_t (*)(int, loff_t *, int, loff_t *, size_t, unsigned int, int, int))cfa_splice )
+                        #define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_SPLICE ,
+                        return IS_DEFINED(CFA_HAVE_IORING_OP_SPLICE);
 
                 if( /*func == (fptr_t)tee || */
                         func == (fptr_t)cfa_tee )
-                        #define _CFA_IO_FEATURE_IORING_OP_TEE ,
-                        return IS_DEFINED(IORING_OP_TEE);
+                        #define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_TEE ,
+                        return IS_DEFINED(CFA_HAVE_IORING_OP_TEE);
         #endif
 

libcfa/src/concurrency/kernel.cfa

@@ -228 +228 @@
 static void * __invoke_processor(void * arg);
 
-void ?{}(processor & this, const char name[], cluster & _cltr) with( this ) {
+static init(processor & this, const char name[], cluster & _cltr) with( this ) {
         this.name = name;
         this.cltr = &_cltr;
         id = -1u;
-        terminated{ 0 };
         destroyer = 0p;
         do_terminate = false;
         preemption_alarm = 0p;
         pending_preemption = false;
-        runner.proc = &this;
 
         #if !defined(__CFA_NO_STATISTICS__)
@@ -244 +242 @@
         #endif
 
-        idle{};
+        __atomic_fetch_add( &cltr->nprocessors, 1u, __ATOMIC_SEQ_CST );
+
+        id = doregister((__processor_id_t*)&this);
+
+        // Lock the RWlock so no-one pushes/pops while we are changing the queue
+        uint_fast32_t last_size = ready_mutate_lock();
+
+                // Adjust the ready queue size
+                ready_queue_grow( cltr );
+
+        // Unlock the RWlock
+        ready_mutate_unlock( last_size );
+
+        __cfadbg_print_safe(runtime_core, "Kernel : core %p created\n", &this);
+}
+
+// Not a ctor, it just preps the destruction but should not destroy members
+void deinit(processor & this) {
+        // Lock the RWlock so no-one pushes/pops while we are changing the queue
+        uint_fast32_t last_size = ready_mutate_lock();
+
+                // Adjust the ready queue size
+                ready_queue_shrink( this.cltr );
+
+                // Make sure we aren't on the idle queue
+                unsafe_remove( this.cltr->idles, &this );
+
+        // Unlock the RWlock
+        ready_mutate_unlock( last_size );
+
+        // Finally we don't need the read_lock any more
+        unregister((__processor_id_t*)&this);
+}
+
+void ?{}(processor & this, const char name[], cluster & _cltr) {
+        ( this.idle ){};
+        ( this.terminated ){ 0 };
+        ( this.runner ){};
+        init( this, name, _cltr );
 
         __cfadbg_print_safe(runtime_core, "Kernel : Starting core %p\n", &this);
 
         this.stack = __create_pthread( &this.kernel_thread, __invoke_processor, (void *)&this );
-        __atomic_fetch_add( &cltr->nprocessors, 1u, __ATOMIC_SEQ_CST );
-
-        __cfadbg_print_safe(runtime_core, "Kernel : core %p created\n", &this);
+
 }
 
@@ -269 +303 @@
 
         free( this.stack );
+
+        deinit( this );
 
         __atomic_fetch_sub( &cltr->nprocessors, 1u, __ATOMIC_SEQ_CST );
@@ -318 +354 @@
 
         __cfadbg_print_safe(runtime_core, "Kernel : core %p starting\n", this);
-
-        // register the processor unless it's the main thread which is handled in the boot sequence
-        if(this != mainProcessor) {
-                this->id = doregister((__processor_id_t*)this);
-                #if !defined(__CFA_NO_STATISTICS__)
-                        if( this->print_halts ) {
-                                __cfaabi_bits_print_safe( STDOUT_FILENO, "Processor : %d - %s (%p)\n", this->id, this->name, (void*)this);
-                        }
-                #endif
-
-                // Lock the RWlock so no-one pushes/pops while we are changing the queue
-                uint_fast32_t last_size = ready_mutate_lock();
-
-                        // Adjust the ready queue size
-                        ready_queue_grow( this->cltr );
-
-                // Unlock the RWlock
-                ready_mutate_unlock( last_size );
-        }
+        #if !defined(__CFA_NO_STATISTICS__)
+                if( this->print_halts ) {
+                        __cfaabi_bits_print_safe( STDOUT_FILENO, "Processor : %d - %s (%p)\n", this->id, this->name, (void*)this);
+                }
+        #endif
 
         {
@@ -375 +397 @@
         V( this->terminated );
 
-        // unregister the processor unless it's the main thread which is handled in the boot sequence
-        if(this != mainProcessor) {
-                // Lock the RWlock so no-one pushes/pops while we are changing the queue
-                uint_fast32_t last_size = ready_mutate_lock();
-
-                        // Adjust the ready queue size
-                        ready_queue_shrink( this->cltr );
-
-                        // Make sure we aren't on the idle queue
-                        #if !defined(__CFA_NO_STATISTICS__)
-                                bool removed =
-                        #endif
-                        unsafe_remove( this->cltr->idles, this );
-
-                        #if !defined(__CFA_NO_STATISTICS__)
-                                if(removed) __tls_stats()->ready.sleep.exits++;
-                        #endif
-
-                // Unlock the RWlock
-                ready_mutate_unlock( last_size );
-
-                // Finally we don't need the read_lock any more
-                unregister((__processor_id_t*)this);
-        }
-        else {
+        if(this == mainProcessor) {
                 // HACK : the coroutine context switch expects this_thread to be set
                 // and it make sense for it to be set in all other cases except here
@@ -859 +857 @@
 
         void ?{}(processor & this) with( this ) {
-                name = "Main Processor";
-                cltr = mainCluster;
-                terminated{ 0 };
-                do_terminate = false;
-                preemption_alarm = 0p;
-                pending_preemption = false;
+                ( this.idle ){};
+                ( this.terminated ){ 0 };
+                ( this.runner ){};
+                init( this, "Main Processor", *mainCluster );
                 kernel_thread = pthread_self();
-                id = -1u;
-
-                #if !defined(__CFA_NO_STATISTICS__)
-                        print_stats = false;
-                        print_halts = false;
-                #endif
 
                 runner{ &this };
                 __cfadbg_print_safe(runtime_core, "Kernel : constructed main processor context %p\n", &runner);
-
-                __atomic_fetch_add( &cltr->nprocessors, 1u, __ATOMIC_SEQ_CST );
         }
 
@@ -883 +871 @@
         mainProcessor = (processor *)&storage_mainProcessor;
         (*mainProcessor){};
-
-        mainProcessor->id = doregister( (__processor_id_t*)mainProcessor);
 
         //initialize the global state variables
@@ -944 +930 @@
         kernel_stop_preemption();
 
-        unregister((__processor_id_t*)mainProcessor);
-
         // Destroy the main processor and its context in reverse order of construction
         // These were manually constructed so we need manually destroy them
         void ^?{}(processor & this) with( this ){
+                deinit( this );
+
                 /* paranoid */ verify( this.do_terminate == true );
                 __atomic_fetch_sub( &cltr->nprocessors, 1u, __ATOMIC_SEQ_CST );

libcfa/src/concurrency/ready_queue.cfa

@@ -186 +186 @@
 //=======================================================================
 void ?{}(__ready_queue_t & this) with (this) {
-
-        lanes.data = alloc(4);
-        for( i; 4 ) {
-                (lanes.data[i]){};
-        }
-        lanes.count = 4;
-        snzi{ log2( lanes.count / 8 ) };
+        lanes.data  = 0p;
+        lanes.count = 0;
 }
 
 void ^?{}(__ready_queue_t & this) with (this) {
-        verify( 4  == lanes.count );
+        verify( 0  == lanes.count );
         verify( !query( snzi ) );
-
-        ^(snzi){};
-
-        for( i; 4 ) {
-                ^(lanes.data[i]){};
-        }
         free(lanes.data);
 }
@@ -495 +484 @@
 }
 
+#warning remove when alloc is fixed
+forall( dtype T | sized(T) )
+static inline T * correct_alloc( T ptr[], size_t dim ) {
+        if( dim == 0 ) {
+                free(ptr);
+                return 0p;
+        }
+        T * temp = alloc( dim );
+        if(ptr) {
+                memcpy( temp, ptr, dim * sizeof(T));
+                free(ptr);
+        }
+        return temp;
+}
+
 // Grow the ready queue
 void ready_queue_grow  (struct cluster * cltr) {
@@ -513 +517 @@
 
                 // Allocate new array (uses realloc and memcpies the data)
-                lanes.data = alloc(lanes.data, ncount);
+                lanes.data = correct_alloc(lanes.data, ncount);
 
                 // Fix the moved data
@@ -558 +562 @@
                 size_t ocount = lanes.count;
                 // Check that we have some space left
-                if(ocount < 8) abort("Program attempted to destroy more Ready Queues than were created");
+                if(ocount < 4) abort("Program attempted to destroy more Ready Queues than were created");
 
                 // reduce the actual count so push doesn't use the old queues
@@ -600 +604 @@
 
                 // Allocate new array (uses realloc and memcpies the data)
-                lanes.data = alloc(lanes.data, lanes.count);
+                lanes.data = correct_alloc(lanes.data, lanes.count);
 
                 // Fix the moved data

libcfa/src/concurrency/snzi.hfa

@@ -120 +120 @@
 //--------------------------------------------------
 // SNZI object
+void  ?{}( __snzi_t & this ) {
+        this.mask = 0;
+        this.root = 0;
+        this.nodes = 0p;
+}
+
 void  ?{}( __snzi_t & this, unsigned depth ) with( this ) {
         mask = (1 << depth) - 1;

libcfa/src/concurrency/stats.cfa

@@ -24 +24 @@
                 stats->ready.sleep.exits   = 0;
 
-                #if defined(HAVE_LINUX_IO_URING_H)
+                #if defined(CFA_HAVE_LINUX_IO_URING_H)
                         stats->io.submit_q.submit_avg.rdy = 0;
                         stats->io.submit_q.submit_avg.csm = 0;
@@ -59 +59 @@
                 __atomic_fetch_add( &cltr->ready.sleep.exits  , proc->ready.sleep.exits  , __ATOMIC_SEQ_CST );
 
-                #if defined(HAVE_LINUX_IO_URING_H)
+                #if defined(CFA_HAVE_LINUX_IO_URING_H)
                         __atomic_fetch_add( &cltr->io.submit_q.submit_avg.rdy          , proc->io.submit_q.submit_avg.rdy          , __ATOMIC_SEQ_CST );
                         __atomic_fetch_add( &cltr->io.submit_q.submit_avg.csm          , proc->io.submit_q.submit_avg.csm          , __ATOMIC_SEQ_CST );
@@ -121 +121 @@
                 }
 
-                #if defined(HAVE_LINUX_IO_URING_H)
+                #if defined(CFA_HAVE_LINUX_IO_URING_H)
                         if( flags & CFA_STATS_IO ) {
                                 double avgrdy = ((double)io.submit_q.submit_avg.rdy) / io.submit_q.submit_avg.cnt;

libcfa/src/concurrency/stats.hfa

@@ -11 +11 @@
         enum {
                 CFA_STATS_READY_Q  = 0x01,
-                #if defined(HAVE_LINUX_IO_URING_H)
+                #if defined(CFA_HAVE_LINUX_IO_URING_H)
                         CFA_STATS_IO = 0x02,
                 #endif
@@ -64 +64 @@
         };
 
-        #if defined(HAVE_LINUX_IO_URING_H)
+        #if defined(CFA_HAVE_LINUX_IO_URING_H)
                 struct __attribute__((aligned(64))) __stats_io_t{
                         struct {
@@ -99 +99 @@
         struct __attribute__((aligned(128))) __stats_t {
                 __stats_readQ_t ready;
-                #if defined(HAVE_LINUX_IO_URING_H)
+                #if defined(CFA_HAVE_LINUX_IO_URING_H)
                         __stats_io_t    io;
                 #endif

libcfa/src/heap.cfa

@@ -10 +10 @@
 // Created On       : Tue Dec 19 21:58:35 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jun 13 22:42:15 2020
-// Update Count     : 805
+// Last Modified On : Mon Jul 20 23:00:32 2020
+// Update Count     : 808
 //
 
@@ -901 +901 @@
           if ( oalign == 0 && size <= odsize && odsize <= size * 2 ) { // allow 50% wasted storage for smaller size
                         header->kind.real.blockSize &= -2;                      // no alignment and turn off 0 fill
+                        if ( size != odsize ) header->kind.real.size = size; // reset allocation size
                         return oaddr;
                 } // if
@@ -929 +930 @@
 
                 size_t odsize = dataStorage( bsize, oaddr, header ); // data storage available in bucket
-          if ( size <= odsize && odsize <= size * 2 ) { // allow up to 50% wasted storage in smaller size
-                        // Do not know size of original allocation => cannot do 0 fill for any additional space because do not know
-                        // where to start filling, i.e., do not overwrite existing values in space.
+          if ( size <= odsize && odsize <= size * 2 ) {         // allow up to 50% wasted storage in smaller size
+                        if ( size != odsize ) header->kind.real.size = size; // reset allocation size
                         return oaddr;
                 } // if
@@ -1098 +1098 @@
         // Returns original total allocation size (not bucket size) => array size is dimension * sizeif(T).
         size_t malloc_size( void * addr ) {
-          if ( unlikely( addr == 0p ) ) return false;           // null allocation is not zero fill
+          if ( unlikely( addr == 0p ) ) return 0;                       // null allocation has zero size
                 HeapManager.Storage.Header * header = headerAddr( addr );
                 if ( (header->kind.fake.alignment & 1) == 1 ) { // fake header ?
@@ -1108 +1108 @@
         // Set allocation size and return previous size.
         size_t $malloc_size_set( void * addr, size_t size ) {
-          if ( unlikely( addr == 0p ) ) return false;           // null allocation is not zero fill
+          if ( unlikely( addr == 0p ) ) return 0;                       // null allocation has 0 size
                 HeapManager.Storage.Header * header = headerAddr( addr );
                 if ( (header->kind.fake.alignment & 1) == 1 ) { // fake header ?
@@ -1227 +1227 @@
                 if ( size <= odsize && odsize <= size * 2 ) {   // allow 50% wasted storage for smaller size
                         header->kind.real.blockSize &= -2;                      // turn off 0 fill
+                        if ( size != odsize ) header->kind.real.size = size; // reset allocation size
                         return oaddr;
                 } // if

libcfa/src/heap.hfa

@@ -10 +10 @@
 // Created On       : Tue May 26 11:23:55 2020
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Jun  1 21:19:00 2020
-// Update Count     : 10
+// Last Modified On : Mon Jul 20 18:52:31 2020
+// Update Count     : 11
 // 
 
@@ -35 +35 @@
         void * resize( void * oaddr, size_t size );
         void * amemalign( size_t align, size_t dim, size_t elemSize );
-        void * cmemalign( size_t align, size_t noOfElems, size_t elemSize );
+        void * cmemalign( size_t align, size_t dim, size_t elemSize );
         size_t malloc_alignment( void * addr );
         bool malloc_zero_fill( void * addr );

libcfa/src/iostream.cfa

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Jul 16 07:43:31 2020
-// Update Count     : 1102
+// Last Modified On : Mon Jul 20 15:00:37 2020
+// Update Count     : 1124
 //
 
@@ -167 +167 @@
         #define P10_UINT64 10_000_000_000_000_000_000_ULL       // 19 zeroes
 
-        static void base10_128( ostype & os, unsigned int128 val ) {
+        static inline void base10_128( ostype & os, unsigned int128 val ) {
+#if defined(__GNUC__) && __GNUC_PREREQ(7,0)                             // gcc version >= 7
                 if ( val > P10_UINT64 ) {
+#else
+                if ( (uint64_t)(val >> 64) != 0 || (uint64_t)val > P10_UINT64 ) { // patch gcc 5 & 6 -O3 bug
+#endif // __GNUC_PREREQ(7,0)
                         base10_128( os, val / P10_UINT64 );                     // recursive
                         fmt( os, "%.19lu", (uint64_t)(val % P10_UINT64) );
@@ -176 +180 @@
         } // base10_128
 
-        static void base10_128( ostype & os, int128 val ) {
+        static inline void base10_128( ostype & os, int128 val ) {
                 if ( val < 0 ) {
                         fmt( os, "-" );                                                         // leading negative sign

libcfa/src/stdlib.cfa

@@ -9 +9 @@
 // Author           : Peter A. Buhr
 // Created On       : Thu Jan 28 17:10:29 2016
-// Last Modified By : Andrew Beach
-// Last Modified On : Tue Jun  2 16:46:00 2020
-// Update Count     : 500
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sun Jul 19 15:05:28 2020
+// Update Count     : 501
 //
 
@@ -25 +25 @@
 
 //---------------------------------------
-
-forall( dtype T | sized(T) ) {
-        T * alloc_set( T ptr[], size_t dim, char fill ) {       // realloc array with fill
-                size_t olen = malloc_usable_size( ptr );                // current allocation
-                void * nptr = (void *)realloc( (void *)ptr, dim * sizeof(T) ); // C realloc
-                size_t nlen = malloc_usable_size( nptr );               // new allocation
-                if ( nlen > olen ) {                                                    // larger ?
-                        memset( (char *)nptr + olen, (int)fill, nlen - olen ); // initialize added storage
-                } // if
-                return (T *)nptr;
-        } // alloc_set
-
-        T * alloc_set( T ptr[], size_t dim, T fill ) {          // realloc array with fill
-                size_t olen = malloc_usable_size( ptr );                // current allocation
-                void * nptr = (void *)realloc( (void *)ptr, dim * sizeof(T) ); // C realloc
-                size_t nlen = malloc_usable_size( nptr );               // new allocation
-                if ( nlen > olen ) {                                                    // larger ?
-                        for ( i; malloc_size( ptr ) / sizeof(T) ~ dim ) {
-                                memcpy( &ptr[i], &fill, sizeof(T) );    // initialize with fill value
-                        } // for
-                } // if
-                return (T *)nptr;
-        } // alloc_align_set
-
-        T * alloc_align_set( T ptr[], size_t align, char fill ) { // aligned realloc with fill
-                size_t olen = malloc_usable_size( ptr );                // current allocation
-                void * nptr = (void *)realloc( (void *)ptr, align, sizeof(T) ); // CFA realloc
-                // char * nptr = alloc_align( ptr, align );
-                size_t nlen = malloc_usable_size( nptr );               // new allocation
-                if ( nlen > olen ) {                                                    // larger ?
-                        memset( (char *)nptr + olen, (int)fill, nlen - olen ); // initialize added storage
-                } // if
-                return (T *)nptr;
-        } // alloc_align_set
-
-        T * alloc_align_set( T ptr[], size_t align, size_t dim, T fill ) { // aligned realloc with fill
-                size_t olen = malloc_usable_size( ptr );                // current allocation
-                void * nptr = (void *)realloc( (void *)ptr, align, sizeof(T) ); // CFA realloc
-                // char * nptr = alloc_align( ptr, align );
-                size_t nlen = malloc_usable_size( nptr );               // new allocation
-                if ( nlen > olen ) {                                                    // larger ?
-                        for ( i; dim ) { memcpy( &ptr[i], &fill, sizeof(T) ); } // initialize with fill value
-                } // if
-                return (T *)nptr;
-        } // alloc_align_set
-} // distribution
 
 // allocation/deallocation and constructor/destructor, non-array types

libcfa/src/stdlib.hfa

@@ -9 +9 @@
 // Author           : Peter A. Buhr
 // Created On       : Thu Jan 28 17:12:35 2016
-// Last Modified By : Andrew Beach
-// Last Modified On : Tue Jun  2 16:47:00 2020
-// Update Count     : 451
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue Jul 21 07:58:05 2020
+// Update Count     : 475
 //
 
@@ -39 +39 @@
 //---------------------------------------
 
+// Macro because of returns
+#define $VAR_ALLOC( allocation, alignment ) \
+        if ( _Alignof(T) <= libAlign() ) return (T *)(void *)allocation( (size_t)sizeof(T) ); /* C allocation */ \
+        else return (T *)alignment( _Alignof(T), sizeof(T) )
+
+#define $ARRAY_ALLOC( allocation, alignment, dim ) \
+        if ( _Alignof(T) <= libAlign() ) return (T *)(void *)allocation( dim, (size_t)sizeof(T) ); /* C allocation */ \
+        else return (T *)alignment( _Alignof(T), dim, sizeof(T) )
+
+#define $RE_SPECIALS( ptr, size, allocation, alignment ) \
+        if ( unlikely( size == 0 ) || unlikely( ptr == 0p ) ) { \
+                if ( unlikely( size == 0 ) ) free( ptr ); \
+                $VAR_ALLOC( malloc, memalign ); \
+        } /* if */
+
 static inline forall( dtype T | sized(T) ) {
         // Cforall safe equivalents, i.e., implicit size specification
 
         T * malloc( void ) {
-                if ( _Alignof(T) <= libAlign() ) return (T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc
-                else return (T *)memalign( _Alignof(T), sizeof(T) );
+                $VAR_ALLOC( malloc, memalign );
         } // malloc
 
         T * aalloc( size_t dim ) {
-                if ( _Alignof(T) <= libAlign() ) return (T *)(void *)aalloc( dim, (size_t)sizeof(T) ); // CFA aalloc
-                else return (T *)amemalign( _Alignof(T), dim, sizeof(T) );
+                $ARRAY_ALLOC( aalloc, amemalign, dim );
         } // aalloc
 
         T * calloc( size_t dim ) {
-                if ( _Alignof(T) <= libAlign() )return (T *)(void *)calloc( dim, sizeof(T) ); // C calloc
-                else return (T *)cmemalign( _Alignof(T), dim, sizeof(T) );
+                $ARRAY_ALLOC( calloc, cmemalign, dim );
         } // calloc
 
-        T * resize( T * ptr, size_t size ) {                            // CFA realloc, eliminate return-type cast
-                return (T *)(void *)resize( (void *)ptr, size ); // C realloc
+        T * resize( T * ptr, size_t size ) {                            // CFA resize, eliminate return-type cast
+                $RE_SPECIALS( ptr, size, malloc, memalign );
+                return (T *)(void *)resize( (void *)ptr, size ); // CFA resize
         } // resize
 
         T * realloc( T * ptr, size_t size ) {                           // CFA realloc, eliminate return-type cast
+                $RE_SPECIALS( ptr, size, malloc, memalign );
                 return (T *)(void *)realloc( (void *)ptr, size ); // C realloc
         } // realloc
@@ -118 +132 @@
 
         T * alloc( T ptr[], size_t dim, bool copy = true ) {
-                if ( copy ) {                                                                   // realloc
-                        return (T *)(void *)realloc( (void *)ptr, dim * sizeof(T) ); // C realloc
+                if ( copy ) {
+                        return realloc( ptr, dim * sizeof(T) );         // CFA realloc
                 } else {
-                        return resize( ptr, dim * sizeof(T) );          // resize
+                        return resize( ptr, dim * sizeof(T) );          // CFA resize
                 } // if
         } // alloc
@@ -146 +160 @@
                 return (T *)memcpy( (T *)alloc( dim ), fill, dim * sizeof(T) ); // initialize with fill value
         } // alloc
-} // distribution
-
-forall( dtype T | sized(T) ) {
-        T * alloc_set( T ptr[], size_t dim, char fill );        // realloc array with fill
-        T * alloc_set( T ptr[], size_t dim, T fill );           // realloc array with fill
+
+        T * alloc_set( T ptr[], size_t dim, char fill ) {       // realloc array with fill
+                size_t osize = malloc_size( ptr );                              // current allocation
+                size_t nsize = dim * sizeof(T);                                 // new allocation
+                T * nptr = realloc( ptr, nsize );                               // CFA realloc
+                if ( nsize > osize ) {                                                  // larger ?
+                        memset( (char *)nptr + osize, (int)fill, nsize - osize ); // initialize added storage
+                } // if
+                return (T *)nptr;
+        } // alloc_set
+
+        T * alloc_set( T ptr[], size_t dim, T & fill ) {        // realloc array with fill
+                size_t odim = malloc_size( ptr ) / sizeof(T);   // current dimension
+                size_t nsize = dim * sizeof(T);                                 // new allocation
+                size_t ndim = nsize / sizeof(T);                                // new dimension
+                T * nptr = realloc( ptr, nsize );                               // CFA realloc
+                if ( ndim > odim ) {                                                    // larger ?
+                        for ( i; odim ~ ndim ) {
+                                memcpy( &nptr[i], &fill, sizeof(T) );   // initialize with fill value
+                        } // for
+                } // if
+                return (T *)nptr;
+        } // alloc_align_set
 } // distribution
 
@@ -196 +228 @@
                 return (T *)memcpy( (T *)alloc_align( align, dim ), fill, dim * sizeof(T) );
         } // alloc_align
-} // distribution
-
-forall( dtype T | sized(T) ) {
-        T * alloc_align_set( T ptr[], size_t align, char fill ); // aligned realloc with fill
-        T * alloc_align_set( T ptr[], size_t align, T fill ); // aligned realloc with fill
-        T * alloc_align_set( T ptr[], size_t align, size_t dim, char fill ); // aligned realloc array with fill
-        T * alloc_align_set( T ptr[], size_t align, size_t dim, T fill ); // aligned realloc array with fill
+
+        T * alloc_align_set( T ptr[], size_t align, size_t dim, char fill ) {
+                size_t osize = malloc_size( ptr );                              // current allocation
+                size_t nsize = dim * sizeof(T);                                 // new allocation
+                T * nptr = realloc( ptr, align, nsize );                // CFA realloc
+                if ( nsize > osize ) {                                                  // larger ?
+                        memset( (char *)nptr + osize, (int)fill, nsize - osize ); // initialize added storage
+                } // if
+                return (T *)nptr;
+        } // alloc_align_set
+
+        T * alloc_align_set( T ptr[], size_t align, size_t dim, T & fill ) {
+                size_t odim = malloc_size( ptr ) / sizeof(T);   // current dimension
+                size_t nsize = dim * sizeof(T);                                 // new allocation
+                size_t ndim = nsize / sizeof(T);                                // new dimension
+                T * nptr = realloc( ptr, align, nsize );                // CFA realloc
+                if ( ndim > odim ) {                                                    // larger ?
+                        for ( i; odim ~ ndim ) {
+                                memcpy( &nptr[i], &fill, sizeof(T) );   // initialize with fill value
+                        } // for
+                } // if
+                return (T *)nptr;
+        } // alloc_align_set
 } // distribution
 

src/Common/PassVisitor.proto.h

@@ -38 +38 @@
         };
 
-        std::stack< cleanup_t > cleanups;
+        std::stack< cleanup_t, std::vector< cleanup_t > > cleanups;
 };
 

src/Virtual/ExpandCasts.cc

@@ -10 +10 @@
 // Created On       : Mon Jul 24 13:59:00 2017
 // Last Modified By : Andrew Beach
-// Last Modified On : Tue May 26 14:37:00 2020
-// Update Count     : 2
+// Last Modified On : Tue Jul 22 10:04:00 2020
+// Update Count     : 3
 //
 
@@ -24 +24 @@
 #include "Common/PassVisitor.h"    // for PassVisitor
 #include "Common/SemanticError.h"  // for SemanticError
+#include "SymTab/Mangler.h"        // for mangleType
 #include "SynTree/Declaration.h"   // for ObjectDecl, StructDecl, FunctionDecl
 #include "SynTree/Expression.h"    // for VirtualCastExpr, CastExpr, Address...
@@ -31 +32 @@
 
 namespace Virtual {
+
+        // Indented until the new ast code gets added.
+
+        /// Maps virtual table types the instance for that type.
+        class VirtualTableMap final {
+                std::unordered_map<std::string, ObjectDecl *> vtable_instances;
+        public:
+                ObjectDecl * insert( ObjectDecl * vtableDecl ) {
+                        std::string const & mangledName = SymTab::Mangler::mangleType( vtableDecl->type );
+                        ObjectDecl *& value = vtable_instances[ mangledName ];
+                        if ( value ) {
+                                if ( vtableDecl->storageClasses.is_extern ) {
+                                        return nullptr;
+                                } else if ( ! value->storageClasses.is_extern ) {
+                                        return value;
+                                }
+                        }
+                        value = vtableDecl;
+                        return nullptr;
+                }
+
+                ObjectDecl * lookup( const Type * vtableType ) {
+                        std::string const & mangledName = SymTab::Mangler::mangleType( vtableType );
+                        const auto it = vtable_instances.find( mangledName );
+                        return ( vtable_instances.end() == it ) ? nullptr : it->second;
+                }
+        };
 
         /* Currently virtual depends on the rather brittle name matching between
@@ -39 +67 @@
          */
 
+        namespace {
+
         std::string get_vtable_name( std::string const & name ) {
                 return name + "_vtable";
@@ -53 +83 @@
         std::string get_vtable_inst_name_root( std::string const & name ) {
                 return get_vtable_name_root( name.substr(1, name.size() - 10 ) );
-        }
-
-        bool is_vtable_name( std::string const & name ) {
-                return (name.substr( name.size() - 7 ) == "_vtable" );
         }
 
@@ -64 +90 @@
         }
 
+        } // namespace
+
         class VirtualCastCore {
-        std::map<std::string, ObjectDecl *> vtable_instances;
-        FunctionDecl *vcast_decl;
-        StructDecl *pvt_decl;
+                VirtualTableMap vtable_instances;
+                FunctionDecl *vcast_decl;
+                StructDecl *pvt_decl;
 
                 Type * pointer_to_pvt(int level_of_indirection) {
@@ -107 +135 @@
         void VirtualCastCore::premutate( ObjectDecl * objectDecl ) {
                 if ( is_vtable_inst_name( objectDecl->get_name() ) ) {
-                        vtable_instances[objectDecl->get_name()] = objectDecl;
-                }
-        }
-
-        // Better error locations for generated casts.
-        static CodeLocation castLocation( VirtualCastExpr * castExpr ) {
+                        if ( ObjectDecl * existing = vtable_instances.insert( objectDecl ) ) {
+                                std::string msg = "Repeated instance of virtual table, original found at: ";
+                                msg += existing->location.filename;
+                                msg += ":" + toString( existing->location.first_line );
+                                SemanticError( objectDecl->location, msg );
+                        }
+                }
+        }
+
+        namespace {
+
+        /// Better error locations for generated casts.
+        CodeLocation castLocation( const VirtualCastExpr * castExpr ) {
                 if ( castExpr->location.isSet() ) {
                         return castExpr->location;
@@ -124 +159 @@
         }
 
+        [[noreturn]] void castError( const VirtualCastExpr * castExpr, std::string const & message ) {
+                SemanticError( castLocation( castExpr ), message );
+        }
+
+        /// Get the virtual table type used in a virtual cast.
+        Type * getVirtualTableType( const VirtualCastExpr * castExpr ) {
+                const Type * objectType;
+                if ( auto target = dynamic_cast<const PointerType *>( castExpr->result ) ) {
+                        objectType = target->base;
+                } else if ( auto target = dynamic_cast<const ReferenceType *>( castExpr->result ) ) {
+                        objectType = target->base;
+                } else {
+                        castError( castExpr, "Virtual cast type must be a pointer or reference type." );
+                }
+                assert( objectType );
+
+                const StructInstType * structType = dynamic_cast<const StructInstType *>( objectType );
+                if ( nullptr == structType ) {
+                        castError( castExpr, "Virtual cast type must refer to a structure type." );
+                }
+                const StructDecl * structDecl = structType->baseStruct;
+                assert( structDecl );
+
+                const ObjectDecl * fieldDecl = nullptr;
+                if ( 0 < structDecl->members.size() ) {
+                        const Declaration * memberDecl = structDecl->members.front();
+                        assert( memberDecl );
+                        fieldDecl = dynamic_cast<const ObjectDecl *>( memberDecl );
+                        if ( fieldDecl && fieldDecl->name != "virtual_table" ) {
+                                fieldDecl = nullptr;
+                        }
+                }
+                if ( nullptr == fieldDecl ) {
+                        castError( castExpr, "Virtual cast type must have a leading virtual_table field." );
+                }
+                const PointerType * fieldType = dynamic_cast<const PointerType *>( fieldDecl->type );
+                if ( nullptr == fieldType ) {
+                        castError( castExpr, "Virtual cast type virtual_table field is not a pointer." );
+                }
+                assert( fieldType->base );
+                auto virtualStructType = dynamic_cast<const StructInstType *>( fieldType->base );
+                assert( virtualStructType );
+
+                // Here is the type, but if it is polymorphic it will have lost information.
+                // (Always a clone so that it may always be deleted.)
+                StructInstType * virtualType = virtualStructType->clone();
+                if ( ! structType->parameters.empty() ) {
+                        deleteAll( virtualType->parameters );
+                        virtualType->parameters.clear();
+                        cloneAll( structType->parameters, virtualType->parameters );
+                }
+                return virtualType;
+        }
+
+        } // namespace
+
         Expression * VirtualCastCore::postmutate( VirtualCastExpr * castExpr ) {
-                assertf( castExpr->get_result(), "Virtual Cast target not found before expansion." );
+                assertf( castExpr->result, "Virtual Cast target not found before expansion." );
 
                 assert( vcast_decl );
                 assert( pvt_decl );
 
-                // Get the base type of the pointer/reference.
-                Type * base;
-                Type * result_type = castExpr->result;
-                if ( PointerType * target = dynamic_cast<PointerType *>( result_type ) ) {
-                        base = target->base;
-                } else if ( ReferenceType * target = dynamic_cast<ReferenceType *>( result_type ) ) {
-                        base = target->base;
-                } else {
+                const Type * vtable_type = getVirtualTableType( castExpr );
+                ObjectDecl * table = vtable_instances.lookup( vtable_type );
+                if ( nullptr == table ) {
                         SemanticError( castLocation( castExpr ),
-                                "Virtual cast type must be a pointer or reference type." );
-                }
-
-                StructInstType * target_struct = dynamic_cast<StructInstType *>( base );
-                if ( nullptr == target_struct ) {
-                        SemanticError( castLocation( castExpr ),
-                                "Virtual cast type must refer to a structure type." );
-                }
-                StructDecl * target_decl = target_struct->get_baseStruct();
-
-                std::map<std::string, ObjectDecl *>::iterator found =
-                        vtable_instances.find( get_vtable_inst_name( target_decl->get_name() ) );
-                if ( vtable_instances.end() == found ) {
-                        SemanticError( castLocation( castExpr ),
-                                "Virtual cast type does not have a virtual table instance." );
-                }
-                ObjectDecl * table = found->second;
+                                "Could not find virtual table instance." );
+                }
 
                 Expression * result = new CastExpr(
@@ -174 +245 @@
                 castExpr->set_result( nullptr );
                 delete castExpr;
+                delete vtable_type;
                 return result;
         }

tests/.expect/alloc.txt

@@ -30 +30 @@
 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 
 CFA realloc array alloc, fill
-0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 
+0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 
 CFA realloc array alloc, fill
 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 
 CFA realloc array alloc, fill
-0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 
+0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 
 
 C   memalign 42 42.5