Changeset a505021

Jenkinsfile

-                      r8c50aed
+                      ra505021
                 //Then publish the results
                 do_plot(Settings.RunBenchmark && Settings.Publish, 'compile'       , groupCompile    , false, 'Compilation')
                 do_plot(Settings.RunBenchmark && Settings.Publish, 'compile.diff'  , groupCompile    , true , 'Compilation (relative)')
                 do_plot(Settings.RunBenchmark && Settings.Publish, 'ctxswitch'     , groupConcurrency, false, 'Context Switching')
                 do_plot(Settings.RunBenchmark && Settings.Publish, 'ctxswitch.diff', groupConcurrency, true , 'Context Switching (relative)')
                 do_plot(Settings.RunBenchmark && Settings.Publish, 'mutex'         , groupConcurrency, false, 'Mutual Exclusion')
                 do_plot(Settings.RunBenchmark && Settings.Publish, 'mutex.diff'    , groupConcurrency, true , 'Mutual Exclusion (relative)')
                 do_plot(Settings.RunBenchmark && Settings.Publish, 'signal'        , groupConcurrency, false, 'Internal and External Scheduling')
                 do_plot(Settings.RunBenchmark && Settings.Publish, 'signal.diff'   , groupConcurrency, true , 'Internal and External Scheduling (relative)')
+                do_plot(Settings.RunBenchmark && Settings.Publish, 'compile'        , groupCompile    , false, 'Compilation')
+                do_plot(Settings.RunBenchmark && Settings.Publish, 'compile.diff'   , groupCompile    , true , 'Compilation (relative)')
+                do_plot(Settings.RunBenchmark && Settings.Publish, 'ctxswitch'      , groupConcurrency, false, 'Context Switching')
+                do_plot(Settings.RunBenchmark && Settings.Publish, 'ctxswitch.diff' , groupConcurrency, true , 'Context Switching (relative)')
+                do_plot(Settings.RunBenchmark && Settings.Publish, 'mutex'          , groupConcurrency, false, 'Mutual Exclusion')
+                do_plot(Settings.RunBenchmark && Settings.Publish, 'mutex.diff'     , groupConcurrency, true , 'Mutual Exclusion (relative)')
+                do_plot(Settings.RunBenchmark && Settings.Publish, 'scheduling'     , groupConcurrency, false, 'Internal and External Scheduling')
+                do_plot(Settings.RunBenchmark && Settings.Publish, 'scheduling.diff', groupConcurrency, true , 'Internal and External Scheduling (relative)')
+        }
+}

benchmark/Makefile.am

-                      r8c50aed
+                      ra505021
 BENCH_V_UPP = $(__bench_v_UPP_$(__quiet))
 BENCH_V_GOC = $(__bench_v_GOC_$(__quiet))
+BENCH_V_PY = $(__bench_v_PY_$(__quiet))
 BENCH_V_RUSTC = $(__bench_v_RUSTC_$(__quiet))
 BENCH_V_NODEJS = $(__bench_v_NODEJS_$(__quiet))
 …
 __bench_v_UPP_verbose = $(AM_V_UPP)
 __bench_v_GOC_verbose = $(AM_V_GOC)
+__bench_v_RUSTC_verbose = $(AM_V_RUSTC)
+__bench_v_PY_verbose = $(AM_V_PY)
+__bench_v_RUSTC_verbose = $(AM_V_RUST)
 __bench_v_NODEJS_verbose = $(AM_V_NODEJS)
 __bench_v_JAVAC_verbose = $(AM_V_JAVAC)
 …
         echo "int main() { return 0; }" > ${@}
+#.SILENT:               # do not print recipe
+.ONESHELL:              # use one shell to execute recipe
+.SILENT:                # do not print recipe
 .NOTPARALLEL:
 .PHONY: compile.csv basic.csv ctxswitch.csv mutex.csv schedint.csv
+.PHONY: jenkins cleancsv
 ## =========================================================================================================
 …
 FIX_NEW_LINES = cat $@ | tr "\n" "\t" | sed -r 's/\t,/,/' | tr "\t" "\n" > $@
+jenkins$(EXEEXT):
+cleancsv:
+        rm -f compile.csv basic.csv ctxswitch.csv mutex.csv scheduling.csv
+jenkins$(EXEEXT): cleancsv
 @DOifskipcompile@
         +make compile.csv
         -+make compile.diff.csv
 @DOendif@
-        +make basic.csv
-        -+make basic.diff.csv
         +make ctxswitch.csv
         -+make ctxswitch.diff.csv
         +make mutex.csv
         -+make mutex.diff.csv
         +make schedint.csv
         -+make schedint.diff.csv
+        +make scheduling.csv
+        -+make scheduling.diff.csv
 @DOifskipcompile@
         cat compile.csv
         -cat compile.diff.csv
 @DOendif@
-        cat basic.csv
-        -cat basic.diff.csv
         cat ctxswitch.csv
         -cat ctxswitch.diff.csv
         cat mutex.csv
         -cat mutex.diff.csv
         cat schedint.csv
         -cat schedint.diff.csv
+        cat scheduling.csv
+        -cat scheduling.diff.csv
 compile.csv:
+        echo "building $@"
         echo "array,attributes,empty,expression,io,monitor,operators,typeof" > $@
         +make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-array.make >> $@
 …
         $(srcdir)/fixcsv.sh $@
-basic.csv:
-        echo "generator,coroutine,thread" > $@
-        +make basic-cfa_generator.runquiet >> $@ && echo -n ',' >> $@
-        +make basic-cfa_coroutine.runquiet >> $@ && echo -n ',' >> $@
-        +make basic-cfa_thread.runquiet >> $@
-        $(srcdir)/fixcsv.sh $@
 ctxswitch.csv:
+        echo "building $@"
         echo "generator,coroutine,thread" > $@
         +make ctxswitch-cfa_generator.runquiet >> $@ && echo -n ',' >> $@
 …
 mutex.csv:
+        echo "building $@"
         echo "1-monitor,2-monitor" > $@
         +make mutex-cfa1.runquiet >> $@ && echo -n ',' >> $@
 …
         $(srcdir)/fixcsv.sh $@
+schedint.csv:
+scheduling.csv:
+        echo "building $@"
         echo "schedint-1,schedint-2,schedext-1,schedext-2" > $@
         +make schedint-cfa1.runquiet >> $@ && echo -n ',' >> $@
 …
 ctxswitch-python_coroutine$(EXEEXT):
         echo "#!/bin/sh" > a.out
+        $(BENCH_V_PY)echo "#!/bin/sh" > a.out
         echo "python3.7 $(srcdir)/ctxswitch/python_cor.py" >> a.out
         chmod a+x a.out
 ctxswitch-nodejs_coroutine$(EXEEXT):
         echo "#!/bin/sh" > a.out
+        $(BENCH_V_NODEJS)echo "#!/bin/sh" > a.out
         echo "nodejs $(srcdir)/ctxswitch/node_cor.js" >> a.out
         chmod a+x a.out
 ctxswitch-nodejs_await$(EXEEXT):
         echo "#!/bin/sh" > a.out
+        $(BENCH_V_NODEJS)echo "#!/bin/sh" > a.out
         echo "nodejs $(srcdir)/ctxswitch/node_await.js" >> a.out
         chmod a+x a.out
 …
 creation-python_coroutine$(EXEEXT):
         echo "#!/bin/sh" > a.out
+        $(BENCH_V_PY)echo "#!/bin/sh" > a.out
         echo "python3.7 $(srcdir)/creation/python_cor.py" >> a.out
         chmod a+x a.out
 creation-nodejs_coroutine$(EXEEXT):
         echo "#!/bin/sh" > a.out
+        $(BENCH_V_NODEJS)echo "#!/bin/sh" > a.out
         echo "nodejs $(srcdir)/creation/node_cor.js" >> a.out
         chmod a+x a.out

benchmark/Makefile.in

-                      r8c50aed
+                      ra505021
 am__v_GOC_0 = @echo "  GOC     " $@;
 am__v_GOC_1 =
+AM_V_PY = $(am__v_PY_@AM_V@)
+am__v_PY_ = $(am__v_PY_@AM_DEFAULT_V@)
+am__v_PY_0 = @echo "  PYTHON  " $@;
+am__v_PY_1 =
 AM_V_RUST = $(am__v_RUST_@AM_V@)
 am__v_RUST_ = $(am__v_RUST_@AM_DEFAULT_V@)
 am__v_RUST_0 = @echo "  RUST     " $@;
+am__v_RUST_0 = @echo "  RUST    " $@;
 am__v_RUST_1 =
 AM_V_NODEJS = $(am__v_NODEJS_@AM_V@)
 am__v_NODEJS_ = $(am__v_NODEJS_@AM_DEFAULT_V@)
 am__v_NODEJS_0 = @echo "  NODEJS     " $@;
+am__v_NODEJS_0 = @echo "  NODEJS  " $@;
 am__v_NODEJS_1 =
 AM_V_JAVAC = $(am__v_JAVAC_@AM_V@)
 …
 BENCH_V_UPP = $(__bench_v_UPP_$(__quiet))
 BENCH_V_GOC = $(__bench_v_GOC_$(__quiet))
+BENCH_V_PY = $(__bench_v_PY_$(__quiet))
 BENCH_V_RUSTC = $(__bench_v_RUSTC_$(__quiet))
 BENCH_V_NODEJS = $(__bench_v_NODEJS_$(__quiet))
 …
 __bench_v_UPP_verbose = $(AM_V_UPP)
 __bench_v_GOC_verbose = $(AM_V_GOC)
+__bench_v_RUSTC_verbose = $(AM_V_RUSTC)
+__bench_v_PY_verbose = $(AM_V_PY)
+__bench_v_RUSTC_verbose = $(AM_V_RUST)
 __bench_v_NODEJS_verbose = $(AM_V_NODEJS)
 __bench_v_JAVAC_verbose = $(AM_V_JAVAC)
 …
         echo "int main() { return 0; }" > ${@}
+#.SILENT:               # do not print recipe
+.ONESHELL:              # use one shell to execute recipe
+.SILENT:                # do not print recipe
 .NOTPARALLEL:
 .PHONY: compile.csv basic.csv ctxswitch.csv mutex.csv schedint.csv
+.PHONY: jenkins cleancsv
 all : basic$(EXEEXT) ctxswitch$(EXEEXT) mutex$(EXEEXT) schedint$(EXEEXT) schedext$(EXEEXT) creation$(EXEEXT)
 …
         +make -C ${abs_top_builddir}/tools repeat
+jenkins$(EXEEXT):
+cleancsv:
+        rm -f compile.csv basic.csv ctxswitch.csv mutex.csv scheduling.csv
+jenkins$(EXEEXT): cleancsv
 @DOifskipcompile@
         +make compile.csv
         -+make compile.diff.csv
 @DOendif@
-        +make basic.csv
-        -+make basic.diff.csv
         +make ctxswitch.csv
         -+make ctxswitch.diff.csv
         +make mutex.csv
         -+make mutex.diff.csv
         +make schedint.csv
         -+make schedint.diff.csv
+        +make scheduling.csv
+        -+make scheduling.diff.csv
 @DOifskipcompile@
         cat compile.csv
         -cat compile.diff.csv
 @DOendif@
-        cat basic.csv
-        -cat basic.diff.csv
         cat ctxswitch.csv
         -cat ctxswitch.diff.csv
         cat mutex.csv
         -cat mutex.diff.csv
         cat schedint.csv
         -cat schedint.diff.csv
+        cat scheduling.csv
+        -cat scheduling.diff.csv
 compile.csv:
+        echo "building $@"
         echo "array,attributes,empty,expression,io,monitor,operators,typeof" > $@
         +make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-array.make >> $@
 …
         $(srcdir)/fixcsv.sh $@
-basic.csv:
-        echo "generator,coroutine,thread" > $@
-        +make basic-cfa_generator.runquiet >> $@ && echo -n ',' >> $@
-        +make basic-cfa_coroutine.runquiet >> $@ && echo -n ',' >> $@
-        +make basic-cfa_thread.runquiet >> $@
-        $(srcdir)/fixcsv.sh $@
 ctxswitch.csv:
+        echo "building $@"
         echo "generator,coroutine,thread" > $@
         +make ctxswitch-cfa_generator.runquiet >> $@ && echo -n ',' >> $@
 …
 mutex.csv:
+        echo "building $@"
         echo "1-monitor,2-monitor" > $@
         +make mutex-cfa1.runquiet >> $@ && echo -n ',' >> $@
 …
         $(srcdir)/fixcsv.sh $@
+schedint.csv:
+scheduling.csv:
+        echo "building $@"
         echo "schedint-1,schedint-2,schedext-1,schedext-2" > $@
         +make schedint-cfa1.runquiet >> $@ && echo -n ',' >> $@
 …
 ctxswitch-python_coroutine$(EXEEXT):
         echo "#!/bin/sh" > a.out
+        $(BENCH_V_PY)echo "#!/bin/sh" > a.out
         echo "python3.7 $(srcdir)/ctxswitch/python_cor.py" >> a.out
         chmod a+x a.out
 ctxswitch-nodejs_coroutine$(EXEEXT):
         echo "#!/bin/sh" > a.out
+        $(BENCH_V_NODEJS)echo "#!/bin/sh" > a.out
         echo "nodejs $(srcdir)/ctxswitch/node_cor.js" >> a.out
         chmod a+x a.out
 ctxswitch-nodejs_await$(EXEEXT):
         echo "#!/bin/sh" > a.out
+        $(BENCH_V_NODEJS)echo "#!/bin/sh" > a.out
         echo "nodejs $(srcdir)/ctxswitch/node_await.js" >> a.out
         chmod a+x a.out
 …
 creation-python_coroutine$(EXEEXT):
         echo "#!/bin/sh" > a.out
+        $(BENCH_V_PY)echo "#!/bin/sh" > a.out
         echo "python3.7 $(srcdir)/creation/python_cor.py" >> a.out
         chmod a+x a.out
 creation-nodejs_coroutine$(EXEEXT):
         echo "#!/bin/sh" > a.out
+        $(BENCH_V_NODEJS)echo "#!/bin/sh" > a.out
         echo "nodejs $(srcdir)/creation/node_cor.js" >> a.out
         chmod a+x a.out

benchmark/baselines/x64/schedint.csv

r8c50aed	ra505021
1		~~waitfor-2,signal-1,signal-2,waitfor~~-1
	1	schedext-2,schedint-1,schedint-2,schedext-1
2	2	393.69606249999987,325.99158333333327,409.01025000000004,319.90975000000003

benchmark/baselines/x86/schedint.csv

r8c50aed	ra505021
1		s~~ignal-2,waitfor-1,waitfor-2,signal~~-1
	1	schedint-2,schedext-1,schedext-2,schedint-1
2	2	532.5297959183672,413.3084897959184,506.7579591836735,423.78826530612247

doc/theses/thierry_delisle_PhD/code/relaxed_list.cpp

-                      r8c50aed
+                      ra505021
 #include <vector>
+#include <getopt.h>
 #include <unistd.h>
 #include <sys/sysinfo.h>
 …
         int value;
+        Node(int value): value(value) {
+                creates++;
+        }
+        ~Node() {
+                destroys++;
+        }
+        int id;
+        Node() { creates++; }
+        Node(int value): value(value) { creates++; }
+        ~Node() { destroys++; }
 };
 …
 std::atomic_size_t Node::destroys = { 0 };
-static const constexpr int nodes_per_threads = 128;
-struct NodeArray {
-        __attribute__((aligned(64))) Node * array[nodes_per_threads];
-        __attribute__((aligned(64))) char pad;
-};
 bool enable_stats = false;
+template<>
+thread_local relaxed_list<Node>::TLS relaxed_list<Node>::tls = {};
+template<>
+relaxed_list<Node> * relaxed_list<Node>::head = nullptr;
+#ifndef NO_STATS
+template<>
+relaxed_list<Node>::GlobalStats relaxed_list<Node>::global_stats = {};
+#endif
+// ================================================================================================
+//                        UTILS
+// ================================================================================================
 struct local_stat_t {
 …
         size_t crc_in  = 0;
         size_t crc_out = 0;
+        size_t valmax = 0;
+        size_t valmin = 100000000ul;
 };
+__attribute__((noinline)) void run_body(
+        std::atomic<bool>& done,
+        Random & rand,
+        Node * (&my_nodes)[128],
+        local_stat_t & local,
+        relaxed_list<Node> & list
+) {
+        while(__builtin_expect(!done.load(std::memory_order_relaxed), true)) {
+                int idx = rand.next() % nodes_per_threads;
+                if (auto node = my_nodes[idx]) {
+                        local.crc_in += node->value;
+                        list.push(node);
+                        my_nodes[idx] = nullptr;
+                        local.in++;
+                }
+                else if(auto node = list.pop()) {
+                        local.crc_out += node->value;
+                        my_nodes[idx] = node;
+                        local.out++;
+                }
+                else {
+                        local.empty++;
+                }
+        }
+}
+void run(unsigned nthread, unsigned nqueues, unsigned fill, double duration) {
+        // List being tested
+        relaxed_list<Node> list = { nthread * nqueues };
+        // Barrier for synchronization
+        barrier_t barrier(nthread + 1);
+        // Data to check everything is OK
+        struct {
+                std::atomic_size_t in  = { 0 };
+                std::atomic_size_t out = { 0 };
+                std::atomic_size_t empty = { 0 };
+                std::atomic_size_t crc_in  = { 0 };
+                std::atomic_size_t crc_out = { 0 };
+                struct {
+                        struct {
+                                std::atomic_size_t attempt = { 0 };
+                                std::atomic_size_t success = { 0 };
+                        } push;
+                        struct {
+                                std::atomic_size_t attempt = { 0 };
+                                std::atomic_size_t success = { 0 };
+                        } pop;
+                } pick;
+        } global;
+        // Flag to signal termination
+        std::atomic_bool done  = { false };
+        // Prep nodes
+        std::cout << "Initializing ";
+        size_t nnodes  = 0;
+        size_t npushed = 0;
+        NodeArray all_nodes[nthread];
+        for(auto & nodes : all_nodes) {
+                Random rand(rdtscl());
+                for(auto & node : nodes.array) {
+                        auto r = rand.next() % 100;
+                        if(r < fill) {
+                                node = new Node(rand.next() % 100);
+                                nnodes++;
+                        } else {
+                                node = nullptr;
+                        }
+                }
+                for(int i = 0; i < 10; i++) {
+                        int idx = rand.next() % nodes_per_threads;
+                        if (auto node = nodes.array[idx]) {
+                                global.crc_in += node->value;
+                                list.push(node);
+                                npushed++;
+                                nodes.array[idx] = nullptr;
+                        }
+                }
+        }
+        std::cout << nnodes << " nodes " << fill << "% (" << npushed << " pushed)" << std::endl;
+        enable_stats = true;
+        std::thread * threads[nthread];
+        unsigned i = 1;
+        for(auto & t : threads) {
+                auto & my_nodes = all_nodes[i - 1].array;
+                t = new std::thread([&done, &list, &barrier, &global, &my_nodes](unsigned tid) {
+                        Random rand(tid + rdtscl());
+                        local_stat_t local;
+                        // affinity(tid);
+                        barrier.wait(tid);
+                        // EXPERIMENT START
+                        run_body(done, rand, my_nodes, local, list);
+                        // EXPERIMENT END
+                        barrier.wait(tid);
+                        global.in    += local.in;
+                        global.out   += local.out;
+                        global.empty += local.empty;
+                        for(auto node : my_nodes) {
+                                delete node;
+                        }
+                        global.crc_in  += local.crc_in;
+                        global.crc_out += local.crc_out;
+                        global.pick.push.attempt += relaxed_list<Node>::tls.pick.push.attempt;
+                        global.pick.push.success += relaxed_list<Node>::tls.pick.push.success;
+                        global.pick.pop .attempt += relaxed_list<Node>::tls.pick.pop.attempt;
+                        global.pick.pop .success += relaxed_list<Node>::tls.pick.pop.success;
+                }, i++);
+        }
+struct global_stat_t {
+        std::atomic_size_t in  = { 0 };
+        std::atomic_size_t out = { 0 };
+        std::atomic_size_t empty = { 0 };
+        std::atomic_size_t crc_in  = { 0 };
+        std::atomic_size_t crc_out = { 0 };
+        std::atomic_size_t valmax = { 0 };
+        std::atomic_size_t valmin = { 100000000ul };
+};
+void atomic_max(std::atomic_size_t & target, size_t value) {
+        for(;;) {
+                size_t expect = target.load(std::memory_order_relaxed);
+                if(value <= expect) return;
+                bool success = target.compare_exchange_strong(expect, value);
+                if(success) return;
+        }
+}
+void atomic_min(std::atomic_size_t & target, size_t value) {
+        for(;;) {
+                size_t expect = target.load(std::memory_order_relaxed);
+                if(value >= expect) return;
+                bool success = target.compare_exchange_strong(expect, value);
+                if(success) return;
+        }
+}
+void tally_stats(global_stat_t & global, local_stat_t & local) {
+        global.in    += local.in;
+        global.out   += local.out;
+        global.empty += local.empty;
+        global.crc_in  += local.crc_in;
+        global.crc_out += local.crc_out;
+        atomic_max(global.valmax, local.valmax);
+        atomic_min(global.valmin, local.valmin);
+        relaxed_list<Node>::stats_tls_tally();
+}
+void waitfor(double & duration, barrier_t & barrier, std::atomic_bool & done) {
         std::cout << "Starting" << std::endl;
         auto before = Clock::now();
 …
         duration = durr.count();
         std::cout << "\rClosing down" << std::endl;
+        for(auto t : threads) {
+                t->join();
+                delete t;
+        }
+        enable_stats = false;
+        while(auto node = list.pop()) {
+                global.crc_out += node->value;
+                delete node;
+        }
+}
+void waitfor(double & duration, barrier_t & barrier, const std::atomic_size_t & count) {
+        std::cout << "Starting" << std::endl;
+        auto before = Clock::now();
+        barrier.wait(0);
+        while(true) {
+                usleep(100000);
+                size_t c = count.load();
+                if( c == 0 ) {
+                        break;
+                }
+                std::cout << "\r" << c;
+                std::cout.flush();
+        }
+        barrier.wait(0);
+        auto after = Clock::now();
+        duration_t durr = after - before;
+        duration = durr.count();
+        std::cout << "\rClosing down" << std::endl;
+}
+void print_stats(double duration, unsigned nthread, global_stat_t & global) {
         assert(Node::creates == Node::destroys);
         assert(global.crc_in == global.crc_out);
 …
         std::cout << "Ops/sec       : " << ops_sec << "\n";
         std::cout << "Total ops     : " << ops << "(" << global.in << "i, " << global.out << "o, " << global.empty << "e)\n";
+        if(global.valmax != 0) {
+                std::cout << "Max runs      : " << global.valmax << "\n";
+                std::cout << "Min runs      : " << global.valmin << "\n";
+        }
         #ifndef NO_STATS
+                double push_sur = (100.0 * double(global.pick.push.success) / global.pick.push.attempt);
+                double pop_sur  = (100.0 * double(global.pick.pop .success) / global.pick.pop .attempt);
+                std::cout << "Push Pick %   : " << push_sur << "(" << global.pick.push.success << " / " << global.pick.push.attempt << ")\n";
+                std::cout << "Pop  Pick %   : " << pop_sur  << "(" << global.pick.pop .success << " / " << global.pick.pop .attempt << ")\n";
+                relaxed_list<Node>::stats_print(std::cout);
         #endif
+}
+void usage(char * argv[]) {
+        std::cerr << argv[0] << ": [DURATION (FLOAT:SEC)] [NTHREADS] [NQUEUES] [FILL]" << std::endl;;
+        std::exit(1);
+void save_fairness(const int data[], int factor, unsigned nthreads, size_t columns, size_t rows, const std::string & output);
+// ================================================================================================
+//                        EXPERIMENTS
+// ================================================================================================
+// ================================================================================================
+__attribute__((noinline)) void runChurn_body(
+        std::atomic<bool>& done,
+        Random & rand,
+        Node * my_nodes[],
+        unsigned nslots,
+        local_stat_t & local,
+        relaxed_list<Node> & list
+) {
+        while(__builtin_expect(!done.load(std::memory_order_relaxed), true)) {
+                int idx = rand.next() % nslots;
+                if (auto node = my_nodes[idx]) {
+                        local.crc_in += node->value;
+                        list.push(node);
+                        my_nodes[idx] = nullptr;
+                        local.in++;
+                }
+                else if(auto node = list.pop()) {
+                        local.crc_out += node->value;
+                        my_nodes[idx] = node;
+                        local.out++;
+                }
+                else {
+                        local.empty++;
+                }
+        }
+}
+void runChurn(unsigned nthread, unsigned nqueues, double duration, unsigned nnodes, const unsigned nslots) {
+        std::cout << "Churn Benchmark" << std::endl;
+        assert(nnodes <= nslots);
+        // List being tested
+        // Barrier for synchronization
+        barrier_t barrier(nthread + 1);
+        // Data to check everything is OK
+        global_stat_t global;
+        // Flag to signal termination
+        std::atomic_bool done  = { false };
+        // Prep nodes
+        std::cout << "Initializing ";
+        size_t npushed = 0;
+        relaxed_list<Node> list = { nthread * nqueues };
+        {
+                Node** all_nodes[nthread];
+                for(auto & nodes : all_nodes) {
+                        nodes = new __attribute__((aligned(64))) Node*[nslots + 8];
+                        Random rand(rdtscl());
+                        for(unsigned i = 0; i < nnodes; i++) {
+                                nodes[i] = new Node(rand.next() % 100);
+                        }
+                        for(unsigned i = nnodes; i < nslots; i++) {
+                                nodes[i] = nullptr;
+                        }
+                        for(int i = 0; i < 10 && i < (int)nslots; i++) {
+                                int idx = rand.next() % nslots;
+                                if (auto node = nodes[idx]) {
+                                        global.crc_in += node->value;
+                                        list.push(node);
+                                        npushed++;
+                                        nodes[idx] = nullptr;
+                                }
+                        }
+                }
+                std::cout << nnodes << " nodes (" << nslots << " slots)" << std::endl;
+                enable_stats = true;
+                std::thread * threads[nthread];
+                unsigned i = 1;
+                for(auto & t : threads) {
+                        auto & my_nodes = all_nodes[i - 1];
+                        t = new std::thread([&done, &list, &barrier, &global, &my_nodes, nslots](unsigned tid) {
+                                Random rand(tid + rdtscl());
+                                local_stat_t local;
+                                // affinity(tid);
+                                barrier.wait(tid);
+                                // EXPERIMENT START
+                                runChurn_body(done, rand, my_nodes, nslots, local, list);
+                                // EXPERIMENT END
+                                barrier.wait(tid);
+                                tally_stats(global, local);
+                                for(unsigned i = 0; i < nslots; i++) {
+                                        delete my_nodes[i];
+                                }
+                        }, i++);
+                }
+                waitfor(duration, barrier, done);
+                for(auto t : threads) {
+                        t->join();
+                        delete t;
+                }
+                enable_stats = false;
+                while(auto node = list.pop()) {
+                        global.crc_out += node->value;
+                        delete node;
+                }
+                for(auto nodes : all_nodes) {
+                        delete[] nodes;
+                }
+        }
+        print_stats(duration, nthread, global);
+}
+// ================================================================================================
+__attribute__((noinline)) void runPingPong_body(
+        std::atomic<bool>& done,
+        Node initial_nodes[],
+        unsigned nnodes,
+        local_stat_t & local,
+        relaxed_list<Node> & list
+) {
+        Node * nodes[nnodes];
+        {
+                unsigned i = 0;
+                for(auto & n : nodes) {
+                        n = &initial_nodes[i++];
+                }
+        }
+        while(__builtin_expect(!done.load(std::memory_order_relaxed), true)) {
+                for(Node * & node : nodes) {
+                        local.crc_in += node->value;
+                        list.push(node);
+                        local.in++;
+                }
+                // -----
+                for(Node * & node : nodes) {
+                        node = list.pop();
+                        assert(node);
+                        local.crc_out += node->value;
+                        local.out++;
+                }
+        }
+}
+void runPingPong(unsigned nthread, unsigned nqueues, double duration, unsigned nnodes) {
+        std::cout << "PingPong Benchmark" << std::endl;
+        // Barrier for synchronization
+        barrier_t barrier(nthread + 1);
+        // Data to check everything is OK
+        global_stat_t global;
+        // Flag to signal termination
+        std::atomic_bool done  = { false };
+        std::cout << "Initializing ";
+        // List being tested
+        relaxed_list<Node> list = { nthread * nqueues };
+        {
+                enable_stats = true;
+                std::thread * threads[nthread];
+                unsigned i = 1;
+                for(auto & t : threads) {
+                        t = new std::thread([&done, &list, &barrier, &global, nnodes](unsigned tid) {
+                                Random rand(tid + rdtscl());
+                                Node nodes[nnodes];
+                                for(auto & n : nodes) {
+                                        n.value = (int)rand.next() % 100;
+                                }
+                                local_stat_t local;
+                                // affinity(tid);
+                                barrier.wait(tid);
+                                // EXPERIMENT START
+                                runPingPong_body(done, nodes, nnodes, local, list);
+                                // EXPERIMENT END
+                                barrier.wait(tid);
+                                tally_stats(global, local);
+                        }, i++);
+                }
+                waitfor(duration, barrier, done);
+                for(auto t : threads) {
+                        t->join();
+                        delete t;
+                }
+                enable_stats = false;
+        }
+        print_stats(duration, nthread, global);
+}
+// ================================================================================================
+__attribute__((noinline)) void runFairness_body(
+        unsigned tid,
+        size_t width,
+        size_t length,
+        int output[],
+        std::atomic_size_t & count,
+        Node initial_nodes[],
+        unsigned nnodes,
+        local_stat_t & local,
+        relaxed_list<Node> & list
+) {
+        Node * nodes[nnodes];
+        {
+                unsigned i = 0;
+                for(auto & n : nodes) {
+                        n = &initial_nodes[i++];
+                }
+        }
+        while(__builtin_expect(0 != count.load(std::memory_order_relaxed), true)) {
+                for(Node * & node : nodes) {
+                        local.crc_in += node->id;
+                        list.push(node);
+                        local.in++;
+                }
+                // -----
+                for(Node * & node : nodes) {
+                        node = list.pop();
+                        assert(node);
+                        if (unsigned(node->value) < length) {
+                                size_t idx = (node->value * width) + node->id;
+                                assert(idx < (width * length));
+                                output[idx] = tid;
+                        }
+                        node->value++;
+                        if(unsigned(node->value) == length) count--;
+                        local.crc_out += node->id;
+                        local.out++;
+                }
+        }
+}
+void runFairness(unsigned nthread, unsigned nqueues, double duration, unsigned nnodes, const std::string & output) {
+        std::cout << "Fairness Benchmark, outputing to : " << output << std::endl;
+        // Barrier for synchronization
+        barrier_t barrier(nthread + 1);
+        // Data to check everything is OK
+        global_stat_t global;
+        std::cout << "Initializing ";
+        // Check fairness by creating a png of where the threads ran
+        size_t width = nthread * nnodes;
+        size_t length = 100000;
+        std::unique_ptr<int[]> data_out { new int[width * length] };
+        // Flag to signal termination
+        std::atomic_size_t count = width;
+        // List being tested
+        relaxed_list<Node> list = { nthread * nqueues };
+        {
+                enable_stats = true;
+                std::thread * threads[nthread];
+                unsigned i = 1;
+                for(auto & t : threads) {
+                        t = new std::thread([&count, &list, &barrier, &global, nnodes, width, length, data_out = data_out.get()](unsigned tid) {
+                                unsigned int start = (tid - 1) * nnodes;
+                                Node nodes[nnodes];
+                                for(auto & n : nodes) {
+                                        n.id = start;
+                                        n.value = 0;
+                                        start++;
+                                }
+                                local_stat_t local;
+                                // affinity(tid);
+                                barrier.wait(tid);
+                                // EXPERIMENT START
+                                runFairness_body(tid, width, length, data_out, count, nodes, nnodes, local, list);
+                                // EXPERIMENT END
+                                barrier.wait(tid);
+                                for(const auto & n : nodes) {
+                                        local.valmax = max(local.valmax, size_t(n.value));
+                                        local.valmin = min(local.valmin, size_t(n.value));
+                                }
+                                tally_stats(global, local);
+                        }, i++);
+                }
+                waitfor(duration, barrier, count);
+                for(auto t : threads) {
+                        t->join();
+                        delete t;
+                }
+                enable_stats = false;
+        }
+        print_stats(duration, nthread, global);
+        save_fairness(data_out.get(), 100, nthread, width, length, output);
+}
+// ================================================================================================
+bool iequals(const std::string& a, const std::string& b)
+{
+    return std::equal(a.begin(), a.end(),
+                      b.begin(), b.end(),
+                      [](char a, char b) {
+                          return std::tolower(a) == std::tolower(b);
+                      });
+}
 …
         double duration   = 5.0;
         unsigned nthreads = 2;
+        unsigned nqueues  = 2;
+        unsigned fill     = 100;
+        unsigned nqueues  = 4;
+        unsigned nnodes   = 100;
+        unsigned nslots   = 100;
+        std::string out   = "fairness.png";
+        enum {
+                Churn,
+                PingPong,
+                Fairness,
+                NONE
+        } benchmark = NONE;
         std::cout.imbue(std::locale(""));
+        switch (argc)
+        {
+        for(;;) {
+                static struct option options[] = {
+                        {"duration",  required_argument, 0, 'd'},
+                        {"nthreads",  required_argument, 0, 't'},
+                        {"nqueues",   required_argument, 0, 'q'},
+                        {"benchmark", required_argument, 0, 'b'},
+                        {0, 0, 0, 0}
+                };
+                int idx = 0;
+                int opt = getopt_long(argc, argv, "d:t:q:b:", options, &idx);
+                std::string arg = optarg ? optarg : "";
+                size_t len = 0;
+                switch(opt) {
+                        // Exit Case
+                        case -1:
+                                /* paranoid */ assert(optind <= argc);
+                                switch(benchmark) {
+                                case NONE:
+                                        std::cerr << "Must specify a benchmark" << std::endl;
+                                        goto usage;
+                                case PingPong:
+                                        nnodes = 1;
+                                        nslots = 1;
+                                        switch(argc - optind) {
+                                        case 0: break;
+                                        case 1:
+                                                try {
+                                                        arg = optarg = argv[optind];
+                                                        nnodes = stoul(optarg, &len);
+                                                        if(len != arg.size()) { throw std::invalid_argument(""); }
+                                                } catch(std::invalid_argument &) {
+                                                        std::cerr << "Number of nodes must be a positive integer, was " << arg << std::endl;
+                                                        goto usage;
+                                                }
+                                                break;
+                                        default:
+                                                std::cerr << "'PingPong' benchmark doesn't accept more than 2 extra arguments" << std::endl;
+                                                goto usage;
+                                        }
+                                        break;
+                                case Churn:
+                                        nnodes = 100;
+                                        nslots = 100;
+                                        switch(argc - optind) {
+                                        case 0: break;
+                                        case 1:
+                                                try {
+                                                        arg = optarg = argv[optind];
+                                                        nnodes = stoul(optarg, &len);
+                                                        if(len != arg.size()) { throw std::invalid_argument(""); }
+                                                        nslots = nnodes;
+                                                } catch(std::invalid_argument &) {
+                                                        std::cerr << "Number of nodes must be a positive integer, was " << arg << std::endl;
+                                                        goto usage;
+                                                }
+                                                break;
+                                        case 2:
+                                                try {
+                                                        arg = optarg = argv[optind];
+                                                        nnodes = stoul(optarg, &len);
+                                                        if(len != arg.size()) { throw std::invalid_argument(""); }
+                                                } catch(std::invalid_argument &) {
+                                                        std::cerr << "Number of nodes must be a positive integer, was " << arg << std::endl;
+                                                        goto usage;
+                                                }
+                                                try {
+                                                        arg = optarg = argv[optind + 1];
+                                                        nslots = stoul(optarg, &len);
+                                                        if(len != arg.size()) { throw std::invalid_argument(""); }
+                                                } catch(std::invalid_argument &) {
+                                                        std::cerr << "Number of slots must be a positive integer, was " << arg << std::endl;
+                                                        goto usage;
+                                                }
+                                                break;
+                                        default:
+                                                std::cerr << "'Churn' benchmark doesn't accept more than 2 extra arguments" << std::endl;
+                                                goto usage;
+                                        }
+                                        break;
+                                case Fairness:
+                                        nnodes = 1;
+                                        switch(argc - optind) {
+                                        case 0: break;
+                                        case 1:
+                                                arg = optarg = argv[optind];
+                                                out = arg;
+                                                break;
+                                        default:
+                                                std::cerr << "'Churn' benchmark doesn't accept more than 2 extra arguments" << std::endl;
+                                                goto usage;
+                                        }
+                                }
+                                goto run;
+                        // Benchmarks
+                        case 'b':
+                                if(benchmark != NONE) {
+                                        std::cerr << "Only when benchmark can be run" << std::endl;
+                                        goto usage;
+                                }
+                                if(iequals(arg, "churn")) {
+                                        benchmark = Churn;
+                                        break;
+                                }
+                                if(iequals(arg, "pingpong")) {
+                                        benchmark = PingPong;
+                                        break;
+                                }
+                                if(iequals(arg, "fairness")) {
+                                        benchmark = Fairness;
+                                        break;
+                                }
+                                std::cerr << "Unkown benchmark " << arg << std::endl;
+                                goto usage;
+                        // Numeric Arguments
+                        case 'd':
+                                try {
+                                        duration = stod(optarg, &len);
+                                        if(len != arg.size()) { throw std::invalid_argument(""); }
+                                } catch(std::invalid_argument &) {
+                                        std::cerr << "Duration must be a valid double, was " << arg << std::endl;
+                                        goto usage;
+                                }
+                                break;
+                        case 't':
+                                try {
+                                        nthreads = stoul(optarg, &len);
+                                        if(len != arg.size()) { throw std::invalid_argument(""); }
+                                } catch(std::invalid_argument &) {
+                                        std::cerr << "Number of threads must be a positive integer, was " << arg << std::endl;
+                                        goto usage;
+                                }
+                                break;
+                        case 'q':
+                                try {
+                                        nqueues = stoul(optarg, &len);
+                                        if(len != arg.size()) { throw std::invalid_argument(""); }
+                                } catch(std::invalid_argument &) {
+                                        std::cerr << "Number of queues must be a positive integer, was " << arg << std::endl;
+                                        goto usage;
+                                }
+                                break;
+                        // Other cases
+                        default: /* ? */
+                                std::cerr << opt << std::endl;
+                        usage:
+                                std::cerr << "Usage: " << argv[0] << ": [options] -b churn [NNODES] [NSLOTS = NNODES]" << std::endl;
+                                std::cerr << "  or:  " << argv[0] << ": [options] -b pingpong [NNODES]" << std::endl;
+                                std::cerr << std::endl;
+                                std::cerr << "  -d, --duration=DURATION  Duration of the experiment, in seconds" << std::endl;
+                                std::cerr << "  -t, --nthreads=NTHREADS  Number of kernel threads" << std::endl;
+                                std::cerr << "  -q, --nqueues=NQUEUES    Number of queues per threads" << std::endl;
+                                std::exit(1);
+                }
+        }
+        run:
+        check_cache_line_size();
+        std::cout << "Running " << nthreads << " threads (" << (nthreads * nqueues) << " queues) for " << duration << " seconds" << std::endl;
+        switch(benchmark) {
+                case Churn:
+                        runChurn(nthreads, nqueues, duration, nnodes, nslots);
+                        break;
+                case PingPong:
+                        runPingPong(nthreads, nqueues, duration, nnodes);
+                        break;
+                case Fairness:
+                        runFairness(nthreads, nqueues, duration, nnodes, out);
+                        break;
+                default:
+                        abort();
+        }
+        return 0;
+}
+const char * __my_progname = "Relaxed List";
+struct rgb_t {
+    double r;       // a fraction between 0 and 1
+    double g;       // a fraction between 0 and 1
+    double b;       // a fraction between 0 and 1
+};
+struct hsv_t {
+    double h;       // angle in degrees
+    double s;       // a fraction between 0 and 1
+    double v;       // a fraction between 0 and 1
+};
+rgb_t hsv2rgb(hsv_t in) {
+        double hh, p, q, t, ff;
+        long   i;
+        rgb_t  out;
+        if(in.s <= 0.0) {       // < is bogus, just shuts up warnings
+                out.r = in.v;
+                out.g = in.v;
+                out.b = in.v;
+                return out;
+        }
+        hh = in.h;
+        if(hh >= 360.0) hh = 0.0;
+        hh /= 60.0;
+        i = (long)hh;
+        ff = hh - i;
+        p = in.v * (1.0 - in.s);
+        q = in.v * (1.0 - (in.s * ff));
+        t = in.v * (1.0 - (in.s * (1.0 - ff)));
+        switch(i) {
+        case 0:
+                out.r = in.v;
+                out.g = t;
+                out.b = p;
+                break;
+        case 1:
+                out.r = q;
+                out.g = in.v;
+                out.b = p;
+                break;
+        case 2:
+                out.r = p;
+                out.g = in.v;
+                out.b = t;
+                break;
+        case 3:
+                out.r = p;
+                out.g = q;
+                out.b = in.v;
+                break;
+        case 4:
+                out.r = t;
+                out.g = p;
+                out.b = in.v;
+                break;
         case 5:
+                fill = std::stoul(argv[4]);
+                [[fallthrough]];
+        case 4:
+                nqueues = std::stoul(argv[3]);
+                [[fallthrough]];
+        case 3:
+                nthreads = std::stoul(argv[2]);
+                [[fallthrough]];
+        case 2:
+                duration = std::stod(argv[1]);
+                if( duration <= 0.0 ) {
+                        std::cerr << "Duration must be positive, was " << argv[1] << "(" << duration << ")" << std::endl;
+                        usage(argv);
+                }
+                [[fallthrough]];
+        case 1:
+        default:
+                out.r = in.v;
+                out.g = p;
+                out.b = q;
                 break;
+        default:
+                usage(argv);
+                break;
+        }
+        check_cache_line_size();
+        std::cout << "Running " << nthreads << " threads (" << (nthreads * nqueues) << " queues) for " << duration << " seconds" << std::endl;
+        run(nthreads, nqueues, fill, duration);
+        return 0;
+}
+template<>
+thread_local relaxed_list<Node>::TLS relaxed_list<Node>::tls = {};
+template<>
+relaxed_list<Node>::intrusive_queue_t::stat::Dif relaxed_list<Node>::intrusive_queue_t::stat::dif = {};
+const char * __my_progname = "Relaxed List";
+        }
+        return out;
+}
+void save_fairness(const int data[], int factor, unsigned nthreads, size_t columns, size_t rows, const std::string & output) {
+        std::ofstream os(output);
+        os << "<html>\n";
+        os << "<head>\n";
+        os << "<style>\n";
+        os << "</style>\n";
+        os << "</head>\n";
+        os << "<body>\n";
+        os << "<table style=\"width=100%\">\n";
+        size_t idx = 0;
+        for(size_t r = 0ul; r < rows; r++) {
+                os << "<tr>\n";
+                for(size_t c = 0ul; c < columns; c++) {
+                        os << "<td class=\"custom custom" << data[idx] << "\"></td>\n";
+                        idx++;
+                }
+                os << "</tr>\n";
+        }
+        os << "</table>\n";
+        os << "</body>\n";
+        os << "</html>\n";
+        os << std::endl;
+}
+#include <png.h>
+#include <setjmp.h>
+/*
+void save_fairness(const int data[], int factor, unsigned nthreads, size_t columns, size_t rows, const std::string & output) {
+        int width  = columns * factor;
+        int height = rows / factor;
+        int code = 0;
+        int idx = 0;
+        FILE *fp = NULL;
+        png_structp png_ptr = NULL;
+        png_infop info_ptr = NULL;
+        png_bytep row = NULL;
+        // Open file for writing (binary mode)
+        fp = fopen(output.c_str(), "wb");
+        if (fp == NULL) {
+                fprintf(stderr, "Could not open file %s for writing\n", output.c_str());
+                code = 1;
+                goto finalise;
+        }
+           // Initialize write structure
+        png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+        if (png_ptr == NULL) {
+                fprintf(stderr, "Could not allocate write struct\n");
+                code = 1;
+                goto finalise;
+        }
+        // Initialize info structure
+        info_ptr = png_create_info_struct(png_ptr);
+        if (info_ptr == NULL) {
+                fprintf(stderr, "Could not allocate info struct\n");
+                code = 1;
+                goto finalise;
+        }
+        // Setup Exception handling
+        if (setjmp(png_jmpbuf(png_ptr))) {
+                fprintf(stderr, "Error during png creation\n");
+                code = 1;
+                goto finalise;
+        }
+        png_init_io(png_ptr, fp);
+        // Write header (8 bit colour depth)
+        png_set_IHDR(png_ptr, info_ptr, width, height,
+, PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE,
+                PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
+        png_write_info(png_ptr, info_ptr);
+        // Allocate memory for one row (3 bytes per pixel - RGB)
+        row = (png_bytep) malloc(3 * width * sizeof(png_byte));
+        // Write image data
+        int x, y;
+        for (y=0 ; y<height ; y++) {
+                for (x=0 ; x<width ; x++) {
+                        auto & r = row[(x * 3) + 0];
+                        auto & g = row[(x * 3) + 1];
+                        auto & b = row[(x * 3) + 2];
+                        assert(idx < (rows * columns));
+                        int color = data[idx] - 1;
+                        assert(color < nthreads);
+                        assert(color >= 0);
+                        idx++;
+                        double angle = double(color) / double(nthreads);
+                        auto c = hsv2rgb({ 360.0 * angle, 0.8, 0.8 });
+                        r = char(c.r * 255.0);
+                        g = char(c.g * 255.0);
+                        b = char(c.b * 255.0);
+                }
+                png_write_row(png_ptr, row);
+        }
+        assert(idx == (rows * columns));
+        // End write
+        png_write_end(png_ptr, NULL);
+        finalise:
+        if (fp != NULL) fclose(fp);
+        if (info_ptr != NULL) png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);
+        if (png_ptr != NULL) png_destroy_write_struct(&png_ptr, (png_infopp)NULL);
+        if (row != NULL) free(row);
+}
+*/

doc/theses/thierry_delisle_PhD/code/relaxed_list.hpp

-                      r8c50aed
+                      ra505021
 };
+static inline bool bts(std::atomic_size_t & target, size_t bit ) {
+        //*
+        int result = 0;
+        asm volatile(
+                "LOCK btsq %[bit], %[target]\n\t"
+                :"=@ccc" (result)
+                : [target] "m" (target), [bit] "r" (bit)
+        );
+        return result != 0;
+        /*/
+        size_t mask = 1ul << bit;
+        size_t ret = target.fetch_or(mask, std::memory_order_relaxed);
+        return (ret & mask) != 0;
+        //*/
+}
+static inline bool btr(std::atomic_size_t & target, size_t bit ) {
+        //*
+        int result = 0;
+        asm volatile(
+                "LOCK btrq %[bit], %[target]\n\t"
+                :"=@ccc" (result)
+                : [target] "m" (target), [bit] "r" (bit)
+        );
+        return result != 0;
+        /*/
+        size_t mask = 1ul << bit;
+        size_t ret = target.fetch_and(~mask, std::memory_order_relaxed);
+        return (ret & mask) != 0;
+        //*/
+}
 extern bool enable_stats;
 …
                 size_t attempt = 0;
                 size_t success = 0;
+                size_t mask_attempt = 0;
+        } pop;
+};
+struct empty_stat {
+        struct {
+                size_t value = 0;
+                size_t count = 0;
+        } push;
+        struct {
+                size_t value = 0;
+                size_t count = 0;
         } pop;
 };
 …
         static_assert(std::is_same<decltype(node_t::_links), _LinksFields_t<node_t>>::value, "Node must have a links field");
 public:
         relaxed_list(unsigned numLists)
+                : numNonEmpty{0}
+                , lists(new intrusive_queue_t[numLists])
+                : lists(new intrusive_queue_t[numLists])
                 , numLists(numLists)
+        {}
+        {
+                assertf(7 * 8 * 8 >= numLists, "List currently only supports 448 sublists");
+                // assert(sizeof(*this) == 128);
+                std::cout << "Constructing Relaxed List with " << numLists << std::endl;
+                #ifndef NO_STATS
+                        if(head) this->next = head;
+                        head = this;
+                #endif
+        }
         ~relaxed_list() {
+                std::cout << "Destroying Relaxed List" << std::endl;
                 lists.reset();
-                #ifndef NO_STATS
-                        std::cout << "Difference   : "
-                                << ssize_t(double(intrusive_queue_t::stat::dif.value) / intrusive_queue_t::stat::dif.num  ) << " avg\t"
-                                << intrusive_queue_t::stat::dif.max << "max" << std::endl;
-                #endif
+        }
 …
                 while(true) {
                         // Pick a random list
                         int i = tls.rng.next() % numLists;
+                        unsigned i = tls.rng.next() % numLists;
                         #ifndef NO_STATS
 …
                         if( !lists[i].lock.try_lock() ) continue;
+                        __attribute__((unused)) int num = numNonEmpty;
                         // Actually push it
+                        lists[i].push(node, numNonEmpty);
+                        if(lists[i].push(node)) {
+                                numNonEmpty++;
+                                size_t qword = i >> 6ull;
+                                size_t bit   = i & 63ull;
+                                assertf((list_mask[qword] & (1ul << bit)) == 0, "Before set %zu:%zu (%u), %zx & %zx", qword, bit, i, list_mask[qword].load(), (1ul << bit));
+                                __attribute__((unused)) bool ret = bts(list_mask[qword], bit);
+                                assert(!ret);
+                                assertf((list_mask[qword] & (1ul << bit)) != 0, "After set %zu:%zu (%u), %zx & %zx", qword, bit, i, list_mask[qword].load(), (1ul << bit));
+                        }
                         assert(numNonEmpty <= (int)numLists);
 …
                         #ifndef NO_STATS
                                 tls.pick.push.success++;
+                                tls.empty.push.value += num;
+                                tls.empty.push.count += 1;
                         #endif
                         return;
 …
         __attribute__((noinline, hot)) node_t * pop() {
+                while(numNonEmpty != 0) {
+                        // Pick two lists at random
+                        int i = tls.rng.next() % numLists;
+                        int j = tls.rng.next() % numLists;
+                        #ifndef NO_STATS
+                                tls.pick.pop.attempt++;
+                        #endif
+                        // Pick the bet list
+                        int w = i;
+                        if( __builtin_expect(lists[j].ts() != 0, true) ) {
+                                w = (lists[i].ts() < lists[j].ts()) ? i : j;
+                        }
+                        auto & list = lists[w];
+                        // If list looks empty retry
+                        if( list.ts() == 0 ) continue;
+                        // If we can't get the lock retry
+                        if( !list.lock.try_lock() ) continue;
+                        // If list is empty, unlock and retry
+                        if( list.ts() == 0 ) {
+                                list.lock.unlock();
+                                continue;
+                        }
+                        // Actually pop the list
+                        auto node = list.pop(numNonEmpty);
+                        assert(node);
+                        // Unlock and return
+                        list.lock.unlock();
+                        assert(numNonEmpty >= 0);
+                        #ifndef NO_STATS
+                                tls.pick.pop.success++;
+                        #endif
+                        return node;
+                }
+                #if !defined(NO_BITMASK)
+                        // for(int r = 0; r < 10 && numNonEmpty != 0; r++) {
+                        //      // Pick two lists at random
+                        //      unsigned i = tls.rng.next() % numLists;
+                        //      unsigned j = tls.rng.next() % numLists;
+                        //      if(auto node = try_pop(i, j)) return node;
+                        // }
+                        int nnempty;
+                        while(0 != (nnempty = numNonEmpty)) {
+                                tls.pick.pop.mask_attempt++;
+                                unsigned i, j;
+                                // if( numLists < 4 || (numLists / nnempty) < 4 ) {
+                                //      // Pick two lists at random
+                                //      i = tls.rng.next() % numLists;
+                                //      j = tls.rng.next() % numLists;
+                                // } else
+                                {
+                                        #ifndef NO_STATS
+                                                // tls.pick.push.mask_attempt++;
+                                        #endif
+                                        // Pick two lists at random
+                                        unsigned num = ((numLists - 1) >> 6) + 1;
+                                        unsigned ri = tls.rng.next();
+                                        unsigned rj = tls.rng.next();
+                                        unsigned wdxi = (ri >> 6u) % num;
+                                        unsigned wdxj = (rj >> 6u) % num;
+                                        size_t maski = list_mask[wdxi].load(std::memory_order_relaxed);
+                                        size_t maskj = list_mask[wdxj].load(std::memory_order_relaxed);
+                                        if(maski == 0 && maskj == 0) continue;
+                                        unsigned bi = rand_bit(ri, maski);
+                                        unsigned bj = rand_bit(rj, maskj);
+                                        assertf(bi < 64, "%zu %u", maski, bi);
+                                        assertf(bj < 64, "%zu %u", maskj, bj);
+                                        i = bi | (wdxi << 6);
+                                        j = bj | (wdxj << 6);
+                                        assertf(i < numLists, "%u", wdxi << 6);
+                                        assertf(j < numLists, "%u", wdxj << 6);
+                                }
+                                if(auto node = try_pop(i, j)) return node;
+                        }
+                #else
+                        while(numNonEmpty != 0) {
+                                // Pick two lists at random
+                                int i = tls.rng.next() % numLists;
+                                int j = tls.rng.next() % numLists;
+                                if(auto node = try_pop(i, j)) return node;
+                        }
+                #endif
                 return nullptr;
+        }
+private:
+        node_t * try_pop(unsigned i, unsigned j) {
+                #ifndef NO_STATS
+                        tls.pick.pop.attempt++;
+                #endif
+                // Pick the bet list
+                int w = i;
+                if( __builtin_expect(lists[j].ts() != 0, true) ) {
+                        w = (lists[i].ts() < lists[j].ts()) ? i : j;
+                }
+                auto & list = lists[w];
+                // If list looks empty retry
+                if( list.ts() == 0 ) return nullptr;
+                // If we can't get the lock retry
+                if( !list.lock.try_lock() ) return nullptr;
+                __attribute__((unused)) int num = numNonEmpty;
+                // If list is empty, unlock and retry
+                if( list.ts() == 0 ) {
+                        list.lock.unlock();
+                        return nullptr;
+                }
+                // Actually pop the list
+                node_t * node;
+                bool emptied;
+                std::tie(node, emptied) = list.pop();
+                assert(node);
+                if(emptied) {
+                        numNonEmpty--;
+                        size_t qword = w >> 6ull;
+                        size_t bit   = w & 63ull;
+                        assert((list_mask[qword] & (1ul << bit)) != 0);
+                        __attribute__((unused)) bool ret = btr(list_mask[qword], bit);
+                        assert(ret);
+                        assert((list_mask[qword] & (1ul << bit)) == 0);
+                }
+                // Unlock and return
+                list.lock.unlock();
+                assert(numNonEmpty >= 0);
+                #ifndef NO_STATS
+                        tls.pick.pop.success++;
+                        tls.empty.pop.value += num;
+                        tls.empty.pop.count += 1;
+                #endif
+                return node;
+        }
 private:
 …
                 struct stat {
                         ssize_t diff = 0;
+                        static struct Dif {
+                                ssize_t value = 0;
+                                size_t  num   = 0;
+                                ssize_t max   = 0;
+                        } dif;
+                        size_t  push = 0;
+                        size_t  pop  = 0;
+                        // size_t value = 0;
+                        // size_t count = 0;
                 };
 …
                 sentinel_t before;
                 sentinel_t after;
+                stat s;
+                #ifndef NO_STATS
+                        stat s;
+                #endif
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Winvalid-offsetof"
                 static constexpr auto fields_offset = offsetof( node_t, _links );
+#pragma GCC diagnostic pop
         public:
                 intrusive_queue_t()
 …
                         , after {{ head(), nullptr }}
+                {
+                        assert((reinterpret_cast<uintptr_t>( head() ) + fields_offset) == reinterpret_cast<uintptr_t>(&before));
+                        assert((reinterpret_cast<uintptr_t>( tail() ) + fields_offset) == reinterpret_cast<uintptr_t>(&after ));
+                        assert(head()->_links.prev == nullptr);
+                        assert(head()->_links.next == tail() );
+                        assert(tail()->_links.next == nullptr);
+                        assert(tail()->_links.prev == head() );
+                        assert(sizeof(*this) == 128);
+                        assert((intptr_t(this) % 128) == 0);
+                }
+                ~intrusive_queue_t() {
+                        #ifndef NO_STATS
+                                stat::dif.value+= s.diff;
+                                stat::dif.num  ++;
+                                stat::dif.max  = std::abs(stat::dif.max) > std::abs(s.diff) ? stat::dif.max : s.diff;
+                        #endif
+                }
+                        /* paranoid */ assert((reinterpret_cast<uintptr_t>( head() ) + fields_offset) == reinterpret_cast<uintptr_t>(&before));
+                        /* paranoid */ assert((reinterpret_cast<uintptr_t>( tail() ) + fields_offset) == reinterpret_cast<uintptr_t>(&after ));
+                        /* paranoid */ assert(head()->_links.prev == nullptr);
+                        /* paranoid */ assert(head()->_links.next == tail() );
+                        /* paranoid */ assert(tail()->_links.next == nullptr);
+                        /* paranoid */ assert(tail()->_links.prev == head() );
+                        /* paranoid */ assert(sizeof(*this) == 128);
+                        /* paranoid */ assert((intptr_t(this) % 128) == 0);
+                }
+                ~intrusive_queue_t() = default;
                 inline node_t * head() const {
 …
+                }
                 inline void push(node_t * node, std::atomic_int & nonEmpty) {
+                inline bool push(node_t * node) {
                         assert(lock);
                         assert(node->_links.ts != 0);
 …
                         prev->_links.next = node;
                         tail->_links.prev = node;
+                        #ifndef NO_STATS
+                                if(enable_stats) {
+                                        s.diff++;
+                                        s.push++;
+                                }
+                        #endif
                         if(before._links.ts == 0l) {
-                                nonEmpty += 1;
                                 before._links.ts = node->_links.ts;
+                        }
                         #ifndef NO_STATS
                                 if(enable_stats) s.diff++;
                         #endif
+                }
                 inline node_t * pop(std::atomic_int & nonEmpty) {
+                                assert(node->_links.prev == this->head());
+                                return true;
+                        }
+                        return false;
+                }
+                inline std::pair<node_t *, bool> pop() {
                         assert(lock);
                         node_t * head = this->head();
 …
                         node_t * node = head->_links.next;
                         node_t * next = node->_links.next;
                         if(node == tail) return nullptr;
+                        if(node == tail) return {nullptr, false};
                         head->_links.next = next;
                         next->_links.prev = head;
+                        #ifndef NO_STATS
+                                if(enable_stats) {
+                                        s.diff--;
+                                        s.pop ++;
+                                }
+                        #endif
                         if(next == tail) {
                                 before._links.ts = 0l;
                                 nonEmpty -= 1;
+                                return {node, true};
+                        }
                         else {
 …
                                 before._links.ts = next->_links.ts;
                                 assert(before._links.ts != 0);
+                        }
+                        #ifndef NO_STATS
+                                if(enable_stats) s.diff--;
+                        #endif
+                        return node;
+                                return {node, false};
+                        }
+                }
 …
         static __attribute__((aligned(128))) thread_local struct TLS {
+                Random    rng = { int(rdtscl()) };
+                pick_stat pick;
+                Random     rng = { int(rdtscl()) };
+                pick_stat  pick;
+                empty_stat empty;
         } tls;
+public:
+        std::atomic_int numNonEmpty  = { 0 };  // number of non-empty lists
+        std::atomic_size_t list_mask[7] = { {0}, {0}, {0}, {0}, {0}, {0}, {0} }; // which queues are empty
 private:
-        std::atomic_int numNonEmpty; // number of non-empty lists
         __attribute__((aligned(64))) std::unique_ptr<intrusive_queue_t []> lists;
         const unsigned numLists;
 …
 public:
         static const constexpr size_t sizeof_queue = sizeof(intrusive_queue_t);
+#ifndef NO_STATS
+        static void stats_print(std::ostream & os) {
+                auto it = head;
+                while(it) {
+                        it->stats_print_local(os);
+                        it = it->next;
+                }
+        }
+        static void stats_tls_tally() {
+                global_stats.pick.push.attempt += tls.pick.push.attempt;
+                global_stats.pick.push.success += tls.pick.push.success;
+                global_stats.pick.pop .attempt += tls.pick.pop.attempt;
+                global_stats.pick.pop .success += tls.pick.pop.success;
+                global_stats.pick.pop .mask_attempt += tls.pick.pop.mask_attempt;
+                global_stats.qstat.push.value += tls.empty.push.value;
+                global_stats.qstat.push.count += tls.empty.push.count;
+                global_stats.qstat.pop .value += tls.empty.pop .value;
+                global_stats.qstat.pop .count += tls.empty.pop .count;
+        }
+private:
+        static struct GlobalStats {
+                struct {
+                        struct {
+                                std::atomic_size_t attempt = { 0 };
+                                std::atomic_size_t success = { 0 };
+                        } push;
+                        struct {
+                                std::atomic_size_t attempt = { 0 };
+                                std::atomic_size_t success = { 0 };
+                                std::atomic_size_t mask_attempt = { 0 };
+                        } pop;
+                } pick;
+                struct {
+                        struct {
+                                std::atomic_size_t value = { 0 };
+                                std::atomic_size_t count = { 0 };
+                        } push;
+                        struct {
+                                std::atomic_size_t value = { 0 };
+                                std::atomic_size_t count = { 0 };
+                        } pop;
+                } qstat;
+        } global_stats;
+        // Link list of all lists for stats
+        __attribute__((aligned(64))) relaxed_list<node_t> * next = nullptr;
+        static relaxed_list<node_t> * head;
+        void stats_print_local(std::ostream & os ) {
+                std::cout << "----- Relaxed List Stats -----" << std::endl;
+                {
+                        ssize_t diff = 0;
+                        size_t  num  = 0;
+                        ssize_t max  = 0;
+                        for(size_t i = 0; i < numLists; i++) {
+                                const auto & list = lists[i];
+                                diff+= list.s.diff;
+                                num ++;
+                                max  = std::abs(max) > std::abs(list.s.diff) ? max : list.s.diff;
+                                os << "Local Q ops   : " << (list.s.push + list.s.pop) << "(" << list.s.push << "i, " << list.s.pop << "o)\n";
+                        }
+                        os << "Difference   : " << ssize_t(double(diff) / num  ) << " avg\t" << max << "max" << std::endl;
+                }
+                const auto & global = global_stats;
+                double push_sur = (100.0 * double(global.pick.push.success) / global.pick.push.attempt);
+                double pop_sur  = (100.0 * double(global.pick.pop .success) / global.pick.pop .attempt);
+                double mpop_sur = (100.0 * double(global.pick.pop .success) / global.pick.pop .mask_attempt);
+                os << "Push   Pick % : " << push_sur << "(" << global.pick.push.success << " / " << global.pick.push.attempt << ")\n";
+                os << "Pop    Pick % : " << pop_sur  << "(" << global.pick.pop .success << " / " << global.pick.pop .attempt << ")\n";
+                os << "TryPop Pick % : " << mpop_sur << "(" << global.pick.pop .success << " / " << global.pick.pop .mask_attempt << ")\n";
+                double avgQ_push = double(global.qstat.push.value) / global.qstat.push.count;
+                double avgQ_pop  = double(global.qstat.pop .value) / global.qstat.pop .count;
+                double avgQ      = double(global.qstat.push.value + global.qstat.pop .value) / (global.qstat.push.count + global.qstat.pop .count);
+                os << "Push   Avg Qs : " << avgQ_push << " (" << global.qstat.push.count << "ops)\n";
+                os << "Pop    Avg Qs : " << avgQ_pop  << " (" << global.qstat.pop .count << "ops)\n";
+                os << "Global Avg Qs : " << avgQ      << " (" << (global.qstat.push.count + global.qstat.pop .count) << "ops)\n";
+        }
+#endif
 };

doc/theses/thierry_delisle_PhD/code/utils.hpp

-                      r8c50aed
+                      ra505021
 #include <unistd.h>
 #include <sys/sysinfo.h>
+#include <x86intrin.h>
 // Barrier from
 …
+}
 void affinity(int tid) {
+static inline void affinity(int tid) {
         static int cpus = get_nprocs();
 …
 static const constexpr std::size_t cache_line_size = 64;
 void check_cache_line_size() {
+static inline void check_cache_line_size() {
         std::cout << "Checking cache line size" << std::endl;
         const std::string cache_file = "/sys/devices/system/cpu/cpu0/cache/index0/coherency_line_size";
 …
         return std::chrono::duration_cast<std::chrono::duration<T, Ratio>>(std::chrono::duration<T>(seconds)).count();
+}
+static inline unsigned rand_bit(unsigned rnum, size_t mask) {
+        unsigned bit = mask ? rnum % __builtin_popcountl(mask) : 0;
+#if !defined(__BMI2__)
+        uint64_t v = mask;   // Input value to find position with rank r.
+        unsigned int r = bit + 1;// Input: bit's desired rank [1-64].
+        unsigned int s;      // Output: Resulting position of bit with rank r [1-64]
+        uint64_t a, b, c, d; // Intermediate temporaries for bit count.
+        unsigned int t;      // Bit count temporary.
+        // Do a normal parallel bit count for a 64-bit integer,
+        // but store all intermediate steps.
+        a =  v - ((v >> 1) & ~0UL/3);
+        b = (a & ~0UL/5) + ((a >> 2) & ~0UL/5);
+        c = (b + (b >> 4)) & ~0UL/0x11;
+        d = (c + (c >> 8)) & ~0UL/0x101;
+        t = (d >> 32) + (d >> 48);
+        // Now do branchless select!
+        s  = 64;
+        s -= ((t - r) & 256) >> 3; r -= (t & ((t - r) >> 8));
+        t  = (d >> (s - 16)) & 0xff;
+        s -= ((t - r) & 256) >> 4; r -= (t & ((t - r) >> 8));
+        t  = (c >> (s - 8)) & 0xf;
+        s -= ((t - r) & 256) >> 5; r -= (t & ((t - r) >> 8));
+        t  = (b >> (s - 4)) & 0x7;
+        s -= ((t - r) & 256) >> 6; r -= (t & ((t - r) >> 8));
+        t  = (a >> (s - 2)) & 0x3;
+        s -= ((t - r) & 256) >> 7; r -= (t & ((t - r) >> 8));
+        t  = (v >> (s - 1)) & 0x1;
+        s -= ((t - r) & 256) >> 8;
+        return s - 1;
+#else
+        uint64_t picked = _pdep_u64(1ul << bit, mask);
+        return picked ? __builtin_ctzl(picked) : 0;
+#endif
+}

driver/cfa.cc

-                      r8c50aed
+                      ra505021
                 args[nargs++] = "-lcfathread";
                 args[nargs++] = "-Wl,--pop-state";
+                args[nargs++] = "-Wl,--push-state,--no-as-needed";
                 args[nargs++] = "-lcfa";
+                args[nargs++] = "-Wl,--pop-state";
                 args[nargs++] = "-pthread";
                 args[nargs++] = "-ldl";

libcfa/prelude/Makefile.am

-                      r8c50aed
+                      ra505021
 ## Created On       : Sun May 31 08:54:01 2015
 ## Last Modified By : Peter A. Buhr
 ## Last Modified On : Wed Dec 14 15:00:35 2016
 ## Update Count     : 205
+## Last Modified On : Mon Feb  3 21:27:18 2020
+## Update Count     : 208
 ###############################################################################
 …
 extras.cf : ${srcdir}/extras.regx ${srcdir}/extras.c
         ${AM_V_GEN}gcc ${AM_CFLAGS} -E ${srcdir}/extras.c | grep -f ${srcdir}/extras.regx > extras.cf
+        ${AM_V_GEN}gcc ${AM_CFLAGS} -E ${srcdir}/extras.c | grep -zo -f ${srcdir}/extras.regx2 | tr '\0' '\n' >> extras.cf
 # create forward declarations for gcc builtins

libcfa/prelude/Makefile.in

-                      r8c50aed
+                      ra505021
 # Makefile.in generated by automake 1.15 from Makefile.am.
+# Makefile.in generated by automake 1.16.1 from Makefile.am.
 # @configure_input@
 # Copyright (C) 1994-2014 Free Software Foundation, Inc.
+# Copyright (C) 1994-2018 Free Software Foundation, Inc.
 # This Makefile.in is free software; the Free Software Foundation
 …
             cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
           *) \
             echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
             cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+            echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles)'; \
+            cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \
         esac;
 …
+distdir: $(DISTFILES)
+distdir: $(BUILT_SOURCES)
+        $(MAKE) $(AM_MAKEFLAGS) distdir-am
+distdir-am: $(DISTFILES)
         @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
         topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
 …
 extras.cf : ${srcdir}/extras.regx ${srcdir}/extras.c
         ${AM_V_GEN}gcc ${AM_CFLAGS} -E ${srcdir}/extras.c | grep -f ${srcdir}/extras.regx > extras.cf
+        ${AM_V_GEN}gcc ${AM_CFLAGS} -E ${srcdir}/extras.c | grep -zo -f ${srcdir}/extras.regx2 | tr '\0' '\n' >> extras.cf
 # create forward declarations for gcc builtins

libcfa/prelude/extras.regx

-                      r8c50aed
+                      ra505021
 typedef.* char32_t;
 typedef.* wchar_t;
-extern.*\*malloc\(.*\).*
-extern.* free\(.*\).*
-extern.* exit\(.*\).*
-extern.* atexit\(.*\).*
-extern.* abort\(.*\).*
-extern.* printf\(.*\).*

libcfa/prelude/prototypes.awk

-                      r8c50aed
+                      ra505021
 # Created On       : Sat May 16 07:57:37 2015
 # Last Modified By : Peter A. Buhr
 # Last Modified On : Thu Jun  6 20:46:28 2019
 # Update Count     : 34
+# Last Modified On : Sat Feb  8 09:46:58 2020
+# Update Count     : 36
+#
 …
 BEGIN {
   FS = "[( )]"
+        FS = "[( )]"
         # order so string search is longest string
         i=-1
 …
 /BT_FN/ {
         for (i = 1; i <= NF; i++) {
           if( match($i, "BT_FN") != 0 ) {
                 prototypes[$i] = $i
+          }
+        for (i = 1; i <= NF; i += 1 ) {
+                if ( match($i, "BT_FN") != 0 ) {
+                        prototypes[$i] = $i
+                }
+        }
+  }
+}
 END {
 …
         for ( prototype in prototypes ) {
           # printf( "//\"%s\"\n", prototype )
           if ( index( "BT_LAST", prototype ) == 1 ) {
                 continue
           } # if
+                # printf( "//\"%s\"\n", prototype )
+                if ( index( "BT_LAST", prototype ) == 1 ) {
+                        continue
+                } # if
           printf( "#define %s(NAME) FUNC_SIMPLE(", prototype )
+                printf( "#define %s(NAME) FUNC_SIMPLE(", prototype )
           if ( sub( "BT_FN_", "", prototype ) == 0 ) {
                 printf( "\n********** BAD MACRO NAME \"%s\" **********\n", prototype )
                 exit 0
           } # if
+                if ( sub( "BT_FN_", "", prototype ) == 0 ) {
+                        printf( "\n********** BAD MACRO NAME \"%s\" **********\n", prototype )
+                        exit 0
+                } # if
+          # generate function return type as macro
+          for ( t = 0; t < N; t += 1 ) {                                        # find longest match
+                type = types[t];
+                if ( index( prototype, type ) == 1 ) {          # found match
+                  printf( "BT_%s, NAME", type )
+                  sub( type, "", prototype )
+                  break;
+                # generate function return type as macro
+                for ( t = 0; t < N; t += 1 ) {                                  # find longest match
+                        type = types[t];
+                        if ( index( prototype, type ) == 1 ) {          # found match
+                                printf( "BT_%s, NAME", type )
+                                sub( type, "", prototype )
+                                break;
+                        } # if
+                } # for
+                # generate function parameter types as macro
+                if ( index( prototype, "VAR" ) != 2 ) {                 # C-style empty parameters ?
+                        for ( p = 0; length( prototype ) > 0; p += 1 ) { # until all parameters types are removed
+                                sub( "_", "", prototype)                                # remove "_"
+                                printf( ", ", type )
+                                temp = prototype
+                                for ( t = 0; t < N; t += 1 ) {                  # find longest match
+                                        type = types[t];
+                                        if ( index( prototype, type ) == 1 ) { # found match
+                                                printf( "BT_%s", type )
+                                                sub( type, "", prototype )
+                                                break;
+                                        } # if
+                                } # for
+                                if ( temp == prototype ) {                              # no match found for parameter in macro table
+                                        printf( "\n********** MISSING TYPE \"%s\" **********\n", prototype )
+                                        exit 0
+                                } # if
+                        } # for
                 } # if
+          } # for
+          # generate function parameter types as macro
+          if ( index( prototype, "VAR" ) != 2 ) {                       # C-style empty parameters ?
+                for ( p = 0; length( prototype ) > 0; p += 1 ) { # until all parameters types are removed
+                  sub( "_", "", prototype)                              # remove "_"
+                  printf( ", ", type )
+                  temp = prototype
+                  for ( t = 0; t < N; t += 1 ) {                        # find longest match
+                        type = types[t];
+                        if ( index( prototype, type ) == 1 ) { # found match
+                          printf( "BT_%s", type )
+                          sub( type, "", prototype )
+                          break;
+                        } # if
+                  } # for
+                  if ( temp == prototype ) {                            # no match found for parameter in macro table
+                        printf( "\n********** MISSING TYPE \"%s\" **********\n", prototype )
+                        exit 0
+                  } # if
+                } # for
+          } # if
+          printf( ")\n" )
+                printf( ")\n" )
         } # for

libcfa/src/assert.cfa

-                      r8c50aed
+                      ra505021
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Nov 21 17:09:26 2019
 // Update Count     : 5
+// Last Modified On : Tue Feb  4 13:00:18 2020
+// Update Count     : 6
 //
 …
         // called by macro assert in assert.h
         void __assert_fail( const char *assertion, const char *file, unsigned int line, const char *function ) {
+        void __assert_fail( const char assertion[], const char file[], unsigned int line, const char function[] ) {
                 __cfaabi_bits_print_safe( STDERR_FILENO, CFA_ASSERT_FMT ".\n", assertion, __progname, function, line, file );
                 abort();
 …
         // called by macro assertf
         void __assert_fail_f( const char *assertion, const char *file, unsigned int line, const char *function, const char *fmt, ... ) {
+        void __assert_fail_f( const char assertion[], const char file[], unsigned int line, const char function[], const char fmt[], ... ) {
                 __cfaabi_bits_acquire();
                 __cfaabi_bits_print_nolock( STDERR_FILENO, CFA_ASSERT_FMT ": ", assertion, __progname, function, line, file );

libcfa/src/bits/debug.cfa

-                      r8c50aed
+                      ra505021
 // Created On       : Thu Mar 30 12:30:01 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Nov 21 17:16:30 2019
 // Update Count     : 10
+// Last Modified On : Tue Feb  4 13:03:16 2020
+// Update Count     : 11
 //
 …
 extern "C" {
+        void __cfaabi_bits_write( int fd, const char *in_buffer, int len ) {
+        void __cfaabi_bits_write( int fd, const char in_buffer[], int len ) {
                 // ensure all data is written
                 for ( int count = 0, retcode; count < len; count += retcode ) {

libcfa/src/bits/debug.hfa

-                      r8c50aed
+                      ra505021
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Nov 21 17:06:58 2019
 // Update Count     : 8
+// Last Modified On : Tue Feb  4 12:29:21 2020
+// Update Count     : 9
 //
 …
         #define __cfaabi_dbg_ctx __PRETTY_FUNCTION__
         #define __cfaabi_dbg_ctx2 , __PRETTY_FUNCTION__
         #define __cfaabi_dbg_ctx_param const char * caller
         #define __cfaabi_dbg_ctx_param2 , const char * caller
+        #define __cfaabi_dbg_ctx_param const char caller[]
+        #define __cfaabi_dbg_ctx_param2 , const char caller[]
 #else
         #define __cfaabi_dbg_debug_do(...)
 …
         #include <stdio.h>
         extern void __cfaabi_bits_write( int fd, const char *buffer, int len );
+        extern void __cfaabi_bits_write( int fd, const char buffer[], int len );
         extern void __cfaabi_bits_acquire();
         extern void __cfaabi_bits_release();

libcfa/src/bits/locks.hfa

-                      r8c50aed
+                      ra505021
 // Created On       : Tue Oct 31 15:14:38 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Aug 11 15:42:24 2018
 // Update Count     : 10
+// Last Modified On : Tue Feb  4 13:03:19 2020
+// Update Count     : 11
 //
 …
                 #ifdef __CFA_DEBUG__
                         void __cfaabi_dbg_record(__spinlock_t & this, const char * prev_name);
+                        void __cfaabi_dbg_record(__spinlock_t & this, const char prev_name[]);
                 #else
                         #define __cfaabi_dbg_record(x, y)

libcfa/src/concurrency/coroutine.cfa

-                      r8c50aed
+                      ra505021
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Dec  5 14:37:29 2019
 // Update Count     : 15
+// Last Modified On : Tue Feb  4 12:29:25 2020
+// Update Count     : 16
 //
 …
+}
 void ?{}( coroutine_desc & this, const char * name, void * storage, size_t storageSize ) with( this ) {
+void ?{}( coroutine_desc & this, const char name[], void * storage, size_t storageSize ) with( this ) {
         (this.context){0p, 0p};
         (this.stack){storage, storageSize};

libcfa/src/concurrency/coroutine.hfa

-                      r8c50aed
+                      ra505021
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Dec  3 22:47:58 2019
 // Update Count     : 10
+// Last Modified On : Tue Feb  4 12:29:26 2020
+// Update Count     : 11
 //
 …
 // void ^?{}( coStack_t & this );
 void ?{}( coroutine_desc & this, const char * name, void * storage, size_t storageSize );
+void ?{}( coroutine_desc & this, const char name[], void * storage, size_t storageSize );
 void ^?{}( coroutine_desc & this );
 …
 static inline void ?{}( coroutine_desc & this, size_t stackSize)                     { this{ "Anonymous Coroutine", 0p, stackSize }; }
 static inline void ?{}( coroutine_desc & this, void * storage, size_t storageSize )  { this{ "Anonymous Coroutine", storage, storageSize }; }
 static inline void ?{}( coroutine_desc & this, const char * name)                    { this{ name, 0p, 0 }; }
 static inline void ?{}( coroutine_desc & this, const char * name, size_t stackSize ) { this{ name, 0p, stackSize }; }
+static inline void ?{}( coroutine_desc & this, const char name[])                    { this{ name, 0p, 0 }; }
+static inline void ?{}( coroutine_desc & this, const char name[], size_t stackSize ) { this{ name, 0p, stackSize }; }
 //-----------------------------------------------------------------------------

libcfa/src/concurrency/kernel.cfa

-                      r8c50aed
+                      ra505021
 // Created On       : Tue Jan 17 12:27:26 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jan 30 22:55:50 2020
 // Update Count     : 56
+// Last Modified On : Tue Feb  4 13:03:15 2020
+// Update Count     : 58
 //
 …
 static void * CtxInvokeProcessor(void * arg);
 void ?{}(processor & this, const char * name, cluster & cltr) with( this ) {
+void ?{}(processor & this, const char name[], cluster & cltr) with( this ) {
         this.name = name;
         this.cltr = &cltr;
 …
+}
 void ?{}(cluster & this, const char * name, Duration preemption_rate) with( this ) {
+void ?{}(cluster & this, const char name[], Duration preemption_rate) with( this ) {
         this.name = name;
         this.preemption_rate = preemption_rate;
 …
+}
 static void Abort( int ret, const char * func ) {
+static void Abort( int ret, const char func[] ) {
         if ( ret ) {                                                                            // pthread routines return errno values
                 abort( "%s : internal error, error(%d) %s.", func, ret, strerror( ret ) );
 …
 __cfaabi_dbg_debug_do(
         extern "C" {
                 void __cfaabi_dbg_record(__spinlock_t & this, const char * prev_name) {
+                void __cfaabi_dbg_record(__spinlock_t & this, const char prev_name[]) {
                         this.prev_name = prev_name;
                         this.prev_thrd = kernelTLS.this_thread;

libcfa/src/concurrency/kernel.hfa

-                      r8c50aed
+                      ra505021
 // Created On       : Tue Jan 17 12:27:26 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Dec  4 07:54:51 2019
 // Update Count     : 18
+// Last Modified On : Tue Feb  4 12:29:26 2020
+// Update Count     : 22
 //
 …
 };
 void  ?{}(processor & this, const char * name, struct cluster & cltr);
+void  ?{}(processor & this, const char name[], struct cluster & cltr);
 void ^?{}(processor & this);
 static inline void  ?{}(processor & this)                    { this{ "Anonymous Processor", *mainCluster}; }
 static inline void  ?{}(processor & this, struct cluster & cltr)    { this{ "Anonymous Processor", cltr}; }
 static inline void  ?{}(processor & this, const char * name) { this{name, *mainCluster }; }
+static inline void  ?{}(processor & this, const char name[]) { this{name, *mainCluster }; }
 static inline [processor *&, processor *& ] __get( processor & this ) /*__attribute__((const))*/ { return this.node.[next, prev]; }
 …
 extern Duration default_preemption();
 void ?{} (cluster & this, const char * name, Duration preemption_rate);
+void ?{} (cluster & this, const char name[], Duration preemption_rate);
 void ^?{}(cluster & this);
 static inline void ?{} (cluster & this)                           { this{"Anonymous Cluster", default_preemption()}; }
 static inline void ?{} (cluster & this, Duration preemption_rate) { this{"Anonymous Cluster", preemption_rate}; }
 static inline void ?{} (cluster & this, const char * name)        { this{name, default_preemption()}; }
+static inline void ?{} (cluster & this, const char name[])        { this{name, default_preemption()}; }
 static inline [cluster *&, cluster *& ] __get( cluster & this ) /*__attribute__((const))*/ { return this.node.[next, prev]; }

libcfa/src/exception.c

-                      r8c50aed
+                      ra505021
+}
+#if defined(PIC)
+#warning Exceptions not yet supported when using Position-Independent Code
+__attribute__((noinline))
+void __cfaabi_ehm__try_terminate(void (*try_block)(),
+                void (*catch_block)(int index, exception_t * except),
+                __attribute__((unused)) int (*match_block)(exception_t * except)) {
+        abort();
+}
+#else // PIC
+#pragma GCC push_options
+#pragma GCC optimize("O0")
 // This is our personality routine. For every stack frame annotated with
 // ".cfi_personality 0x3,__gcfa_personality_v0" this function will be called twice when unwinding.
 …
         // Setup the personality routine and exception table.
+#ifdef __PIC__
+        asm volatile (".cfi_personality 0x9b,CFA.ref.__gcfa_personality_v0");
+        asm volatile (".cfi_lsda 0x1b, .LLSDACFA2");
+#else
         asm volatile (".cfi_personality 0x3,__gcfa_personality_v0");
         asm volatile (".cfi_lsda 0x3, .LLSDACFA2");
+#endif
         // Label which defines the start of the area for which the handler is setup.
 …
 // have a single call to the try routine.
+#ifdef __PIC__
+#if defined( __i386 ) || defined( __x86_64 )
+asm (
+        // HEADER
+        ".LFECFA1:\n"
+        "       .globl  __gcfa_personality_v0\n"
+        "       .section        .gcc_except_table,\"a\",@progbits\n"
+        // TABLE HEADER (important field is the BODY length at the end)
+        ".LLSDACFA2:\n"
+        "       .byte   0xff\n"
+        "       .byte   0xff\n"
+        "       .byte   0x1\n"
+        "       .uleb128 .LLSDACSECFA2-.LLSDACSBCFA2\n"
+        // BODY (language specific data)
+        // This uses language specific data and can be modified arbitrarily
+        // We use handled area offset, handled area length,
+        // handler landing pad offset and 1 (action code, gcc seems to use 0).
+        ".LLSDACSBCFA2:\n"
+        "       .uleb128 .TRYSTART-__cfaabi_ehm__try_terminate\n"
+        "       .uleb128 .TRYEND-.TRYSTART\n"
+        "       .uleb128 .CATCH-__cfaabi_ehm__try_terminate\n"
+        "       .uleb128 1\n"
+        ".LLSDACSECFA2:\n"
+        // TABLE FOOTER
+        "       .text\n"
+        "       .size   __cfaabi_ehm__try_terminate, .-__cfaabi_ehm__try_terminate\n"
+);
+// Somehow this piece of helps with the resolution of debug symbols.
+__attribute__((unused)) static const int dummy = 0;
+asm (
+        // Add a hidden symbol which points at the function.
+        "       .hidden CFA.ref.__gcfa_personality_v0\n"
+        "       .weak   CFA.ref.__gcfa_personality_v0\n"
+        // No clue what this does specifically
+        "       .section        .data.rel.local.CFA.ref.__gcfa_personality_v0,\"awG\",@progbits,CFA.ref.__gcfa_personality_v0,comdat\n"
+        "       .align 8\n"
+        "       .type CFA.ref.__gcfa_personality_v0, @object\n"
+        "       .size CFA.ref.__gcfa_personality_v0, 8\n"
+        "CFA.ref.__gcfa_personality_v0:\n"
+#if defined( __x86_64 )
+        "       .quad __gcfa_personality_v0\n"
+#else // then __i386
+        "   .long __gcfa_personality_v0\n"
+#endif
+);
+#else
+#error Exception Handling: unknown architecture for position independent code.
+#endif // __i386 || __x86_64
+#else // __PIC__
 #if defined( __i386 ) || defined( __x86_64 )
 asm (
 …
         "       .size   __cfaabi_ehm__try_terminate, .-__cfaabi_ehm__try_terminate\n"
         "       .ident  \"GCC: (Ubuntu 6.2.0-3ubuntu11~16.04) 6.2.0 20160901\"\n"
 //      "       .section        .note.GNU-stack,\"x\",@progbits\n"
+        "       .section        .note.GNU-stack,\"x\",@progbits\n"
 );
+#else
+#error Exception Handling: unknown architecture for position dependent code.
 #endif // __i386 || __x86_64
+#endif // PIC
+#endif // __PIC__
+#pragma GCC pop_options

libcfa/src/fstream.cfa

-                      r8c50aed
+                      ra505021
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Nov 29 06:56:46 2019
 // Update Count     : 355
+// Last Modified On : Fri Feb  7 19:01:01 2020
+// Update Count     : 363
 //
 …
 void ?{}( ofstream & os, void * file ) {
+        os.file = file;
+        os.sepDefault = true;
+        os.sepOnOff = false;
+        os.nlOnOff = true;
+        os.prt = false;
+        os.sawNL = false;
+        os.$file = file;
+        os.$sepDefault = true;
+        os.$sepOnOff = false;
+        os.$nlOnOff = true;
+        os.$prt = false;
+        os.$sawNL = false;
+        $sepSetCur( os, sepGet( os ) );
         sepSet( os, " " );
-        sepSetCur( os, sepGet( os ) );
         sepSetTuple( os, ", " );
 } // ?{}
 // private
 bool sepPrt( ofstream & os ) { setNL( os, false ); return os.sepOnOff; }
 void sepReset( ofstream & os ) { os.sepOnOff = os.sepDefault; }
 void sepReset( ofstream & os, bool reset ) { os.sepDefault = reset; os.sepOnOff = os.sepDefault; }
 const char * sepGetCur( ofstream & os ) { return os.sepCur; }
 void sepSetCur( ofstream & os, const char * sepCur ) { os.sepCur = sepCur; }
 bool getNL( ofstream & os ) { return os.sawNL; }
 void setNL( ofstream & os, bool state ) { os.sawNL = state; }
 bool getANL( ofstream & os ) { return os.nlOnOff; }
 bool getPrt( ofstream & os ) { return os.prt; }
 void setPrt( ofstream & os, bool state ) { os.prt = state; }
+bool $sepPrt( ofstream & os ) { $setNL( os, false ); return os.$sepOnOff; }
+void $sepReset( ofstream & os ) { os.$sepOnOff = os.$sepDefault; }
+void $sepReset( ofstream & os, bool reset ) { os.$sepDefault = reset; os.$sepOnOff = os.$sepDefault; }
+const char * $sepGetCur( ofstream & os ) { return os.$sepCur; }
+void $sepSetCur( ofstream & os, const char sepCur[] ) { os.$sepCur = sepCur; }
+bool $getNL( ofstream & os ) { return os.$sawNL; }
+void $setNL( ofstream & os, bool state ) { os.$sawNL = state; }
+bool $getANL( ofstream & os ) { return os.$nlOnOff; }
+bool $getPrt( ofstream & os ) { return os.$prt; }
+void $setPrt( ofstream & os, bool state ) { os.$prt = state; }
 // public
 void ?{}( ofstream & os ) { os.file = 0; }
 void ?{}( ofstream & os, const char * name, const char * mode ) {
+void ?{}( ofstream & os ) { os.$file = 0p; }
+void ?{}( ofstream & os, const char name[], const char mode[] ) {
         open( os, name, mode );
 } // ?{}
 void ?{}( ofstream & os, const char * name ) {
+void ?{}( ofstream & os, const char name[] ) {
         open( os, name, "w" );
 } // ?{}
 …
 } // ^?{}
 void sepOn( ofstream & os ) { os.sepOnOff = ! getNL( os ); }
 void sepOff( ofstream & os ) { os.sepOnOff = false; }
+void sepOn( ofstream & os ) { os.$sepOnOff = ! $getNL( os ); }
+void sepOff( ofstream & os ) { os.$sepOnOff = false; }
 bool sepDisable( ofstream & os ) {
         bool temp = os.sepDefault;
         os.sepDefault = false;
         sepReset( os );
+        bool temp = os.$sepDefault;
+        os.$sepDefault = false;
+        $sepReset( os );
         return temp;
 } // sepDisable
 bool sepEnable( ofstream & os ) {
         bool temp = os.sepDefault;
         os.sepDefault = true;
         if ( os.sepOnOff ) sepReset( os );                                      // start of line ?
+        bool temp = os.$sepDefault;
+        os.$sepDefault = true;
+        if ( os.$sepOnOff ) $sepReset( os );                            // start of line ?
         return temp;
 } // sepEnable
 void nlOn( ofstream & os ) { os.nlOnOff = true; }
 void nlOff( ofstream & os ) { os.nlOnOff = false; }
 const char * sepGet( ofstream & os ) { return os.separator; }
 void sepSet( ofstream & os, const char * s ) {
+void nlOn( ofstream & os ) { os.$nlOnOff = true; }
+void nlOff( ofstream & os ) { os.$nlOnOff = false; }
+const char * sepGet( ofstream & os ) { return os.$separator; }
+void sepSet( ofstream & os, const char s[] ) {
         assert( s );
         strncpy( os.separator, s, sepSize - 1 );
         os.separator[sepSize - 1] = '\0';
+        strncpy( os.$separator, s, sepSize - 1 );
+        os.$separator[sepSize - 1] = '\0';
 } // sepSet
 const char * sepGetTuple( ofstream & os ) { return os.tupleSeparator; }
 void sepSetTuple( ofstream & os, const char * s ) {
+const char * sepGetTuple( ofstream & os ) { return os.$tupleSeparator; }
+void sepSetTuple( ofstream & os, const char s[] ) {
         assert( s );
         strncpy( os.tupleSeparator, s, sepSize - 1 );
         os.tupleSeparator[sepSize - 1] = '\0';
+        strncpy( os.$tupleSeparator, s, sepSize - 1 );
+        os.$tupleSeparator[sepSize - 1] = '\0';
 } // sepSet
 void ends( ofstream & os ) {
         if ( getANL( os ) ) nl( os );
         else setPrt( os, false );                                                       // turn off
+        if ( $getANL( os ) ) nl( os );
+        else $setPrt( os, false );                                                      // turn off
         if ( &os == &exit ) exit( EXIT_FAILURE );
         if ( &os == &abort ) abort();
 …
 int fail( ofstream & os ) {
         return os.file == 0 || ferror( (FILE *)(os.file) );
+        return os.$file == 0 || ferror( (FILE *)(os.$file) );
 } // fail
 int flush( ofstream & os ) {
         return fflush( (FILE *)(os.file) );
+        return fflush( (FILE *)(os.$file) );
 } // flush
 void open( ofstream & os, const char * name, const char * mode ) {
+void open( ofstream & os, const char name[], const char mode[] ) {
         FILE * file = fopen( name, mode );
         #ifdef __CFA_DEBUG__
         if ( file == 0 ) {
+        if ( file == 0p ) {
                 abort | IO_MSG "open output file \"" | name | "\"" | nl | strerror( errno );
         } // if
 …
 } // open
 void open( ofstream & os, const char * name ) {
+void open( ofstream & os, const char name[] ) {
         open( os, name, "w" );
 } // open
 void close( ofstream & os ) {
         if ( (FILE *)(os.file) == stdout || (FILE *)(os.file) == stderr ) return;
         if ( fclose( (FILE *)(os.file) ) == EOF ) {
+        if ( (FILE *)(os.$file) == stdout || (FILE *)(os.$file) == stderr ) return;
+        if ( fclose( (FILE *)(os.$file) ) == EOF ) {
                 abort | IO_MSG "close output" | nl | strerror( errno );
         } // if
 } // close
 ofstream & write( ofstream & os, const char * data, size_t size ) {
+ofstream & write( ofstream & os, const char data[], size_t size ) {
         if ( fail( os ) ) {
                 abort | IO_MSG "attempt write I/O on failed stream";
         } // if
         if ( fwrite( data, 1, size, (FILE *)(os.file) ) != size ) {
+        if ( fwrite( data, 1, size, (FILE *)(os.$file) ) != size ) {
                 abort | IO_MSG "write" | nl | strerror( errno );
         } // if
 …
         va_list args;
         va_start( args, format );
         int len = vfprintf( (FILE *)(os.file), format, args );
+        int len = vfprintf( (FILE *)(os.$file), format, args );
         if ( len == EOF ) {
                 if ( ferror( (FILE *)(os.file) ) ) {
+                if ( ferror( (FILE *)(os.$file) ) ) {
                         abort | IO_MSG "invalid write";
                 } // if
 …
         va_end( args );
         setPrt( os, true );                                                                     // called in output cascade
         sepReset( os );                                                                         // reset separator
+        $setPrt( os, true );                                                            // called in output cascade
+        $sepReset( os );                                                                        // reset separator
         return len;
 } // fmt
 …
 // private
 void ?{}( ifstream & is, void * file ) {
         is.file = file;
         is.nlOnOff = false;
+        is.$file = file;
+        is.$nlOnOff = false;
 } // ?{}
 // public
 void ?{}( ifstream & is ) {     is.file = 0; }
 void ?{}( ifstream & is, const char * name, const char * mode ) {
+void ?{}( ifstream & is ) { is.$file = 0p; }
+void ?{}( ifstream & is, const char name[], const char mode[] ) {
         open( is, name, mode );
 } // ?{}
 void ?{}( ifstream & is, const char * name ) {
+void ?{}( ifstream & is, const char name[] ) {
         open( is, name, "r" );
 } // ?{}
 …
 } // ^?{}
 void nlOn( ifstream & os ) { os.nlOnOff = true; }
 void nlOff( ifstream & os ) { os.nlOnOff = false; }
 bool getANL( ifstream & os ) { return os.nlOnOff; }
+void nlOn( ifstream & os ) { os.$nlOnOff = true; }
+void nlOff( ifstream & os ) { os.$nlOnOff = false; }
+bool getANL( ifstream & os ) { return os.$nlOnOff; }
 int fail( ifstream & is ) {
         return is.file == 0 || ferror( (FILE *)(is.file) );
+        return is.$file == 0p || ferror( (FILE *)(is.$file) );
 } // fail
 int eof( ifstream & is ) {
         return feof( (FILE *)(is.file) );
+        return feof( (FILE *)(is.$file) );
 } // eof
 void open( ifstream & is, const char * name, const char * mode ) {
+void open( ifstream & is, const char name[], const char mode[] ) {
         FILE * file = fopen( name, mode );
         #ifdef __CFA_DEBUG__
         if ( file == 0 ) {
+        if ( file == 0p ) {
                 abort | IO_MSG "open input file \"" | name | "\"" | nl | strerror( errno );
         } // if
         #endif // __CFA_DEBUG__
         is.file = file;
 } // open
 void open( ifstream & is, const char * name ) {
+        is.$file = file;
+} // open
+void open( ifstream & is, const char name[] ) {
         open( is, name, "r" );
 } // open
 void close( ifstream & is ) {
         if ( (FILE *)(is.file) == stdin ) return;
         if ( fclose( (FILE *)(is.file) ) == EOF ) {
+        if ( (FILE *)(is.$file) == stdin ) return;
+        if ( fclose( (FILE *)(is.$file) ) == EOF ) {
                 abort | IO_MSG "close input" | nl | strerror( errno );
         } // if
 …
         } // if
         if ( fread( data, size, 1, (FILE *)(is.file) ) == 0 ) {
+        if ( fread( data, size, 1, (FILE *)(is.$file) ) == 0 ) {
                 abort | IO_MSG "read" | nl | strerror( errno );
         } // if
 …
         } // if
         if ( ungetc( c, (FILE *)(is.file) ) == EOF ) {
+        if ( ungetc( c, (FILE *)(is.$file) ) == EOF ) {
                 abort | IO_MSG "ungetc" | nl | strerror( errno );
         } // if
 …
         va_start( args, format );
         int len = vfscanf( (FILE *)(is.file), format, args );
+        int len = vfscanf( (FILE *)(is.$file), format, args );
         if ( len == EOF ) {
                 if ( ferror( (FILE *)(is.file) ) ) {
+                if ( ferror( (FILE *)(is.$file) ) ) {
                         abort | IO_MSG "invalid read";
                 } // if

libcfa/src/fstream.hfa

-                      r8c50aed
+                      ra505021
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Nov 29 06:56:02 2019
 // Update Count     : 168
+// Last Modified On : Mon Feb 17 08:29:23 2020
+// Update Count     : 175
 //
 …
 enum { sepSize = 16 };
 struct ofstream {
         void * file;
         bool sepDefault;
         bool sepOnOff;
         bool nlOnOff;
         bool prt;                                                                                       // print text
         bool sawNL;
         const char * sepCur;
         char separator[sepSize];
         char tupleSeparator[sepSize];
+        void * $file;
+        bool $sepDefault;
+        bool $sepOnOff;
+        bool $nlOnOff;
+        bool $prt;                                                                                      // print text
+        bool $sawNL;
+        const char * $sepCur;
+        char $separator[sepSize];
+        char $tupleSeparator[sepSize];
 }; // ofstream
 // private
 bool sepPrt( ofstream & );
 void sepReset( ofstream & );
 void sepReset( ofstream &, bool );
 const char * sepGetCur( ofstream & );
 void sepSetCur( ofstream &, const char * );
 bool getNL( ofstream & );
 void setNL( ofstream &, bool );
 bool getANL( ofstream & );
 bool getPrt( ofstream & );
 void setPrt( ofstream &, bool );
+bool $sepPrt( ofstream & );
+void $sepReset( ofstream & );
+void $sepReset( ofstream &, bool );
+const char * $sepGetCur( ofstream & );
+void $sepSetCur( ofstream &, const char [] );
+bool $getNL( ofstream & );
+void $setNL( ofstream &, bool );
+bool $getANL( ofstream & );
+bool $getPrt( ofstream & );
+void $setPrt( ofstream &, bool );
 // public
 …
 const char * sepGet( ofstream & );
 void sepSet( ofstream &, const char * );
+void sepSet( ofstream &, const char [] );
 const char * sepGetTuple( ofstream & );
 void sepSetTuple( ofstream &, const char * );
+void sepSetTuple( ofstream &, const char [] );
 void ends( ofstream & os );
 int fail( ofstream & );
 int flush( ofstream & );
 void open( ofstream &, const char * name, const char * mode );
 void open( ofstream &, const char * name );
+void open( ofstream &, const char name[], const char mode[] );
+void open( ofstream &, const char name[] );
 void close( ofstream & );
 ofstream & write( ofstream &, const char * data, size_t size );
 int fmt( ofstream &, const char format[], ... );
+ofstream & write( ofstream &, const char data[], size_t size );
+int fmt( ofstream &, const char format[], ... ) __attribute__(( format(printf, 2, 3) ));
 void ?{}( ofstream & os );
 void ?{}( ofstream & os, const char * name, const char * mode );
 void ?{}( ofstream & os, const char * name );
+void ?{}( ofstream & os, const char name[], const char mode[] );
+void ?{}( ofstream & os, const char name[] );
 void ^?{}( ofstream & os );
 …
 struct ifstream {
         void * file;
         bool nlOnOff;
+        void * $file;
+        bool $nlOnOff;
 }; // ifstream
 …
 int fail( ifstream & is );
 int eof( ifstream & is );
 void open( ifstream & is, const char * name, const char * mode );
 void open( ifstream & is, const char * name );
+void open( ifstream & is, const char name[], const char mode[] );
+void open( ifstream & is, const char name[] );
 void close( ifstream & is );
 ifstream & read( ifstream & is, char * data, size_t size );
 ifstream & ungetc( ifstream & is, char c );
 int fmt( ifstream &, const char format[], ... );
+int fmt( ifstream &, const char format[], ... ) __attribute__(( format(scanf, 2, 3) ));
 void ?{}( ifstream & is );
 void ?{}( ifstream & is, const char * name, const char * mode );
 void ?{}( ifstream & is, const char * name );
+void ?{}( ifstream & is, const char name[], const char mode[] );
+void ?{}( ifstream & is, const char name[] );
 void ^?{}( ifstream & is );

libcfa/src/gmp.hfa

-                      r8c50aed
+                      ra505021
 // Created On       : Tue Apr 19 08:43:43 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 13 15:25:05 2019
 // Update Count     : 27
+// Last Modified On : Sun Feb  9 09:56:54 2020
+// Update Count     : 31
 //
 …
 static inline {
         // constructor
+        // constructor, zero_t/one_t are unnecessary because of relationship with signed/unsigned int
         void ?{}( Int & this ) { mpz_init( this.mpz ); }
         void ?{}( Int & this, Int init ) { mpz_init_set( this.mpz, init.mpz ); }
-        void ?{}( Int & this, zero_t ) { mpz_init_set_si( this.mpz, 0 ); }
-        void ?{}( Int & this, one_t ) { mpz_init_set_si( this.mpz, 1 ); }
         void ?{}( Int & this, signed long int init ) { mpz_init_set_si( this.mpz, init ); }
         void ?{}( Int & this, unsigned long int init ) { mpz_init_set_ui( this.mpz, init ); }
         void ?{}( Int & this, const char * val ) { if ( mpz_init_set_str( this.mpz, val, 0 ) ) abort(); }
+        void ?{}( Int & this, const char val[] ) { if ( mpz_init_set_str( this.mpz, val, 0 ) ) abort(); }
         void ^?{}( Int & this ) { mpz_clear( this.mpz ); }
 …
         Int ?`mp( signed long int init ) { return (Int){ init }; }
         Int ?`mp( unsigned long int init ) { return (Int){ init }; }
         Int ?`mp( const char * init ) { return (Int){ init }; }
+        Int ?`mp( const char init[] ) { return (Int){ init }; }
         // assignment
 …
         Int ?=?( Int & lhs, long int rhs ) { mpz_set_si( lhs.mpz, rhs ); return lhs; }
         Int ?=?( Int & lhs, unsigned long int rhs ) { mpz_set_ui( lhs.mpz, rhs ); return lhs; }
         Int ?=?( Int & lhs, const char * rhs ) { if ( mpz_set_str( lhs.mpz, rhs, 0 ) ) { abort | "invalid string conversion"; } return lhs; }
+        Int ?=?( Int & lhs, const char rhs[] ) { if ( mpz_set_str( lhs.mpz, rhs, 0 ) ) { abort | "invalid string conversion"; } return lhs; }
         char ?=?( char & lhs, Int rhs ) { char val = mpz_get_si( rhs.mpz ); lhs = val; return lhs; }
 …
         forall( dtype ostype | ostream( ostype ) ) {
                 ostype & ?|?( ostype & os, Int mp ) {
                         if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                        if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
                         gmp_printf( "%Zd", mp.mpz );
                         sepOn( os );

libcfa/src/heap.cfa

-                      r8c50aed
+                      ra505021
 // Created On       : Tue Dec 19 21:58:35 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Dec  8 21:01:31 2019
 // Update Count     : 647
+// Last Modified On : Tue Feb  4 10:04:51 2020
+// Update Count     : 648
 //
 …
 static inline void checkHeader( bool check, const char * name, void * addr ) {
+static inline void checkHeader( bool check, const char name[], void * addr ) {
         if ( unlikely( check ) ) {                                                      // bad address ?
                 abort( "Attempt to %s storage %p with address outside the heap.\n"
 …
 static inline bool headers( const char * name __attribute__(( unused )), void * addr, HeapManager.Storage.Header *& header, HeapManager.FreeHeader *& freeElem, size_t & size, size_t & alignment ) with ( heapManager ) {
+static inline bool headers( const char name[] __attribute__(( unused )), void * addr, HeapManager.Storage.Header *& header, HeapManager.FreeHeader *& freeElem, size_t & size, size_t & alignment ) with ( heapManager ) {
         header = headerAddr( addr );

libcfa/src/interpose.cfa

-                      r8c50aed
+                      ra505021
 // Created On       : Wed Mar 29 16:10:31 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jan 30 17:47:32 2020
 // Update Count     : 156
+// Last Modified On : Mon Feb 17 10:18:53 2020
+// Update Count     : 166
 //
 …
 #include "bits/signal.hfa"                                                              // sigHandler_?
 #include "startup.hfa"                                                                  // STARTUP_PRIORITY_CORE
+#include <assert.h>
 //=============================================================================================
 …
 typedef void (* generic_fptr_t)(void);
 generic_fptr_t interpose_symbol( const char * symbol, const char * version ) {
+generic_fptr_t interpose_symbol( const char symbol[], const char version[] ) {
         const char * error;
 …
 extern "C" {
         void abort( void ) __attribute__(( __nothrow__, __leaf__, __noreturn__ )) {
                 abort( false, NULL ); // FIX ME: 0p does not work
+                abort( false, "%s", "" );
+        }
 …
 void * kernel_abort( void ) __attribute__(( __nothrow__, __leaf__, __weak__ )) { return 0p; }
 void kernel_abort_msg( void * data, char * buffer, int size ) __attribute__(( __nothrow__, __leaf__, __weak__ )) {}
+void kernel_abort_msg( void * data, char buffer[], int size ) __attribute__(( __nothrow__, __leaf__, __weak__ )) {}
 // See concurrency/kernel.cfa for strong definition used in multi-processor mode.
 int kernel_abort_lastframe( void ) __attribute__(( __nothrow__, __leaf__, __weak__ )) { return 4; }
 …
 static void __cfaabi_backtrace( int start ) {
+        enum {
+                Frames = 50,                                                                    // maximum number of stack frames
+        };
+        enum { Frames = 50, };                                                          // maximum number of stack frames
         int last = kernel_abort_lastframe();                            // skip last N stack frames
         void * array[Frames];
         size_t size = backtrace( array, Frames );
         char ** messages = backtrace_symbols( array, size );
+        char ** messages = backtrace_symbols( array, size ); // does not demangle names
         *index( messages[0], '(' ) = '\0';                                      // find executable name
 …
                 char * name = 0p, * offset_begin = 0p, * offset_end = 0p;
                 for ( char * p = messages[i]; *p; ++p ) {               // find parantheses and +offset
+                for ( char * p = messages[i]; *p; p += 1 ) {    // find parantheses and +offset
                         //__cfaabi_bits_print_nolock( "X %s\n", p);
                         if ( *p == '(' ) {
 …
         __cfaabi_bits_write( STDERR_FILENO, abort_text, len );
+        if ( fmt ) {
+                va_list args;
+                va_start( args, fmt );
+                len = vsnprintf( abort_text, abort_text_size, fmt, args );
+                va_end( args );
+                __cfaabi_bits_write( STDERR_FILENO, abort_text, len );
+                if ( fmt[strlen( fmt ) - 1] != '\n' ) {                 // add optional newline if missing at the end of the format text
+                        __cfaabi_dbg_write( "\n", 1 );
+                }
+        }
+        assert( fmt );
+        va_list args;
+        va_start( args, fmt );
+        len = vsnprintf( abort_text, abort_text_size, fmt, args );
+        va_end( args );
+        __cfaabi_bits_write( STDERR_FILENO, abort_text, len );
+        if ( fmt[strlen( fmt ) - 1] != '\n' ) {                         // add optional newline if missing at the end of the format text
+                __cfaabi_dbg_write( "\n", 1 );
+        } // if
         kernel_abort_msg( kernel_data, abort_text, abort_text_size );
+        __cfaabi_backtrace( signalAbort ? 4 : 3 );
+        __cfaabi_backtrace( signalAbort ? 4 : 2 );
         __cabi_libc.abort();                                                            // print stack trace in handler

libcfa/src/iostream.cfa

-                      r8c50aed
+                      ra505021
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 13 08:07:59 2019
 // Update Count     : 821
+// Last Modified On : Thu Feb 20 15:53:23 2020
+// Update Count     : 829
 //
 …
 #include <stdio.h>
 #include <stdbool.h>                                                                    // true/false
+#include <stdint.h>                                                                             // UINT64_MAX
 //#include <string.h>                                                                   // strlen, strcmp
 extern size_t strlen (const char *__s) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
 …
 forall( dtype ostype | ostream( ostype ) ) {
         ostype & ?|?( ostype & os, zero_t ) {
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
                 fmt( os, "%d", 0n );
                 return os;
 …
         ostype & ?|?( ostype & os, one_t ) {
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
                 fmt( os, "%d", 1n );
                 return os;
 …
         ostype & ?|?( ostype & os, bool b ) {
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
                 fmt( os, "%s", b ? "true" : "false" );
                 return os;
 …
         ostype & ?|?( ostype & os, char c ) {
                 fmt( os, "%c", c );
                 if ( c == '\n' ) setNL( os, true );
+                if ( c == '\n' ) $setNL( os, true );
                 return sepOff( os );
         } // ?|?
 …
         ostype & ?|?( ostype & os, signed char sc ) {
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
                 fmt( os, "%hhd", sc );
                 return os;
 …
         ostype & ?|?( ostype & os, unsigned char usc ) {
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
                 fmt( os, "%hhu", usc );
                 return os;
 …
         ostype & ?|?( ostype & os, short int si ) {
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
                 fmt( os, "%hd", si );
                 return os;
 …
         ostype & ?|?( ostype & os, unsigned short int usi ) {
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
                 fmt( os, "%hu", usi );
                 return os;
 …
         ostype & ?|?( ostype & os, int i ) {
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
                 fmt( os, "%d", i );
                 return os;
 …
         ostype & ?|?( ostype & os, unsigned int ui ) {
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
                 fmt( os, "%u", ui );
                 return os;
 …
         ostype & ?|?( ostype & os, long int li ) {
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
                 fmt( os, "%ld", li );
                 return os;
 …
         ostype & ?|?( ostype & os, unsigned long int uli ) {
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
                 fmt( os, "%lu", uli );
                 return os;
 …
         ostype & ?|?( ostype & os, long long int lli ) {
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
                 fmt( os, "%lld", lli );
                 return os;
 …
         ostype & ?|?( ostype & os, unsigned long long int ulli ) {
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
                 fmt( os, "%llu", ulli );
                 return os;
 …
                 (ostype &)(os | ulli); ends( os );
         } // ?|?
+#if defined( __SIZEOF_INT128__ )
+        //      UINT64_MAX 18_446_744_073_709_551_615_ULL
+        #define P10_UINT64 10_000_000_000_000_000_000_ULL       // 19 zeroes
+        static void base10_128( ostype & os, unsigned int128 val ) {
+                if ( val > UINT64_MAX ) {
+                        base10_128( os, val / P10_UINT64 );                     // recursive
+                        fmt( os, "%.19lu", (uint64_t)(val % P10_UINT64) );
+                } else {
+                        fmt( os, "%lu", (uint64_t)val );
+                } // if
+        } // base10_128
+        static void base10_128( ostype & os, int128 val ) {
+                if ( val < 0 ) {
+                        fmt( os, "-" );                                                         // leading negative sign
+                        val = -val;
+                } // if
+                base10_128( os, (unsigned int128)val );                 // print zero/positive value
+        } // base10_128
+        ostype & ?|?( ostype & os, int128 llli ) {
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                base10_128( os, llli );
+                return os;
+        } // ?|?
+        void & ?|?( ostype & os, int128 llli ) {
+                (ostype &)(os | llli); ends( os );
+        } // ?|?
+        ostype & ?|?( ostype & os, unsigned int128 ullli ) {
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                base10_128( os, ullli );
+                return os;
+        } // ?|?
+        void & ?|?( ostype & os, unsigned int128 ullli ) {
+                (ostype &)(os | ullli); ends( os );
+        } // ?|?
+#endif // __SIZEOF_INT128__
         #define PrintWithDP( os, format, val, ... ) \
 …
         ostype & ?|?( ostype & os, float f ) {
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
                 PrintWithDP( os, "%g", f );
                 return os;
 …
         ostype & ?|?( ostype & os, double d ) {
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
                 PrintWithDP( os, "%.*lg", d, DBL_DIG );
                 return os;
 …
         ostype & ?|?( ostype & os, long double ld ) {
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
                 PrintWithDP( os, "%.*Lg", ld, LDBL_DIG );
                 return os;
 …
         ostype & ?|?( ostype & os, float _Complex fc ) {
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
 //              os | crealf( fc ) | nonl;
                 PrintWithDP( os, "%g", crealf( fc ) );
 …
         ostype & ?|?( ostype & os, double _Complex dc ) {
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
 //              os | creal( dc ) | nonl;
                 PrintWithDP( os, "%.*lg", creal( dc ), DBL_DIG );
 …
         ostype & ?|?( ostype & os, long double _Complex ldc ) {
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
 //              os | creall( ldc ) || nonl;
                 PrintWithDP( os, "%.*Lg", creall( ldc ), LDBL_DIG );
 …
         } // ?|?
         ostype & ?|?( ostype & os, const char * str ) {
+        ostype & ?|?( ostype & os, const char str[] ) {
                 enum { Open = 1, Close, OpenClose };
                 static const unsigned char mask[256] @= {
 …
                 // first character IS NOT spacing or closing punctuation => add left separator
                 unsigned char ch = str[0];                                              // must make unsigned
                 if ( sepPrt( os ) && mask[ ch ] != Close && mask[ ch ] != OpenClose ) {
                         fmt( os, "%s", sepGetCur( os ) );
+                if ( $sepPrt( os ) && mask[ ch ] != Close && mask[ ch ] != OpenClose ) {
+                        fmt( os, "%s", $sepGetCur( os ) );
                 } // if
                 // if string starts line, must reset to determine open state because separator is off
                 sepReset( os );                                                                 // reset separator
+                $sepReset( os );                                                                // reset separator
                 // last character IS spacing or opening punctuation => turn off separator for next item
                 size_t len = strlen( str );
                 ch = str[len - 1];                                                              // must make unsigned
                 if ( sepPrt( os ) && mask[ ch ] != Open && mask[ ch ] != OpenClose ) {
+                if ( $sepPrt( os ) && mask[ ch ] != Open && mask[ ch ] != OpenClose ) {
                         sepOn( os );
                 } else {
                         sepOff( os );
                 } // if
                 if ( ch == '\n' ) setNL( os, true );                    // check *AFTER* sepPrt call above as it resets NL flag
+                if ( ch == '\n' ) $setNL( os, true );                   // check *AFTER* $sepPrt call above as it resets NL flag
                 return write( os, str, len );
         } // ?|?
+        void ?|?( ostype & os, const char * str ) {
+        void ?|?( ostype & os, const char str[] ) {
                 (ostype &)(os | str); ends( os );
         } // ?|?
 //      ostype & ?|?( ostype & os, const char16_t * str ) {
 //              if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+//              if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
 //              fmt( os, "%ls", str );
 //              return os;
 …
 // #if ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 ) // char32_t == wchar_t => ambiguous
 //      ostype & ?|?( ostype & os, const char32_t * str ) {
 //              if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+//              if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
 //              fmt( os, "%ls", str );
 //              return os;
 …
 //      ostype & ?|?( ostype & os, const wchar_t * str ) {
 //              if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+//              if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
 //              fmt( os, "%ls", str );
 //              return os;
 …
         ostype & ?|?( ostype & os, const void * p ) {
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
                 fmt( os, "%p", p );
                 return os;
 …
         void ?|?( ostype & os, ostype & (* manip)( ostype & ) ) {
                 (ostype &)(manip( os ));
                 if ( getPrt( os ) ) ends( os );                                 // something printed ?
                 setPrt( os, false );                                                    // turn off
+                if ( $getPrt( os ) ) ends( os );                                // something printed ?
+                $setPrt( os, false );                                                   // turn off
         } // ?|?
 …
         ostype & nl( ostype & os ) {
                 (ostype &)(os | '\n');
                 setPrt( os, false );                                                    // turn off
                 setNL( os, true );
+                $setPrt( os, false );                                                   // turn off
+                $setNL( os, true );
                 flush( os );
                 return sepOff( os );                                                    // prepare for next line
 …
         ostype & nonl( ostype & os ) {
                 setPrt( os, false );                                                    // turn off
+                $setPrt( os, false );                                                   // turn off
                 return os;
         } // nonl
 …
         ostype & ?|?( ostype & os, T arg, Params rest ) {
                 (ostype &)(os | arg);                                                   // print first argument
                 sepSetCur( os, sepGetTuple( os ) );                             // switch to tuple separator
+                $sepSetCur( os, sepGetTuple( os ) );                    // switch to tuple separator
                 (ostype &)(os | rest);                                                  // print remaining arguments
                 sepSetCur( os, sepGet( os ) );                                  // switch to regular separator
+                $sepSetCur( os, sepGet( os ) );                                 // switch to regular separator
                 return os;
         } // ?|?
 …
                 // (ostype &)(?|?( os, arg, rest )); ends( os );
                 (ostype &)(os | arg);                                                   // print first argument
                 sepSetCur( os, sepGetTuple( os ) );                             // switch to tuple separator
+                $sepSetCur( os, sepGetTuple( os ) );                    // switch to tuple separator
                 (ostype &)(os | rest);                                                  // print remaining arguments
                 sepSetCur( os, sepGet( os ) );                                  // switch to regular separator
+                $sepSetCur( os, sepGet( os ) );                                 // switch to regular separator
                 ends( os );
         } // ?|?
 …
 forall( dtype ostype | ostream( ostype ) ) { \
         ostype & ?|?( ostype & os, _Ostream_Manip(T) f ) { \
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); \
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); \
+\
                 if ( f.base == 'b' || f.base == 'B' ) {                 /* bespoke binary format */ \
 …
+\
                 if ( ! f.flags.pc ) {                                                   /* no precision */ \
-                        /* printf( "%s\n", &fmtstr[star] ); */ \
                         fmtstr[sizeof(IFMTNP)-2] = f.base;                      /* sizeof includes '\0' */ \
+                        /* printf( "%s %c %c\n", &fmtstr[star], f.base, CODE ); */ \
                         fmt( os, &fmtstr[star], f.wd, f.val ); \
                 } else {                                                                                /* precision */ \
                         fmtstr[sizeof(IFMTP)-2] = f.base;                       /* sizeof includes '\0' */ \
                         /* printf( "%s\n", &fmtstr[star] ); */ \
+                        /* printf( "%s %c %c\n", &fmtstr[star], f.base, CODE ); */ \
                         fmt( os, &fmtstr[star], f.wd, f.pc, f.val ); \
                 } /* if */ \
 …
 IntegralFMTImpl( signed long long int, 'd', "%    *ll ", "%    *.*ll " )
 IntegralFMTImpl( unsigned long long int, 'u', "%    *ll ", "%    *.*ll " )
+#if defined( __SIZEOF_INT128__ )
+// Default prefix for non-decimal prints is 0b, 0, 0x.
+#define IntegralFMTImpl128( T, SIGNED, CODE, IFMTNP, IFMTP ) \
+forall( dtype ostype | ostream( ostype ) ) \
+static void base10_128( ostype & os, _Ostream_Manip(T) fmt ) { \
+        if ( fmt.val > UINT64_MAX ) { \
+                fmt.val /= P10_UINT64; \
+                base10_128( os, fmt ); /* recursive */ \
+                _Ostream_Manip(unsigned long long int) fmt2 @= { (uint64_t)(fmt.val % P10_UINT64), 0, 19, 'u', { .all : 0 } }; \
+                fmt2.flags.nobsdp = true; \
+                printf( "fmt2 %c %lld %d\n", fmt2.base, fmt2.val, fmt2.all );   \
+                sepOff( os ); \
+                (ostype &)(os | fmt2); \
+        } else { \
+                printf( "fmt %c %lld %d\n", fmt.base, fmt.val, fmt.all ); \
+                (ostype &)(os | fmt); \
+        } /* if */ \
+} /* base10_128 */                                                 \
+forall( dtype ostype | ostream( ostype ) ) { \
+        ostype & ?|?( ostype & os, _Ostream_Manip(T) f ) { \
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); \
+\
+                if ( f.base == 'b' | f.base == 'o' | f.base == 'x' | f.base == 'X' ) { \
+                        unsigned long long int msig = (unsigned long long int)(f.val >> 64); \
+                        unsigned long long int lsig = (unsigned long long int)(f.val); \
+                        _Ostream_Manip(SIGNED long long int) fmt @= { msig, f.wd, f.pc, f.base, { .all : f.all } }; \
+                        _Ostream_Manip(unsigned long long int) fmt2 @= { lsig, 0, 0, f.base, { .all : 0 } }; \
+                        if ( msig == 0 ) { \
+                                fmt.val = lsig; \
+                                (ostype &)(os | fmt); \
+                        } else { \
+                                fmt2.flags.pad0 = fmt2.flags.nobsdp = true;     \
+                                if ( f.base == 'b' ) { \
+                                        if ( f.wd > 64 ) fmt.wd = f.wd - 64; \
+                                        fmt2.wd = 64; \
+                                        (ostype &)(os | fmt | "" | fmt2); \
+                                } else if ( f.base == 'o' ) { \
+                                        fmt.val = (unsigned long long int)fmt.val >> 2; \
+                                        if ( f.wd > 21 ) fmt.wd = f.wd - 21; \
+                                        fmt2.wd = 1; \
+                                        fmt2.val = ((msig & 0x3) << 1) + 1; \
+                                        (ostype &)(os | fmt | "" | fmt2); \
+                                        sepOff( os ); \
+                                        fmt2.wd = 21; \
+                                        fmt2.val = lsig & 0x7fffffffffffffff; \
+                                        (ostype &)(os | fmt2); \
+                                } else { \
+                                        if ( f.flags.left ) { \
+                                                if ( f.wd > 16 ) fmt2.wd = f.wd - 16;   \
+                                                fmt.wd = 16;                                                    \
+                                        } else { \
+                                                if ( f.wd > 16 ) fmt.wd = f.wd - 16;    \
+                                                fmt2.wd = 16;                                                   \
+                                        } /* if */ \
+                                        (ostype &)(os | fmt | "" | fmt2); \
+                                } /* if */ \
+                        } /* if */ \
+                } else { \
+                        base10_128( os, f ); \
+                } /* if */ \
+                return os; \
+        } /* ?|? */ \
+        void ?|?( ostype & os, _Ostream_Manip(T) f ) { (ostype &)(os | f); ends( os ); } \
+} // distribution
+IntegralFMTImpl128( int128, signed, 'd', "%    *ll ", "%    *.*ll " )
+IntegralFMTImpl128( unsigned int128, unsigned, 'u', "%    *ll ", "%    *.*ll " )
+#endif // __SIZEOF_INT128__
 //*********************************** floating point ***********************************
 …
 forall( dtype ostype | ostream( ostype ) ) { \
         ostype & ?|?( ostype & os, _Ostream_Manip(T) f ) { \
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); \
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); \
                 char fmtstr[sizeof(DFMTP)];                                             /* sizeof includes '\0' */ \
                 if ( ! f.flags.pc ) memcpy( &fmtstr, DFMTNP, sizeof(DFMTNP) ); \
 …
                 return os; \
         } /* ?|? */ \
+\
         void ?|?( ostype & os, _Ostream_Manip(T) f ) { (ostype &)(os | f); ends( os ); } \
 } // distribution
 …
                 } // if
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
                 #define CFMTNP "% * "
 …
                 return os;
         } // ?|?
         void ?|?( ostype & os, _Ostream_Manip(char) f ) { (ostype &)(os | f); ends( os ); }
 } // distribution
 …
                 } // if
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
                 #define SFMTNP "% * "
 …
                 return os;
         } // ?|?
         void ?|?( ostype & os, _Ostream_Manip(const char *) f ) { (ostype &)(os | f); ends( os ); }
 } // distribution
 …
         } // ?|?
         // istype & ?|?( istype & is, const char * fmt ) {
+        // istype & ?|?( istype & is, const char fmt[] ) {
         //      fmt( is, fmt, "" );
         //      return is;

libcfa/src/iostream.hfa

-                      r8c50aed
+                      ra505021
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 12 12:08:38 2019
 // Update Count     : 334
+// Last Modified On : Thu Feb 20 15:30:56 2020
+// Update Count     : 337
 //
 …
 trait ostream( dtype ostype ) {
         // private
         bool sepPrt( ostype & );                                                        // get separator state (on/off)
         void sepReset( ostype & );                                                      // set separator state to default state
         void sepReset( ostype &, bool );                                        // set separator and default state
         const char * sepGetCur( ostype & );                                     // get current separator string
         void sepSetCur( ostype &, const char * );                       // set current separator string
         bool getNL( ostype & );                                                         // check newline
         void setNL( ostype &, bool );                                           // saw newline
         bool getANL( ostype & );                                                        // get auto newline (on/off)
         bool getPrt( ostype & );                                                        // get fmt called in output cascade
         void setPrt( ostype &, bool );                                          // set fmt called in output cascade
+        bool $sepPrt( ostype & );                                                       // get separator state (on/off)
+        void $sepReset( ostype & );                                                     // set separator state to default state
+        void $sepReset( ostype &, bool );                                       // set separator and default state
+        const char * $sepGetCur( ostype & );                            // get current separator string
+        void $sepSetCur( ostype &, const char [] );                     // set current separator string
+        bool $getNL( ostype & );                                                        // check newline
+        void $setNL( ostype &, bool );                                          // saw newline
+        bool $getANL( ostype & );                                                       // get auto newline (on/off)
+        bool $getPrt( ostype & );                                                       // get fmt called in output cascade
+        void $setPrt( ostype &, bool );                                         // set fmt called in output cascade
         // public
         void sepOn( ostype & );                                                         // turn separator state on
 …
         const char * sepGet( ostype & );                                        // get separator string
         void sepSet( ostype &, const char * );                          // set separator to string (15 character maximum)
+        void sepSet( ostype &, const char [] );                         // set separator to string (15 character maximum)
         const char * sepGetTuple( ostype & );                           // get tuple separator string
         void sepSetTuple( ostype &, const char * );                     // set tuple separator to string (15 character maximum)
+        void sepSetTuple( ostype &, const char [] );            // set tuple separator to string (15 character maximum)
         void ends( ostype & os );                                                       // end of output statement
         int fail( ostype & );
         int flush( ostype & );
         void open( ostype & os, const char * name, const char * mode );
+        void open( ostype & os, const char name[], const char mode[] );
         void close( ostype & os );
         ostype & write( ostype &, const char *, size_t );
+        ostype & write( ostype &, const char [], size_t );
         int fmt( ostype &, const char format[], ... ) __attribute__(( format(printf, 2, 3) ));
 }; // ostream
 …
         ostype & ?|?( ostype &, unsigned long long int );
         void ?|?( ostype &, unsigned long long int );
+#if defined( __SIZEOF_INT128__ )
+        ostype & ?|?( ostype &, int128 );
+        void ?|?( ostype &, int128 );
+        ostype & ?|?( ostype &, unsigned int128 );
+        void ?|?( ostype &, unsigned int128 );
+#endif // __SIZEOF_INT128__
         ostype & ?|?( ostype &, float );
 …
         void ?|?( ostype &, long double _Complex );
         ostype & ?|?( ostype &, const char * );
         void ?|?( ostype &, const char * );
+        ostype & ?|?( ostype &, const char [] );
+        void ?|?( ostype &, const char [] );
         // ostype & ?|?( ostype &, const char16_t * );
 #if ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 ) // char32_t == wchar_t => ambiguous
 …
 IntegralFMTDecl( signed long long int, 'd' )
 IntegralFMTDecl( unsigned long long int, 'u' )
+#if defined( __SIZEOF_INT128__ )
+IntegralFMTDecl( int128, 'd' )
+IntegralFMTDecl( unsigned int128, 'u' )
+#endif
 //*********************************** floating point ***********************************
 …
 static inline {
         _Ostream_Manip(const char *) bin( const char * s ) { return (_Ostream_Manip(const char *))@{ s, 1, 0, 'b', { .all : 0 } }; }
         _Ostream_Manip(const char *) oct( const char * s ) { return (_Ostream_Manip(const char *))@{ s, 1, 0, 'o', { .all : 0 } }; }
         _Ostream_Manip(const char *) hex( const char * s ) { return (_Ostream_Manip(const char *))@{ s, 1, 0, 'x', { .all : 0 } }; }
         _Ostream_Manip(const char *) wd( unsigned int w, const char * s ) { return (_Ostream_Manip(const char *))@{ s, w, 0, 's', { .all : 0 } }; }
         _Ostream_Manip(const char *) wd( unsigned int w, unsigned char pc, const char * s ) { return (_Ostream_Manip(const char *))@{ s, w, pc, 's', { .flags.pc : true } }; }
+        _Ostream_Manip(const char *) bin( const char s[] ) { return (_Ostream_Manip(const char *))@{ s, 1, 0, 'b', { .all : 0 } }; }
+        _Ostream_Manip(const char *) oct( const char s[] ) { return (_Ostream_Manip(const char *))@{ s, 1, 0, 'o', { .all : 0 } }; }
+        _Ostream_Manip(const char *) hex( const char s[] ) { return (_Ostream_Manip(const char *))@{ s, 1, 0, 'x', { .all : 0 } }; }
+        _Ostream_Manip(const char *) wd( unsigned int w, const char s[] ) { return (_Ostream_Manip(const char *))@{ s, w, 0, 's', { .all : 0 } }; }
+        _Ostream_Manip(const char *) wd( unsigned int w, unsigned char pc, const char s[] ) { return (_Ostream_Manip(const char *))@{ s, w, pc, 's', { .flags.pc : true } }; }
         _Ostream_Manip(const char *) & wd( unsigned int w, _Ostream_Manip(const char *) & fmt ) { fmt.wd = w; return fmt; }
         _Ostream_Manip(const char *) & wd( unsigned int w, unsigned char pc, _Ostream_Manip(const char *) & fmt ) { fmt.wd = w; fmt.pc = pc; fmt.flags.pc = true; return fmt; }
 …
         int fail( istype & );
         int eof( istype & );
         void open( istype & is, const char * name );
+        void open( istype & is, const char name[] );
         void close( istype & is );
         istype & read( istype &, char *, size_t );
 …
         istype & ?|?( istype &, long double _Complex & );
 //      istype & ?|?( istype &, const char * );
+//      istype & ?|?( istype &, const char [] );
         istype & ?|?( istype &, char * );
 …
 static inline {
         _Istream_Cstr skip( unsigned int n ) { return (_Istream_Cstr){ 0p, 0p, n, { .all : 0 } }; }
         _Istream_Cstr skip( const char * scanset ) { return (_Istream_Cstr){ 0p, scanset, -1, { .all : 0 } }; }
         _Istream_Cstr incl( const char * scanset, char * s ) { return (_Istream_Cstr){ s, scanset, -1, { .flags.inex : false } }; }
         _Istream_Cstr & incl( const char * scanset, _Istream_Cstr & fmt ) { fmt.scanset = scanset; fmt.flags.inex = false; return fmt; }
         _Istream_Cstr excl( const char * scanset, char * s ) { return (_Istream_Cstr){ s, scanset, -1, { .flags.inex : true } }; }
         _Istream_Cstr & excl( const char * scanset, _Istream_Cstr & fmt ) { fmt.scanset = scanset; fmt.flags.inex = true; return fmt; }
         _Istream_Cstr ignore( const char * s ) { return (_Istream_Cstr)@{ s, 0p, -1, { .flags.ignore : true } }; }
+        _Istream_Cstr skip( const char scanset[] ) { return (_Istream_Cstr){ 0p, scanset, -1, { .all : 0 } }; }
+        _Istream_Cstr incl( const char scanset[], char * s ) { return (_Istream_Cstr){ s, scanset, -1, { .flags.inex : false } }; }
+        _Istream_Cstr & incl( const char scanset[], _Istream_Cstr & fmt ) { fmt.scanset = scanset; fmt.flags.inex = false; return fmt; }
+        _Istream_Cstr excl( const char scanset[], char * s ) { return (_Istream_Cstr){ s, scanset, -1, { .flags.inex : true } }; }
+        _Istream_Cstr & excl( const char scanset[], _Istream_Cstr & fmt ) { fmt.scanset = scanset; fmt.flags.inex = true; return fmt; }
+        _Istream_Cstr ignore( const char s[] ) { return (_Istream_Cstr)@{ s, 0p, -1, { .flags.ignore : true } }; }
         _Istream_Cstr & ignore( _Istream_Cstr & fmt ) { fmt.flags.ignore = true; return fmt; }
         _Istream_Cstr wdi( unsigned int w, char * s ) { return (_Istream_Cstr)@{ s, 0p, w, { .all : 0 } }; }
+        _Istream_Cstr wdi( unsigned int w, char s[] ) { return (_Istream_Cstr)@{ s, 0p, w, { .all : 0 } }; }
         _Istream_Cstr & wdi( unsigned int w, _Istream_Cstr & fmt ) { fmt.wd = w; return fmt; }
 } // distribution

libcfa/src/math.hfa

-                      r8c50aed
+                      ra505021
 // Created On       : Mon Apr 18 23:37:04 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 13 11:02:15 2018
 // Update Count     : 116
+// Last Modified On : Tue Feb  4 10:27:11 2020
+// Update Count     : 117
 //
 …
 static inline long double fdim( long double x, long double y ) { return fdiml( x, y ); }
 static inline float nan( const char * tag ) { return nanf( tag ); }
 // extern "C" { double nan( const char * ); }
 static inline long double nan( const char * tag ) { return nanl( tag ); }
+static inline float nan( const char tag[] ) { return nanf( tag ); }
+// extern "C" { double nan( const char [] ); }
+static inline long double nan( const char tag[] ) { return nanl( tag ); }
 //---------------------- Exponential ----------------------

libcfa/src/rational.cfa

-                      r8c50aed
+                      ra505021
 // Created On       : Wed Apr  6 17:54:28 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 12 18:12:08 2019
 // Update Count     : 184
+// Last Modified On : Sat Feb  8 17:56:36 2020
+// Update Count     : 187
 //
 …
         } // rational
+        void ?{}( Rational(RationalImpl) & r, zero_t ) {
+                r{ (RationalImpl){0}, (RationalImpl){1} };
+        } // rational
+        void ?{}( Rational(RationalImpl) & r, one_t ) {
+                r{ (RationalImpl){1}, (RationalImpl){1} };
+        } // rational
         // getter for numerator/denominator

libcfa/src/startup.cfa

-                      r8c50aed
+                      ra505021
 // Created On       : Tue Jul 24 16:21:57 2018
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Dec 13 13:16:45 2019
 // Update Count     : 29
+// Last Modified On : Tue Feb  4 13:03:18 2020
+// Update Count     : 30
 //
 …
 struct __spinlock_t;
 extern "C" {
         void __cfaabi_dbg_record(struct __spinlock_t & this, const char * prev_name) __attribute__(( weak )) {}
+        void __cfaabi_dbg_record(struct __spinlock_t & this, const char prev_name[]) __attribute__(( weak )) {}
+}

libcfa/src/stdhdr/assert.h

-                      r8c50aed
+                      ra505021
 // Created On       : Mon Jul  4 23:25:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Jul 31 23:09:32 2017
 // Update Count     : 13
+// Last Modified On : Tue Feb  4 12:58:49 2020
+// Update Count     : 15
 //
 …
         #define assertf( expr, fmt, ... ) ((expr) ? ((void)0) : __assert_fail_f(__VSTRINGIFY__(expr), __FILE__, __LINE__, __PRETTY_FUNCTION__, fmt, ## __VA_ARGS__ ))
         void __assert_fail_f( const char *assertion, const char *file, unsigned int line, const char *function, const char *fmt, ... ) __attribute__((noreturn, format( printf, 5, 6) ));
+        void __assert_fail_f( const char assertion[], const char file[], unsigned int line, const char function[], const char fmt[], ... ) __attribute__((noreturn, format( printf, 5, 6) ));
 #endif

libcfa/src/stdhdr/bfdlink.h

-                      r8c50aed
+                      ra505021
 // Created On       : Tue Jul 18 07:26:04 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Feb  1 07:15:29 2020
 // Update Count     : 5
+// Last Modified On : Fri Feb  7 19:05:08 2020
+// Update Count     : 6
 //
 // include file uses the CFA keyword "with".
 #if ! defined( with )                                                                   // nesting ?
 #define with ``with``                                                                   // make keyword an identifier
+#define with ``with                                                                             // make keyword an identifier
 #define __CFA_BFDLINK_H__
 #endif

libcfa/src/stdhdr/hwloc.h

-                      r8c50aed
+                      ra505021
 // Created On       : Tue Jul 18 07:45:00 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Feb  1 07:15:39 2020
 // Update Count     : 5
+// Last Modified On : Fri Feb  7 19:05:18 2020
+// Update Count     : 6
 //
 // include file uses the CFA keyword "thread".
 #if ! defined( thread )                                                                 // nesting ?
 #define thread ``thread``                                                               // make keyword an identifier
+#define thread ``thread                                                                 // make keyword an identifier
 #define __CFA_HWLOC_H__
 #endif

libcfa/src/stdhdr/krb5.h

-                      r8c50aed
+                      ra505021
 // Created On       : Tue Jul 18 07:55:44 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Feb  1 07:15:47 2020
 // Update Count     : 5
+// Last Modified On : Fri Feb  7 19:05:35 2020
+// Update Count     : 6
 //
 // include file uses the CFA keyword "enable".
 #if ! defined( enable )                                                                 // nesting ?
 #define enable ``enable``                                                               // make keyword an identifier
+#define enable ``enable                                                                 // make keyword an identifier
 #define __CFA_KRB5_H__
 #endif

libcfa/src/stdhdr/math.h

-                      r8c50aed
+                      ra505021
 // Created On       : Mon Jul  4 23:25:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Feb  1 07:15:58 2020
 // Update Count     : 14
+// Last Modified On : Fri Feb  7 19:05:27 2020
+// Update Count     : 15
 //
 extern "C" {
 #if ! defined( exception )                                                              // nesting ?
 #define exception ``exception``                                                 // make keyword an identifier
+#define exception ``exception                                                   // make keyword an identifier
 #define __CFA_MATH_H__
 #endif

libcfa/src/stdhdr/sys/ucontext.h

-                      r8c50aed
+                      ra505021
 // Created On       : Thu Feb  8 23:48:16 2018
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Feb  1 07:16:05 2020
 // Update Count     : 5
+// Last Modified On : Fri Feb  7 19:05:41 2020
+// Update Count     : 6
 //
 #if ! defined( ftype )                                                                  // nesting ?
 #define ftype ``ftype``                                                                 // make keyword an identifier
+#define ftype ``ftype                                                                   // make keyword an identifier
 #define __CFA_UCONTEXT_H__
 #endif

libcfa/src/stdlib.cfa

-                      r8c50aed
+                      ra505021
 // Created On       : Thu Jan 28 17:10:29 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Nov 20 17:22:47 2019
 // Update Count     : 485
+// Last Modified On : Tue Feb  4 08:27:08 2020
+// Update Count     : 486
 //
 …
 //---------------------------------------
 float _Complex strto( const char * sptr, char ** eptr ) {
+float _Complex strto( const char sptr[], char ** eptr ) {
         float re, im;
         char * eeptr;
 …
 } // strto
 double _Complex strto( const char * sptr, char ** eptr ) {
+double _Complex strto( const char sptr[], char ** eptr ) {
         double re, im;
         char * eeptr;
 …
 } // strto
 long double _Complex strto( const char * sptr, char ** eptr ) {
+long double _Complex strto( const char sptr[], char ** eptr ) {
         long double re, im;
         char * eeptr;

libcfa/src/stdlib.hfa

-                      r8c50aed
+                      ra505021
 // Created On       : Thu Jan 28 17:12:35 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Nov 29 23:08:02 2019
 // Update Count     : 400
+// Last Modified On : Tue Feb  4 08:27:01 2020
+// Update Count     : 401
 //
 …
 static inline {
         int strto( const char * sptr, char ** eptr, int base ) { return (int)strtol( sptr, eptr, base ); }
         unsigned int strto( const char * sptr, char ** eptr, int base ) { return (unsigned int)strtoul( sptr, eptr, base ); }
         long int strto( const char * sptr, char ** eptr, int base ) { return strtol( sptr, eptr, base ); }
         unsigned long int strto( const char * sptr, char ** eptr, int base ) { return strtoul( sptr, eptr, base ); }
         long long int strto( const char * sptr, char ** eptr, int base ) { return strtoll( sptr, eptr, base ); }
         unsigned long long int strto( const char * sptr, char ** eptr, int base ) { return strtoull( sptr, eptr, base ); }
         float strto( const char * sptr, char ** eptr ) { return strtof( sptr, eptr ); }
         double strto( const char * sptr, char ** eptr ) { return strtod( sptr, eptr ); }
         long double strto( const char * sptr, char ** eptr ) { return strtold( sptr, eptr ); }
 } // distribution
 float _Complex strto( const char * sptr, char ** eptr );
 double _Complex strto( const char * sptr, char ** eptr );
 long double _Complex strto( const char * sptr, char ** eptr );
+        int strto( const char sptr[], char ** eptr, int base ) { return (int)strtol( sptr, eptr, base ); }
+        unsigned int strto( const char sptr[], char ** eptr, int base ) { return (unsigned int)strtoul( sptr, eptr, base ); }
+        long int strto( const char sptr[], char ** eptr, int base ) { return strtol( sptr, eptr, base ); }
+        unsigned long int strto( const char sptr[], char ** eptr, int base ) { return strtoul( sptr, eptr, base ); }
+        long long int strto( const char sptr[], char ** eptr, int base ) { return strtoll( sptr, eptr, base ); }
+        unsigned long long int strto( const char sptr[], char ** eptr, int base ) { return strtoull( sptr, eptr, base ); }
+        float strto( const char sptr[], char ** eptr ) { return strtof( sptr, eptr ); }
+        double strto( const char sptr[], char ** eptr ) { return strtod( sptr, eptr ); }
+        long double strto( const char sptr[], char ** eptr ) { return strtold( sptr, eptr ); }
+} // distribution
+float _Complex strto( const char sptr[], char ** eptr );
+double _Complex strto( const char sptr[], char ** eptr );
+long double _Complex strto( const char sptr[], char ** eptr );
 static inline {
         int ato( const char * sptr ) { return (int)strtol( sptr, 0p, 10 ); }
         unsigned int ato( const char * sptr ) { return (unsigned int)strtoul( sptr, 0p, 10 ); }
         long int ato( const char * sptr ) { return strtol( sptr, 0p, 10 ); }
         unsigned long int ato( const char * sptr ) { return strtoul( sptr, 0p, 10 ); }
         long long int ato( const char * sptr ) { return strtoll( sptr, 0p, 10 ); }
         unsigned long long int ato( const char * sptr ) { return strtoull( sptr, 0p, 10 ); }
         float ato( const char * sptr ) { return strtof( sptr, 0p ); }
         double ato( const char * sptr ) { return strtod( sptr, 0p ); }
         long double ato( const char * sptr ) { return strtold( sptr, 0p ); }
         float _Complex ato( const char * sptr ) { return strto( sptr, 0p ); }
         double _Complex ato( const char * sptr ) { return strto( sptr, 0p ); }
         long double _Complex ato( const char * sptr ) { return strto( sptr, 0p ); }
+        int ato( const char sptr[] ) { return (int)strtol( sptr, 0p, 10 ); }
+        unsigned int ato( const char sptr[] ) { return (unsigned int)strtoul( sptr, 0p, 10 ); }
+        long int ato( const char sptr[] ) { return strtol( sptr, 0p, 10 ); }
+        unsigned long int ato( const char sptr[] ) { return strtoul( sptr, 0p, 10 ); }
+        long long int ato( const char sptr[] ) { return strtoll( sptr, 0p, 10 ); }
+        unsigned long long int ato( const char sptr[] ) { return strtoull( sptr, 0p, 10 ); }
+        float ato( const char sptr[] ) { return strtof( sptr, 0p ); }
+        double ato( const char sptr[] ) { return strtod( sptr, 0p ); }
+        long double ato( const char sptr[] ) { return strtold( sptr, 0p ); }
+        float _Complex ato( const char sptr[] ) { return strto( sptr, 0p ); }
+        double _Complex ato( const char sptr[] ) { return strto( sptr, 0p ); }
+        long double _Complex ato( const char sptr[] ) { return strto( sptr, 0p ); }
 } // distribution

libcfa/src/time.cfa

-                      r8c50aed
+                      ra505021
 // Created On       : Tue Mar 27 13:33:14 2018
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Jan  5 17:27:40 2020
 // Update Count     : 69
+// Last Modified On : Tue Feb  4 08:24:18 2020
+// Update Count     : 70
 //
 …
 } // dd_mm_yy
 size_t strftime( char * buf, size_t size, const char * fmt, Time time ) with( time ) {
+size_t strftime( char buf[], size_t size, const char fmt[], Time time ) with( time ) {
         time_t s = tn / TIMEGRAN;
         tm tm;

libcfa/src/time.hfa

-                      r8c50aed
+                      ra505021
 // Created On       : Wed Mar 14 23:18:57 2018
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Jan  6 12:50:16 2020
 // Update Count     : 653
+// Last Modified On : Tue Feb  4 08:24:32 2020
+// Update Count     : 654
 //
 …
 } // dmy
 size_t strftime( char * buf, size_t size, const char * fmt, Time time );
+size_t strftime( char buf[], size_t size, const char fmt[], Time time );
 //------------------------- timeval (cont) -------------------------

longrun_tests/Makefile.in

-                      r8c50aed
+                      ra505021
 am__v_GOC_0 = @echo "  GOC     " $@;
 am__v_GOC_1 =
+AM_V_PY = $(am__v_PY_@AM_V@)
+am__v_PY_ = $(am__v_PY_@AM_DEFAULT_V@)
+am__v_PY_0 = @echo "  PYTHON  " $@;
+am__v_PY_1 =
 AM_V_RUST = $(am__v_RUST_@AM_V@)
 am__v_RUST_ = $(am__v_RUST_@AM_DEFAULT_V@)
 am__v_RUST_0 = @echo "  RUST     " $@;
+am__v_RUST_0 = @echo "  RUST    " $@;
 am__v_RUST_1 =
 AM_V_NODEJS = $(am__v_NODEJS_@AM_V@)
 am__v_NODEJS_ = $(am__v_NODEJS_@AM_DEFAULT_V@)
 am__v_NODEJS_0 = @echo "  NODEJS     " $@;
+am__v_NODEJS_0 = @echo "  NODEJS  " $@;
 am__v_NODEJS_1 =
 AM_V_JAVAC = $(am__v_JAVAC_@AM_V@)

src/CodeGen/CodeGenerator.cc

-                      r8c50aed
+                      ra505021
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Dec 13 23:13:28 2019
 // Update Count     : 508
+// Last Modified On : Sun Feb 16 08:32:48 2020
+// Update Count     : 532
 //
 #include "CodeGenerator.h"
 …
         int CodeGenerator::tabsize = 4;
         // the kinds of statements that would ideally be followed by whitespace
+        // The kinds of statements that would ideally be followed by whitespace.
         bool wantSpacing( Statement * stmt) {
                 return dynamic_cast< IfStmt * >( stmt ) || dynamic_cast< CompoundStmt * >( stmt ) ||
 …
+        }
+        /* Using updateLocation at the beginning of a node and endl
+         * within a node should become the method of formating.
+         */
+        // Using updateLocation at the beginning of a node and endl within a node should become the method of formating.
         void CodeGenerator::updateLocation( CodeLocation const & to ) {
                 // skip if linemarks shouldn't appear or if codelocation is unset
 …
                 } else {
                         output << "\n# " << to.first_line << " \"" << to.filename
                                << "\"\n" << indent;
+                                   << "\"\n" << indent;
                         currentLocation = to;
+                }
 …
         void CodeGenerator::genAttributes( list< Attribute * > & attributes ) {
           if ( attributes.empty() ) return;
+                if ( attributes.empty() ) return;
                 output << "__attribute__ ((";
                 for ( list< Attribute * >::iterator attr( attributes.begin() );; ) {
 …
                                 output << ")";
                         } // if
                   if ( ++attr == attributes.end() ) break;
+                        if ( ++attr == attributes.end() ) break;
                         output << ",";                                                          // separator
                 } // for
 …
                 previsit( (BaseSyntaxNode *)node );
                 GuardAction( [this, node](){
                         if ( options.printExprTypes && node->result ) {
                                 output << " /* " << genType( node->result, "", options ) << " */ ";
+                        }
                 } );
+                                if ( options.printExprTypes && node->result ) {
+                                        output << " /* " << genType( node->result, "", options ) << " */ ";
+                                }
+                        } );
+        }
 …
                 extension( applicationExpr );
                 if ( VariableExpr * varExpr = dynamic_cast< VariableExpr* >( applicationExpr->get_function() ) ) {
                         OperatorInfo opInfo;
                         if ( varExpr->get_var()->get_linkage() == LinkageSpec::Intrinsic && operatorLookup( varExpr->get_var()->get_name(), opInfo ) ) {
+                        const OperatorInfo * opInfo;
+                        if ( varExpr->get_var()->get_linkage() == LinkageSpec::Intrinsic && ( opInfo = operatorLookup( varExpr->get_var()->get_name() ) ) ) {
                                 std::list< Expression* >::iterator arg = applicationExpr->get_args().begin();
                                 switch ( opInfo.type ) {
+                                switch ( opInfo->type ) {
                                   case OT_INDEX:
                                         assert( applicationExpr->get_args().size() == 2 );
 …
                                                 output << "(";
                                                 (*arg++)->accept( *visitor );
                                                 output << ") /* " << opInfo.inputName << " */";
+                                                output << ") /* " << opInfo->inputName << " */";
                                         } else if ( applicationExpr->get_args().size() == 2 ) {
                                                 // intrinsic two parameter constructors are essentially bitwise assignment
                                                 output << "(";
                                                 (*arg++)->accept( *visitor );
                                                 output << opInfo.symbol;
+                                                output << opInfo->symbol;
                                                 (*arg)->accept( *visitor );
                                                 output << ") /* " << opInfo.inputName << " */";
+                                                output << ") /* " << opInfo->inputName << " */";
                                         } else {
                                                 // no constructors with 0 or more than 2 parameters
 …
                                         assert( applicationExpr->get_args().size() == 1 );
                                         output << "(";
                                         output << opInfo.symbol;
+                                        output << opInfo->symbol;
                                         (*arg)->accept( *visitor );
                                         output << ")";
 …
                                         assert( applicationExpr->get_args().size() == 1 );
                                         (*arg)->accept( *visitor );
                                         output << opInfo.symbol;
+                                        output << opInfo->symbol;
                                         break;
 …
                                         output << "(";
                                         (*arg++)->accept( *visitor );
                                         output << opInfo.symbol;
+                                        output << opInfo->symbol;
                                         (*arg)->accept( *visitor );
                                         output << ")";
 …
                 extension( untypedExpr );
                 if ( NameExpr * nameExpr = dynamic_cast< NameExpr* >( untypedExpr->function ) ) {
                         OperatorInfo opInfo;
                         if ( operatorLookup( nameExpr->name, opInfo ) ) {
+                        const OperatorInfo * opInfo = operatorLookup( nameExpr->name );
+                        if ( opInfo ) {
                                 std::list< Expression* >::iterator arg = untypedExpr->args.begin();
                                 switch ( opInfo.type ) {
+                                switch ( opInfo->type ) {
                                   case OT_INDEX:
                                         assert( untypedExpr->args.size() == 2 );
 …
                                                 output << "(";
                                                 (*arg++)->accept( *visitor );
                                                 output << ") /* " << opInfo.inputName << " */";
+                                                output << ") /* " << opInfo->inputName << " */";
                                         } else if ( untypedExpr->get_args().size() == 2 ) {
                                                 // intrinsic two parameter constructors are essentially bitwise assignment
                                                 output << "(";
                                                 (*arg++)->accept( *visitor );
                                                 output << opInfo.symbol;
+                                                output << opInfo->symbol;
                                                 (*arg)->accept( *visitor );
                                                 output << ") /* " << opInfo.inputName << " */";
+                                                output << ") /* " << opInfo->inputName << " */";
                                         } else {
                                                 // no constructors with 0 or more than 2 parameters
 …
                                                 output << "(";
                                                 (*arg++)->accept( *visitor );
                                                 output << opInfo.symbol << "{ ";
+                                                output << opInfo->symbol << "{ ";
                                                 genCommaList( arg, untypedExpr->args.end() );
                                                 output << "}) /* " << opInfo.inputName << " */";
+                                                output << "}) /* " << opInfo->inputName << " */";
                                         } // if
                                         break;
 …
                                         assert( untypedExpr->args.size() == 1 );
                                         output << "(";
                                         output << opInfo.symbol;
+                                        output << opInfo->symbol;
                                         (*arg)->accept( *visitor );
                                         output << ")";
 …
                                         assert( untypedExpr->args.size() == 1 );
                                         (*arg)->accept( *visitor );
                                         output << opInfo.symbol;
+                                        output << opInfo->symbol;
                                         break;
 …
                                         output << "(";
                                         (*arg++)->accept( *visitor );
                                         output << opInfo.symbol;
+                                        output << opInfo->symbol;
                                         (*arg)->accept( *visitor );
                                         output << ")";
 …
         void CodeGenerator::postvisit( NameExpr * nameExpr ) {
                 extension( nameExpr );
                 OperatorInfo opInfo;
                 if ( operatorLookup( nameExpr->name, opInfo ) ) {
                         if ( opInfo.type == OT_CONSTANT ) {
                                 output << opInfo.symbol;
+                const OperatorInfo * opInfo = operatorLookup( nameExpr->name );
+                if ( opInfo ) {
+                        if ( opInfo->type == OT_CONSTANT ) {
+                                output << opInfo->symbol;
                         } else {
                                 output << opInfo.outputName;
+                                output << opInfo->outputName;
+                        }
                 } else {
 …
         void CodeGenerator::postvisit( VariableExpr * variableExpr ) {
                 extension( variableExpr );
                 OperatorInfo opInfo;
                 if ( variableExpr->get_var()->get_linkage() == LinkageSpec::Intrinsic && operatorLookup( variableExpr->get_var()->get_name(), opInfo ) && opInfo.type == OT_CONSTANT ) {
                         output << opInfo.symbol;
+                const OperatorInfo * opInfo;
+                if ( variableExpr->get_var()->get_linkage() == LinkageSpec::Intrinsic && (opInfo = operatorLookup( variableExpr->get_var()->get_name() )) && opInfo->type == OT_CONSTANT ) {
+                        output << opInfo->symbol;
                 } else {
                         output << mangleName( variableExpr->get_var() );
 …
                   case BranchStmt::FallThroughDefault:
                         assertf( ! options.genC, "fallthru should not reach code generation." );
                   output << "fallthru";
+                        output << "fallthru";
                         break;
                 } // switch
 …
                 output << ((throwStmt->get_kind() == ThrowStmt::Terminate) ?
                            "throw" : "throwResume");
+                                   "throw" : "throwResume");
                 if (throwStmt->get_expr()) {
                         output << " ";
 …
                 output << ((stmt->get_kind() == CatchStmt::Terminate) ?
                 "catch" : "catchResume");
+                                   "catch" : "catchResume");
                 output << "( ";
                 stmt->decl->accept( *visitor );
 …
         std::string genName( DeclarationWithType * decl ) {
                 CodeGen::OperatorInfo opInfo;
                 if ( operatorLookup( decl->get_name(), opInfo ) ) {
                         return opInfo.outputName;
+                const OperatorInfo * opInfo = operatorLookup( decl->get_name() );
+                if ( opInfo ) {
+                        return opInfo->outputName;
                 } else {
                         return decl->get_name();

src/CodeGen/CodeGenerator.h

-                      r8c50aed
+                      ra505021
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Tue Apr 30 12:01:00 2019
 // Update Count     : 57
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sun Feb 16 03:58:31 2020
+// Update Count     : 62
 //
 …
 namespace CodeGen {
         struct CodeGenerator : public WithShortCircuiting, public WithGuards, public WithVisitorRef<CodeGenerator> {
           static int tabsize;
+                static int tabsize;
                 CodeGenerator( std::ostream &os, bool pretty = false, bool genC = false, bool lineMarks = false, bool printExprTypes = false );
 …
                 void postvisit( AsmStmt * );
                 void postvisit( DirectiveStmt * );
                 void postvisit( AsmDecl * );                            // special: statement in declaration context
+                void postvisit( AsmDecl * );                                    // special: statement in declaration context
                 void postvisit( IfStmt * );
                 void postvisit( SwitchStmt * );
 …
                 LabelPrinter printLabels;
                 Options options;
         public:
+          public:
                 LineEnder endl;
         private:
+          private:
                 CodeLocation currentLocation;
 …
         template< class Iterator >
         void CodeGenerator::genCommaList( Iterator begin, Iterator end ) {
           if ( begin == end ) return;
+                if ( begin == end ) return;
                 for ( ;; ) {
                         (*begin++)->accept( *visitor );
                   if ( begin == end ) break;
+                        if ( begin == end ) break;
                         output << ", ";                                                         // separator
                 } // for

src/CodeGen/FixMain.h

-                      r8c50aed
+                      ra505021
 // Created On       : Thr Jan 12 14:11:09 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Dec 13 23:12:21 2019
 // Update Count     : 3
+// Last Modified On : Sun Feb 16 03:24:32 2020
+// Update Count     : 5
 //
 …
                 static std::unique_ptr<FunctionDecl> main_signature;
         };
 };
+} // namespace CodeGen

src/CodeGen/GenType.h

-                      r8c50aed
+                      ra505021
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Tue Apr 30 11:47:00 2019
 // Update Count     : 3
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sun Feb 16 04:11:40 2020
+// Update Count     : 5
 //
 …
         std::string genType( Type *type, const std::string &baseString, const Options &options );
         std::string genType( Type *type, const std::string &baseString, bool pretty = false, bool genC = false, bool lineMarks = false );
   std::string genPrettyType( Type * type, const std::string & baseString );
+        std::string genPrettyType( Type * type, const std::string & baseString );
 } // namespace CodeGen

src/CodeGen/Generate.cc

-                      r8c50aed
+                      ra505021
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Dec 13 23:38:56 2019
 // Update Count     : 8
+// Last Modified On : Sun Feb 16 03:01:51 2020
+// Update Count     : 9
 //
 #include "Generate.h"
 …
         void generate( BaseSyntaxNode * node, std::ostream & os ) {
                 if ( Type * type = dynamic_cast< Type * >( node ) ) {
                         os << CodeGen::genPrettyType( type, "" );
+                        os << genPrettyType( type, "" );
                 } else {
                         PassVisitor<CodeGenerator> cgv( os, true, false, false, false );

src/CodeGen/OperatorTable.cc

-                      r8c50aed
+                      ra505021
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 15 17:12:22 2017
 // Update Count     : 15
+// Last Modified On : Tue Feb 18 15:55:01 2020
+// Update Count     : 55
 //
 …
 #include <map>        // for map, _Rb_tree_const_iterator, map<>::const_iterator
 #include <utility>    // for pair
+using namespace std;
 #include "OperatorTable.h"
 …
 namespace CodeGen {
         namespace {
                 const OperatorInfo tableValues[] = {
                         {       "?[?]",         "",             "_operator_index",                              OT_INDEX                        },
                         {       "?{}",          "=",    "_constructor",                                 OT_CTOR                         },
                         {       "^?{}",         "",             "_destructor",                                  OT_DTOR                         },
                         {       "?()",          "",             "_operator_call",                               OT_CALL                         },
                         {       "?++",          "++",   "_operator_postincr",                   OT_POSTFIXASSIGN        },
                         {       "?--",          "--",   "_operator_postdecr",                   OT_POSTFIXASSIGN        },
                         {       "*?",           "*",    "_operator_deref",                              OT_PREFIX                       },
                         {       "+?",           "+",    "_operator_unaryplus",                  OT_PREFIX                       },
                         {       "-?",           "-",    "_operator_unaryminus",                 OT_PREFIX                       },
                         {       "~?",           "~",    "_operator_bitnot",                             OT_PREFIX                       },
                         {       "!?",           "!",    "_operator_lognot",                             OT_PREFIX                       },
                         {       "++?",          "++",   "_operator_preincr",                    OT_PREFIXASSIGN         },
                         {       "--?",          "--",   "_operator_predecr",                    OT_PREFIXASSIGN         },
                         {       "?\\?",         "\\",   "_operator_exponential",                OT_INFIX                        },
                         {       "?*?",          "*",    "_operator_multiply",                   OT_INFIX                        },
                         {       "?/?",          "/",    "_operator_divide",                             OT_INFIX                        },
                         {       "?%?",          "%",    "_operator_modulus",                    OT_INFIX                        },
                         {       "?+?",          "+",    "_operator_add",                                OT_INFIX                        },
                         {       "?-?",          "-",    "_operator_subtract",                   OT_INFIX                        },
                         {       "?<<?",         "<<",   "_operator_shiftleft",                  OT_INFIX                        },
                         {       "?>>?",         ">>",   "_operator_shiftright",                 OT_INFIX                        },
                         {       "?<?",          "<",    "_operator_less",                               OT_INFIX                &n

Context Navigation

Legend: