Diff [7a8011331cd3137af75be1b83777c648932350ce:1c507ebe808ee009690c5d37d901d8c25ab95fd5] for / – Cforall

Jenkinsfile

-              r7a80113
+              r1c507eb
                 echo GitLogMessage()
+                // This is a complete hack but it solves problems with automake thinking it needs to regenerate makefiles
+                // We fudged automake/missing to handle that but automake stills bakes prints inside the makefiles
+                // and these cause more problems.
+                sh 'find . -name Makefile.in -exec touch {} +'
+        }
+}
 …
                                         description: 'Which compiler to use',                                   \
                                         name: 'Compiler',                                                                       \
                                         choices: 'gcc-9\ngcc-8\ngcc-7\ngcc-6\ngcc-5\ngcc-4.9\nclang',   \
+                                        choices: 'gcc-9\ngcc-8\ngcc-7\ngcc-6\ngcc-5\ngcc-4.9\nclang',                                   \
                                         defaultValue: 'gcc-8',                                                          \
                                 ],                                                                                              \

benchmark/io/http/filecache.cfa

-              r7a80113
+              r1c507eb
         cache_line * entries;
         size_t size;
-        int * rawfds;
-        int nfds;
 } file_cache;
 …
+}
 int put_file( cache_line & entry, int fd ) {
+int put_file( cache_line & entry ) {
         uint32_t idx = murmur3_32( (const uint8_t *)entry.file, strlen(entry.file), options.file_cache.hash_seed ) % file_cache.size;
 …
         file_cache.entries[idx] = entry;
-        file_cache.entries[idx].fd = fd;
         return i > 0 ? 1 : 0;
+}
 …
         size_t fcount = 0;
         size_t fsize = 16;
+        cache_line * raw = alloc(fsize);
+        cache_line * raw = 0p;
+        raw = alloc(raw, fsize, true);
         // Step 1 get a dense array of all files
         int walk(const char *fpath, const struct stat *sb, int typeflag) {
 …
                 if(fcount > fsize) {
                         fsize *= 2;
                         raw = alloc(fsize, raw`realloc);
+                        raw = alloc(raw, fsize, true);
+                }
 …
         file_cache.entries = anew(file_cache.size);
-        if(options.file_cache.fixed_fds) {
-                file_cache.nfds   = fcount;
-                file_cache.rawfds = alloc(fcount);
+        }
         // Step 3 fill the cache
         int conflicts = 0;
         for(i; fcount) {
+                int fd;
+                if(options.file_cache.fixed_fds) {
+                        file_cache.rawfds[i] = raw[i].fd;
+                        fd = i;
+                }
+                else {
+                        fd = raw[i].fd;
+                }
+                conflicts += put_file( raw[i], fd );
+                conflicts += put_file( raw[i] );
+        }
         printf("Filled cache from path \"%s\" with %zu files\n", path, fcount);
 …
+        }
+        size_t s = file_cache.nfds + extra;
+        int * data = alloc(s, file_cache.rawfds`realloc);
+        return [data, file_cache.nfds];
+        return [aalloc(extra), 0];
+}

benchmark/io/http/main.cfa

-              r7a80113
+              r1c507eb
 #include <kernel.hfa>
 #include <stats.hfa>
-#include <time.hfa>
 #include <thread.hfa>
+#include "channel.hfa"
 #include "filecache.hfa"
 #include "options.hfa"
 #include "worker.hfa"
-extern void register_fixed_files( cluster &, int *, unsigned count );
-Duration default_preemption() {
-        return 0;
+}
 //=============================================================================================
 // Globals
 //=============================================================================================
+channel & wait_connect;
 struct ServerProc {
         processor self;
 …
         // Run Server Cluster
+        {
                 cluster cl = { "Server Cluster", options.clopts.params };
+                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.clopts.instance = &cl;
+                channel chan = { options.clopts.chan_size };
+                &wait_connect = &chan;
                 int pipe_cnt = options.clopts.nworkers * 2;
 …
+                }
-                if(options.file_cache.fixed_fds) {
-                        register_fixed_files(cl, fds, pipe_off);
+                }
+                {
                         ServerProc procs[options.clopts.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
+                                        {
+                                        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];
-                                                workers[i].sockfd  = server_fd;
-                                                workers[i].addr    = (struct sockaddr *)&address;
-                                                workers[i].addrlen = (socklen_t*)&addrlen;
-                                                workers[i].flags   = 0;
+                                        }
                                         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)) {
 …
                                         printf("Shutting Down\n");
+                                }
+                                printf("Acceptor Closed\n");
+                                // Clean-up the workers
+                                for(options.clopts.nworkers) {
+                                        put( wait_connect, -1 );
+                                }
+                        }

benchmark/io/http/options.cfa

-              r7a80113
+              r1c507eb
 ,     // nworkers;
 ,     // flags;
+,    // chan_size;
                 false, // procstats
                 false, // viewhalts
 …
 const char * parse_options( int argc, char * argv[] ) {
+        bool uthrdpo = false;
         bool subthrd = false;
         bool eagrsub = false;
 …
                 {'t', "threads",        "Number of worker threads to use", options.clopts.nworkers},
                 {'b', "accept-backlog", "Maximum number of pending accepts", options.socket.backlog},
+                {'B', "channel-size",   "Maximum number of accepted connection pending", options.clopts.chan_size},
                 {'r', "request_len",    "Maximum number of bytes in the http request, requests with more data will be answered with Http Code 414", options.socket.buflen},
                 {'S', "seed",           "seed to use for hashing", options.file_cache.hash_seed },
                 {'C', "cache-size",     "Size of the cache to use, if set to small, will uses closes power of 2", options.file_cache.size },
                 {'l', "list-files",     "List the files in the specified path and exit", options.file_cache.list, parse_settrue },
+                {'u', "userthread",     "If set, cluster uses user-thread to poll I/O", uthrdpo, parse_settrue },
                 {'s', "submitthread",   "If set, cluster uses polling thread to submit I/O", subthrd, parse_settrue },
                 {'e', "eagersubmit",    "If set, cluster submits I/O eagerly but still aggregates submits", eagrsub, parse_settrue},
 …
         parse_args( argc, argv, opt, opt_cnt, "[OPTIONS]... [PATH]\ncforall http server", left );
+        options.clopts.params.poller_submits = subthrd;
+        options.clopts.params.eager_submits  = eagrsub;
+        if( uthrdpo ) {
+                options.clopts.flags |= CFA_CLUSTER_IO_POLLER_USER_THREAD;
+        }
+        if( subthrd ) {
+                options.clopts.flags |= CFA_CLUSTER_IO_POLLER_THREAD_SUBMITS;
+        }
+        if( eagrsub ) {
+                options.clopts.flags |= CFA_CLUSTER_IO_EAGER_SUBMITS;
+        }
         if( fixedfd ) {
 …
         if( sqkpoll ) {
                 options.clopts.params.poll_submit = true;
+                options.clopts.flags |= CFA_CLUSTER_IO_KERNEL_POLL_SUBMITS;
                 options.file_cache.fixed_fds = true;
+        }
         if( iokpoll ) {
                 options.clopts.params.poll_complete = true;
+                options.clopts.flags |= CFA_CLUSTER_IO_KERNEL_POLL_COMPLETES;
                 options.file_cache.open_flags |= O_DIRECT;
+        }
         options.clopts.params.num_ready = sublen;
+        options.clopts.flags |= (sublen << CFA_CLUSTER_IO_BUFFLEN_OFFSET);
         if( left[0] == 0p ) { return "."; }

benchmark/io/http/options.hfa

-              r7a80113
+              r1c507eb
 #include <stdint.h>
-#include <kernel.hfa>
 struct cluster;
 …
                 int nprocs;
                 int nworkers;
+                io_context_params params;
+                int flags;
+                int chan_size;
                 bool procstats;
                 bool viewhalts;

benchmark/io/http/protocol.cfa

-              r7a80113
+              r1c507eb
 extern "C" {
       int snprintf ( char * s, size_t n, const char * format, ... );
-        #include <linux/io_uring.h>
+}
 #include <string.h>
 #include <errno.h>
-#include "options.hfa"
 const char * http_msgs[] = {
 …
         READ:
         for() {
                 int ret = cfa_read(fd, (void*)it, count, 0, -1`s, 0p, 0p);
                 if(ret == 0 ) return [OK200, true, 0, 0];
+                int ret = cfa_read(fd, it, count);
+                if(ret == 0 ) return [OK200, true, 0p, 0];
                 if(ret < 0 ) {
                         if( errno == EAGAIN || errno == EWOULDBLOCK) continue READ;
 …
                 count -= ret;
                 if( count < 1 ) return [E414, false, 0, 0];
+                if( count < 1 ) return [E414, false, 0p, 0];
+        }
 …
         it = buffer;
         int ret = memcmp(it, "GET /", 5);
         if( ret != 0 ) return [E400, false, 0, 0];
+        if( ret != 0 ) return [E400, false, 0p, 0];
         it += 5;
 …
         ssize_t ret;
         SPLICE1: while(count > 0) {
                 ret = cfa_splice(ans_fd, &offset, pipe[1], 0p, count, SPLICE_F_MOVE | SPLICE_F_MORE, 0, -1`s, 0p, 0p);
+                ret = cfa_splice(ans_fd, &offset, pipe[1], 0p, count, SPLICE_F_MOVE | SPLICE_F_MORE);
                 if( ret < 0 ) {
                         if( errno != EAGAIN && errno != EWOULDBLOCK) continue SPLICE1;
 …
                 size_t in_pipe = ret;
                 SPLICE2: while(in_pipe > 0) {
                         ret = cfa_splice(pipe[0], 0p, fd, 0p, in_pipe, SPLICE_F_MOVE | SPLICE_F_MORE, 0, -1`s, 0p, 0p);
+                        ret = cfa_splice(pipe[0], 0p, fd, 0p, in_pipe, SPLICE_F_MOVE | SPLICE_F_MORE);
                         if( ret < 0 ) {
                                 if( errno != EAGAIN && errno != EWOULDBLOCK) continue SPLICE2;

benchmark/io/http/worker.cfa

-              r7a80113
+              r1c507eb
         CONNECTION:
         for() {
+                int fd = cfa_accept4( this.[sockfd, addr, addrlen, flags], 0, -1`s, 0p, 0p );
+                if(fd < 0) {
+                        if( errno == ECONNABORTED ) break;
+                        abort( "accept error: (%d) %s\n", (int)errno, strerror(errno) );
+                }
+                int fd = take(wait_connect);
+                if (fd < 0) break;
                 printf("New connection %d, waiting for requests\n", fd);
 …
+        }
+}
+//=============================================================================================
+// Acceptor Thread
+//=============================================================================================
+void ?{}( Acceptor & this, int sockfd, struct sockaddr * addr, socklen_t * addrlen, int flags ) {
+        ((thread&)this){ "Acceptor Thread", *options.clopts.instance };
+        this.sockfd  = sockfd;
+        this.addr    = addr;
+        this.addrlen = addrlen;
+        this.flags   = flags;
+}
+void main( Acceptor & this ) {
+        for() {
+                int ret = cfa_accept4( this.[sockfd, addr, addrlen, flags] );
+                if(ret < 0) {
+                        if( errno == ECONNABORTED ) break;
+                        abort( "accept error: (%d) %s\n", (int)errno, strerror(errno) );
+                }
+                printf("New connection accepted\n");
+                put( wait_connect, ret );
+        }
+}

benchmark/io/http/worker.hfa

-              r7a80113
+              r1c507eb
+}
+#include "channel.hfa"
+extern channel & wait_connect;
 //=============================================================================================
 // Worker Thread
 …
 thread Worker {
         int pipe[2];
+};
+void ?{}( Worker & this );
+void main( Worker & );
+//=============================================================================================
+// Acceptor Thread
+//=============================================================================================
+thread Acceptor {
         int sockfd;
         struct sockaddr * addr;
 …
         int flags;
 };
+void ?{}( Worker & this);
+void main( Worker & );
+void ?{}( Acceptor & this, int sockfd, struct sockaddr * addr, socklen_t * addrlen, int flags );
+void main( Acceptor & this );

doc/theses/thierry_delisle_PhD/comp_II/comp_II.tex

-              r7a80113
+              r1c507eb
 \section{Introduction}
 \subsection{\CFA and the \CFA concurrency package}
 \CFA~\cite{Moss18} is a modern, polymorphic, non-object-oriented, concurrent, backwards-compatible extension of the C programming language.
+\CFA\cite{Moss18} is a modern, polymorphic, non-object-oriented, concurrent, backwards-compatible extension of the C programming language.
 It aims to add high-productivity features while maintaining the predictable performance of C.
 As such, concurrency in \CFA~\cite{Delisle19} aims to offer simple and safe high-level tools while still allowing performant code.
 \CFA concurrent code is written in the synchronous programming paradigm but uses \glspl{uthrd} to achieve the simplicity and maintainability of synchronous programming without sacrificing the efficiency of asynchronous programming.
+As such, concurrency in \CFA\cite{Delisle19} aims to offer simple and safe high-level tools while still allowing performant code.
+\CFA concurrent code is written in the synchronous programming paradigm but uses \glspl{uthrd} in order to achieve the simplicity and maintainability of synchronous programming without sacrificing the efficiency of asynchronous programming.
 As such, the \CFA \newterm{scheduler} is a preemptive user-level scheduler that maps \glspl{uthrd} onto \glspl{kthrd}.
-\subsection{Scheduling}
 \newterm{Scheduling} occurs when execution switches from one thread to another, where the second thread is implicitly chosen by the scheduler.
 This scheduling is an indirect handoff, as opposed to generators and coroutines that explicitly switch to the next generator and coroutine respectively.
+This scheduling is an indirect handoff, as opposed to generators and coroutines which explicitly switch to the next generator and coroutine respectively.
 The cost of switching between two threads for an indirect handoff has two components:
 \begin{enumerate}
 …
 and the cost of scheduling, \ie deciding which thread to run next among all the threads ready to run.
 \end{enumerate}
 The first cost is generally constant\footnote{Affecting the constant context-switch cost is whether it is done in one step, where the first thread schedules the second, or in two steps, where the first thread context switches to a third scheduler thread.}, while the scheduling cost can vary based on the system state.
 Adding multiple \glspl{kthrd} does not fundamentally change the scheduler semantics or requirements, it simply adds new correctness requirements, \ie \newterm{linearizability}\footnote{Meaning however fast the CPU threads run, there is an equivalent sequential order that gives the same result.}, and a new dimension to performance: scalability, where scheduling cost also depends on contention.
+The first cost is generally constant and fixed\footnote{Affecting the constant context-switch cost is whether it is done in one step, after the scheduling, or in two steps, context-switching to a third fixed thread before scheduling.}, while the scheduling cost can vary based on the system state.
+Adding multiple \glspl{kthrd} does not fundamentally change the scheduler semantics or requirements, it simply adds new correctness requirements, \ie \newterm{linearizability}\footnote{Meaning, however fast the CPU threads run, there is an equivalent sequential order that gives the same result.}, and a new dimension to performance: scalability, where scheduling cost now also depends on contention.
 The more threads switch, the more the administration cost of scheduling becomes noticeable.
 It is therefore important to build a scheduler with the lowest possible cost and latency.
 Another important consideration is \newterm{fairness}.
 In principle, scheduling should give the illusion of perfect fairness, where all threads ready to run are running \emph{simultaneously}.
-In practice, there can be advantages to unfair scheduling, similar to the express cash register at a grocery store.
 While the illusion of simultaneity is easier to reason about, it can break down if the scheduler allows too much unfairness.
 Therefore, the scheduler should offer as much fairness as needed to guarantee eventual progress, but use unfairness to help performance.
+\subsection{Research Goal}
 The goal of this research is to produce a scheduler that is simple for programmers to understand and offers good general performance.
+In practice, threads must wait in turn but there can be advantages to unfair scheduling, similar to the express cash register at a grocery store.
+The goal of this research is to produce a scheduler that is simple for programmers to understand and offers good performance.
 Here understandability does not refer to the API but to how much scheduling concerns programmers need to take into account when writing a \CFA concurrent package.
 Therefore, the main consequence of this goal is :
+Therefore, the main goal of this proposal is :
 \begin{quote}
 The \CFA scheduler should be \emph{viable} for \emph{any} workload.
 \end{quote}
 For a general-purpose scheduler, it is impossible to produce an optimal algorithm as that requires knowledge of the future behaviour of threads.
 As such, scheduling performance is generally either defined by a best-case scenario, \ie a workload to which the scheduler is tailored, or a worst-case scenario, \ie the scheduler behaves no worse than \emph{X}.
+For a general-purpose scheduler, it is impossible to produce an optimal algorithm as it would require knowledge of the future behaviour of threads.
+As such, scheduling performance is generally either defined by the best-case scenario, \ie a workload to which the scheduler is tailored, or the worst-case scenario, \ie the scheduler behaves no worse than \emph{X}.
 For this proposal, the performance is evaluated using the second approach to allow \CFA programmers to rely on scheduling performance.
 Because there is no optimal scheduler, ultimately \CFA may allow programmers to write their own scheduler; but that is not the subject of this proposal, which considers only the default scheduler.
 …
         \item creating an abstraction layer over the operating system to handle kernel-threads spinning unnecessarily,
         \item scheduling blocking I/O operations,
         \item and writing sufficient library tools to allow developers to indirectly use the scheduler, either through tuning knobs in the default scheduler or replacing the default scheduler.
+        \item and writing sufficient library tools to allow developers to indirectly use the scheduler, either through tuning knobs or replacing the default scheduler.
 \end{enumerate}
 …
 \paragraph{Performance} The performance of a scheduler can generally be measured in terms of scheduling cost, scalability and latency.
 \newterm{Scheduling cost} is the cost to switch from one thread to another, as mentioned above.
+For compute-bound concurrent applications with little context switching, the scheduling cost is negligible.
+For applications with high context-switch rates, scheduling cost can begin to dominating the cost.
+\newterm{Scalability} is the cost of adding multiple kernel threads.
+It can increase the time for scheduling because of contention from the multiple threads accessing shared resources, \eg a single ready queue.
+For simple applications, where a single kernel thread does most of the scheduling, it is generally the dominating cost.
+\newterm{Scalability} is the cost of adding multiple kernel threads because it increases the time for context switching because of contention by multiple threads accessing shared resources, \eg the ready queue.
 Finally, \newterm{tail latency} is service delay and relates to thread fairness.
 Specifically, latency measures how long a thread waits to run once scheduled and is evaluated by the worst case.
+Specifically, latency measures how long a thread waits to run once scheduled and is evaluated in the worst case.
 The \CFA scheduler should offer good performance for all three metrics.
 …
 \newterm{Eventual progress} guarantees every scheduled thread is eventually run, \ie prevent starvation.
 As a hard requirement, the \CFA scheduler must guarantee eventual progress, otherwise the above-mentioned illusion of simultaneous execution is broken and the scheduler becomes much more complex to reason about.
 \newterm{Predictability} and \newterm{reliability} mean similar workloads achieve similar performance so programmer execution intuition is respected.
+\newterm{Predictability} and \newterm{reliability} mean similar workloads achieve similar performance and programmer execution intuition is respected.
 For example, a thread that yields aggressively should not run more often than other threads.
 While this is intuitive, it does not hold true for many work-stealing or feedback based schedulers.
 The \CFA scheduler must guarantee eventual progress, should be predictable, and offer reliable performance.
+The \CFA scheduler must guarantee eventual progress and should be predictable and offer reliable performance.
 \paragraph{Efficiency} Finally, efficient usage of CPU resources is also an important requirement and is discussed in depth towards the end of the proposal.
 \newterm{Efficiency} means avoiding using CPU cycles when there are no threads to run (conserve energy/heat), and conversely, using as many available CPU cycles when the workload can benefit from it.
+\newterm{Efficiency} means avoiding using CPU cycles when there are no threads to run, and conversely, use all CPUs available when the workload can benefit from it.
 Balancing these two states is where the complexity lies.
 The \CFA scheduler should be efficient with respect to the underlying (shared) computer.
 …
 \begin{enumerate}
         \item Threads live long enough for useful feedback information to be gathered.
         \item Threads belong to multiple users so fairness across users is largely invisible.
+        \item Threads belong to multiple users so fairness across threads is insufficient.
 \end{enumerate}
 …
 Security concerns mean more precise and robust fairness metrics must be used to guarantee fairness across processes created by users as well as threads created within a process.
 In the case of the \CFA scheduler, every thread runs in the same user space and is controlled by the same user.
+Fairness across threads is therefore a given and it is then possible to safely ignore the possibility that threads are malevolent.
+This approach allows for a much simpler fairness metric, and in this proposal, \emph{fairness} is defined as:
+\begin{quote}
+When multiple threads are cycling through the system, the total ordering of threads being scheduled, \ie pushed onto the ready queue, should not differ much from the total ordering of threads being executed, \ie popped from the ready queue.
+\end{quote}
+Fairness across users is therefore a given and it is then possible to safely ignore the possibility that threads are malevolent.
+This approach allows for a much simpler fairness metric and in this proposal \emph{fairness} is defined as: when multiple threads are cycling through the system, the total ordering of threads being scheduled, \ie pushed onto the ready queue, should not differ much from the total ordering of threads being executed, \ie popped from the ready queue.
 Since feedback is not necessarily feasible within the lifetime of all threads and a simple fairness metric can be used, the scheduling strategy proposed for the \CFA runtime does not use per-threads feedback.
 …
 Threads with equal priority are scheduled using a secondary strategy, often something simple like round robin or FIFO.
 A consequence of priority is that, as long as there is a thread with a higher priority that desires to run, a thread with a lower priority does not run.
 The potential for thread starvation dramatically increases programming complexity since starving threads and priority inversion (prioritizing a lower priority thread) can both lead to serious problems.
+This possible starving of threads can dramatically increase programming complexity since starving threads and priority inversion (prioritizing a lower priority thread) can both lead to serious problems.
 An important observation is that threads do not need to have explicit priorities for problems to occur.
 Indeed, any system with multiple ready queues that attempts to exhaust one queue before accessing the other queues, essentially provides implicit priority, which can encounter starvation problems.
+Indeed, any system with multiple ready queues that attempts to exhaust one queue before accessing the other queues, essentially provide implicit priority, which can encounter starvation problems.
 For example, a popular scheduling strategy that suffers from implicit priorities is work stealing.
 \newterm{Work stealing} is generally presented as follows:
 …
         \item If a processor's ready queue is empty, attempt to run threads from some other processor's ready queue.
 \end{enumerate}
 In a loaded system\footnote{A \newterm{loaded system} is a system where threads are being run at the same rate they are scheduled.}, if a thread does not yield, block, or preempt for an extended period of time, threads on the same processor's list starve if no other processors exhaust their list.
 Since priorities can be complex for programmers to incorporate into their execution intuition, the \CFA scheduling strategy does not provided explicit priorities and attempts to eliminate implicit priorities.
+Since priorities can be complex for programmers to incorporate into their execution intuition, the scheduling strategy proposed for the \CFA runtime does not use a strategy with either implicit or explicit thread priorities.
 \subsection{Schedulers without feedback or priorities}
 This proposal conjectures that it is possible to construct a default scheduler for the \CFA runtime that offers good scalability and a simple fairness guarantee that is easy for programmers to reason about.
 The simplest fairness guarantee is FIFO ordering, \ie threads scheduled first come first.
+The simplest fairness guarantee is FIFO ordering, \ie threads scheduled first run first.
 However, enforcing FIFO ordering generally conflicts with scalability across multiple processors because of the additional synchronization.
 Thankfully, strict FIFO is not needed for sufficient fairness.
 Since concurrency is inherently non-deterministic, fairness concerns in scheduling are only a problem if a thread repeatedly runs before another thread can run.
 Some relaxation is possible because non-determinism means programmers already handle ordering problems to produce correct code and hence rely on weak guarantees, \eg that a thread \emph{eventually} runs.
+Some relaxation is possible because non-determinism means programmers already handle ordering problems to produce correct code and hence rely on weak guarantees, \eg that a specific thread will \emph{eventually} run.
 Since some reordering does not break correctness, the FIFO fairness guarantee can be significantly relaxed without causing problems.
 For this proposal, the target guarantee is that the \CFA scheduler provides \emph{probable} FIFO ordering, which allows reordering but makes it improbable that threads are reordered far from their position in total ordering.
 The \CFA scheduler fairness is defined as follows:
 \begin{quote}
 Given two threads $X$ and $Y$, the odds that thread $X$ runs $N$ times \emph{after} thread $Y$ is scheduled but \emph{before} it is run, decreases exponentially with regard to $N$.
 \end{quote}
+\begin{itemize}
+        \item Given two threads $X$ and $Y$, the odds that thread $X$ runs $N$ times \emph{after} thread $Y$ is scheduled but \emph{before} it is run, decreases exponentially with regard to $N$.
+\end{itemize}
 While this is not a bounded guarantee, the probability that unfairness persist for long periods of times decreases exponentially, making persisting unfairness virtually impossible.
 …
 The described queue uses an array of underlying strictly FIFO queues as shown in Figure~\ref{fig:base}\footnote{For this section, the number of underlying queues is assumed to be constant.
 Section~\ref{sec:resize} discusses resizing the array.}.
 Pushing new data is done by selecting one of the underlying queues at random, recording a timestamp for the operation, and pushing to the selected queue.
+Pushing new data is done by selecting one of these underlying queues at random, recording a timestamp for the operation and pushing to the selected queue.
 Popping is done by selecting two queues at random and popping from the queue with the oldest timestamp.
 A higher number of underlying queues leads to less contention on each queue and therefore better performance.
+A higher number of underlying queues lead to less contention on each queue and therefore better performance.
 In a loaded system, it is highly likely the queues are non-empty, \ie several threads are on each of the underlying queues.
 For this case, selecting a queue at random to pop from is highly likely to yield a queue with available items.
+This means that selecting a queue at random to pop from is highly likely to yield a queue with available items.
 In Figure~\ref{fig:base}, ignoring the ellipsis, the chances of getting an empty queue is 2/7 per pick, meaning two random picks yield an item approximately 9 times out of 10.
 …
                 \input{base.pstex_t}
         \end{center}
         \caption{Loaded relaxed FIFO list base on an array of strictly FIFO lists.
         A timestamp appears in each node and array cell.}
+        \caption{Relaxed FIFO list at the base of the scheduler: an array of strictly FIFO lists.
+        The timestamp is in all nodes and cell arrays.}
         \label{fig:base}
 \end{figure}
 …
                 \input{empty.pstex_t}
         \end{center}
         \caption{Unloaded relaxed FIFO list where the array contains many empty cells.}
+        \caption{``More empty'' state of the queue: the array contains many empty cells.}
         \label{fig:empty}
 \end{figure}
 In an unloaded system, several of the queues are empty, so selecting a random queue for popping is less likely to yield a successful selection and more attempts are needed, resulting in a performance degradation.
+When the ready queue is \emph{more empty}, \ie several of the queues are empty, selecting a random queue for popping is less likely to yield a successful selection and more attempts are needed, resulting in a performance degradation.
 Figure~\ref{fig:empty} shows an example with fewer elements, where the chances of getting an empty queue is 5/7 per pick, meaning two random picks yield an item only half the time.
 Since the ready queue is not empty, the pop operation \emph{must} find an element before returning and therefore must retry.
 …
 \end{table}
 Performance can be improved in Table~\ref{tab:perfcases} case~D by adding information to help processors find which inner queues are used.
+Performance can be improved in case~D (Table~\ref{tab:perfcases}) by adding information to help processors find which inner queues are used.
 This addition aims to avoid the cost of retrying the pop operation but does not affect contention on the underlying queues and can incur some management cost for both push and pop operations.
 The approach used to encode this information can vary in density and be either global or local.
 …
 With a multi-word bitmask, this maximum limit can be increased arbitrarily, but it is not possible to check if the queue is empty by reading the bitmask atomically.
 Finally, a dense bitmap, either single or multi-word, causes additional problems in Table~\ref{tab:perfcases} case C, because many processors are continuously scanning the bitmask to find the few available threads.
+Finally, a dense bitmap, either single or multi-word, causes additional problems in case C (Table 1), because many processors are continuously scanning the bitmask to find the few available threads.
 This increased contention on the bitmask(s) reduces performance because of cache misses after updates and the bitmask is updated more frequently by the scanning processors racing to read and/or update that information.
 This increased update frequency means the information in the bitmask is more often stale before a processor can use it to find an item, \ie mask read says there are available user threads but none on queue.
 …
 \begin{figure}
         \begin{center}
+                {\resizebox{0.73\textwidth}{!}{\input{emptybit}}}
+        \end{center}
+        \vspace*{-5pt}
+        \caption{Unloaded queue with added bitmask to indicate which array cells have items.}
+                {\resizebox{0.8\textwidth}{!}{\input{emptybit}}}
+        \end{center}
+        \caption{``More empty'' queue with added bitmask to indicate which array cells have items.}
         \label{fig:emptybit}
+        \begin{center}
+                {\resizebox{0.73\textwidth}{!}{\input{emptytree}}}
+        \end{center}
+        \vspace*{-5pt}
+        \caption{Unloaded queue with added binary search tree indicate which array cells have items.}
+\end{figure}
+Figure~\ref{fig:emptytree} shows another approach using a hierarchical tree data-structure to reduce contention and has been shown to work in similar cases~\cite{ellen2007snzi}\footnote{This particular paper seems to be patented in the US.
+How does that affect \CFA? Can I use it in my work?}.
+However, this approach may lead to poorer performance in case~B (Table~\ref{tab:perfcases}) due to the inherent pointer chasing cost and already low contention cost in that case.
+\begin{figure}
+        \begin{center}
+                {\resizebox{0.8\textwidth}{!}{\input{emptytree}}}
+        \end{center}
+        \caption{``More empty'' queue with added binary search tree indicate which array cells have items.}
         \label{fig:emptytree}
+        \begin{center}
+                {\resizebox{0.9\textwidth}{!}{\input{emptytls}}}
+        \end{center}
+        \vspace*{-5pt}
+        \caption{Unloaded queue with added per processor bitmask to indicate which array cells have items.}
+        \label{fig:emptytls}
+\end{figure}
+Figure~\ref{fig:emptytree} shows an approach using a hierarchical tree data-structure to reduce contention and has been shown to work in similar cases~\cite{ellen2007snzi}\footnote{This particular paper seems to be patented in the US.
+How does that affect \CFA? Can I use it in my work?}.
+However, this approach may lead to poorer performance in Table~\ref{tab:perfcases} case~B due to the inherent pointer chasing cost and already low contention cost in that case.
+Figure~\ref{fig:emptytls} shows an approach using dense information, similar to the bitmap, but have each thread keep its own independent copy of it.
+\end{figure}
+Finally, a third approach is to use dense information, similar to the bitmap, but have each thread keep its own independent copy of it.
 While this approach can offer good scalability \emph{and} low latency, the liveliness of the information can become a problem.
 In the simple cases, local copies with empty underlying queues can become stale and end-up not being useful for the pop operation.
+In the simple cases, local copies of which underlying queues are empty can become stale and end-up not being useful for the pop operation.
 A more serious problem is that reliable information is necessary for some parts of this algorithm to be correct.
 As mentioned in this section, processors must know \emph{reliably} whether the list is empty or not to decide if they can return \texttt{NULL} or if they must keep looking during a pop operation.
 Section~\ref{sec:sleep} discusses another case where reliable information is required for the algorithm to be correct.
+\begin{figure}
+        \begin{center}
+                \input{emptytls}
+        \end{center}
+        \caption{``More empty'' queue with added per processor bitmask to indicate which array cells have items.}
+        \label{fig:emptytls}
+\end{figure}
 There is a fundamental tradeoff among these approach.
 Dense global information about empty underlying queues helps zero-contention cases at the cost of the high-contention case.
 Sparse global information helps high-contention cases but increases latency in zero-contention cases to read and ``aggregate'' the information\footnote{Hierarchical structures, \eg binary search tree, effectively aggregate information but follow pointer chains, learning information at each node.
+Dense global information about empty underlying queues helps zero-contention cases at the cost of high-contention case.
+Sparse global information helps high-contention cases but increases latency in zero-contention-cases, to read and ``aggregate'' the information\footnote{Hierarchical structures, \eg binary search tree, effectively aggregate information but follow pointer chains, learning information at each node.
 Similarly, other sparse schemes need to read multiple cachelines to acquire all the information needed.}.
+Finally, dense local information has both the advantages of low latency in zero-contention cases and scalability in high-contention cases.
+However, the information can become stale making it difficult to use to ensure correctness.
+Finally, dense local information has both the advantages of low latency in zero-contention cases and scalability in high-contention cases. However the information can become stale making it difficult to use to ensure correctness.
 The fact that these solutions have these fundamental limits suggest to me a better solution that attempts to combine these properties in an interesting way.
 Also, the lock discussed in Section~\ref{sec:resize} allows for solutions that adapt to the number of processors, which could also prove useful.
 …
 How much scalability is actually needed is highly debatable.
 \emph{libfibre}~\cite{libfibre} has compared favourably to other schedulers in webserver tests~\cite{Karsten20} and uses a single atomic counter in its scheduling algorithm similarly to the proposed bitmask.
+\emph{libfibre}\cite{libfibre} has compared favourably to other schedulers in webserver tests\cite{Karsten20} and uses a single atomic counter in its scheduling algorithm similarly to the proposed bitmask.
 As such, the single atomic instruction on a shared cacheline may be sufficiently performant.
 I have built a prototype of this ready queue in the shape of a data queue, \ie nodes on the queue are structures with a single $int$ representing a thread and intrusive data fields.
 Using this prototype, preliminary performance experiments confirm the expected performance in Table~\ref{tab:perfcases}.
 However, these experiments only offer a hint at the actual performance of the scheduler since threads are involved in more complex operations, \eg threads are not independent of each other: when a thread blocks some other thread must intervene to wake it.
+I have built a prototype of this ready queue in the shape of a data queue, \ie nodes on the queue are structures with a single int representing a thread and intrusive data fields.
+Using this prototype, I ran preliminary performance experiments that confirm the expected performance in Table~\ref{tab:perfcases}.
+However, these experiments only offer a hint at the actual performance of the scheduler since threads form more complex operations than simple integer nodes, \eg threads are not independent of each other, when a thread blocks some other thread must intervene to wake it.
 I have also integrated this prototype into the \CFA runtime, but have not yet created performance experiments to compare results, as creating one-to-one comparisons between the prototype and the \CFA runtime will be complex.
 …
 Threads on a cluster are always scheduled on one of the processors of the cluster.
 Currently, the runtime handles dynamically adding and removing processors from clusters at any time.
 Since this feature is part of the existing design, the proposed scheduler must also support this behaviour.
+Since this is part of the existing design, the proposed scheduler must also support this behaviour.
 However, dynamically resizing a cluster is considered a rare event associated with setup, tear down and major configuration changes.
 This assumption is made both in the design of the proposed scheduler as well as in the original design of the \CFA runtime system.
 As such, the proposed scheduler must honour the correctness of this behaviour but does not have any performance objectives with regard to resizing a cluster.
 That is, the time to add or remove processors and how much this disrupts the performance of other threads is considered a secondary concern since it should be amortized over long periods of times.
+How long adding or removing processors take and how much this disrupts the performance of other threads is considered a secondary concern since it should be amortized over long periods of times.
 However, as mentioned in Section~\ref{sec:queue}, contention on the underlying queues can have a direct impact on performance.
 The number of underlying queues must therefore be adjusted as the number of processors grows or shrinks.
 …
 There are possible alternatives to the reader-writer lock solution.
 This problem is effectively a memory reclamation problem and as such there is a large body of research on the subject~\cite{brown2015reclaiming, michael2004hazard}.
+This problem is effectively a memory reclamation problem and as such there is a large body of research on the subject\cite{michael2004hazard, brown2015reclaiming}.
 However, the reader-write lock-solution is simple and can be leveraged to solve other problems (\eg processor ordering and memory reclamation of threads), which makes it an attractive solution.
 …
 Individual processors always finish scheduling user threads before looking for new work, which means that the last processor to go to sleep cannot miss threads scheduled from inside the cluster (if they do, that demonstrates the ready queue is not linearizable).
 However, this guarantee does not hold if threads are scheduled from outside the cluster, either due to an external event like timers and I/O, or due to a user (or kernel) thread migrating from a different cluster.
 In this case, missed signals can lead to the cluster deadlocking\footnote{Clusters should only deadlock in cases where a \CFA programmer \emph{actually} writes \CFA code that leads to a deadlock.}.
+In this case, missed signals can lead to the cluster deadlocking\footnote{Clusters should only deadlock in cases where a \CFA programmer \emph{actually} write \CFA code that leads to a deadlock.}.
 Therefore, it is important that the scheduling of threads include a mechanism where signals \emph{cannot} be missed.
 For performance reasons, it can be advantageous to have a secondary mechanism that allows signals to be missed in cases where it cannot lead to a deadlock.
+To be safe, this process must include a ``handshake'' where it is guaranteed that either:
+\begin{enumerate}
+\item
+the sleeping processor notices that a user thread is scheduled after the sleeping processor signalled its intent to block or
+\item
+code scheduling threads sees the intent to sleep before scheduling and be able to wake-up the processor.
+\end{enumerate}
+To be safe, this process must include a ``handshake'' where it is guaranteed that either~: the sleeping processor notices that a user thread is scheduled after the sleeping processor signalled its intent to block or code scheduling threads sees the intent to sleep before scheduling and be able to wake-up the processor.
 This matter is complicated by the fact that pthreads and Linux offer few tools to implement this solution and no guarantee of ordering of threads waking up for most of these tools.
 Another important issue is avoiding kernel threads sleeping and waking frequently because there is a significant operating-system cost.
 This scenario happens when a program oscillates between high and low activity, needing most and then few processors.
+This scenario happens when a program oscillates between high and low activity, needing most and then fewer processors.
 A possible partial solution is to order the processors so that the one which most recently went to sleep is woken up.
 This allows other sleeping processors to reach deeper sleep state (when these are available) while keeping ``hot'' processors warmer.
 …
 Processors that are unnecessarily unblocked lead to unnecessary contention, CPU usage, and power consumption, while too many sleeping processors can lead to suboptimal throughput.
 Furthermore, transitions from sleeping to awake and vice versa also add unnecessary latency.
 There is already a wealth of research on the subject~\cite{schillings1996engineering, wiki:thunderherd} and I may use an existing approach for the idle-sleep heuristic in this project, \eg~\cite{Karsten20}.
+There is already a wealth of research on the subject\cite{schillings1996engineering, wiki:thunderherd} and I may use an existing approach for the idle-sleep heuristic in this project, \eg\cite{Karsten20}.
 \subsection{Asynchronous I/O}
 …
 an event-engine to (de)multiplex the operations,
 \item
 and a synchronous interface for users.
+and a synchronous interface for users to use.
 \end{enumerate}
 None of these components currently exist in \CFA and I will need to build all three for this project.
 \paragraph{OS Asynchronous Abstraction}
 One fundamental part for converting blocking I/O operations into non-blocking is having an underlying asynchronous I/O interface to direct the I/O operations.
+\paragraph{OS Abstraction}
+One fundamental part for converting blocking I/O operations into non-blocking ones is having an underlying asynchronous I/O interface to direct the I/O operations.
 While there exists many different APIs for asynchronous I/O, it is not part of this proposal to create a novel API.
 It is sufficient to make one work in the complex context of the \CFA runtime.
 \uC uses the $select$~\cite{select} as its interface, which handles ttys, pipes and sockets, but not disk.
+\uC uses the $select$\cite{select} as its interface, which handles ttys, pipes and sockets, but not disk.
 $select$ entails significant complexity and is being replaced in UNIX operating systems, which make it a less interesting alternative.
 Another popular interface is $epoll$~\cite{epoll}, which is supposed to be cheaper than $select$.
 However, $epoll$ also does not handle the file system and anecdotal evidence suggest it has problems with Linux pipes and ttys.
 A popular cross-platform alternative is $libuv$~\cite{libuv}, which offers asynchronous sockets and asynchronous file system operations (among other features).
+Another popular interface is $epoll$\cite{epoll}, which is supposed to be cheaper than $select$.
+However, $epoll$ also does not handle the file system and anecdotal evidence suggest it has problems with Linux pipes and $TTY$s.
+A popular cross-platform alternative is $libuv$\cite{libuv}, which offers asynchronous sockets and asynchronous file system operations (among other features).
 However, as a full-featured library it includes much more than I need and could conflict with other features of \CFA unless significant effort is made to merge them together.
 A very recent alternative that I am investigating is $io_uring$~\cite{io_uring}.
+A very recent alternative that I am investigating is $io_uring$\cite{io_uring}.
 It claims to address some of the issues with $epoll$ and my early investigating suggests that the claim is accurate.
 $io_uring$ uses a much more general approach where system calls are registered to a queue and later executed by the kernel, rather than relying on system calls to subsequently wait for changes on file descriptors or return an error.
 I believe this approach allows for fewer problems, \eg the manpage for $open$~\cite{open} states:
+$io_uring$ uses a much more general approach where system calls are registered to a queue and later executed by the kernel, rather than relying on system calls to return an error instead of blocking and subsequently waiting for changes on file descriptors.
+I believe this approach allows for fewer problems, \eg the manpage for $open$\cite{open} states:
 \begin{quote}
 Note that [the $O_NONBLOCK$ flag] has no effect for regular files and block devices;
 …
 Since $O_NONBLOCK$ semantics might eventually be implemented, applications should not depend upon blocking behaviour when specifying this flag for regular files and block devices.
 \end{quote}
 This makes approaches based on $select$/$epoll$ less reliable since they may not work for every file descriptors.
 For this reason, I plan to use $io_uring$ as the OS abstraction for the \CFA runtime unless further work encounters a fatal problem.
 However, only a small subset of the features are available in Ubuntu as of April 2020~\cite{wiki:ubuntu-linux}, which will limit performance comparisons.
+This makes approach based on $epoll$/$select$ less reliable since they may not work for every file descriptors.
+For this reason, I plan to use $io_uring$ as the OS abstraction for the \CFA runtime unless further work shows problems I haven't encountered yet.
+However, only a small subset of the features are available in Ubuntu as of April 2020\cite{wiki:ubuntu-linux}, which will limit performance comparisons.
 I do not believe this will affect the comparison result.
 \paragraph{Event Engine}
 Above the OS asynchronous abstraction is the event engine.
+Laying on top of the asynchronous interface layer is the event engine.
 This engine is responsible for multiplexing (batching) the synchronous I/O requests into asynchronous I/O requests and demultiplexing the results to appropriate blocked user threads.
 This step can be straightforward for simple cases, but becomes quite complex when there are thousands of user threads performing both reads and writes, possibly on overlapping file descriptors.
 …
 The interface can be novel but it is preferable to match the existing POSIX interface when possible to be compatible with existing code.
 Matching allows C programs written using this interface to be transparently converted to \CFA with minimal effort.
 Where new functionality is needed, I will add novel interface extensions to fill gaps and provide advanced features.
+Where new functionality is needed, I will create a novel interface to fill gaps and provide advanced features.
 …
 \section{Discussion}
 I believe that runtime system and scheduling are still open topics.
 Many ``state of the art'' production frameworks still use single-threaded event loops because of performance considerations, \eg~\cite{nginx-design}, and, to my knowledge, no widely available system language offers modern threading facilities.
+Many ``state of the art'' production frameworks still use single-threaded event loops because of performance considerations, \eg \cite{nginx-design}, and, to my knowledge, no widely available system language offers modern threading facilities.
 I believe the proposed work offers a novel runtime and scheduling package, where existing work only offers fragments that users must assemble themselves when possible.

libcfa/configure.ac

-              r7a80113
+              r1c507eb
 AH_TEMPLATE([CFA_HAVE_IORING_OP_PROVIDE_BUFFERS],[Defined if io_uring support is present when compiling libcfathread and supports the operation IORING_OP_PROVIDE_BUFFERS.])
 AH_TEMPLATE([CFA_HAVE_IORING_OP_REMOVE_BUFFER],[Defined if io_uring support is present when compiling libcfathread and supports the operation IORING_OP_REMOVE_BUFFER.])
-AH_TEMPLATE([CFA_HAVE_IORING_OP_TEE],[Defined if io_uring support is present when compiling libcfathread and supports the operation IORING_OP_TEE.])
 AH_TEMPLATE([CFA_HAVE_IOSQE_FIXED_FILE],[Defined if io_uring support is present when compiling libcfathread and supports the flag FIXED_FILE.])
 AH_TEMPLATE([CFA_HAVE_IOSQE_IO_DRAIN],[Defined if io_uring support is present when compiling libcfathread and supports the flag IO_DRAIN.])
 …
 AH_TEMPLATE([CFA_HAVE_SPLICE_F_FD_IN_FIXED],[Defined if io_uring support is present when compiling libcfathread and supports the flag SPLICE_F_FD_IN_FIXED.])
 AH_TEMPLATE([CFA_HAVE_IORING_SETUP_ATTACH_WQ],[Defined if io_uring support is present when compiling libcfathread and supports the flag IORING_SETUP_ATTACH_WQ.])
+AH_TEMPLATE([CFA_HAVE_PREADV2],[Defined if preadv2 support is present when compiling libcfathread.])
+AH_TEMPLATE([CFA_HAVE_PWRITEV2],[Defined if pwritev2 support is present when compiling libcfathread.])
+AH_TEMPLATE([CFA_HAVE_PWRITEV2],[Defined if pwritev2 support is present when compiling libcfathread.])
+AH_TEMPLATE([CFA_HAVE_STATX],[Defined if statx support is present when compiling libcfathread.])
+AH_TEMPLATE([CFA_HAVE_OPENAT2],[Defined if openat2 support is present when compiling libcfathread.])
+AH_TEMPLATE([HAVE_PREADV2],[Defined if preadv2 support is present when compiling libcfathread.])
+AH_TEMPLATE([HAVE_PWRITEV2],[Defined if pwritev2 support is present when compiling libcfathread.])
 AH_TEMPLATE([__CFA_NO_STATISTICS__],[Defined if libcfathread was compiled without support for statistics.])
 define(ioring_ops, [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,IORING_OP_TEE])
+define(ioring_ops, [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])
 define(ioring_flags, [IOSQE_FIXED_FILE,IOSQE_IO_DRAIN,IOSQE_ASYNC,IOSQE_IO_LINK,IOSQE_IO_HARDLINK,SPLICE_F_FD_IN_FIXED,IORING_SETUP_ATTACH_WQ])
 …
         ])
 ])
+AC_CHECK_FUNC([preadv2], [AC_DEFINE([CFA_HAVE_PREADV2])])
+AC_CHECK_FUNC([pwritev2], [AC_DEFINE([CFA_HAVE_PWRITEV2])])
+AC_CHECK_FUNCS([preadv2 pwritev2])
 AC_CONFIG_FILES([
 …
         prelude/Makefile
         ])
-AC_CONFIG_FILES([src/concurrency/io/call.cfa], [python3 ${srcdir}/src/concurrency/io/call.cfa.in > src/concurrency/io/call.cfa])
 AC_CONFIG_HEADERS(prelude/defines.hfa)

libcfa/prelude/defines.hfa.in

-              r7a80113
+              r1c507eb
 /* Defined if io_uring support is present when compiling libcfathread and
-   supports the operation IORING_OP_TEE. */
-#undef CFA_HAVE_IORING_OP_TEE
-/* Defined if io_uring support is present when compiling libcfathread and
    supports the operation IORING_OP_TIMEOUT. */
 #undef CFA_HAVE_IORING_OP_TIMEOUT
 …
 #undef CFA_HAVE_LINUX_IO_URING_H
-/* Defined if openat2 support is present when compiling libcfathread. */
-#undef CFA_HAVE_OPENAT2
-/* Defined if preadv2 support is present when compiling libcfathread. */
-#undef CFA_HAVE_PREADV2
-/* Defined if pwritev2 support is present when compiling libcfathread. */
-#undef CFA_HAVE_PWRITEV2
 /* Defined if io_uring support is present when compiling libcfathread and
    supports the flag SPLICE_F_FD_IN_FIXED. */
 #undef CFA_HAVE_SPLICE_F_FD_IN_FIXED
-/* Defined if statx support is present when compiling libcfathread. */
-#undef CFA_HAVE_STATX
 /* Location of include files. */
 #undef CFA_INCDIR
 …
 #undef HAVE_MEMORY_H
+/* Define to 1 if you have the `preadv2' function. */
+#undef HAVE_PREADV2
+/* Define to 1 if you have the `pwritev2' function. */
+#undef HAVE_PWRITEV2
 /* Define to 1 if you have the <stdint.h> header file. */
 #undef HAVE_STDINT_H

libcfa/src/Makefile.am

-              r7a80113
+              r1c507eb
         iterator.hfa \
         limits.hfa \
-        memory.hfa \
         parseargs.hfa \
         rational.hfa \
 …
         concurrency/io/setup.cfa \
         concurrency/io/types.hfa \
         concurrency/io/call.cfa \
+        concurrency/iocall.cfa \
         concurrency/iofwd.hfa \
         concurrency/kernel_private.hfa \

libcfa/src/bits/locks.hfa

-              r7a80113
+              r1c507eb
                                 struct oneshot * expected = this.ptr;
                                 // was this abandoned?
+                                #if defined(__GNUC__) && __GNUC__ >= 7
+                                        #pragma GCC diagnostic push
+                                        #pragma GCC diagnostic ignored "-Wfree-nonheap-object"
+                                #endif
+                                        if( expected == 3p ) { free( &this ); return false; }
+                                #if defined(__GNUC__) && __GNUC__ >= 7
+                                        #pragma GCC diagnostic pop
+                                #endif
+                                if( expected == 3p ) { free( &this ); return false; }
                                 /* paranoid */ verify( expected != 1p ); // Future is already fulfilled, should not happen

libcfa/src/concurrency/coroutine.cfa

-              r7a80113
+              r1c507eb
 //-----------------------------------------------------------------------------
-FORALL_DATA_INSTANCE(CoroutineCancelled,
-                (dtype coroutine_t | sized(coroutine_t)), (coroutine_t))
-struct __cfaehm_node {
-        struct _Unwind_Exception unwind_exception;
-        struct __cfaehm_node * next;
-        int handler_index;
-};
-forall(dtype T)
-void mark_exception(CoroutineCancelled(T) *) {}
-forall(dtype T | sized(T))
-void copy(CoroutineCancelled(T) * dst, CoroutineCancelled(T) * src) {
-        dst->the_coroutine = src->the_coroutine;
-        dst->the_exception = src->the_exception;
+}
-forall(dtype T)
-const char * msg(CoroutineCancelled(T) *) {
-        return "CoroutineCancelled(...)";
+}
-// This code should not be inlined. It is the error path on resume.
-forall(dtype T | is_coroutine(T))
-void __cfaehm_cancelled_coroutine( T & cor, $coroutine * desc ) {
-        verify( desc->cancellation );
-        desc->state = Cancelled;
-        exception_t * except = (exception_t *)(1 + (__cfaehm_node *)desc->cancellation);
-        CoroutineCancelled(T) except;
-        except.the_coroutine = &cor;
-        except.the_exception = except;
-        throwResume except;
-        except->virtual_table->free( except );
-        free( desc->cancellation );
-        desc->cancellation = 0p;
+}
-//-----------------------------------------------------------------------------
 // Global state variables
 …
         this->storage->limit = storage;
         this->storage->base  = (void*)((intptr_t)storage + size);
-        this->storage->exception_context.top_resume = 0p;
-        this->storage->exception_context.current_exception = 0p;
         __attribute__((may_alias)) intptr_t * istorage = (intptr_t*)&this->storage;
         *istorage |= userStack ? 0x1 : 0x0;

libcfa/src/concurrency/coroutine.hfa

-              r7a80113
+              r1c507eb
 #include <assert.h>
 #include "invoke.h"
-#include "../exception.hfa"
-//-----------------------------------------------------------------------------
-// Exception thrown from resume when a coroutine stack is cancelled.
-// Should not have to be be sized (see trac #196).
-FORALL_DATA_EXCEPTION(CoroutineCancelled,
-                (dtype coroutine_t | sized(coroutine_t)), (coroutine_t)) (
-        coroutine_t * the_coroutine;
-        exception_t * the_exception;
-);
-forall(dtype T)
-void mark_exception(CoroutineCancelled(T) *);
-forall(dtype T | sized(T))
-void copy(CoroutineCancelled(T) * dst, CoroutineCancelled(T) * src);
-forall(dtype T)
-const char * msg(CoroutineCancelled(T) *);
 //-----------------------------------------------------------------------------
 …
 // Anything that implements this trait can be resumed.
 // Anything that is resumed is a coroutine.
+trait is_coroutine(dtype T | sized(T)
+                | is_resumption_exception(CoroutineCancelled(T))
+                | VTABLE_ASSERTION(CoroutineCancelled, (T))) {
+        void main(T & this);
+        $coroutine * get_coroutine(T & this);
+trait is_coroutine(dtype T) {
+      void main(T & this);
+      $coroutine * get_coroutine(T & this);
 };
 …
+}
-forall(dtype T | is_coroutine(T))
-void __cfaehm_cancelled_coroutine( T & cor, $coroutine * desc );
 // Resume implementation inlined for performance
 forall(dtype T | is_coroutine(T))
 …
         // always done for performance testing
         $ctx_switch( src, dst );
-        if ( unlikely(dst->cancellation) ) {
-                __cfaehm_cancelled_coroutine( cor, dst );
+        }
         return cor;

libcfa/src/concurrency/exception.cfa

-              r7a80113
+              r1c507eb
 STOP_AT_END_FUNCTION(coroutine_cancelstop,
+        struct $coroutine * src = ($coroutine *)stop_param;
+        struct $coroutine * dst = src->last;
+        $ctx_switch( src, dst );
+        // TODO: Instead pass information to the last resumer.
         abort();
+)

libcfa/src/concurrency/exception.hfa

-              r7a80113
+              r1c507eb
 #include "bits/defs.hfa"
 #include "invoke.h"
+struct _Unwind_Exception;
+// It must also be usable as a C header file.
 #ifdef __cforall
 extern "C" {
-#define HIDE_EXPORTS
 #endif
-#include "unwind.h"
 struct exception_context_t * this_exception_context(void) OPTIONAL_THREAD;
 …
 #ifdef __cforall
-#undef HIDE_EXPORTS
+}
 #endif

libcfa/src/concurrency/invoke.h

r7a80113	r1c507eb
68	68	};
69	69
70		enum __Coroutine_State { Halted, Start, Primed, Blocked, Ready, Active~~, Cancelled~~ };
	70	enum __Coroutine_State { Halted, Start, Primed, Blocked, Ready, Active };
71	71
72	72	struct $coroutine {

libcfa/src/concurrency/io.cfa

-              r7a80113
+              r1c507eb
         static inline void process(struct io_uring_cqe & cqe ) {
+                struct io_future_t * future = (struct io_future_t *)(uintptr_t)cqe.user_data;
+                __cfadbg_print_safe( io, "Kernel I/O : Syscall completed : cqe %p, result %d for %p\n", future, cqe.res, data->thrd );
+                fulfil( *future, cqe.res );
+                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;
+                post( data->sem );
+        }

libcfa/src/concurrency/io/types.hfa

-              r7a80113
+              r1c507eb
 #pragma once
+extern "C" {
+        #include <linux/types.h>
+}
+#if defined(CFA_HAVE_LINUX_IO_URING_H)
+        extern "C" {
+                #include <linux/types.h>
+        }
 #include "bits/locks.hfa"
+      #include "bits/locks.hfa"
-#if defined(CFA_HAVE_LINUX_IO_URING_H)
         #define LEADER_LOCK
         struct __leaderlock_t {
 …
         };
+        //-----------------------------------------------------------------------
+        // IO user data
+        struct __io_user_data_t {
+                __s32 result;
+                oneshot sem;
+        };
         //-----------------------------------------------------------------------
         // Misc
 …
         void __ioctx_prepare_block($io_ctx_thread & ctx, struct epoll_event & ev);
 #endif
-//-----------------------------------------------------------------------
-// IO user data
-struct io_future_t {
-        future_t self;
-        __s32 result;
-};
-static inline {
-        bool fulfil( io_future_t & this, __s32 result ) {
-                this.result = result;
-                return fulfil(this.self);
+        }
-        // Wait for the future to be fulfilled
-        bool wait( io_future_t & this ) {
-                return wait(this.self);
+        }
+}

libcfa/src/concurrency/iofwd.hfa

-              r7a80113
+              r1c507eb
 struct cluster;
-struct io_future_t;
 struct io_context;
 struct io_cancellation;
 …
 struct statx;
+//----------
+// synchronous calls
+#if defined(CFA_HAVE_PREADV2)
+        extern ssize_t cfa_preadv2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);
+#endif
+#if defined(CFA_HAVE_PWRITEV2)
+        extern ssize_t cfa_pwritev2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);
+#endif
+extern int cfa_fsync(int fd, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);
+extern int cfa_epoll_ctl(int epfd, int op, int fd, struct epoll_event *event, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);
+extern int cfa_sync_file_range(int fd, off64_t offset, off64_t nbytes, unsigned int flags, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);
+extern  ssize_t cfa_sendmsg(int sockfd, const struct msghdr *msg, int flags, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);
+extern ssize_t cfa_recvmsg(int sockfd, struct msghdr *msg, int flags, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);
+extern ssize_t cfa_send(int sockfd, const void *buf, size_t len, int flags, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);
+extern ssize_t cfa_recv(int sockfd, void *buf, size_t len, int flags, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);
+extern int cfa_accept4(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);
+extern int cfa_connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);
+extern int cfa_fallocate(int fd, int mode, off_t offset, off_t len, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);
+extern int cfa_posix_fadvise(int fd, off_t offset, off_t len, int advice, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);
+extern int cfa_madvise(void *addr, size_t length, int advice, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);
+extern int cfa_openat(int dirfd, const char *pathname, int flags, mode_t mode, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);
+#if defined(CFA_HAVE_OPENAT2)
+        extern int cfa_openat2(int dirfd, const char *pathname, struct open_how * how, size_t size, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);
+#endif
+extern int cfa_close(int fd, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);
+#if defined(CFA_HAVE_STATX)
+        extern int cfa_statx(int dirfd, const char *pathname, int flags, unsigned int mask, struct statx *statxbuf, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);
+#endif
+extern ssize_t cfa_read(int fd, void * buf, size_t count, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);
+extern ssize_t cfa_write(int fd, void * buf, size_t count, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);
+extern 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 submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);
+extern ssize_t cfa_tee(int fd_in, int fd_out, size_t len, unsigned int flags, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);
+//----------
+// asynchronous calls
+#if defined(CFA_HAVE_PREADV2)
+        extern void async_preadv2(io_future_t & future, int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags, int submit_flags, io_cancellation * cancellation, io_context * context);
+#endif
+#if defined(CFA_HAVE_PWRITEV2)
+        extern void async_pwritev2(io_future_t & future, int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags, int submit_flags, io_cancellation * cancellation, io_context * context);
+#endif
+extern void async_fsync(io_future_t & future, int fd, int submit_flags, io_cancellation * cancellation, io_context * context);
+extern void async_epoll_ctl(io_future_t & future, int epfd, int op, int fd, struct epoll_event *event, int submit_flags, io_cancellation * cancellation, io_context * context);
+extern void async_sync_file_range(io_future_t & future, int fd, off64_t offset, off64_t nbytes, unsigned int flags, int submit_flags, io_cancellation * cancellation, io_context * context);
+extern void async_sendmsg(io_future_t & future, int sockfd, const struct msghdr *msg, int flags, int submit_flags, io_cancellation * cancellation, io_context * context);
+extern void async_recvmsg(io_future_t & future, int sockfd, struct msghdr *msg, int flags, int submit_flags, io_cancellation * cancellation, io_context * context);
+extern void async_send(io_future_t & future, int sockfd, const void *buf, size_t len, int flags, int submit_flags, io_cancellation * cancellation, io_context * context);
+extern void async_recv(io_future_t & future, int sockfd, void *buf, size_t len, int flags, int submit_flags, io_cancellation * cancellation, io_context * context);
+extern void async_accept4(io_future_t & future, int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags, int submit_flags, io_cancellation * cancellation, io_context * context);
+extern void async_connect(io_future_t & future, int sockfd, const struct sockaddr *addr, socklen_t addrlen, int submit_flags, io_cancellation * cancellation, io_context * context);
+extern void async_fallocate(io_future_t & future, int fd, int mode, off_t offset, off_t len, int submit_flags, io_cancellation * cancellation, io_context * context);
+extern void async_posix_fadvise(io_future_t & future, int fd, off_t offset, off_t len, int advice, int submit_flags, io_cancellation * cancellation, io_context * context);
+extern void async_madvise(io_future_t & future, void *addr, size_t length, int advice, int submit_flags, io_cancellation * cancellation, io_context * context);
+extern void async_openat(io_future_t & future, int dirfd, const char *pathname, int flags, mode_t mode, int submit_flags, io_cancellation * cancellation, io_context * context);
+#if defined(CFA_HAVE_OPENAT2)
+        extern void async_openat2(io_future_t & future, int dirfd, const char *pathname, struct open_how * how, size_t size, int submit_flags, io_cancellation * cancellation, io_context * context);
+#endif
+extern void async_close(io_future_t & future, int fd, int submit_flags, io_cancellation * cancellation, io_context * context);
+#if defined(CFA_HAVE_STATX)
+        extern void async_statx(io_future_t & future, int dirfd, const char *pathname, int flags, unsigned int mask, struct statx *statxbuf, int submit_flags, io_cancellation * cancellation, io_context * context);
+#endif
+void async_read(io_future_t & future, int fd, void * buf, size_t count, int submit_flags, io_cancellation * cancellation, io_context * context);
+extern void async_write(io_future_t & future, int fd, void * buf, size_t count, int submit_flags, io_cancellation * cancellation, io_context * context);
+extern void async_splice(io_future_t & future, int fd_in, loff_t *off_in, int fd_out, loff_t *off_out, size_t len, unsigned int flags, int submit_flags, io_cancellation * cancellation, io_context * context);
+extern void async_tee(io_future_t & future, int fd_in, int fd_out, size_t len, unsigned int flags, int submit_flags, io_cancellation * cancellation, io_context * context);
+extern ssize_t cfa_preadv2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags, int submit_flags = 0, Duration timeout = -1`s, io_cancellation * cancellation = 0p, io_context * context = 0p);
+extern ssize_t cfa_pwritev2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags, int submit_flags = 0, Duration timeout = -1`s, io_cancellation * cancellation = 0p, io_context * context = 0p);
+extern int cfa_fsync(int fd, int submit_flags = 0, Duration timeout = -1`s, io_cancellation * cancellation = 0p, io_context * context = 0p);
+extern int cfa_sync_file_range(int fd, int64_t offset, int64_t nbytes, unsigned int flags, int submit_flags = 0, Duration timeout = -1`s, io_cancellation * cancellation = 0p, io_context * context = 0p);
+extern ssize_t cfa_sendmsg(int sockfd, const struct msghdr *msg, int flags, int submit_flags = 0, Duration timeout = -1`s, io_cancellation * cancellation = 0p, io_context * context = 0p);
+extern ssize_t cfa_recvmsg(int sockfd, struct msghdr *msg, int flags, int submit_flags = 0, Duration timeout = -1`s, io_cancellation * cancellation = 0p, io_context * context = 0p);
+extern ssize_t cfa_send(int sockfd, const void *buf, size_t len, int flags, int submit_flags = 0, Duration timeout = -1`s, io_cancellation * cancellation = 0p, io_context * context = 0p);
+extern ssize_t cfa_recv(int sockfd, void *buf, size_t len, int flags, int submit_flags = 0, Duration timeout = -1`s, io_cancellation * cancellation = 0p, io_context * context = 0p);
+extern int cfa_accept4(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags, int submit_flags = 0, Duration timeout = -1`s, io_cancellation * cancellation = 0p, io_context * context = 0p);
+extern int cfa_connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen, int submit_flags = 0, Duration timeout = -1`s, io_cancellation * cancellation = 0p, io_context * context = 0p);
+extern int cfa_fallocate(int fd, int mode, uint64_t offset, uint64_t len, int submit_flags = 0, Duration timeout = -1`s, io_cancellation * cancellation = 0p, io_context * context = 0p);
+extern int cfa_fadvise(int fd, uint64_t offset, uint64_t len, int advice, int submit_flags = 0, Duration timeout = -1`s, io_cancellation * cancellation = 0p, io_context * context = 0p);
+extern int cfa_madvise(void *addr, size_t length, int advice, int submit_flags = 0, Duration timeout = -1`s, io_cancellation * cancellation = 0p, io_context * context = 0p);
+extern int cfa_openat(int dirfd, const char *pathname, int flags, mode_t mode, int submit_flags = 0, Duration timeout = -1`s, io_cancellation * cancellation = 0p, io_context * context = 0p);
+extern int cfa_close(int fd, int submit_flags = 0, Duration timeout = -1`s, io_cancellation * cancellation = 0p, io_context * context = 0p);
+extern int cfa_statx(int dirfd, const char *pathname, int flags, unsigned int mask, struct statx *statxbuf, int submit_flags = 0, Duration timeout = -1`s, io_cancellation * cancellation = 0p, io_context * context = 0p);
+extern ssize_t cfa_read(int fd, void *buf, size_t count, int submit_flags = 0, Duration timeout = -1`s, io_cancellation * cancellation = 0p, io_context * context = 0p);
+extern ssize_t cfa_write(int fd, void *buf, size_t count, int submit_flags = 0, Duration timeout = -1`s, io_cancellation * cancellation = 0p, io_context * context = 0p);
+extern 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 submit_flags = 0, Duration timeout = -1`s, io_cancellation * cancellation = 0p, io_context * context = 0p);
+extern ssize_t cfa_tee(int fd_in, int fd_out, size_t len, unsigned int flags, int submit_flags = 0, Duration timeout = -1`s, io_cancellation * cancellation = 0p, io_context * context = 0p);
 //-----------------------------------------------------------------------------

libcfa/src/concurrency/kernel.hfa

-              r7a80113
+              r1c507eb
 extern "C" {
+        #include <bits/pthreadtypes.h>
+        #include <linux/types.h>
+#include <bits/pthreadtypes.h>
+}
 …
 struct io_cancellation {
         __u64 target;
+        uint32_t target;
 };

libcfa/src/concurrency/monitor.cfa

-              r7a80113
+              r1c507eb
         __cfaabi_dbg_print_safe( "Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner);
+        if( unlikely(0 != (0x1 & (uintptr_t)this->owner)) ) {
+                abort( "Attempt by thread \"%.256s\" (%p) to access joined monitor %p.", thrd->self_cor.name, thrd, this );
+        }
+        else if( !this->owner ) {
+        if( !this->owner ) {
                 // No one has the monitor, just take it
                 __set_owner( this, thrd );
 …
+}
 static void __dtor_enter( $monitor * this, fptr_t func, bool join ) {
+static void __dtor_enter( $monitor * this, fptr_t func ) {
         // Lock the monitor spinlock
         lock( this->lock __cfaabi_dbg_ctx2 );
 …
                 return;
+        }
         else if( this->owner == thrd && !join) {
+        else if( this->owner == thrd) {
                 // We already have the monitor... but where about to destroy it so the nesting will fail
                 // Abort!
                 abort( "Attempt to destroy monitor %p by thread \"%.256s\" (%p) in nested mutex.", this, thrd->self_cor.name, thrd );
+        }
-        // SKULLDUGGERY: join will act as a dtor so it would normally trigger to above check
-        // to avoid that it sets the owner to the special value thrd | 1p before exiting
-        else if( this->owner == ($thread*)(1 | (uintptr_t)thrd) ) {
-                // restore the owner and just return
-                __cfaabi_dbg_print_safe( "Kernel : Destroying free mon %p\n", this);
-                // No one has the monitor, just take it
-                this->owner = thrd;
-                verifyf( kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
-                unlock( this->lock );
-                return;
+        }
 …
 // Leave single monitor for the last time
 void __dtor_leave( $monitor * this, bool join ) {
+void __dtor_leave( $monitor * this ) {
         __cfaabi_dbg_debug_do(
                 if( TL_GET( this_thread ) != this->owner ) {
                         abort( "Destroyed monitor %p has inconsistent owner, expected %p got %p.\n", this, TL_GET( this_thread ), this->owner);
+                }
                 if( this->recursion != 1  && !join ) {
+                if( this->recursion != 1 ) {
                         abort( "Destroyed monitor %p has %d outstanding nested calls.\n", this, this->recursion - 1);
+                }
+        )
-        this->owner = ($thread*)(1 | (uintptr_t)this->owner);
+}
 …
+}
-// Join a thread
-forall( dtype T | is_thread(T) )
-T & join( T & this ) {
-        $monitor *    m = get_monitor(this);
-        void (*dtor)(T& mutex this) = ^?{};
-        monitor_dtor_guard_t __guard = { &m, (fptr_t)dtor, true };
+        {
-                return this;
+        }
+}
 // Enter multiple monitor
 // relies on the monitor array being sorted
 …
 // Ctor for monitor guard
 // Sorts monitors before entering
 void ?{}( monitor_dtor_guard_t & this, $monitor * m [], fptr_t func, bool join ) {
+void ?{}( monitor_dtor_guard_t & this, $monitor * m [], fptr_t func ) {
         // optimization
         $thread * thrd = TL_GET( this_thread );
 …
         this.prev = thrd->monitors;
-        // Save whether we are in a join or not
-        this.join = join;
         // Update thread context (needed for conditions)
         (thrd->monitors){m, 1, func};
         __dtor_enter( this.m, func, join );
+        __dtor_enter( this.m, func );
+}
 …
 void ^?{}( monitor_dtor_guard_t & this ) {
         // Leave the monitors in order
         __dtor_leave( this.m, this.join );
+        __dtor_leave( this.m );
         // Restore thread context

libcfa/src/concurrency/monitor.hfa

-              r7a80113
+              r1c507eb
         $monitor *    m;
         __monitor_group_t prev;
-        bool join;
 };
 void ?{}( monitor_dtor_guard_t & this, $monitor ** m, void (*func)(), bool join );
+void ?{}( monitor_dtor_guard_t & this, $monitor ** m, void (*func)() );
 void ^?{}( monitor_dtor_guard_t & this );

libcfa/src/concurrency/thread.hfa

-              r7a80113
+              r1c507eb
 void sleep( Duration duration );
-//----------
-// join
-forall( dtype T | is_thread(T) )
-T & join( T & this );
 // Local Variables: //
 // mode: c //

libcfa/src/exception.h

-              r7a80113
+              r1c507eb
 // implemented in the .c file either so they all have to be inline.
 trait is_exception(dtype exceptT) {
+trait is_exception(dtype T) {
         /* The first field must be a pointer to a virtual table.
          * That virtual table must be a decendent of the base exception virtual tab$
          */
         void mark_exception(exceptT *);
+        void mark_exception(T *);
         // This is never used and should be a no-op.
 };
 trait is_termination_exception(dtype exceptT | is_exception(exceptT)) {
         void defaultTerminationHandler(exceptT &);
+trait is_termination_exception(dtype T | is_exception(T)) {
+        void defaultTerminationHandler(T &);
 };
 trait is_resumption_exception(dtype exceptT | is_exception(exceptT)) {
         void defaultResumptionHandler(exceptT &);
+trait is_resumption_exception(dtype T | is_exception(T)) {
+        void defaultResumptionHandler(T &);
 };
 forall(dtype exceptT | is_termination_exception(exceptT))
 static inline void $throw(exceptT & except) {
+forall(dtype T | is_termination_exception(T))
+static inline void $throw(T & except) {
         __cfaehm_throw_terminate(
                 (exception_t *)&except,
 …
+}
 forall(dtype exceptT | is_resumption_exception(exceptT))
 static inline void $throwResume(exceptT & except) {
+forall(dtype T | is_resumption_exception(T))
+static inline void $throwResume(T & except) {
         __cfaehm_throw_resume(
                 (exception_t *)&except,
 …
+}
 forall(dtype exceptT | is_exception(exceptT))
 static inline void cancel_stack(exceptT & except) __attribute__((noreturn)) {
+forall(dtype T | is_exception(T))
+static inline void cancel_stack(T & except) __attribute__((noreturn)) {
         __cfaehm_cancel_stack( (exception_t *)&except );
+}
 forall(dtype exceptT | is_exception(exceptT))
 static inline void defaultTerminationHandler(exceptT & except) {
+forall(dtype T | is_exception(T))
+static inline void defaultTerminationHandler(T & except) {
         return cancel_stack( except );
+}
 forall(dtype exceptT | is_exception(exceptT))
 static inline void defaultResumptionHandler(exceptT & except) {
+forall(dtype T | is_exception(T))
+static inline void defaultResumptionHandler(T & except) {
         throw except;
+}

libcfa/src/exception.hfa

-              r7a80113
+              r1c507eb
                 size_t size; \
                 void (*copy)(exception_name * this, exception_name * other); \
                 void (*^?{})(exception_name & this); \
+                void (*free)(exception_name & this); \
                 const char * (*msg)(exception_name * this); \
                 _CLOSE
 …
                 size_t size; \
                 void (*copy)(exception_name parameters * this, exception_name parameters * other); \
                 void (*^?{})(exception_name parameters & this); \
+                void (*free)(exception_name parameters & this); \
                 const char * (*msg)(exception_name parameters * this); \
                 _CLOSE

libcfa/src/heap.cfa

-              r7a80113
+              r1c507eb
 // Created On       : Tue Dec 19 21:58:35 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Sep  7 22:17:46 2020
 // Update Count     : 957
+// Last Modified On : Thu Sep  3 16:22:54 2020
+// Update Count     : 943
 //
 …
                 size_t bsize, oalign;
                 headers( "resize", oaddr, header, freeElem, bsize, oalign );
                 size_t odsize = dataStorage( bsize, oaddr, header ); // data storage available in bucket
                 // same size, DO NOT preserve STICKY PROPERTIES.
                 if ( oalign == libAlign() && size <= odsize && odsize <= size * 2 ) { // allow 50% wasted storage for smaller size
+                if ( oalign <= libAlign() && size <= odsize && odsize <= size * 2 ) { // allow 50% wasted storage for smaller size
                         header->kind.real.blockSize &= -2;                      // no alignment and turn off 0 fill
                         header->kind.real.size = size;                          // reset allocation size
 …
                 size_t odsize = dataStorage( bsize, oaddr, header ); // data storage available in bucket
                 size_t osize = header->kind.real.size;                  // old allocation size
                 bool ozfill = (header->kind.real.blockSize & 2); // old allocation zero filled
           if ( unlikely( size <= odsize ) && odsize <= size * 2 ) { // allow up to 50% wasted storage
+                bool ozfill = (header->kind.real.blockSize & 2) != 0; // old allocation zero filled
+          if ( unlikely( size <= odsize ) && size > odsize / 2 ) { // allow up to 50% wasted storage
                         header->kind.real.size = size;                          // reset allocation size
                         if ( unlikely( ozfill ) && size > osize ) {     // previous request zero fill and larger ?
 …
                 void * naddr;
                 if ( likely( oalign == libAlign() ) ) {                 // previous request not aligned ?
+                if ( likely( oalign <= libAlign() ) ) {                 // previous request not aligned ?
                         naddr = mallocNoStats( size );                          // create new area
                 } else {
 …
         } // if
         // Attempt to reuse existing alignment.
+        // Attempt to reuse existing storage.
         HeapManager.Storage.Header * header = headerAddr( oaddr );
+        bool isFakeHeader = header->kind.fake.alignment & 1; // old fake header ?
+        size_t oalign;
+        if ( isFakeHeader ) {
+                oalign = header->kind.fake.alignment & -2;              // old alignment
+                if ( (uintptr_t)oaddr % nalign == 0                             // lucky match ?
+                         && ( oalign <= nalign                                          // going down
+                                  || (oalign >= nalign && oalign <= 256) ) // little alignment storage wasted ?
+                        ) {
+        if ( unlikely ( ( header->kind.fake.alignment & 1 == 1 &&       // old fake header ?
+                                 (uintptr_t)oaddr % nalign == 0 &&                              // lucky match ?
+                                 header->kind.fake.alignment <= nalign &&               // ok to leave LSB at 1
+                                 nalign <= 128 )                                                                // not too much alignment storage wasted ?
+                        ||   ( header->kind.fake.alignment & 1 != 1 &&          // old real header ( aligned on libAlign ) ?
+                                 nalign == libAlign() ) ) ) {                                   // new alignment also on libAlign
+                HeapManager.FreeHeader * freeElem;
+                size_t bsize, oalign;
+                headers( "resize", oaddr, header, freeElem, bsize, oalign );
+                size_t odsize = dataStorage( bsize, oaddr, header ); // data storage available in bucket
+                if ( size <= odsize && odsize <= size * 2 ) { // allow 50% wasted data storage
                         headerAddr( oaddr )->kind.fake.alignment = nalign | 1; // update alignment (could be the same)
+                        HeapManager.FreeHeader * freeElem;
+                        size_t bsize, oalign;
+                        headers( "resize", oaddr, header, freeElem, bsize, oalign );
+                        size_t odsize = dataStorage( bsize, oaddr, header ); // data storage available in bucket
+                        if ( size <= odsize && odsize <= size * 2 ) { // allow 50% wasted data storage
+                                headerAddr( oaddr )->kind.fake.alignment = nalign | 1; // update alignment (could be the same)
+                                header->kind.real.blockSize &= -2;              // turn off 0 fill
+                                header->kind.real.size = size;                  // reset allocation size
+                                return oaddr;
+                        } // if
+                } // if
+        } else if ( ! isFakeHeader                                                      // old real header (aligned on libAlign) ?
+                                && nalign == libAlign() ) {                             // new alignment also on libAlign => no fake header needed
+                return resize( oaddr, size );                                   // duplicate special case checks
+                        header->kind.real.blockSize &= -2;              // turn off 0 fill
+                        header->kind.real.size = size;                  // reset allocation size
+                        return oaddr;
+                } // if
         } // if
 …
         } // if
+        // Attempt to reuse existing alignment.
+        HeapManager.Storage.Header * header = headerAddr( oaddr );
+        bool isFakeHeader = header->kind.fake.alignment & 1; // old fake header ?
+        size_t oalign;
+        if ( isFakeHeader ) {
+                oalign = header->kind.fake.alignment & -2;              // old alignment
+                if ( (uintptr_t)oaddr % nalign == 0                             // lucky match ?
+                         && ( oalign <= nalign                                          // going down
+                                  || (oalign >= nalign && oalign <= 256) ) // little alignment storage wasted ?
+                        ) {
+                        headerAddr( oaddr )->kind.fake.alignment = nalign | 1; // update alignment (could be the same)
+                        return realloc( oaddr, size );                          // duplicate alignment and special case checks
+                } // if
+        } else if ( ! isFakeHeader                                                      // old real header (aligned on libAlign) ?
+                                && nalign == libAlign() )                               // new alignment also on libAlign => no fake header needed
+                return realloc( oaddr, size );                                  // duplicate alignment and special case checks
+        HeapManager.Storage.Header * header;
+        HeapManager.FreeHeader * freeElem;
+        size_t bsize, oalign;
+        headers( "realloc", oaddr, header, freeElem, bsize, oalign );
+        // Attempt to reuse existing storage.
+        if ( unlikely ( ( header->kind.fake.alignment & 1 == 1 &&       // old fake header ?
+                                 (uintptr_t)oaddr % nalign == 0 &&                              // lucky match ?
+                                 header->kind.fake.alignment <= nalign &&               // ok to leave LSB at 1
+                                 nalign <= 128 )                                                                // not too much alignment storage wasted ?
+                        ||   ( header->kind.fake.alignment & 1 != 1 &&          // old real header ( aligned on libAlign ) ?
+                                 nalign == libAlign() ) ) ) {                                   // new alignment also on libAlign
+                headerAddr( oaddr )->kind.fake.alignment = nalign | 1; // update alignment (could be the same)
+                return realloc( oaddr, size );
+        } // if
+        // change size and copy old content to new storage
         #ifdef __STATISTICS__
 …
         #endif // __STATISTICS__
-        HeapManager.FreeHeader * freeElem;
-        size_t bsize;
-        headers( "realloc", oaddr, header, freeElem, bsize, oalign );
-        // change size and copy old content to new storage
         size_t osize = header->kind.real.size;                          // old allocation size
         bool ozfill = (header->kind.real.blockSize & 2);        // old allocation zero filled
+        bool ozfill = (header->kind.real.blockSize & 2) != 0; // old allocation zero filled
         void * naddr = memalignNoStats( nalign, size );         // create new aligned area

src/AST/Convert.cpp

-              r7a80113
+              r1c507eb
+        }
         const ast::Type * postvisit( const ast::BaseInstType * old, ReferenceToType * ty ) {
+        const ast::Type * postvisit( const ast::ReferenceToType * old, ReferenceToType * ty ) {
                 ty->forall = get<TypeDecl>().acceptL( old->forall );
                 ty->parameters = get<Expression>().acceptL( old->params );
 …
+        }
         void postvisit( const ReferenceToType * old, ast::BaseInstType * ty ) {
+        void postvisit( const ReferenceToType * old, ast::ReferenceToType * ty ) {
                 ty->forall = GET_ACCEPT_V( forall, TypeDecl );
                 ty->params = GET_ACCEPT_V( parameters, Expr );

src/AST/Fwd.hpp

r7a80113	r1c507eb
107	107	class QualifiedType;
108	108	class FunctionType;
109		class ~~BaseInst~~Type;
	109	class ReferenceToType;
110	110	template<typename decl_t> class SueInstType;
111	111	using StructInstType = SueInstType<StructDecl>;

src/AST/GenericSubstitution.cpp

r7a80113	r1c507eb
42	42	private:
43	43	// make substitution for generic type
44		void makeSub( const ~~BaseInst~~Type * ty ) {
	44	void makeSub( const ReferenceToType * ty ) {
45	45	visit_children = false;
46	46	const AggregateDecl * aggr = ty->aggr();

src/AST/Node.cpp

-              r7a80113
+              r1c507eb
 template class ast::ptr_base< ast::FunctionType, ast::Node::ref_type::weak >;
 template class ast::ptr_base< ast::FunctionType, ast::Node::ref_type::strong >;
 template class ast::ptr_base< ast::BaseInstType, ast::Node::ref_type::weak >;
 template class ast::ptr_base< ast::BaseInstType, ast::Node::ref_type::strong >;
+template class ast::ptr_base< ast::ReferenceToType, ast::Node::ref_type::weak >;
+template class ast::ptr_base< ast::ReferenceToType, ast::Node::ref_type::strong >;
 template class ast::ptr_base< ast::StructInstType, ast::Node::ref_type::weak >;
 template class ast::ptr_base< ast::StructInstType, ast::Node::ref_type::strong >;

src/AST/Pass.hpp

-              r7a80113
+              r1c507eb
 // | PureVisitor           - makes the visitor pure, it never modifies nodes in place and always
 //                           clones nodes it needs to make changes to
 // | WithConstTypeSubstitution - provides polymorphic const TypeSubstitution * typeSubs for the
+// | WithTypeSubstitution  - provides polymorphic const TypeSubstitution * env for the
 //                           current expression
 // | WithStmtsToAdd        - provides the ability to insert statements before or after the current
 …
 // | WithSymbolTable       - provides symbol table functionality
 // | WithForallSubstitutor - maintains links between TypeInstType and TypeDecl under mutation
-//
-// Other Special Members:
-// | result                - Either a method that takes no parameters or a field. If a method (or
-//                           callable field) get_result calls it, otherwise the value is returned.
 //-------------------------------------------------------------------------------------------------
 template< typename core_t >
 …
         virtual ~Pass() = default;
-        /// Storage for the actual pass.
-        core_t core;
-        /// If the core defines a result, call it if possible, otherwise return it.
-        inline auto get_result() -> decltype( __pass::get_result( core, '0' ) ) {
-                return __pass::get_result( core, '0' );
+        }
         /// Construct and run a pass on a translation unit.
         template< typename... Args >
 …
+        }
-        /// Contruct and run a pass on a pointer to extract a value.
-        template< typename node_type, typename... Args >
-        static auto read( node_type const * node, Args&&... args ) {
-                Pass<core_t> visitor( std::forward<Args>( args )... );
-                node_type const * temp = node->accept( visitor );
-                assert( temp == node );
-                return visitor.get_result();
+        }
-        // Versions of the above for older compilers.
         template< typename... Args >
         static void run( std::list< ptr<Decl> > & decls ) {
 …
+        }
+        template< typename node_type, typename... Args >
+        static auto read( node_type const * node ) {
+                Pass<core_t> visitor;
+                node_type const * temp = node->accept( visitor );
+                assert( temp == node );
+                return visitor.get_result();
+        }
+        /// Storage for the actual pass
+        core_t core;
         /// Visit function declarations
 …
 //-------------------------------------------------------------------------------------------------
+/// Keep track of the polymorphic const TypeSubstitution * env for the current expression
 /// If used the visitor will always clone nodes.
 struct PureVisitor {};
-/// Keep track of the polymorphic const TypeSubstitution * typeSubs for the current expression.
 struct WithConstTypeSubstitution {
         const TypeSubstitution * typeSubs = nullptr;
+        const TypeSubstitution * env = nullptr;
 };

src/AST/Pass.impl.hpp

-              r7a80113
+              r1c507eb
                 __pedantic_pass_assert( expr );
                 const ast::TypeSubstitution ** typeSubs_ptr = __pass::typeSubs( core, 0 );
                 if ( typeSubs_ptr && expr->env ) {
                         *typeSubs_ptr = expr->env;
+                const ast::TypeSubstitution ** env_ptr = __pass::env( core, 0);
+                if ( env_ptr && expr->env ) {
+                        *env_ptr = expr->env;
+                }
 …
                 // These may be modified by subnode but most be restored once we exit this statemnet.
                 ValueGuardPtr< const ast::TypeSubstitution * > __old_env         ( __pass::typeSubs( core, 0 ) );
+                ValueGuardPtr< const ast::TypeSubstitution * > __old_env         ( __pass::env( core, 0) );
                 ValueGuardPtr< typename std::remove_pointer< decltype(stmts_before) >::type > __old_decls_before( stmts_before );
                 ValueGuardPtr< typename std::remove_pointer< decltype(stmts_after ) >::type > __old_decls_after ( stmts_after  );
 …
                 // These may be modified by subnode but most be restored once we exit this statemnet.
                 ValueGuardPtr< const ast::TypeSubstitution * > __old_env( __pass::typeSubs( core, 0 ) );
+                ValueGuardPtr< const ast::TypeSubstitution * > __old_env( __pass::env( core, 0) );
                 ValueGuardPtr< typename std::remove_pointer< decltype(stmts_before) >::type > __old_decls_before( stmts_before );
                 ValueGuardPtr< typename std::remove_pointer< decltype(stmts_after ) >::type > __old_decls_after ( stmts_after  );

src/AST/Pass.proto.hpp

-              r7a80113
+              r1c507eb
         // List of fields and their expected types
         FIELD_PTR( typeSubs, const ast::TypeSubstitution * )
+        FIELD_PTR( env, const ast::TypeSubstitution * )
         FIELD_PTR( stmtsToAddBefore, std::list< ast::ptr< ast::Stmt > > )
         FIELD_PTR( stmtsToAddAfter , std::list< ast::ptr< ast::Stmt > > )
 …
         } // namespace forall
-        template<typename core_t>
-        static inline auto get_result( core_t & core, char ) -> decltype( core.result() ) {
-                return core.result();
+        }
-        template<typename core_t>
-        static inline auto get_result( core_t & core, int ) -> decltype( core.result ) {
-                return core.result;
+        }
-        template<typename core_t>
-        static inline void get_result( core_t &, long ) {}
 } // namespace __pass
 } // namespace ast

src/AST/Print.cpp

r7a80113	r1c507eb
270	270	}
271	271
272		void preprint( const ast::~~BaseInst~~Type * node ) {
	272	void preprint( const ast::ReferenceToType * node ) {
273	273	print( node->forall );
274	274	print( node->attributes );

src/AST/SymbolTable.cpp

-              r7a80113
+              r1c507eb
                 if ( ! expr->result ) continue;
                 const Type * resTy = expr->result->stripReferences();
                 auto aggrType = dynamic_cast< const BaseInstType * >( resTy );
+                auto aggrType = dynamic_cast< const ReferenceToType * >( resTy );
                 assertf( aggrType, "WithStmt expr has non-aggregate type: %s",
                         toString( expr->result ).c_str() );
 …
                         if ( dwt->name == "" ) {
                                 const Type * t = dwt->get_type()->stripReferences();
                                 if ( auto rty = dynamic_cast<const BaseInstType *>( t ) ) {
+                                if ( auto rty = dynamic_cast<const ReferenceToType *>( t ) ) {
                                         if ( ! dynamic_cast<const StructInstType *>(rty)
                                                 && ! dynamic_cast<const UnionInstType *>(rty) ) continue;

src/AST/Type.cpp

-              r7a80113
+              r1c507eb
+}
 // --- BaseInstType
 void BaseInstType::initWithSub( const BaseInstType & o, Pass< ForallSubstitutor > & sub ) {
+// --- ReferenceToType
+void ReferenceToType::initWithSub( const ReferenceToType & o, Pass< ForallSubstitutor > & sub ) {
         ParameterizedType::initWithSub( o, sub ); // initialize substitution
         params = sub.core( o.params );            // apply to parameters
+}
 BaseInstType::BaseInstType( const BaseInstType & o )
+ReferenceToType::ReferenceToType( const ReferenceToType & o )
 : ParameterizedType( o.qualifiers, copy( o.attributes ) ), params(), name( o.name ),
   hoistType( o.hoistType ) {
 …
+}
 std::vector<readonly<Decl>> BaseInstType::lookup( const std::string& name ) const {
+std::vector<readonly<Decl>> ReferenceToType::lookup( const std::string& name ) const {
         assertf( aggr(), "Must have aggregate to perform lookup" );
 …
 SueInstType<decl_t>::SueInstType(
         const decl_t * b, CV::Qualifiers q, std::vector<ptr<Attribute>>&& as )
 : BaseInstType( b->name, q, move(as) ), base( b ) {}
+: ReferenceToType( b->name, q, move(as) ), base( b ) {}
 template<typename decl_t>
 …
 TraitInstType::TraitInstType(
         const TraitDecl * b, CV::Qualifiers q, std::vector<ptr<Attribute>>&& as )
 : BaseInstType( b->name, q, move(as) ), base( b ) {}
+: ReferenceToType( b->name, q, move(as) ), base( b ) {}
 // --- TypeInstType
 TypeInstType::TypeInstType( const TypeInstType & o )
 : BaseInstType( o.name, o.qualifiers, copy( o.attributes ) ), base(), kind( o.kind ) {
+: ReferenceToType( o.name, o.qualifiers, copy( o.attributes ) ), base(), kind( o.kind ) {
         Pass< ForallSubstitutor > sub;
         initWithSub( o, sub );      // initialize substitution

src/AST/Type.hpp

-              r7a80113
+              r1c507eb
 /// base class for types that refer to types declared elsewhere (aggregates and typedefs)
 class BaseInstType : public ParameterizedType {
+class ReferenceToType : public ParameterizedType {
 protected:
         /// Initializes forall and parameters based on substitutor
         void initWithSub( const BaseInstType & o, Pass< ForallSubstitutor > & sub );
+        void initWithSub( const ReferenceToType & o, Pass< ForallSubstitutor > & sub );
 public:
         std::vector<ptr<Expr>> params;
 …
         bool hoistType = false;
         BaseInstType(
+        ReferenceToType(
                 const std::string& n, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} )
         : ParameterizedType(q, std::move(as)), params(), name(n) {}
         BaseInstType( const BaseInstType & o );
+        ReferenceToType( const ReferenceToType & o );
         /// Gets aggregate declaration this type refers to
 …
 private:
         virtual BaseInstType * clone() const override = 0;
+        virtual ReferenceToType * clone() const override = 0;
         MUTATE_FRIEND
 };
 …
 // Common implementation for the SUE instance types. Not to be used directly.
 template<typename decl_t>
 class SueInstType final : public BaseInstType {
+class SueInstType final : public ReferenceToType {
 public:
         using base_type = decl_t;
 …
         SueInstType(
                 const std::string& n, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} )
         : BaseInstType( n, q, std::move(as) ), base() {}
+        : ReferenceToType( n, q, std::move(as) ), base() {}
         SueInstType(
 …
 /// An instance of a trait type.
 class TraitInstType final : public BaseInstType {
+class TraitInstType final : public ReferenceToType {
 public:
         readonly<TraitDecl> base;
 …
         TraitInstType(
                 const std::string& n, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} )
         : BaseInstType( n, q, std::move(as) ), base() {}
+        : ReferenceToType( n, q, std::move(as) ), base() {}
         TraitInstType(
 …
 /// instance of named type alias (typedef or variable)
 class TypeInstType final : public BaseInstType {
+class TypeInstType final : public ReferenceToType {
 public:
         readonly<TypeDecl> base;
 …
                 const std::string& n, const TypeDecl * b, CV::Qualifiers q = {},
                 std::vector<ptr<Attribute>> && as = {} )
         : BaseInstType( n, q, std::move(as) ), base( b ), kind( b->kind ) {}
+        : ReferenceToType( n, q, std::move(as) ), base( b ), kind( b->kind ) {}
         TypeInstType( const std::string& n, TypeDecl::Kind k, CV::Qualifiers q = {},
                 std::vector<ptr<Attribute>> && as = {} )
         : BaseInstType( n, q, std::move(as) ), base(), kind( k ) {}
+        : ReferenceToType( n, q, std::move(as) ), base(), kind( k ) {}
         TypeInstType( const TypeInstType & o );

src/AST/TypeSubstitution.cpp

r7a80113	r1c507eb
176	176	}
177	177
178		void TypeSubstitution::Substituter::handleAggregateType( const ~~BaseInst~~Type * type ) {
	178	void TypeSubstitution::Substituter::handleAggregateType( const ReferenceToType * type ) {
179	179	GuardValue( boundVars );
180	180	// bind type variables from forall-qualifiers

src/AST/TypeSubstitution.hpp

r7a80113	r1c507eb
169	169	void previsit( const ParameterizedType * type );
170	170	/// Records type variable bindings from forall-statements and instantiations of generic types
171		void handleAggregateType( const ~~BaseInst~~Type * type );
	171	void handleAggregateType( const ReferenceToType * type );
172	172
173	173	void previsit( const StructInstType * aggregateUseType );

src/Common/Stats/Stats.cc

-              r7a80113
+              r1c507eb
+        }
-        namespace ResolveTime {
-                bool enabled = false;
+        }
         struct {
                 const char * const opt;
 …
                 { "heap"    , Heap::enabled },
                 { "time"    , Time::enabled },
-                { "resolve" , ResolveTime::enabled },
         };

src/Common/module.mk

-              r7a80113
+              r1c507eb
       Common/ErrorObjects.h \
       Common/Eval.cc \
-      Common/Examine.cc \
-      Common/Examine.h \
       Common/FilterCombos.h \
       Common/Indenter.h \
 …
       Common/Stats/Heap.cc \
       Common/Stats/Heap.h \
-      Common/Stats/ResolveTime.cc \
-      Common/Stats/ResolveTime.h \
       Common/Stats/Stats.cc \
       Common/Stats/Time.cc \

src/Concurrency/Keywords.cc

-              r7a80113
+              r1c507eb
 #include <string>                         // for string, operator==
-#include <iostream>
-#include "Common/Examine.h"               // for isMainFor
 #include "Common/PassVisitor.h"           // for PassVisitor
 #include "Common/SemanticError.h"         // for SemanticError
 …
 #include "SynTree/Type.h"                 // for StructInstType, Type, PointerType
 #include "SynTree/Visitor.h"              // for Visitor, acceptAll
-#include "Virtual/Tables.h"
 class Attribute;
 namespace Concurrency {
-        inline static std::string getVTableName( std::string const & exception_name ) {
-                return exception_name.empty() ? std::string() : Virtual::vtableTypeName(exception_name);
+        }
         //=============================================================================================
         // Pass declarations
 …
           public:
+                ConcurrentSueKeyword( std::string&& type_name, std::string&& field_name,
+                        std::string&& getter_name, std::string&& context_error, std::string&& exception_name,
+                        bool needs_main, AggregateDecl::Aggregate cast_target ) :
+                  type_name( type_name ), field_name( field_name ), getter_name( getter_name ),
+                  context_error( context_error ), vtable_name( getVTableName( exception_name ) ),
+                  needs_main( needs_main ), cast_target( cast_target ) {}
+                ConcurrentSueKeyword( std::string&& type_name, std::string&& field_name, std::string&& getter_name, std::string&& context_error, bool needs_main, AggregateDecl::Aggregate cast_target ) :
+                  type_name( type_name ), field_name( field_name ), getter_name( getter_name ), context_error( context_error ), needs_main( needs_main ), cast_target( cast_target ) {}
                 virtual ~ConcurrentSueKeyword() {}
 …
                 void handle( StructDecl * );
-                void addVtableForward( StructDecl * );
                 FunctionDecl * forwardDeclare( StructDecl * );
                 ObjectDecl * addField( StructDecl * );
 …
                 const std::string getter_name;
                 const std::string context_error;
-                const std::string vtable_name;
                 bool needs_main;
                 AggregateDecl::Aggregate cast_target;
 …
                 StructDecl   * type_decl = nullptr;
                 FunctionDecl * dtor_decl = nullptr;
-                StructDecl * vtable_decl = nullptr;
         };
 …
                         "get_thread",
                         "thread keyword requires threads to be in scope, add #include <thread.hfa>\n",
-                        "",
                         true,
                         AggregateDecl::Thread
 …
                         "get_coroutine",
                         "coroutine keyword requires coroutines to be in scope, add #include <coroutine.hfa>\n",
-                        "CoroutineCancelled",
                         true,
                         AggregateDecl::Coroutine
 …
                         "get_monitor",
                         "monitor keyword requires monitors to be in scope, add #include <monitor.hfa>\n",
-                        "",
                         false,
                         AggregateDecl::Monitor
 …
                         "get_generator",
                         "Unable to find builtin type $generator\n",
-                        "",
                         true,
                         AggregateDecl::Generator
 …
         private:
+                DeclarationWithType * is_main( FunctionDecl * );
                 bool is_real_suspend( FunctionDecl * );
 …
                         handle( decl );
+                }
-                else if ( !vtable_decl && vtable_name == decl->name && decl->body ) {
-                        vtable_decl = decl;
+                }
-                // Might be able to get ride of is target.
-                assert( is_target(decl) == (cast_target == decl->kind) );
                 return decl;
+        }
         DeclarationWithType * ConcurrentSueKeyword::postmutate( FunctionDecl * decl ) {
+                if ( type_decl && isDestructorFor( decl, type_decl ) )
+                        dtor_decl = decl;
+                else if ( vtable_name.empty() )
+                        ;
+                else if ( auto param = isMainFor( decl, cast_target ) ) {
+                        // This should never trigger.
+                        assert( vtable_decl );
+                        // Should be safe because of isMainFor.
+                        StructInstType * struct_type = static_cast<StructInstType *>(
+                                static_cast<ReferenceType *>( param->get_type() )->base );
+                        assert( struct_type );
+                        declsToAddAfter.push_back( Virtual::makeVtableInstance( vtable_decl, {
+                                new TypeExpr( struct_type->clone() ),
+                        }, struct_type, nullptr ) );
+                }
+                if( !type_decl ) return decl;
+                if( !CodeGen::isDestructor( decl->name ) ) return decl;
+                auto params = decl->type->parameters;
+                if( params.size() != 1 ) return decl;
+                auto type = dynamic_cast<ReferenceType*>( params.front()->get_type() );
+                if( !type ) return decl;
+                auto stype = dynamic_cast<StructInstType*>( type->base );
+                if( !stype ) return decl;
+                if( stype->baseStruct != type_decl ) return decl;
+                if( !dtor_decl ) dtor_decl = decl;
                 return decl;
+        }
 …
                 if( !dtor_decl ) SemanticError( decl, context_error );
-                addVtableForward( decl );
                 FunctionDecl * func = forwardDeclare( decl );
                 ObjectDecl * field = addField( decl );
                 addRoutines( field, func );
+        }
-        void ConcurrentSueKeyword::addVtableForward( StructDecl * decl ) {
-                if ( vtable_decl ) {
-                        declsToAddBefore.push_back( Virtual::makeVtableForward( vtable_decl, {
-                                new TypeExpr( new StructInstType( noQualifiers, decl ) ),
-                        } ) );
-                // Its only an error if we want a vtable and don't have one.
-                } else if ( ! vtable_name.empty() ) {
-                        SemanticError( decl, context_error );
+                }
+        }
 …
         // Suspend keyword implementation
         //=============================================================================================
+        DeclarationWithType * SuspendKeyword::is_main( FunctionDecl * func) {
+                if(func->name != "main") return nullptr;
+                if(func->type->parameters.size() != 1) return nullptr;
+                auto param = func->type->parameters.front();
+                auto type  = dynamic_cast<ReferenceType * >(param->get_type());
+                if(!type) return nullptr;
+                auto obj   = dynamic_cast<StructInstType *>(type->base);
+                if(!obj) return nullptr;
+                if(!obj->baseStruct->is_generator()) return nullptr;
+                return param;
+        }
         bool SuspendKeyword::is_real_suspend( FunctionDecl * func ) {
                 if(isMangled(func->linkage)) return false; // the real suspend isn't mangled
 …
                 // Is this the main of a generator?
                 auto param = isMainFor( func, AggregateDecl::Aggregate::Generator );
+                auto param = is_main( func );
                 if(!param) return;
 …
+                                        {
                                                 new SingleInit( new AddressExpr( new VariableExpr( monitors ) ) ),
+                                                new SingleInit( new CastExpr( new VariableExpr( func ), generic_func->clone(), false ) ),
+                                                new SingleInit( new ConstantExpr( Constant::from_bool( false ) ) )
+                                                new SingleInit( new CastExpr( new VariableExpr( func ), generic_func->clone(), false ) )
                                         },
                                         noDesignators,
 …
 // tab-width: 4 //
 // End: //

src/ResolvExpr/CandidateFinder.cpp

-              r7a80113
+              r1c507eb
                 /// Adds aggregate member interpretations
                 void addAggMembers(
                         const ast::BaseInstType * aggrInst, const ast::Expr * expr,
+                        const ast::ReferenceToType * aggrInst, const ast::Expr * expr,
                         const Candidate & cand, const Cost & addedCost, const std::string & name
                 ) {
 …
                 void postvisit( const ast::UntypedOffsetofExpr * offsetofExpr ) {
                         const ast::BaseInstType * aggInst;
+                        const ast::ReferenceToType * aggInst;
                         if (( aggInst = offsetofExpr->type.as< ast::StructInstType >() )) ;
                         else if (( aggInst = offsetofExpr->type.as< ast::UnionInstType >() )) ;

src/ResolvExpr/ConversionCost.cc

r7a80113	r1c507eb
520	520	return convertToReferenceCost( src, refType, srcIsLvalue, symtab, env, localPtrsAssignable );
521	521	} else {
522		return ast::Pass<ConversionCost_new>::read( src, dst, srcIsLvalue, symtab, env, localConversionCost );
	522	ast::Pass<ConversionCost_new> converter( dst, srcIsLvalue, symtab, env, localConversionCost );
	523	src->accept( converter );
	524	return converter.core.cost;
523	525	}
524	526	}
…	…
561	563	}
562	564	} else {
563		return ast::Pass<ConversionCost_new>::read( src, dst, srcIsLvalue, symtab, env, localConversionCost );
	565	ast::Pass<ConversionCost_new> converter( dst, srcIsLvalue, symtab, env, localConversionCost );
	566	src->accept( converter );
	567	return converter.core.cost;
564	568	}
565	569	} else {

src/ResolvExpr/ConversionCost.h

r7a80113	r1c507eb
88	88	static size_t traceId;
89	89	Cost cost;
90		~~Cost result() { return cost; }~~
91	90
92	91	ConversionCost_new( const ast::Type * dst, bool srcIsLvalue, const ast::SymbolTable & symtab,

src/ResolvExpr/CurrentObject.cc

-              r7a80113
+              r1c507eb
         MemberIterator * createMemberIterator( const CodeLocation & loc, const Type * type ) {
                 if ( auto aggr = dynamic_cast< const BaseInstType * >( type ) ) {
+                if ( auto aggr = dynamic_cast< const ReferenceToType * >( type ) ) {
                         if ( auto sit = dynamic_cast< const StructInstType * >( aggr ) ) {
                                 return new StructIterator{ loc, sit };
 …
                                         dynamic_cast< const EnumInstType * >( type )
                                                 || dynamic_cast< const TypeInstType * >( type ),
                                         "Encountered unhandled BaseInstType in createMemberIterator: %s",
+                                        "Encountered unhandled ReferenceToType in createMemberIterator: %s",
                                                 toString( type ).c_str() );
                                 return new SimpleIterator{ loc, type };
 …
                                         DesignatorChain & d = *dit;
                                         PRINT( std::cerr << "____actual: " << t << std::endl; )
                                         if ( auto refType = dynamic_cast< const BaseInstType * >( t ) ) {
+                                        if ( auto refType = dynamic_cast< const ReferenceToType * >( t ) ) {
                                                 // concatenate identical field names
                                                 for ( const Decl * mem : refType->lookup( nexpr->name ) ) {

src/ResolvExpr/Resolver.cc

-              r7a80113
+              r1c507eb
 #include "Common/PassVisitor.h"          // for PassVisitor
 #include "Common/SemanticError.h"        // for SemanticError
-#include "Common/Stats/ResolveTime.h"    // for ResolveTime::start(), ResolveTime::stop()
 #include "Common/utility.h"              // for ValueGuard, group_iterate
 #include "InitTweak/GenInit.h"
 …
                 /// Finds deleted expressions in an expression tree
                 struct DeleteFinder_new final : public ast::WithShortCircuiting {
                         const ast::DeletedExpr * result = nullptr;
+                        const ast::DeletedExpr * delExpr = nullptr;
                         void previsit( const ast::DeletedExpr * expr ) {
                                 if ( result ) { visit_children = false; }
                                 else { result = expr; }
+                                if ( delExpr ) { visit_children = false; }
+                                else { delExpr = expr; }
+                        }
                         void previsit( const ast::Expr * ) {
                                 if ( result ) { visit_children = false; }
+                                if ( delExpr ) { visit_children = false; }
+                        }
                 };
 …
         /// Check if this expression is or includes a deleted expression
         const ast::DeletedExpr * findDeletedExpr( const ast::Expr * expr ) {
+                return ast::Pass<DeleteFinder_new>::read( expr );
+                ast::Pass<DeleteFinder_new> finder;
+                expr->accept( finder );
+                return finder.core.delExpr;
+        }
 …
                         const ast::Expr * untyped, const ast::SymbolTable & symtab
                 ) {
+                        Stats::ResolveTime::start( untyped );
+                        auto res = findKindExpression( untyped, symtab );
+                        Stats::ResolveTime::stop();
+                        return res;
+                        return findKindExpression( untyped, symtab );
+                }
         } // anonymous namespace
 …
                 const ast::ThrowStmt *       previsit( const ast::ThrowStmt * );
                 const ast::CatchStmt *       previsit( const ast::CatchStmt * );
-                const ast::CatchStmt *       postvisit( const ast::CatchStmt * );
                 const ast::WaitForStmt *     previsit( const ast::WaitForStmt * );
 …
         const ast::CatchStmt * Resolver_new::previsit( const ast::CatchStmt * catchStmt ) {
+                // Until we are very sure this invarent (ifs that move between passes have thenPart)
+                // holds, check it. This allows a check for when to decode the mangling.
+                if ( auto ifStmt = catchStmt->body.as<ast::IfStmt>() ) {
+                        assert( ifStmt->thenPart );
+                }
+                // Encode the catchStmt so the condition can see the declaration.
+                // TODO: This will need a fix for the decl/cond scoping problem.
                 if ( catchStmt->cond ) {
+                        ast::CatchStmt * stmt = mutate( catchStmt );
+                        stmt->body = new ast::IfStmt( stmt->location, stmt->cond, nullptr, stmt->body );
+                        stmt->cond = nullptr;
+                        return stmt;
+                }
+                return catchStmt;
+        }
+        const ast::CatchStmt * Resolver_new::postvisit( const ast::CatchStmt * catchStmt ) {
+                // Decode the catchStmt so everything is stored properly.
+                const ast::IfStmt * ifStmt = catchStmt->body.as<ast::IfStmt>();
+                if ( nullptr != ifStmt && nullptr == ifStmt->thenPart ) {
+                        assert( ifStmt->cond );
+                        assert( ifStmt->elsePart );
+                        ast::CatchStmt * stmt = ast::mutate( catchStmt );
+                        stmt->cond = ifStmt->cond;
+                        stmt->body = ifStmt->elsePart;
+                        // ifStmt should be implicately deleted here.
+                        return stmt;
+                        ast::ptr< ast::Type > boolType = new ast::BasicType{ ast::BasicType::Bool };
+                        catchStmt = ast::mutate_field(
+                                catchStmt, &ast::CatchStmt::cond,
+                                findSingleExpression( catchStmt->cond, boolType, symtab ) );
+                }
                 return catchStmt;

src/SymTab/Mangler.cc

-              r7a80113
+              r1c507eb
                   private:
                         void mangleDecl( const ast::DeclWithType *declaration );
                         void mangleRef( const ast::BaseInstType *refType, std::string prefix );
+                        void mangleRef( const ast::ReferenceToType *refType, std::string prefix );
                         void printQualifiers( const ast::Type *type );
 …
+                }
                 void Mangler_new::mangleRef( const ast::BaseInstType * refType, std::string prefix ) {
+                void Mangler_new::mangleRef( const ast::ReferenceToType * refType, std::string prefix ) {
                         printQualifiers( refType );

src/SymTab/Validate.cc

-              r7a80113
+              r1c507eb
+        }
-        static bool isNonParameterAttribute( Attribute * attr ) {
-                static const std::vector<std::string> bad_names = {
-                        "aligned", "__aligned__",
-                };
-                for ( auto name : bad_names ) {
-                        if ( name == attr->name ) {
-                                return true;
+                        }
+                }
-                return false;
+        }
         Type * ReplaceTypedef::postmutate( TypeInstType * typeInst ) {
                 // instances of typedef types will come here. If it is an instance
 …
                         ret->location = typeInst->location;
                         ret->get_qualifiers() |= typeInst->get_qualifiers();
+                        // GCC ignores certain attributes if they arrive by typedef, this mimics that.
+                        if ( inFunctionType ) {
+                                ret->attributes.remove_if( isNonParameterAttribute );
+                        }
+                        ret->attributes.splice( ret->attributes.end(), typeInst->attributes );
+                        // attributes are not carried over from typedef to function parameters/return values
+                        if ( ! inFunctionType ) {
+                                ret->attributes.splice( ret->attributes.end(), typeInst->attributes );
+                        } else {
+                                deleteAll( ret->attributes );
+                                ret->attributes.clear();
+                        }
                         // place instance parameters on the typedef'd type
                         if ( ! typeInst->parameters.empty() ) {
 …
+                }
                 void checkGenericParameters( const ast::BaseInstType * inst ) {
+                void checkGenericParameters( const ast::ReferenceToType * inst ) {
                         for ( const ast::Expr * param : inst->params ) {
                                 if ( ! dynamic_cast< const ast::TypeExpr * >( param ) ) {

src/Virtual/module.mk

-              r7a80113
+              r1c507eb
 ###############################################################################
+SRC += Virtual/ExpandCasts.cc Virtual/ExpandCasts.h \
+        Virtual/Tables.cc Virtual/Tables.h
+SRCDEMANGLE += Virtual/Tables.cc
+SRC += Virtual/ExpandCasts.cc Virtual/ExpandCasts.h

tests/Makefile.am

-              r7a80113
+              r1c507eb
 # since automake doesn't have support for CFA we have to
 AM_CFLAGS = $(if $(test), 2> $(test), ) \
-        -fdebug-prefix-map=$(abspath ${abs_srcdir})= \
-        -fdebug-prefix-map=/tmp= \
         -g \
         -Wall \
 …
 # adjusted CC but without the actual distcc call
 CFACCLOCAL = $(if $(DISTCC_CFA_PATH),$(DISTCC_CFA_PATH) ${ARCH_FLAGS},$(TARGET_CFA) ${DEBUG_FLAGS} ${ARCH_FLAGS})
-CFACCLINK = $(CFACCLOCAL) $(if $(test), 2> $(test), ) $($(shell echo "${@}_FLAGSLD" | sed 's/-\|\//_/g'))
 PRETTY_PATH=mkdir -p $(dir $(abspath ${@})) && cd ${srcdir} &&
 …
 % : %.cfa $(CFACCBIN)
         $(CFACOMPILETEST) -c -o $(abspath ${@}).o
+        $(CFACCLINK) ${@}.o -o $(abspath ${@})
+        rm $(abspath ${@}).o
+        $(CFACCLOCAL) $($(shell echo "${@}_FLAGSLD" | sed 's/-\|\//_/g')) $(abspath ${@}).o -o $(abspath ${@})
 # implicit rule for c++ test
 …
 # CUSTOM TARGET
 #------------------------------------------------------------------------------
-# tests that just validate syntax
-expression : expression.cfa $(CFACCBIN)
-        $(CFACOMPILETEST) -c -fsyntax-only 2> $(abspath ${@})
 # expected failures
 # use custom target since they require a custom define and custom dependencies
 …
         $(CFACCLOCAL) $($(shell echo "${@}_FLAGSLD" | sed 's/-\|\//_/g')) $(abspath ${@}).o -o $(abspath ${@})
-# Linking tests
-# Meta tests to make sure we see linking errors (can't compile with -O2 since it may multiply number of calls)
-linking/linkerror : linking/linkerror.cfa $(CFACCBIN)
-        $(CFACOMPILETEST) -O0 -c -o $(abspath ${@}).o
-        $(CFACCLINK)  -O0 ${@}.o -o $(abspath ${@})
-        rm $(abspath ${@}).o
 #------------------------------------------------------------------------------
 # Other targets

tests/alloc2.cfa

-              r7a80113
+              r1c507eb
 void test_base( void * ip, size_t size, size_t align) {
         tests_total += 1;
-//      printf("DEBUG: starting test %d\n", tests_total);
         bool passed = (malloc_size(ip) == size) && (malloc_usable_size(ip) >= size) && (malloc_alignment(ip) == align) && ((uintptr_t)ip % align  == 0);
         if (!passed) {
 …
                 tests_failed += 1;
+        }
-//      printf("DEBUG: done test %d\n", tests_total);
+}
 void test_fill( void * ip_, size_t start, size_t end, char fill) {
         tests_total += 1;
-//      printf("DEBUG: starting test %d\n", tests_total);
         bool passed = true;
         char * ip = (char *) ip_;
 …
                 tests_failed += 1;
+        }
-//      printf("DEBUG: done test %d\n", tests_total);
+}
 void test_fill( void * ip_, size_t start, size_t end, int fill) {
         tests_total += 1;
-//      printf("DEBUG: starting test %d\n", tests_total);
         bool passed = true;
         int * ip = (int *) ip_;
 …
                 tests_failed += 1;
+        }
-//      printf("DEBUG: done test %d\n", tests_total);
+}
 void test_fill( void * ip_, size_t start, size_t end, int * fill) {
         tests_total += 1;
-//      printf("DEBUG: starting test %d\n", tests_total);
         bool passed = (memcmp((void*)((uintptr_t)ip_ + start), (void*)fill, end) == 0);
         if (!passed) {
 …
                 tests_failed += 1;
+        }
-//      printf("DEBUG: done test %d\n", tests_total);
+}
 void test_fill( void * ip_, size_t start, size_t end, T1 fill) {
         tests_total += 1;
-//      printf("DEBUG: starting test %d\n", tests_total);
         bool passed = true;
         T1 * ip = (T1 *) ip_;
 …
                 tests_failed += 1;
+        }
-//      printf("DEBUG: done test %d\n", tests_total);
+}
 void test_fill( void * ip_, size_t start, size_t end, T1 * fill) {
         tests_total += 1;
-//      printf("DEBUG: starting test %d\n", tests_total);
         bool passed = (memcmp((void*)((uintptr_t)ip_ + start), (void*)fill, end) == 0);
         if (!passed) {
 …
                 tests_failed += 1;
+        }
-//      printf("DEBUG: done test %d\n", tests_total);
+}
 void test_use( int * ip, size_t dim) {
         tests_total += 1;
-//      printf("DEBUG: starting test %d\n", tests_total);
         bool passed = true;
         for (i; 0 ~ dim) ip[i] = 0xdeadbeef;
 …
                 tests_failed += 1;
+        }
-//      printf("DEBUG: done test %d\n", tests_total);
+}
 void test_use( T1 * ip, size_t dim) {
         tests_total += 1;
-//      printf("DEBUG: starting test %d\n", tests_total);
         bool passed = true;
         for (i; 0 ~ dim) ip[i].data = 0xdeadbeef;
 …
                 tests_failed += 1;
+        }
-//      printf("DEBUG: done test %d\n", tests_total);
+}

tests/heap.cfa

-              r7a80113
+              r1c507eb
 // Created On       : Tue Nov  6 17:54:56 2018
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Sep  7 18:37:41 2020
 // Update Count     : 72
+// Last Modified On : Sun Aug  9 08:05:16 2020
+// Update Count     : 57
 //
 …
         } // for
-        // check malloc/resize/free (sbrk)
-        for ( i; 2 ~ NoOfAllocs ~ 12 ) {
-                // initial N byte allocation
-                char * area = (char *)malloc( i );
-                area[0] = '\345'; area[i - 1] = '\345';                 // fill first/penultimate byte
-                // Do not start this loop index at 0 because resize of 0 bytes frees the storage.
-                int prev = i;
-                for ( s; i ~ 256 * 1024 ~ 26 ) {                                // start at initial memory request
-                        if ( area[0] != '\345' || area[prev - 1] != '\345' ) abort( "malloc/resize/free corrupt storage" );
-                        area = (char *)resize( area, s );                       // attempt to reuse storage
-                        area[0] = area[s - 1] = '\345';                         // fill last byte
-                        prev = s;
-                } // for
-                free( area );
-        } // for
-        // check malloc/resize/free (mmap)
-        for ( i; 2 ~ NoOfAllocs ~ 12 ) {
-                // initial N byte allocation
-                size_t s = i + default_mmap_start();                    // cross over point
-                char * area = (char *)malloc( s );
-                area[0] = '\345'; area[s - 1] = '\345';                 // fill first/penultimate byte
-                // Do not start this loop index at 0 because resize of 0 bytes frees the storage.
-                int prev = s;
-                for ( r; s ~ 256 * 1024 ~ 26 ) {                                // start at initial memory request
-                        if ( area[0] != '\345' || area[prev - 1] != '\345' ) abort( "malloc/resize/free corrupt storage" );
-                        area = (char *)resize( area, s );                       // attempt to reuse storage
-                        area[0] = area[r - 1] = '\345';                         // fill last byte
-                        prev = r;
-                } // for
-                free( area );
-        } // for
-        // check malloc/realloc/free (sbrk)
-        for ( i; 2 ~ NoOfAllocs ~ 12 ) {
-                // initial N byte allocation
-                char * area = (char *)malloc( i );
-                area[0] = '\345'; area[i - 1] = '\345';                 // fill first/penultimate byte
-                // Do not start this loop index at 0 because realloc of 0 bytes frees the storage.
-                int prev = i;
-                for ( s; i ~ 256 * 1024 ~ 26 ) {                                // start at initial memory request
-                        if ( area[0] != '\345' || area[prev - 1] != '\345' ) abort( "malloc/realloc/free corrupt storage" );
-                        area = (char *)realloc( area, s );                      // attempt to reuse storage
-                        area[s - 1] = '\345';                                           // fill last byte
-                        prev = s;
-                } // for
-                free( area );
-        } // for
-        // check malloc/realloc/free (mmap)
-        for ( i; 2 ~ NoOfAllocs ~ 12 ) {
-                // initial N byte allocation
-                size_t s = i + default_mmap_start();                    // cross over point
-                char * area = (char *)malloc( s );
-                area[0] = '\345'; area[s - 1] = '\345';                 // fill first/penultimate byte
-                // Do not start this loop index at 0 because realloc of 0 bytes frees the storage.
-                int prev = s;
-                for ( r; s ~ 256 * 1024 ~ 26 ) {                                // start at initial memory request
-                        if ( area[0] != '\345' || area[prev - 1] != '\345' ) abort( "malloc/realloc/free corrupt storage" );
-                        area = (char *)realloc( area, s );                      // attempt to reuse storage
-                        area[r - 1] = '\345';                                           // fill last byte
-                        prev = r;
-                } // for
-                free( area );
-        } // for
         // check calloc/realloc/free (sbrk)
 …
                                  area[malloc_size( area ) - 1] != '\0' ||
                                  ! malloc_zero_fill( area ) ) abort( "cmemalign/realloc/free corrupt storage3" );
-                        area[s - 1] = '\345';                                           // fill last byte
-                } // for
-                free( area );
-        } // for
-        // check memalign/resize with align/free
-        amount = 2;
-        for ( a; libAlign() ~= limit ~ a ) {                            // generate powers of 2
-                // initial N byte allocation
-                char * area = (char *)memalign( a, amount );    // aligned N-byte allocation
-                //sout | alignments[a] | area | endl;
-                if ( (size_t)area % a != 0 || malloc_alignment( area ) != a ) { // check for initial alignment
-                        abort( "memalign/resize with align/free bad alignment : memalign(%d,%d) = %p", (int)a, (int)amount, area );
-                } // if
-                area[0] = '\345'; area[amount - 2] = '\345';    // fill first/penultimate byte
-                // Do not start this loop index at 0 because resize of 0 bytes frees the storage.
-                for ( s; amount ~ 256 * 1024 ) {                                // start at initial memory request
-                        area = (char *)resize( area, a * 2, s );        // attempt to reuse storage
-                        //sout | i | area | endl;
-                        if ( (size_t)area % a * 2 != 0 ) {                      // check for initial alignment
-                                abort( "memalign/resize with align/free bad alignment %p", area );
-                        } // if
                         area[s - 1] = '\345';                                           // fill last byte
                 } // for

tests/pybin/tools.py

r7a80113	r1c507eb
120	120	return None
121	121
122		file = open(file, mode~~, encoding="latin-1") # use latin-1 so all chars mean something.~~
	122	file = open(file, mode)
123	123	exitstack.push(file)
124	124	return file

tests/test.py

r7a80113	r1c507eb
207	207	else:
208	208	if os.stat(out_file).st_size < 1048576:
209		with open (out_file, "r"~~, encoding='latin-1') as myfile: # use latin-1 so all chars mean something.~~
	209	with open (out_file, "r") as myfile:
210	210	error = myfile.read()
211	211	else:

Context Navigation

Changes in / [7a80113:1c507eb]

Legend:

Download in other formats: