Changes in / [aefb247:bdfc032]

Files:

• benchmark/Makefile.am (modified) (10 diffs)
• benchmark/Makefile.in (modified) (9 diffs)
• benchmark/basic/fetch_add.c (added)
• benchmark/basic/function.c (added)
• benchmark/basic/loop.c (added)
• benchmark/basic/tls_fetch_add.c (added)
• benchmark/basic/ttst_lock.c (added)
• benchmark/bench.h (modified) (3 diffs)
• benchmark/creation/JavaThread.java (modified) (4 diffs)
• benchmark/creation/cfa_cor.cfa (modified) (1 diff)
• benchmark/creation/cfa_gen.cfa (added)
• benchmark/creation/cfa_thrd.cfa (modified) (1 diff)
• benchmark/creation/goroutine.go (modified) (2 diffs)
• benchmark/creation/node_cor.js (added)
• benchmark/creation/pthreads.c (modified) (3 diffs)
• benchmark/creation/python_cor.py (added)
• benchmark/creation/rust_thrd.rs (added)
• benchmark/creation/upp_cor.cc (modified) (1 diff)
• benchmark/creation/upp_thrd.cc (modified) (1 diff)
• benchmark/ctxswitch/JavaThread.java (modified) (3 diffs)
• benchmark/ctxswitch/cfa_cor.cfa (modified) (1 diff)
• benchmark/ctxswitch/cfa_cor_then.cfa (modified) (1 diff)
• benchmark/ctxswitch/cfa_gen.cfa (modified) (1 diff)
• benchmark/ctxswitch/cfa_thrd.cfa (modified) (1 diff)
• benchmark/ctxswitch/cfa_thrd2.cfa (modified) (1 diff)
• benchmark/ctxswitch/goroutine.go (modified) (2 diffs)
• benchmark/ctxswitch/kos_fibre.cpp (modified) (1 diff)
• benchmark/ctxswitch/kos_fibre2.cpp (modified) (1 diff)
• benchmark/ctxswitch/node_await.js (added)
• benchmark/ctxswitch/node_cor.js (added)
• benchmark/ctxswitch/pthreads.c (modified) (1 diff)
• benchmark/ctxswitch/python_cor.py (added)
• benchmark/ctxswitch/rust_thrd.rs (added)
• benchmark/ctxswitch/upp_cor.cc (modified) (2 diffs)
• benchmark/ctxswitch/upp_thrd.cc (modified) (1 diff)
• benchmark/exclude (added)
• benchmark/fetch_add.c (deleted)
• benchmark/function.c (deleted)
• benchmark/loop.c (deleted)
• benchmark/mutex/JavaThread.java (modified) (4 diffs)
• benchmark/mutex/cfa1.cfa (modified) (1 diff)
• benchmark/mutex/cfa2.cfa (modified) (1 diff)
• benchmark/mutex/cfa4.cfa (modified) (1 diff)
• benchmark/mutex/goroutine.go (added)
• benchmark/mutex/pthreads.c (modified) (1 diff)
• benchmark/mutex/rust.rs (added)
• benchmark/mutex/upp.cc (modified) (1 diff)
• benchmark/mutexC/JavaThread.java (added)
• benchmark/mutexC/cfa1.cfa (added)
• benchmark/mutexC/cfa2.cfa (added)
• benchmark/mutexC/cfa4.cfa (added)
• benchmark/mutexC/pthreads.c (added)
• benchmark/mutexC/rust.rs (added)
• benchmark/mutexC/upp.cc (added)
• benchmark/schedext/cfa1.cfa (modified) (1 diff)
• benchmark/schedext/cfa2.cfa (modified) (1 diff)
• benchmark/schedext/cfa4.cfa (modified) (1 diff)
• benchmark/schedext/goroutine.go (added)
• benchmark/schedext/upp.cc (modified) (1 diff)
• benchmark/schedint/JavaThread.java (modified) (4 diffs)
• benchmark/schedint/cfa1.cfa (modified) (1 diff)
• benchmark/schedint/cfa2.cfa (modified) (1 diff)
• benchmark/schedint/cfa4.cfa (modified) (1 diff)
• benchmark/schedint/pthreads.c (modified) (1 diff)
• benchmark/schedint/rust.rs (added)
• benchmark/schedint/upp.cc (modified) (2 diffs)
• benchmark/tls-fetch_add.c (deleted)
• benchmark/ttst_lock.c (deleted)
• driver/cfa.cc (modified) (2 diffs)
• libcfa/src/Makefile.in (modified) (2 diffs)
• libcfa/src/bits/containers.hfa (modified) (8 diffs)
• libcfa/src/bits/defs.hfa (modified) (2 diffs)
• libcfa/src/bits/signal.hfa (modified) (2 diffs)
• libcfa/src/clock.hfa (modified) (3 diffs)
• libcfa/src/concurrency/CtxSwitch-x86_64.S (modified) (1 diff)
• libcfa/src/concurrency/alarm.cfa (modified) (2 diffs)
• libcfa/src/concurrency/coroutine.cfa (modified) (2 diffs)
• libcfa/src/concurrency/coroutine.hfa (modified) (2 diffs)
• libcfa/src/concurrency/invoke.c (modified) (6 diffs)
• libcfa/src/concurrency/kernel.cfa (modified) (5 diffs)
• libcfa/src/concurrency/kernel_private.hfa (modified) (1 diff)
• libcfa/src/concurrency/monitor.cfa (modified) (1 diff)
• libcfa/src/concurrency/thread.cfa (modified) (3 diffs)
• libcfa/src/concurrency/thread.hfa (modified) (1 diff)
• libcfa/src/executor.cfa (modified) (2 diffs)
• libcfa/src/interpose.cfa (modified) (11 diffs)
• libcfa/src/startup.cfa (modified) (2 diffs)
• libcfa/src/stdhdr/bfdlink.h (modified) (1 diff)
• libcfa/src/stdhdr/hwloc.h (modified) (1 diff)
• libcfa/src/stdhdr/krb5.h (modified) (1 diff)
• libcfa/src/stdhdr/math.h (modified) (1 diff)
• libcfa/src/stdhdr/sys/ucontext.h (modified) (1 diff)
• libcfa/src/time.cfa (modified) (8 diffs)
• libcfa/src/time.hfa (modified) (6 diffs)
• libcfa/src/time_t.hfa (modified) (3 diffs)
• longrun_tests/Makefile.in (modified) (2 diffs)
• src/Common/Stats/Time.h (modified) (3 diffs)
• src/Concurrency/Keywords.cc (modified) (1 diff)
• src/Concurrency/Waitfor.cc (modified) (2 diffs)
• src/ControlStruct/LabelFixer.cc (modified) (5 diffs)
• src/ControlStruct/MLEMutator.cc (modified) (14 diffs)
• src/ControlStruct/MLEMutator.h (modified) (4 diffs)
• src/Parser/lex.ll (modified) (2 diffs)
• src/Parser/parser.yy (modified) (15 diffs)
• src/SymTab/Validate.cc (modified) (1 diff)
• src/SynTree/Statement.cc (modified) (34 diffs)
• src/SynTree/Statement.h (modified) (3 diffs)
• src/cfa.make (modified) (3 diffs)
• tests/.expect/time.txt (modified) (1 diff)
• tests/Makefile.in (modified) (2 diffs)
• tests/concurrent/examples/boundedBufferEXT.cfa (modified) (3 diffs)
• tests/concurrent/examples/boundedBufferTHREAD.cfa (modified) (2 diffs)
• tests/concurrent/examples/gortn.cfa (modified) (2 diffs)
• tests/concurrent/waitfor/barge.cfa (modified) (1 diff)
• tests/concurrent/waitfor/dtor.cfa (modified) (1 diff)
• tests/concurrent/waitfor/else.cfa (modified) (4 diffs)
• tests/concurrent/waitfor/parse.cfa (modified) (7 diffs)
• tests/concurrent/waitfor/parse2.cfa (modified) (13 diffs)
• tests/concurrent/waitfor/recurse.cfa (modified) (3 diffs)
• tests/concurrent/waitfor/statment.cfa (modified) (1 diff)
• tests/concurrent/waitfor/when.cfa (modified) (1 diff)
• tests/except-0.cfa (deleted)
• tests/except-1.cfa (deleted)
• tests/except-2.cfa (deleted)
• tests/except-3.cfa (deleted)
• tests/except-mac.hfa (deleted)
• tests/exceptions/.expect/finally-error.txt (added)
• tests/exceptions/except-0.cfa (added)
• tests/exceptions/except-1.cfa (added)
• tests/exceptions/except-2.cfa (added)
• tests/exceptions/except-3.cfa (added)
• tests/exceptions/except-mac.hfa (added)
• tests/exceptions/finally-error.cfa (added)
• tests/expression.cfa (modified) (1 diff)
• tests/quotedKeyword.cfa (modified) (2 diffs)
• tests/time.cfa (modified) (4 diffs)
• tools/stat.py (modified) (1 diff)

benchmark/Makefile.am

@@ -11 +11 @@
 ## Created On       : Sun May 31 09:08:15 2015
 ## Last Modified By : Peter A. Buhr
-## Last Modified On : Mon Jul 29 18:02:19 2019
-## Update Count     : 54
+## Last Modified On : Sat Jan 25 09:20:44 2020
+## Update Count     : 255
 ###############################################################################
 
@@ -28 +28 @@
 BENCH_V_CFA = $(__bench_v_CFA_$(__quiet))
 BENCH_V_CXX = $(__bench_v_CXX_$(__quiet))
+BENCH_V_UPP = $(__bench_v_UPP_$(__quiet))
 BENCH_V_GOC = $(__bench_v_GOC_$(__quiet))
+BENCH_V_RUSTC = $(__bench_v_RUSTC_$(__quiet))
+BENCH_V_NODEJS = $(__bench_v_NODEJS_$(__quiet))
 BENCH_V_JAVAC = $(__bench_v_JAVAC_$(__quiet))
-BENCH_V_UPP = $(__bench_v_UPP_$(__quiet))
 
 __quiet = verbose
@@ -36 +38 @@
 __bench_v_CFA_quiet = @
 __bench_v_CXX_quiet = @
+__bench_v_UPP_quiet = @
 __bench_v_GOC_quiet = @
+__bench_v_RUSTC_quiet = @
 __bench_v_JAVAC_quiet = @
-__bench_v_UPP_quiet = @
 __bench_v_CC_verbose = $(AM_V_CC)
 __bench_v_CFA_verbose = $(AM_V_CFA)
 __bench_v_CXX_verbose = $(AM_V_CXX)
+__bench_v_UPP_verbose = $(AM_V_UPP)
 __bench_v_GOC_verbose = $(AM_V_GOC)
+__bench_v_RUSTC_verbose = $(AM_V_RUSTC)
+__bench_v_NODEJS_verbose = $(AM_V_NODEJS)
 __bench_v_JAVAC_verbose = $(AM_V_JAVAC)
-__bench_v_UPP_verbose = $(AM_V_UPP)
 
 
@@ -51 +56 @@
 STATS    = ${abs_top_srcdir}/tools/stat.py
 # NEED AT LEAST 4 DATA VALUES FOR BENCHMARKS BECAUSE THE MAX AND MIN VALUES ARE REMOVED
-repeats  = 5 # 31 for benchmarks
+repeats  = 13 # 31 for benchmarks
 arch     = x64
 skipcompile = no
@@ -62 +67 @@
 
 dummyC.c:
-        @echo "int main() { return 0; }" > ${@}
+        echo "int main() { return 0; }" > ${@}
 
 dummyCXX.cpp:
-        @echo "int main() { return 0; }" > ${@}
-
+        echo "int main() { return 0; }" > ${@}
+
+#.SILENT:               # do not print recipe
+.ONESHELL:              # use one shell to execute recipe
 .NOTPARALLEL:
-.PHONY: compile.csv ctxswitch.csv mutex.csv signal.csv
-
-## =========================================================================================================
-all : ctxswitch$(EXEEXT) mutex$(EXEEXT) signal$(EXEEXT) waitfor$(EXEEXT) creation$(EXEEXT)
+.PHONY: compile.csv basic.csv ctxswitch.csv mutex.csv schedint.csv
+
+## =========================================================================================================
+
+all : basic$(EXEEXT) ctxswitch$(EXEEXT) mutex$(EXEEXT) schedint$(EXEEXT) schedext$(EXEEXT) creation$(EXEEXT)
+
+basic_loop_DURATION = 15000000000
+basic_function_DURATION = 10000000000
+basic_tls_fetch_add_DURATION = 10000000000
+basic_DURATION = 250000000
+
+ctxswitch_pthread_DURATION = 25000000
+ctxswitch_rust_thread_DURATION = $(ctxswitch_pthread_DURATION)
+ctxswitch_cfa_generator_DURATION = 5000000000
+ctxswitch_nodejs_await_DURATION = 5000000
+ctxswitch_DURATION = 100000000
+
+#mutex_java_DURATION = 10000000
+mutex_DURATION = 50000000
+
+schedint_pthread_DURATION = 1000000
+schedint_java_DURATION = $(schedint_pthread_DURATION)
+schedint_rust_DURATION = $(schedint_pthread_DURATION)
+schedint_DURATION = 10000000
+
+schedext_DURATION = 10000000
+
+creation_pthread_DURATION = 250000
+creation_rust_thread_DURATION = ${creation_pthread_DURATION}
+creation_java_thread_DURATION = ${creation_pthread_DURATION}
+creation_cfa_coroutine_DURATION = 100000000
+creation_cfa_coroutine_eager_DURATION = 10000000
+creation_upp_coroutine_DURATION = ${creation_cfa_coroutine_eager_DURATION}
+creation_cfa_thread_DURATION = 10000000
+creation_upp_thread_DURATION = ${creation_cfa_thread_DURATION}
+creation_DURATION = 10000000
 
 %.run : %$(EXEEXT) ${REPEAT}
-        @rm -f .result.log
-        @echo "------------------------------------------------------"
-        @echo $<
-        @${REPEAT} ${repeats} ./a.out | tee -a .result.log
-        @${STATS} .result.log
-        @echo "------------------------------------------------------"
-        @rm -f a.out .result.log *.class
+        rm -f .result.log
+        echo "------------------------------------------------------"
+        echo $<
+        ${REPEAT} ${repeats} -- ./a.out\
+                $(if ${$(subst -,_,$(basename $@))_DURATION},\
+                        ${$(subst -,_,$(basename $@))_DURATION},\
+                        ${$(firstword $(subst -, ,$(basename $@)))_DURATION}) | tee -a .result.log
+        ${STATS} .result.log
+        echo "------------------------------------------------------"
+        rm -f a.out .result.log *.class
+
+#       ${REPEAT} ${repeats} -- /usr/bin/time -f "%Uu %Ss %Er %Mkb" ./a.out
 
 %.runquiet :
-        @+make $(basename $@) CFLAGS="-w" __quiet=quiet
-        @taskset -c 1 ./a.out
-        @rm -f a.out
+        +make $(basename $@) CFLAGS="-w" __quiet=quiet
+        taskset -c 1 ./a.out
+        rm -f a.out
 
 %.make :
-        @printf "${PRINT_FORMAT}" $(basename $(subst compile-,,$@))
-        @+/usr/bin/time -f ${TIME_FORMAT} make $(basename $@) 2>&1
+        printf "${PRINT_FORMAT}" $(basename $(subst compile-,,$@))
+        +/usr/bin/time -f ${TIME_FORMAT} make $(basename $@) 2>&1
 
 ${REPEAT} :
-        @+make -C ${abs_top_builddir}/tools repeat
+        +make -C ${abs_top_builddir}/tools repeat
 
 ## =========================================================================================================
@@ -100 +144 @@
 jenkins$(EXEEXT):
 @DOifskipcompile@
-        @+make compile.csv
-        @-+make compile.diff.csv
+        +make compile.csv
+        -+make compile.diff.csv
 @DOendif@
-        @+make ctxswitch.csv
-        @-+make ctxswitch.diff.csv
-        @+make mutex.csv
-        @-+make mutex.diff.csv
-        @+make signal.csv
-        @-+make signal.diff.csv
+        +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
 @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 signal.csv
-        -cat signal.diff.csv
+        cat schedint.csv
+        -cat schedint.diff.csv
 
 compile.csv:
-        @echo "array,attributes,empty,expression,io,monitor,operators,typeof" > $@
-        @+make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-array.make >> $@
-        @+make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-attributes.make >> $@
-        @+make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-empty.make >> $@
-        @+make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-expression.make >> $@
-        @+make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-io.make >> $@
-        @+make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-monitor.make >> $@
-        @+make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-operators.make >> $@
-        @+make TIME_FORMAT='%e' PRINT_FORMAT='' compile-typeof.make >> $@
-        @$(srcdir)/fixcsv.sh $@
+        echo "array,attributes,empty,expression,io,monitor,operators,typeof" > $@
+        +make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-array.make >> $@
+        +make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-attributes.make >> $@
+        +make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-empty.make >> $@
+        +make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-expression.make >> $@
+        +make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-io.make >> $@
+        +make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-monitor.make >> $@
+        +make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-operators.make >> $@
+        +make TIME_FORMAT='%e' PRINT_FORMAT='' compile-typeof.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 "generator,coroutine,thread" > $@
-        @+make ctxswitch-cfa_generator.runquiet >> $@ && echo -n ',' >> $@
-        @+make ctxswitch-cfa_coroutine.runquiet >> $@ && echo -n ',' >> $@
-        @+make ctxswitch-cfa_thread.runquiet >> $@
-        @$(srcdir)/fixcsv.sh $@
+        echo "generator,coroutine,thread" > $@
+        +make ctxswitch-cfa_generator.runquiet >> $@ && echo -n ',' >> $@
+        +make ctxswitch-cfa_coroutine.runquiet >> $@ && echo -n ',' >> $@
+        +make ctxswitch-cfa_thread.runquiet >> $@
+        $(srcdir)/fixcsv.sh $@
 
 mutex.csv:
-        @echo "1-monitor,2-monitor" > $@
-        @+make mutex-cfa1.runquiet >> $@ && echo -n ',' >> $@
-        @+make mutex-cfa2.runquiet >> $@
-        @$(srcdir)/fixcsv.sh $@
-
-signal.csv:
-        @echo "signal-1,signal-2,waitfor-1,waitfor-2" > $@
-        @+make signal-cfa1.runquiet >> $@ && echo -n ',' >> $@
-        @+make signal-cfa2.runquiet >> $@ && echo -n ',' >> $@
-        @+make waitfor-cfa1.runquiet >> $@ && echo -n ',' >> $@
-        @+make waitfor-cfa2.runquiet >> $@
-        @$(srcdir)/fixcsv.sh $@
+        echo "1-monitor,2-monitor" > $@
+        +make mutex-cfa1.runquiet >> $@ && echo -n ',' >> $@
+        +make mutex-cfa2.runquiet >> $@
+        $(srcdir)/fixcsv.sh $@
+
+schedint.csv:
+        echo "schedint-1,schedint-2,schedext-1,schedext-2" > $@
+        +make schedint-cfa1.runquiet >> $@ && echo -n ',' >> $@
+        +make schedint-cfa2.runquiet >> $@ && echo -n ',' >> $@
+        +make schedext-cfa1.runquiet >> $@ && echo -n ',' >> $@
+        +make schedext-cfa2.runquiet >> $@
+        $(srcdir)/fixcsv.sh $@
 
 %.diff.csv: %.csv
-        @test -e $(srcdir)/baselines/$(arch)/$< || (echo "Error : Missing baseline for ${<}" && false)
-        @$(srcdir)/baselines/calc.py $(srcdir)/baselines/$(arch)/$(<) $(<) > $@
-
-
-## =========================================================================================================
-loop$(EXEEXT):
-        $(BENCH_V_CC)$(COMPILE) -DBENCH_N=5000000000 $(srcdir)/loop.c
-
-function$(EXEEXT):
-        $(BENCH_V_CC)$(COMPILE) -DBENCH_N=5000000000 $(srcdir)/function.c
-
-fetch_add$(EXEEXT):
-        $(BENCH_V_CC)$(COMPILE) -DBENCH_N=500000000  $(srcdir)/fetch_add.c
-
-ttst_lock$(EXEEXT):
-        $(BENCH_V_CC)$(COMPILE) -DBENCH_N=500000000  $(srcdir)/ttst_lock.c
-
-tls-fetch_add$(EXEEXT):
-        $(BENCH_V_CC)$(COMPILE) -DBENCH_N=500000000  $(srcdir)/tls-fetch_add.c
-
-## =========================================================================================================
-CTXSWITCH_DEPEND  =                 \
-        loop.run                                \
-        function.run                    \
-        fetch_add.run                   \
-        ttst_lock.run                   \
-        tls-fetch_add.run                       \
-        ctxswitch-pthread.run           \
+        test -e $(srcdir)/baselines/$(arch)/$< || (echo "Error : Missing baseline for ${<}" && false)
+        $(srcdir)/baselines/calc.py $(srcdir)/baselines/$(arch)/$(<) $(<) > $@
+
+## =========================================================================================================
+
+BASIC_DEPEND  =                                 \
+        basic-loop.run                          \
+        basic-function.run                      \
+        basic-fetch_add.run                     \
+        basic-ttst_lock.run                     \
+        basic-tls-fetch_add.run
+
+basic-loop$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) $(srcdir)/basic/loop.c
+
+basic-function$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) $(srcdir)/basic/function.c
+
+basic-fetch_add$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) $(srcdir)/basic/fetch_add.c
+
+basic-ttst_lock$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) $(srcdir)/basic/ttst_lock.c
+
+basic-tls-fetch_add$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) $(srcdir)/basic/tls_fetch_add.c
+
+basic$(EXEEXT): $(BASIC_DEPEND)
+
+## =========================================================================================================
+
+CTXSWITCH_DEPEND  =                     \
         ctxswitch-cfa_generator.run     \
         ctxswitch-cfa_coroutine.run     \
@@ -188 +247 @@
         ctxswitch-upp_coroutine.run     \
         ctxswitch-upp_thread.run        \
-        ctxswitch-goroutine.run         \
-        ctxswitch-java_thread.run
-
+        ctxswitch-python_coroutine.run  \
+        ctxswitch-nodejs_coroutine.run  \
+        ctxswitch-nodejs_await.run      \
+        ctxswitch-goroutine_thread.run  \
+        ctxswitch-rust_thread.run       \
+        ctxswitch-nodejs_coroutine.run  \
+        ctxswitch-java_thread.run       \
+        ctxswitch-pthread.run
 
 if WITH_LIBFIBRE
-CTXSWITCH_DEPEND  +=           \
-        ctxswitch-kos_fibre.run  \
+CTXSWITCH_DEPEND  +=                    \
+        ctxswitch-kos_fibre.run         \
         ctxswitch-kos_fibre2.run
-
 
 ctxswitch-kos_fibre$(EXEEXT):
@@ -207 +270 @@
 ctxswitch$(EXEEXT): $(CTXSWITCH_DEPEND)
 
-ctxswitch-pthread$(EXEEXT):
-        $(BENCH_V_CC)$(COMPILE)    -DBENCH_N=50000000 $(srcdir)/ctxswitch/pthreads.c
-
 ctxswitch-cfa_generator$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_gen.cfa
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/ctxswitch/cfa_gen.cfa
 
 ctxswitch-cfa_coroutine$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_cor.cfa
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/ctxswitch/cfa_cor.cfa
 
 ctxswitch-cfa_thread$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_thrd.cfa
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/ctxswitch/cfa_thrd.cfa
 
 ctxswitch-cfa_thread2$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_thrd2.cfa
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/ctxswitch/cfa_thrd2.cfa
 
 ctxswitch-upp_coroutine$(EXEEXT):
-        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/upp_cor.cc
+        $(BENCH_V_UPP)$(UPPCOMPILE) $(srcdir)/ctxswitch/upp_cor.cc
 
 ctxswitch-upp_thread$(EXEEXT):
-        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/upp_thrd.cc
-
-ctxswitch-goroutine$(EXEEXT):
+        $(BENCH_V_UPP)$(UPPCOMPILE) $(srcdir)/ctxswitch/upp_thrd.cc
+
+ctxswitch-python_coroutine$(EXEEXT):
+        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
+        echo "nodejs $(srcdir)/ctxswitch/node_cor.js" >> a.out
+        chmod a+x a.out
+
+ctxswitch-nodejs_await$(EXEEXT):
+        echo "#!/bin/sh" > a.out
+        echo "nodejs $(srcdir)/ctxswitch/node_await.js" >> a.out
+        chmod a+x a.out
+
+ctxswitch-goroutine_thread$(EXEEXT):
         $(BENCH_V_GOC)go build -o a.out $(srcdir)/ctxswitch/goroutine.go
+
+ctxswitch-rust_thread$(EXEEXT):
+        $(BENCH_V_RUSTC)rustc -C opt-level=3 -o a.out $(srcdir)/ctxswitch/rust_thrd.rs
 
 ctxswitch-java_thread$(EXEEXT):
         $(BENCH_V_JAVAC)javac -d $(builddir) $(srcdir)/ctxswitch/JavaThread.java
-        @echo "#!/bin/sh" > a.out
-        @echo "java JavaThread" >> a.out
-        @chmod a+x a.out
-
-## =========================================================================================================
-mutex$(EXEEXT) :\
-        loop.run                        \
-        function.run            \
-        fetch_add.run           \
-        mutex-pthread_lock.run  \
-        mutex-upp.run           \
+        echo "#!/bin/sh" > a.out
+        echo "java JavaThread" >> a.out
+        chmod a+x a.out
+
+ctxswitch-pthread$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) $(srcdir)/ctxswitch/pthreads.c
+
+## =========================================================================================================
+
+mutex$(EXEEXT) :                \
         mutex-cfa1.run          \
         mutex-cfa2.run          \
         mutex-cfa4.run          \
-        mutex-java_thread.run
-
-mutex-pthread_lock$(EXEEXT):
-        $(BENCH_V_CC)$(COMPILE)    -DBENCH_N=50000000 $(srcdir)/mutex/pthreads.c
+        mutex-upp.run           \
+        mutex-go.run            \
+        mutex-rust.run          \
+        mutex-java.run          \
+        mutex-pthread.run
+
+mutex-pthread$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) $(srcdir)/mutex/pthreads.c
+
+mutex-cfa1$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/mutex/cfa1.cfa
+
+mutex-cfa2$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/mutex/cfa2.cfa
+
+mutex-cfa4$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/mutex/cfa4.cfa
 
 mutex-upp$(EXEEXT):
-        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/mutex/upp.cc
-
-mutex-cfa1$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=5000000  $(srcdir)/mutex/cfa1.cfa
-
-mutex-cfa2$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=5000000  $(srcdir)/mutex/cfa2.cfa
-
-mutex-cfa4$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=5000000  $(srcdir)/mutex/cfa4.cfa
-
-mutex-java_thread$(EXEEXT):
+        $(BENCH_V_UPP)$(UPPCOMPILE) $(srcdir)/mutex/upp.cc
+
+mutex-go$(EXEEXT):
+        $(BENCH_V_GOC)go build -o a.out $(srcdir)/mutex/goroutine.go
+
+mutex-rust$(EXEEXT):
+        $(BENCH_V_RUSTC)rustc -C opt-level=3 -o a.out $(srcdir)/mutex/rust.rs
+
+mutex-java$(EXEEXT):
         $(BENCH_V_JAVAC)javac -d $(builddir) $(srcdir)/mutex/JavaThread.java
-        @echo "#!/bin/sh" > a.out
-        @echo "java JavaThread" >> a.out
-        @chmod a+x a.out
-
-## =========================================================================================================
-signal$(EXEEXT) :\
-        signal-pthread_cond.run \
-        signal-upp.run          \
-        signal-cfa1.run         \
-        signal-cfa2.run         \
-        signal-cfa4.run         \
-        signal-java_thread.run
-
-signal-pthread_cond$(EXEEXT):
-        $(BENCH_V_CC)$(COMPILE)    -DBENCH_N=500000  $(srcdir)/schedint/pthreads.c
-
-signal-upp$(EXEEXT):
-        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=5000000 $(srcdir)/schedint/upp.cc
-
-signal-cfa1$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedint/cfa1.cfa
-
-signal-cfa2$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedint/cfa2.cfa
-
-signal-cfa4$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedint/cfa4.cfa
-
-signal-java_thread$(EXEEXT):
+        echo "#!/bin/sh" > a.out
+        echo "java JavaThread" >> a.out
+        chmod a+x a.out
+
+## =========================================================================================================
+
+schedint$(EXEEXT) :             \
+        schedint-cfa1.run       \
+        schedint-cfa2.run       \
+        schedint-cfa4.run       \
+        schedint-upp.run        \
+        schedint-rust.run       \
+        schedint-java.run       \
+        schedint-pthread.run
+
+schedint-cfa1$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/schedint/cfa1.cfa
+
+schedint-cfa2$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/schedint/cfa2.cfa
+
+schedint-cfa4$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/schedint/cfa4.cfa
+
+schedint-upp$(EXEEXT):
+        $(BENCH_V_UPP)$(UPPCOMPILE) $(srcdir)/schedint/upp.cc
+
+schedint-rust$(EXEEXT):
+        $(BENCH_V_RUSTC)rustc -C opt-level=3 -o a.out $(srcdir)/schedint/rust.rs
+
+schedint-java$(EXEEXT):
         $(BENCH_V_JAVAC)javac -d $(builddir) $(srcdir)/schedint/JavaThread.java
-        @echo "#!/bin/sh" > a.out
-        @echo "java JavaThread" >> a.out
-        @chmod a+x a.out
-
-
-## =========================================================================================================
-waitfor$(EXEEXT) :\
-        waitfor-upp.run         \
-        waitfor-cfa1.run                \
-        waitfor-cfa2.run                \
-        waitfor-cfa4.run
-
-waitfor-upp$(EXEEXT):
-        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=5000000 $(srcdir)/schedext/upp.cc
-
-waitfor-cfa1$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedext/cfa1.cfa
-
-waitfor-cfa2$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedext/cfa2.cfa
-
-waitfor-cfa4$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedext/cfa4.cfa
-
-## =========================================================================================================
-creation$(EXEEXT) :\
-        creation-pthread.run                    \
+        echo "#!/bin/sh" > a.out
+        echo "java JavaThread" >> a.out
+        chmod a+x a.out
+
+schedint-pthread$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) $(srcdir)/schedint/pthreads.c
+
+## =========================================================================================================
+
+schedext$(EXEEXT) :             \
+        schedext-cfa1.run       \
+        schedext-cfa2.run       \
+        schedext-cfa4.run       \
+        schedext-upp.run        \
+        schedext-goroutine.run
+
+schedext-cfa1$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/schedext/cfa1.cfa
+
+schedext-cfa2$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/schedext/cfa2.cfa
+
+schedext-cfa4$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/schedext/cfa4.cfa
+
+schedext-upp$(EXEEXT):
+        $(BENCH_V_UPP)$(UPPCOMPILE) $(srcdir)/schedext/upp.cc
+
+schedext-goroutine$(EXEEXT):
+        $(BENCH_V_GOC)go build -o a.out $(srcdir)/schedext/goroutine.go
+
+
+## =========================================================================================================
+
+creation$(EXEEXT) :                             \
+        creation-cfa_generator.run              \
         creation-cfa_coroutine.run              \
         creation-cfa_coroutine_eager.run        \
@@ -328 +426 @@
         creation-upp_coroutine.run              \
         creation-upp_thread.run                 \
-        creation-goroutine.run                  \
-        creation-java_thread.run
+        creation-python_coroutine.run           \
+        creation-nodejs_coroutine.run           \
+        creation-goroutine_thread.run           \
+        creation-rust_thread.run                \
+        creation-java_thread.run                \
+        creation-pthread.run
+
+creation-cfa_generator$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/creation/cfa_gen.cfa
 
 creation-cfa_coroutine$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=10000000 $(srcdir)/creation/cfa_cor.cfa
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/creation/cfa_cor.cfa
 
 creation-cfa_coroutine_eager$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=10000000 $(srcdir)/creation/cfa_cor.cfa  -DEAGER
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/creation/cfa_cor.cfa  -DEAGER
 
 creation-cfa_thread$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=10000000 $(srcdir)/creation/cfa_thrd.cfa
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/creation/cfa_thrd.cfa
 
 creation-upp_coroutine$(EXEEXT):
-        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/creation/upp_cor.cc
+        $(BENCH_V_UPP)$(UPPCOMPILE) $(srcdir)/creation/upp_cor.cc
 
 creation-upp_thread$(EXEEXT):
-        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/creation/upp_thrd.cc
-
-creation-pthread$(EXEEXT):
-        $(BENCH_V_CC)$(COMPILE)    -DBENCH_N=250000   $(srcdir)/creation/pthreads.c
-
-creation-goroutine$(EXEEXT):
+        $(BENCH_V_UPP)$(UPPCOMPILE) $(srcdir)/creation/upp_thrd.cc
+
+creation-python_coroutine$(EXEEXT):
+        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
+        echo "nodejs $(srcdir)/creation/node_cor.js" >> a.out
+        chmod a+x a.out
+
+creation-goroutine_thread$(EXEEXT):
         $(BENCH_V_GOC)go build -o a.out $(srcdir)/creation/goroutine.go
+
+creation-rust_thread$(EXEEXT):
+        $(BENCH_V_RUSTC)rustc -C opt-level=3 -o a.out $(srcdir)/creation/rust_thrd.rs
 
 creation-java_thread$(EXEEXT):
         $(BENCH_V_JAVAC)javac -d $(builddir) $(srcdir)/creation/JavaThread.java
-        @echo "#!/bin/sh" > a.out
-        @echo "java JavaThread" >> a.out
-        @chmod a+x a.out
-
-## =========================================================================================================
-
-compile$(EXEEXT) :\
+        echo "#!/bin/sh" > a.out
+        echo "java JavaThread" >> a.out
+        chmod a+x a.out
+
+creation-pthread$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) $(srcdir)/creation/pthreads.c
+
+## =========================================================================================================
+
+compile$(EXEEXT) :              \
         compile-array.make      \
         compile-attributes.make \
@@ -370 +488 @@
         compile-typeof.make
 
-
 testdir = $(top_srcdir)/tests
 
 compile-array$(EXEEXT):
-        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/array.cfa
+        $(CFACOMPILE) -fsyntax-only -w $(testdir)/array.cfa
 
 compile-attributes$(EXEEXT):
-        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/attributes.cfa
+        $(CFACOMPILE) -fsyntax-only -w $(testdir)/attributes.cfa
 
 compile-empty$(EXEEXT):
-        @$(CFACOMPILE) -fsyntax-only -w $(srcdir)/compile/empty.cfa
+        $(CFACOMPILE) -fsyntax-only -w $(srcdir)/compile/empty.cfa
 
 compile-expression$(EXEEXT):
-        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/expression.cfa
+        $(CFACOMPILE) -fsyntax-only -w $(testdir)/expression.cfa
 
 compile-io$(EXEEXT):
-        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/io1.cfa
+        $(CFACOMPILE) -fsyntax-only -w $(testdir)/io1.cfa
 
 compile-monitor$(EXEEXT):
-        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/concurrent/monitor.cfa
+        $(CFACOMPILE) -fsyntax-only -w $(testdir)/concurrent/monitor.cfa
 
 compile-operators$(EXEEXT):
-        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/operators.cfa
+        $(CFACOMPILE) -fsyntax-only -w $(testdir)/operators.cfa
 
 compile-thread$(EXEEXT):
-        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/concurrent/thread.cfa
+        $(CFACOMPILE) -fsyntax-only -w $(testdir)/concurrent/thread.cfa
 
 compile-typeof$(EXEEXT):
-        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/typeof.cfa
+        $(CFACOMPILE) -fsyntax-only -w $(testdir)/typeof.cfa

benchmark/Makefile.in

@@ -93 +93 @@
 EXTRA_PROGRAMS = dummy$(EXEEXT)
 @WITH_LIBFIBRE_TRUE@am__append_1 = \
-@WITH_LIBFIBRE_TRUE@    ctxswitch-kos_fibre.run  \
+@WITH_LIBFIBRE_TRUE@    ctxswitch-kos_fibre.run         \
 @WITH_LIBFIBRE_TRUE@    ctxswitch-kos_fibre2.run
 
@@ -358 +358 @@
 am__v_CFA_0 = @echo "  CFA     " $@;
 am__v_CFA_1 = 
-AM_V_JAVAC = $(am__v_JAVAC_@AM_V@)
-am__v_JAVAC_ = $(am__v_JAVAC_@AM_DEFAULT_V@)
-am__v_JAVAC_0 = @echo "  JAVAC   " $@;
-am__v_JAVAC_1 = 
-AM_V_GOC = $(am__v_GOC_@AM_V@)
-am__v_GOC_ = $(am__v_GOC_@AM_DEFAULT_V@)
-am__v_GOC_0 = @echo "  GOC     " $@;
-am__v_GOC_1 = 
 UPPCC = u++
 UPPCOMPILE = $(UPPCC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_UPPFLAGS) $(UPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_CFLAGS) $(CFLAGS)
@@ -372 +364 @@
 am__v_UPP_0 = @echo "  UPP     " $@;
 am__v_UPP_1 = 
+AM_V_GOC = $(am__v_GOC_@AM_V@)
+am__v_GOC_ = $(am__v_GOC_@AM_DEFAULT_V@)
+am__v_GOC_0 = @echo "  GOC     " $@;
+am__v_GOC_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_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_1 = 
+AM_V_JAVAC = $(am__v_JAVAC_@AM_V@)
+am__v_JAVAC_ = $(am__v_JAVAC_@AM_DEFAULT_V@)
+am__v_JAVAC_0 = @echo "  JAVAC   " $@;
+am__v_JAVAC_1 = 
 
 # applies to both programs
@@ -380 +388 @@
 BENCH_V_CFA = $(__bench_v_CFA_$(__quiet))
 BENCH_V_CXX = $(__bench_v_CXX_$(__quiet))
+BENCH_V_UPP = $(__bench_v_UPP_$(__quiet))
 BENCH_V_GOC = $(__bench_v_GOC_$(__quiet))
+BENCH_V_RUSTC = $(__bench_v_RUSTC_$(__quiet))
+BENCH_V_NODEJS = $(__bench_v_NODEJS_$(__quiet))
 BENCH_V_JAVAC = $(__bench_v_JAVAC_$(__quiet))
-BENCH_V_UPP = $(__bench_v_UPP_$(__quiet))
 __quiet = verbose
 __bench_v_CC_quiet = @
 __bench_v_CFA_quiet = @
 __bench_v_CXX_quiet = @
+__bench_v_UPP_quiet = @
 __bench_v_GOC_quiet = @
+__bench_v_RUSTC_quiet = @
 __bench_v_JAVAC_quiet = @
-__bench_v_UPP_quiet = @
 __bench_v_CC_verbose = $(AM_V_CC)
 __bench_v_CFA_verbose = $(AM_V_CFA)
 __bench_v_CXX_verbose = $(AM_V_CXX)
+__bench_v_UPP_verbose = $(AM_V_UPP)
 __bench_v_GOC_verbose = $(AM_V_GOC)
+__bench_v_RUSTC_verbose = $(AM_V_RUSTC)
+__bench_v_NODEJS_verbose = $(AM_V_NODEJS)
 __bench_v_JAVAC_verbose = $(AM_V_JAVAC)
-__bench_v_UPP_verbose = $(AM_V_UPP)
 TOOLSDIR = ${abs_top_builddir}/tools/
 REPEAT = ${abs_top_builddir}/tools/repeat
 STATS = ${abs_top_srcdir}/tools/stat.py
 # NEED AT LEAST 4 DATA VALUES FOR BENCHMARKS BECAUSE THE MAX AND MIN VALUES ARE REMOVED
-repeats = 5 # 31 for benchmarks
+repeats = 13 # 31 for benchmarks
 arch = x64
 skipcompile = no
@@ -406 +419 @@
 PRINT_FORMAT = %20s: #Comments needed for spacing
 dummy_SOURCES = dummyC.c dummyCXX.cpp
+basic_loop_DURATION = 15000000000
+basic_function_DURATION = 10000000000
+basic_tls_fetch_add_DURATION = 10000000000
+basic_DURATION = 250000000
+ctxswitch_pthread_DURATION = 25000000
+ctxswitch_rust_thread_DURATION = $(ctxswitch_pthread_DURATION)
+ctxswitch_cfa_generator_DURATION = 5000000000
+ctxswitch_nodejs_await_DURATION = 5000000
+ctxswitch_DURATION = 100000000
+
+#mutex_java_DURATION = 10000000
+mutex_DURATION = 50000000
+schedint_pthread_DURATION = 1000000
+schedint_java_DURATION = $(schedint_pthread_DURATION)
+schedint_rust_DURATION = $(schedint_pthread_DURATION)
+schedint_DURATION = 10000000
+schedext_DURATION = 10000000
+creation_pthread_DURATION = 250000
+creation_rust_thread_DURATION = ${creation_pthread_DURATION}
+creation_java_thread_DURATION = ${creation_pthread_DURATION}
+creation_cfa_coroutine_DURATION = 100000000
+creation_cfa_coroutine_eager_DURATION = 10000000
+creation_upp_coroutine_DURATION = ${creation_cfa_coroutine_eager_DURATION}
+creation_cfa_thread_DURATION = 10000000
+creation_upp_thread_DURATION = ${creation_cfa_thread_DURATION}
+creation_DURATION = 10000000
 FIX_NEW_LINES = cat $@ | tr "\n" "\t" | sed -r 's/\t,/,/' | tr "\t" "\n" > $@
-CTXSWITCH_DEPEND = loop.run function.run fetch_add.run ttst_lock.run \
-        tls-fetch_add.run ctxswitch-pthread.run \
-        ctxswitch-cfa_generator.run ctxswitch-cfa_coroutine.run \
-        ctxswitch-cfa_thread.run ctxswitch-cfa_thread2.run \
-        ctxswitch-upp_coroutine.run ctxswitch-upp_thread.run \
-        ctxswitch-goroutine.run ctxswitch-java_thread.run \
-        $(am__append_1)
+BASIC_DEPEND = \
+        basic-loop.run                          \
+        basic-function.run                      \
+        basic-fetch_add.run                     \
+        basic-ttst_lock.run                     \
+        basic-tls-fetch_add.run
+
+CTXSWITCH_DEPEND = ctxswitch-cfa_generator.run \
+        ctxswitch-cfa_coroutine.run ctxswitch-cfa_thread.run \
+        ctxswitch-cfa_thread2.run ctxswitch-upp_coroutine.run \
+        ctxswitch-upp_thread.run ctxswitch-python_coroutine.run \
+        ctxswitch-nodejs_coroutine.run ctxswitch-nodejs_await.run \
+        ctxswitch-goroutine_thread.run ctxswitch-rust_thread.run \
+        ctxswitch-nodejs_coroutine.run ctxswitch-java_thread.run \
+        ctxswitch-pthread.run $(am__append_1)
 testdir = $(top_srcdir)/tests
 all: all-am
@@ -732 +779 @@
 
 dummyC.c:
-        @echo "int main() { return 0; }" > ${@}
+        echo "int main() { return 0; }" > ${@}
 
 dummyCXX.cpp:
-        @echo "int main() { return 0; }" > ${@}
-
+        echo "int main() { return 0; }" > ${@}
+
+#.SILENT:               # do not print recipe
+.ONESHELL:              # use one shell to execute recipe
 .NOTPARALLEL:
-.PHONY: compile.csv ctxswitch.csv mutex.csv signal.csv
-
-all : ctxswitch$(EXEEXT) mutex$(EXEEXT) signal$(EXEEXT) waitfor$(EXEEXT) creation$(EXEEXT)
+.PHONY: compile.csv basic.csv ctxswitch.csv mutex.csv schedint.csv
+
+all : basic$(EXEEXT) ctxswitch$(EXEEXT) mutex$(EXEEXT) schedint$(EXEEXT) schedext$(EXEEXT) creation$(EXEEXT)
 
 %.run : %$(EXEEXT) ${REPEAT}
-        @rm -f .result.log
-        @echo "------------------------------------------------------"
-        @echo $<
-        @${REPEAT} ${repeats} ./a.out | tee -a .result.log
-        @${STATS} .result.log
-        @echo "------------------------------------------------------"
-        @rm -f a.out .result.log *.class
+        rm -f .result.log
+        echo "------------------------------------------------------"
+        echo $<
+        ${REPEAT} ${repeats} -- ./a.out\
+                $(if ${$(subst -,_,$(basename $@))_DURATION},\
+                        ${$(subst -,_,$(basename $@))_DURATION},\
+                        ${$(firstword $(subst -, ,$(basename $@)))_DURATION}) | tee -a .result.log
+        ${STATS} .result.log
+        echo "------------------------------------------------------"
+        rm -f a.out .result.log *.class
+
+#       ${REPEAT} ${repeats} -- /usr/bin/time -f "%Uu %Ss %Er %Mkb" ./a.out
 
 %.runquiet :
-        @+make $(basename $@) CFLAGS="-w" __quiet=quiet
-        @taskset -c 1 ./a.out
-        @rm -f a.out
+        +make $(basename $@) CFLAGS="-w" __quiet=quiet
+        taskset -c 1 ./a.out
+        rm -f a.out
 
 %.make :
-        @printf "${PRINT_FORMAT}" $(basename $(subst compile-,,$@))
-        @+/usr/bin/time -f ${TIME_FORMAT} make $(basename $@) 2>&1
+        printf "${PRINT_FORMAT}" $(basename $(subst compile-,,$@))
+        +/usr/bin/time -f ${TIME_FORMAT} make $(basename $@) 2>&1
 
 ${REPEAT} :
-        @+make -C ${abs_top_builddir}/tools repeat
+        +make -C ${abs_top_builddir}/tools repeat
 
 jenkins$(EXEEXT):
 @DOifskipcompile@
-        @+make compile.csv
-        @-+make compile.diff.csv
+        +make compile.csv
+        -+make compile.diff.csv
 @DOendif@
-        @+make ctxswitch.csv
-        @-+make ctxswitch.diff.csv
-        @+make mutex.csv
-        @-+make mutex.diff.csv
-        @+make signal.csv
-        @-+make signal.diff.csv
+        +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
 @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 signal.csv
-        -cat signal.diff.csv
+        cat schedint.csv
+        -cat schedint.diff.csv
 
 compile.csv:
-        @echo "array,attributes,empty,expression,io,monitor,operators,typeof" > $@
-        @+make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-array.make >> $@
-        @+make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-attributes.make >> $@
-        @+make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-empty.make >> $@
-        @+make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-expression.make >> $@
-        @+make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-io.make >> $@
-        @+make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-monitor.make >> $@
-        @+make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-operators.make >> $@
-        @+make TIME_FORMAT='%e' PRINT_FORMAT='' compile-typeof.make >> $@
-        @$(srcdir)/fixcsv.sh $@
+        echo "array,attributes,empty,expression,io,monitor,operators,typeof" > $@
+        +make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-array.make >> $@
+        +make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-attributes.make >> $@
+        +make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-empty.make >> $@
+        +make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-expression.make >> $@
+        +make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-io.make >> $@
+        +make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-monitor.make >> $@
+        +make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-operators.make >> $@
+        +make TIME_FORMAT='%e' PRINT_FORMAT='' compile-typeof.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 "generator,coroutine,thread" > $@
-        @+make ctxswitch-cfa_generator.runquiet >> $@ && echo -n ',' >> $@
-        @+make ctxswitch-cfa_coroutine.runquiet >> $@ && echo -n ',' >> $@
-        @+make ctxswitch-cfa_thread.runquiet >> $@
-        @$(srcdir)/fixcsv.sh $@
+        echo "generator,coroutine,thread" > $@
+        +make ctxswitch-cfa_generator.runquiet >> $@ && echo -n ',' >> $@
+        +make ctxswitch-cfa_coroutine.runquiet >> $@ && echo -n ',' >> $@
+        +make ctxswitch-cfa_thread.runquiet >> $@
+        $(srcdir)/fixcsv.sh $@
 
 mutex.csv:
-        @echo "1-monitor,2-monitor" > $@
-        @+make mutex-cfa1.runquiet >> $@ && echo -n ',' >> $@
-        @+make mutex-cfa2.runquiet >> $@
-        @$(srcdir)/fixcsv.sh $@
-
-signal.csv:
-        @echo "signal-1,signal-2,waitfor-1,waitfor-2" > $@
-        @+make signal-cfa1.runquiet >> $@ && echo -n ',' >> $@
-        @+make signal-cfa2.runquiet >> $@ && echo -n ',' >> $@
-        @+make waitfor-cfa1.runquiet >> $@ && echo -n ',' >> $@
-        @+make waitfor-cfa2.runquiet >> $@
-        @$(srcdir)/fixcsv.sh $@
+        echo "1-monitor,2-monitor" > $@
+        +make mutex-cfa1.runquiet >> $@ && echo -n ',' >> $@
+        +make mutex-cfa2.runquiet >> $@
+        $(srcdir)/fixcsv.sh $@
+
+schedint.csv:
+        echo "schedint-1,schedint-2,schedext-1,schedext-2" > $@
+        +make schedint-cfa1.runquiet >> $@ && echo -n ',' >> $@
+        +make schedint-cfa2.runquiet >> $@ && echo -n ',' >> $@
+        +make schedext-cfa1.runquiet >> $@ && echo -n ',' >> $@
+        +make schedext-cfa2.runquiet >> $@
+        $(srcdir)/fixcsv.sh $@
 
 %.diff.csv: %.csv
-        @test -e $(srcdir)/baselines/$(arch)/$< || (echo "Error : Missing baseline for ${<}" && false)
-        @$(srcdir)/baselines/calc.py $(srcdir)/baselines/$(arch)/$(<) $(<) > $@
-
-loop$(EXEEXT):
-        $(BENCH_V_CC)$(COMPILE) -DBENCH_N=5000000000 $(srcdir)/loop.c
-
-function$(EXEEXT):
-        $(BENCH_V_CC)$(COMPILE) -DBENCH_N=5000000000 $(srcdir)/function.c
-
-fetch_add$(EXEEXT):
-        $(BENCH_V_CC)$(COMPILE) -DBENCH_N=500000000  $(srcdir)/fetch_add.c
-
-ttst_lock$(EXEEXT):
-        $(BENCH_V_CC)$(COMPILE) -DBENCH_N=500000000  $(srcdir)/ttst_lock.c
-
-tls-fetch_add$(EXEEXT):
-        $(BENCH_V_CC)$(COMPILE) -DBENCH_N=500000000  $(srcdir)/tls-fetch_add.c
+        test -e $(srcdir)/baselines/$(arch)/$< || (echo "Error : Missing baseline for ${<}" && false)
+        $(srcdir)/baselines/calc.py $(srcdir)/baselines/$(arch)/$(<) $(<) > $@
+
+basic-loop$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) $(srcdir)/basic/loop.c
+
+basic-function$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) $(srcdir)/basic/function.c
+
+basic-fetch_add$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) $(srcdir)/basic/fetch_add.c
+
+basic-ttst_lock$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) $(srcdir)/basic/ttst_lock.c
+
+basic-tls-fetch_add$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) $(srcdir)/basic/tls_fetch_add.c
+
+basic$(EXEEXT): $(BASIC_DEPEND)
 
 @WITH_LIBFIBRE_TRUE@ctxswitch-kos_fibre$(EXEEXT):
@@ -845 +912 @@
 ctxswitch$(EXEEXT): $(CTXSWITCH_DEPEND)
 
-ctxswitch-pthread$(EXEEXT):
-        $(BENCH_V_CC)$(COMPILE)    -DBENCH_N=50000000 $(srcdir)/ctxswitch/pthreads.c
-
 ctxswitch-cfa_generator$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_gen.cfa
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/ctxswitch/cfa_gen.cfa
 
 ctxswitch-cfa_coroutine$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_cor.cfa
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/ctxswitch/cfa_cor.cfa
 
 ctxswitch-cfa_thread$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_thrd.cfa
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/ctxswitch/cfa_thrd.cfa
 
 ctxswitch-cfa_thread2$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_thrd2.cfa
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/ctxswitch/cfa_thrd2.cfa
 
 ctxswitch-upp_coroutine$(EXEEXT):
-        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/upp_cor.cc
+        $(BENCH_V_UPP)$(UPPCOMPILE) $(srcdir)/ctxswitch/upp_cor.cc
 
 ctxswitch-upp_thread$(EXEEXT):
-        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/upp_thrd.cc
-
-ctxswitch-goroutine$(EXEEXT):
+        $(BENCH_V_UPP)$(UPPCOMPILE) $(srcdir)/ctxswitch/upp_thrd.cc
+
+ctxswitch-python_coroutine$(EXEEXT):
+        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
+        echo "nodejs $(srcdir)/ctxswitch/node_cor.js" >> a.out
+        chmod a+x a.out
+
+ctxswitch-nodejs_await$(EXEEXT):
+        echo "#!/bin/sh" > a.out
+        echo "nodejs $(srcdir)/ctxswitch/node_await.js" >> a.out
+        chmod a+x a.out
+
+ctxswitch-goroutine_thread$(EXEEXT):
         $(BENCH_V_GOC)go build -o a.out $(srcdir)/ctxswitch/goroutine.go
+
+ctxswitch-rust_thread$(EXEEXT):
+        $(BENCH_V_RUSTC)rustc -C opt-level=3 -o a.out $(srcdir)/ctxswitch/rust_thrd.rs
 
 ctxswitch-java_thread$(EXEEXT):
         $(BENCH_V_JAVAC)javac -d $(builddir) $(srcdir)/ctxswitch/JavaThread.java
-        @echo "#!/bin/sh" > a.out
-        @echo "java JavaThread" >> a.out
-        @chmod a+x a.out
-
-mutex$(EXEEXT) :\
-        loop.run                        \
-        function.run            \
-        fetch_add.run           \
-        mutex-pthread_lock.run  \
-        mutex-upp.run           \
+        echo "#!/bin/sh" > a.out
+        echo "java JavaThread" >> a.out
+        chmod a+x a.out
+
+ctxswitch-pthread$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) $(srcdir)/ctxswitch/pthreads.c
+
+mutex$(EXEEXT) :                \
         mutex-cfa1.run          \
         mutex-cfa2.run          \
         mutex-cfa4.run          \
-        mutex-java_thread.run
-
-mutex-pthread_lock$(EXEEXT):
-        $(BENCH_V_CC)$(COMPILE)    -DBENCH_N=50000000 $(srcdir)/mutex/pthreads.c
+        mutex-upp.run           \
+        mutex-go.run            \
+        mutex-rust.run          \
+        mutex-java.run          \
+        mutex-pthread.run
+
+mutex-pthread$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) $(srcdir)/mutex/pthreads.c
+
+mutex-cfa1$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/mutex/cfa1.cfa
+
+mutex-cfa2$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/mutex/cfa2.cfa
+
+mutex-cfa4$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/mutex/cfa4.cfa
 
 mutex-upp$(EXEEXT):
-        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/mutex/upp.cc
-
-mutex-cfa1$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=5000000  $(srcdir)/mutex/cfa1.cfa
-
-mutex-cfa2$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=5000000  $(srcdir)/mutex/cfa2.cfa
-
-mutex-cfa4$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=5000000  $(srcdir)/mutex/cfa4.cfa
-
-mutex-java_thread$(EXEEXT):
+        $(BENCH_V_UPP)$(UPPCOMPILE) $(srcdir)/mutex/upp.cc
+
+mutex-go$(EXEEXT):
+        $(BENCH_V_GOC)go build -o a.out $(srcdir)/mutex/goroutine.go
+
+mutex-rust$(EXEEXT):
+        $(BENCH_V_RUSTC)rustc -C opt-level=3 -o a.out $(srcdir)/mutex/rust.rs
+
+mutex-java$(EXEEXT):
         $(BENCH_V_JAVAC)javac -d $(builddir) $(srcdir)/mutex/JavaThread.java
-        @echo "#!/bin/sh" > a.out
-        @echo "java JavaThread" >> a.out
-        @chmod a+x a.out
-
-signal$(EXEEXT) :\
-        signal-pthread_cond.run \
-        signal-upp.run          \
-        signal-cfa1.run         \
-        signal-cfa2.run         \
-        signal-cfa4.run         \
-        signal-java_thread.run
-
-signal-pthread_cond$(EXEEXT):
-        $(BENCH_V_CC)$(COMPILE)    -DBENCH_N=500000  $(srcdir)/schedint/pthreads.c
-
-signal-upp$(EXEEXT):
-        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=5000000 $(srcdir)/schedint/upp.cc
-
-signal-cfa1$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedint/cfa1.cfa
-
-signal-cfa2$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedint/cfa2.cfa
-
-signal-cfa4$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedint/cfa4.cfa
-
-signal-java_thread$(EXEEXT):
+        echo "#!/bin/sh" > a.out
+        echo "java JavaThread" >> a.out
+        chmod a+x a.out
+
+schedint$(EXEEXT) :             \
+        schedint-cfa1.run       \
+        schedint-cfa2.run       \
+        schedint-cfa4.run       \
+        schedint-upp.run        \
+        schedint-rust.run       \
+        schedint-java.run       \
+        schedint-pthread.run
+
+schedint-cfa1$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/schedint/cfa1.cfa
+
+schedint-cfa2$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/schedint/cfa2.cfa
+
+schedint-cfa4$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/schedint/cfa4.cfa
+
+schedint-upp$(EXEEXT):
+        $(BENCH_V_UPP)$(UPPCOMPILE) $(srcdir)/schedint/upp.cc
+
+schedint-rust$(EXEEXT):
+        $(BENCH_V_RUSTC)rustc -C opt-level=3 -o a.out $(srcdir)/schedint/rust.rs
+
+schedint-java$(EXEEXT):
         $(BENCH_V_JAVAC)javac -d $(builddir) $(srcdir)/schedint/JavaThread.java
-        @echo "#!/bin/sh" > a.out
-        @echo "java JavaThread" >> a.out
-        @chmod a+x a.out
-
-waitfor$(EXEEXT) :\
-        waitfor-upp.run         \
-        waitfor-cfa1.run                \
-        waitfor-cfa2.run                \
-        waitfor-cfa4.run
-
-waitfor-upp$(EXEEXT):
-        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=5000000 $(srcdir)/schedext/upp.cc
-
-waitfor-cfa1$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedext/cfa1.cfa
-
-waitfor-cfa2$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedext/cfa2.cfa
-
-waitfor-cfa4$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedext/cfa4.cfa
-
-creation$(EXEEXT) :\
-        creation-pthread.run                    \
+        echo "#!/bin/sh" > a.out
+        echo "java JavaThread" >> a.out
+        chmod a+x a.out
+
+schedint-pthread$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) $(srcdir)/schedint/pthreads.c
+
+schedext$(EXEEXT) :             \
+        schedext-cfa1.run       \
+        schedext-cfa2.run       \
+        schedext-cfa4.run       \
+        schedext-upp.run        \
+        schedext-goroutine.run
+
+schedext-cfa1$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/schedext/cfa1.cfa
+
+schedext-cfa2$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/schedext/cfa2.cfa
+
+schedext-cfa4$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/schedext/cfa4.cfa
+
+schedext-upp$(EXEEXT):
+        $(BENCH_V_UPP)$(UPPCOMPILE) $(srcdir)/schedext/upp.cc
+
+schedext-goroutine$(EXEEXT):
+        $(BENCH_V_GOC)go build -o a.out $(srcdir)/schedext/goroutine.go
+
+creation$(EXEEXT) :                             \
+        creation-cfa_generator.run              \
         creation-cfa_coroutine.run              \
         creation-cfa_coroutine_eager.run        \
@@ -961 +1059 @@
         creation-upp_coroutine.run              \
         creation-upp_thread.run                 \
-        creation-goroutine.run                  \
-        creation-java_thread.run
+        creation-python_coroutine.run           \
+        creation-nodejs_coroutine.run           \
+        creation-goroutine_thread.run           \
+        creation-rust_thread.run                \
+        creation-java_thread.run                \
+        creation-pthread.run
+
+creation-cfa_generator$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/creation/cfa_gen.cfa
 
 creation-cfa_coroutine$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=10000000 $(srcdir)/creation/cfa_cor.cfa
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/creation/cfa_cor.cfa
 
 creation-cfa_coroutine_eager$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=10000000 $(srcdir)/creation/cfa_cor.cfa  -DEAGER
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/creation/cfa_cor.cfa  -DEAGER
 
 creation-cfa_thread$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=10000000 $(srcdir)/creation/cfa_thrd.cfa
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/creation/cfa_thrd.cfa
 
 creation-upp_coroutine$(EXEEXT):
-        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/creation/upp_cor.cc
+        $(BENCH_V_UPP)$(UPPCOMPILE) $(srcdir)/creation/upp_cor.cc
 
 creation-upp_thread$(EXEEXT):
-        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/creation/upp_thrd.cc
-
-creation-pthread$(EXEEXT):
-        $(BENCH_V_CC)$(COMPILE)    -DBENCH_N=250000   $(srcdir)/creation/pthreads.c
-
-creation-goroutine$(EXEEXT):
+        $(BENCH_V_UPP)$(UPPCOMPILE) $(srcdir)/creation/upp_thrd.cc
+
+creation-python_coroutine$(EXEEXT):
+        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
+        echo "nodejs $(srcdir)/creation/node_cor.js" >> a.out
+        chmod a+x a.out
+
+creation-goroutine_thread$(EXEEXT):
         $(BENCH_V_GOC)go build -o a.out $(srcdir)/creation/goroutine.go
+
+creation-rust_thread$(EXEEXT):
+        $(BENCH_V_RUSTC)rustc -C opt-level=3 -o a.out $(srcdir)/creation/rust_thrd.rs
 
 creation-java_thread$(EXEEXT):
         $(BENCH_V_JAVAC)javac -d $(builddir) $(srcdir)/creation/JavaThread.java
-        @echo "#!/bin/sh" > a.out
-        @echo "java JavaThread" >> a.out
-        @chmod a+x a.out
-
-compile$(EXEEXT) :\
+        echo "#!/bin/sh" > a.out
+        echo "java JavaThread" >> a.out
+        chmod a+x a.out
+
+creation-pthread$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) $(srcdir)/creation/pthreads.c
+
+compile$(EXEEXT) :              \
         compile-array.make      \
         compile-attributes.make \
@@ -1002 +1120 @@
 
 compile-array$(EXEEXT):
-        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/array.cfa
+        $(CFACOMPILE) -fsyntax-only -w $(testdir)/array.cfa
 
 compile-attributes$(EXEEXT):
-        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/attributes.cfa
+        $(CFACOMPILE) -fsyntax-only -w $(testdir)/attributes.cfa
 
 compile-empty$(EXEEXT):
-        @$(CFACOMPILE) -fsyntax-only -w $(srcdir)/compile/empty.cfa
+        $(CFACOMPILE) -fsyntax-only -w $(srcdir)/compile/empty.cfa
 
 compile-expression$(EXEEXT):
-        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/expression.cfa
+        $(CFACOMPILE) -fsyntax-only -w $(testdir)/expression.cfa
 
 compile-io$(EXEEXT):
-        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/io1.cfa
+        $(CFACOMPILE) -fsyntax-only -w $(testdir)/io1.cfa
 
 compile-monitor$(EXEEXT):
-        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/concurrent/monitor.cfa
+        $(CFACOMPILE) -fsyntax-only -w $(testdir)/concurrent/monitor.cfa
 
 compile-operators$(EXEEXT):
-        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/operators.cfa
+        $(CFACOMPILE) -fsyntax-only -w $(testdir)/operators.cfa
 
 compile-thread$(EXEEXT):
-        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/concurrent/thread.cfa
+        $(CFACOMPILE) -fsyntax-only -w $(testdir)/concurrent/thread.cfa
 
 compile-typeof$(EXEEXT):
-        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/typeof.cfa
+        $(CFACOMPILE) -fsyntax-only -w $(testdir)/typeof.cfa
 
 # Tell versions [3.59,3.63) of GNU make to not export all variables.

benchmark/bench.h

@@ -5 +5 @@
 #endif
         #include <stdlib.h>
-        #include <unistd.h>                                     // sysconf
+        #include <stdint.h>                             // uint64_t
+        #include <unistd.h>                             // sysconf
 #if ! defined(__cforall)
         #include <time.h>
@@ -15 +16 @@
 
 
-static inline unsigned long long int bench_time() {
-    struct timespec ts;
-    clock_gettime(
-#if defined( __linux__ )
-         CLOCK_THREAD_CPUTIME_ID,
-#elif defined( __freebsd__ )
-         CLOCK_PROF,
-#elif defined( __solaris__ )
-         CLOCK_HIGHRES,
-#else
-    #error uC++ : internal error, unsupported architecture
-#endif
-         &ts );
-    return 1000000000LL * ts.tv_sec + ts.tv_nsec;
-} // Time
+static inline uint64_t bench_time() {
+        struct timespec ts;
+        clock_gettime( CLOCK_THREAD_CPUTIME_ID, &ts );
+        return 1000000000LL * ts.tv_sec + ts.tv_nsec;
+} // bench_time
 
 #ifndef BENCH_N
-#define BENCH_N 500 //10000000
+#define BENCH_N 10000000
 #endif
 
+size_t times = BENCH_N;
+
+#define BENCH_START()                           \
+        if ( argc > 2 ) exit( EXIT_FAILURE );   \
+        if ( argc == 2 ) {                      \
+                times = atoi( argv[1] );        \
+        }
+
 #define BENCH(statement, output)                \
-        size_t n = BENCH_N;                     \
-        if( argc > 2 ) return 1;                \
-        if( argc == 2 ) {                               \
-                n = atoi(argv[1]);              \
-        }                                               \
-        long long int StartTime, EndTime;       \
+        uint64_t StartTime, EndTime;            \
         StartTime = bench_time();               \
-        statement;                                      \
+        statement;                              \
         EndTime = bench_time();                 \
-        double output =         \
-            (double)( EndTime - StartTime ) / n;
+        double output = (double)( EndTime - StartTime ) / times;
+
 
 #if defined(__cforall)
@@ -53 +47 @@
 }
 #endif
+#if defined(__U_CPLUSPLUS__)
+unsigned int uDefaultPreemption() {
+        return 0;
+}
+#endif

benchmark/creation/JavaThread.java

@@ -26 +26 @@
         static int x = 2;
 
-        static private final int NoOfTimes = Integer.parseInt("10000") ;
+        static private int times = Integer.parseInt("10000") ;
 
         public static class MyThread extends Thread {
@@ -33 +33 @@
         }
         public static void helper() throws InterruptedException {
-                for(int i = 1; i <= NoOfTimes; i += 1) {
+                for(int i = 1; i <= times; i += 1) {
                         MyThread m = new MyThread();
                         x = nextRandom( x );
@@ -44 +44 @@
                 helper();
                 long end = System.nanoTime();
-                System.out.println( (end - start) / NoOfTimes );
+                System.out.println( (end - start) / times );
         }
         public static void main(String[] args) throws InterruptedException {
-                for (int n = Integer.parseInt("5"); --n >= 0 ; ) { 
+                if ( args.length > 2 ) System.exit( 1 );
+                if ( args.length == 2 ) { times = Integer.parseInt(args[1]); }
+
+                for (int i = Integer.parseInt("5"); --i >= 0 ; ) { 
                         InnerMain();
-                        Thread.sleep(2000);     // 2 seconds
+                        Thread.sleep(2000);             // 2 seconds
                         x = nextRandom(x);
                 }
@@ -55 +58 @@
         }
 }
+
+// Local Variables: //
+// tab-width: 4 //
+// End: //

benchmark/creation/cfa_cor.cfa

@@ -5 +5 @@
 
 coroutine MyCoroutine {};
-void ?{} (MyCoroutine & this) {
+void ?{}( MyCoroutine & this ) {
 #ifdef EAGER
-        resume(this);
+        resume( this );
 #endif
 }
-void main(MyCoroutine &) {}
+void main( MyCoroutine & ) {}
 
-int main(int argc, char* argv[]) {
+int main( int argc, char * argv[] ) {
+        BENCH_START()
         BENCH(
-                for ( i; n ) {
-                        MyCoroutine m;
+                for ( times ) {
+                        MyCoroutine c;
                 },
                 result
         )
+        printf( "%g\n", result );
+}
 
-        printf("%g\n", result);
-}
+// Local Variables: //
+// tab-width: 4 //
+// End: //

benchmark/creation/cfa_thrd.cfa

@@ -7 +7 @@
 void main(MyThread &) {}
 
-int main(int argc, char* argv[]) {
+int main( int argc, char * argv[] ) {
+        BENCH_START()
         BENCH(
-                for ( i; n ) {
+                for ( times ) {
                         MyThread m;
                 },
                 result
         )
+        printf( "%g\n", result );
+}
 
-        printf("%g\n", result);
-}
+// Local Variables: //
+// tab-width: 4 //
+// End: //

benchmark/creation/goroutine.go

@@ -2 +2 @@
 
 import (
-    "fmt"
-    "time"
+        "fmt"
+        "time"
+        "os"
+        "strconv"
 )
 
@@ -17 +19 @@
 
 func main() {
-        const NoOfTimes = 500000
+        var times int = 10000000
+        if len( os.Args ) > 2 { os.Exit( 1 ) }
+        if len( os.Args ) == 2 { times, _ = strconv.Atoi(os.Args[1]) }
+
         start := time.Now()
-        for i := 1; i <= NoOfTimes; i += 1 {
+        for i := 1; i <= times; i += 1 {
                 go noop()               // creation
+                <- shake                // wait for completion
         }
         end := time.Now()
-        fmt.Printf("%d\n", end.Sub(start) / time.Duration(NoOfTimes))
-        <- shake
+        fmt.Printf( "%d\n", end.Sub(start) / time.Duration(times) )
 }
+
+// Local Variables: //
+// tab-width: 4 //
+// End: //

benchmark/creation/pthreads.c

@@ -4 +4 @@
 #include "bench.h"
 
-static void *foo(void *arg) {
+static void * foo(void *arg) {
     return arg;
 }
 
-int main(int argc, char* argv[]) {
+int main( int argc, char * argv[] ) {
+        BENCH_START()
         BENCH(
-                for (size_t i = 0; i < n; i++) {
+                for (size_t i = 0; i < times; i++) {
                         pthread_t thread;
                         if (pthread_create(&thread, NULL, foo, NULL) < 0) {
@@ -16 +17 @@
                                 return 1;
                         }
-
                         if (pthread_join( thread, NULL) < 0) {
                                 perror( "failure" );
@@ -24 +24 @@
                 result
         )
+        printf( "%g\n", result );
+}
 
-        printf("%g\n", result);
-}
+// Local Variables: //
+// tab-width: 4 //
+// End: //

benchmark/creation/upp_cor.cc

@@ -5 +5 @@
 _Coroutine MyCor {
         void main() {}
+  public:
+        MyCor() { resume(); }
 };
 
-int main(int argc, char* argv[]) {
+int main( int argc, char * argv[] ) {
+        BENCH_START()
         BENCH(
-                for (size_t i = 0; i < n; i++) {
+                for (size_t i = 0; i < times; i++) {
                         MyCor m;
                 },
                 result
         )
+        printf( "%g\n", result );
+}
 
-        printf("%g\n", result);
-}
+// Local Variables: //
+// tab-width: 4 //
+// End: //

benchmark/creation/upp_thrd.cc

@@ -7 +7 @@
 };
 
-int main(int argc, char* argv[]) {
+int main( int argc, char * argv[] ) {
+        BENCH_START()
         BENCH(
-                for (size_t i = 0; i < n; i++) {
+                for (size_t i = 0; i < times; i++) {
                         MyThread m;
                 },
                 result
         )
+        printf( "%g\n", result );
+}
 
-        printf("%g\n", result);
-}
+// Local Variables: //
+// tab-width: 4 //
+// End: //

benchmark/ctxswitch/JavaThread.java

@@ -26 +26 @@
         static int x = 2;
 
-        static private final int NoOfTimes = Integer.parseInt("1000000") ;
+        static private int times = Integer.parseInt("100000");
 
         public static void helper() {
-                for(int i = 1; i <= NoOfTimes; i += 1) {
+                for(int i = 1; i <= times; i += 1) {
                         Thread.yield();
                 }
@@ -37 +37 @@
                 helper();
                 long end = System.nanoTime();
-                System.out.println( (end - start) / NoOfTimes );
+                System.out.println( (end - start) / times );
         }
         public static void main(String[] args) throws InterruptedException {
-                for (int n = Integer.parseInt("5"); --n >= 0 ; ) { 
+                if ( args.length > 2 ) System.exit( 1 );
+                if ( args.length == 2 ) { times = Integer.parseInt(args[1]); }
+
+                for (int i = Integer.parseInt("5"); --i >= 0 ; ) {
                         InnerMain();
-                        Thread.sleep(2000);     // 2 seconds
+                        Thread.sleep(2000);     // 2 seconds
                         x = nextRandom(x);
                 }
@@ -48 +51 @@
         }
 }
+
+// Local Variables: //
+// tab-width: 4 //
+// End: //

benchmark/ctxswitch/cfa_cor.cfa

@@ -4 +4 @@
 #include "bench.h"
 
-coroutine GreatSuspender {};
-
-void ?{}( GreatSuspender & this ) {
-        prime(this);
-}
-
-void main( __attribute__((unused)) GreatSuspender & this ) {
-        while( true ) {
+coroutine C {} c;
+void main( __attribute__((unused)) C & ) {
+        while () {
                 suspend();
         }
 }
-
-int main(int argc, char* argv[]) {
-        GreatSuspender s;
-
+int main( int argc, char * argv[] ) {
+        BENCH_START()
         BENCH(
-                for ( i; n ) {
-                        resume( s );
+                for ( times ) {
+                        resume( c );
                 },
                 result
         )
+        printf( "%g\n", result );
+}
 
-        printf("%g\n", result);
-}
+// Local Variables: //
+// tab-width: 4 //
+// End: //

benchmark/ctxswitch/cfa_cor_then.cfa

@@ -6 +6 @@
 void noOp(void) {}
 
-coroutine GreatSuspender {};
+coroutine C {} c;
 
-void ?{}( GreatSuspender & this ) {
+void ?{}( C & this ) {
         prime(this);
 }
 
-void main( __attribute__((unused)) GreatSuspender & this ) {
-        while( true ) {
+void main( __attribute__((unused)) C & this ) {
+        while () {
                 suspend_then(noOp);
         }
 }
 
-int main(int argc, char* argv[]) {
-        GreatSuspender s;
-
+int main( int argc, char * argv[] ) {
+        BENCH_START()
         BENCH(
-                for ( i; n ) {
-                        resume( s );
+                for ( times ) {
+                        resume( c );
                 },
                 result
         )
+        printf( "%g\n", result );
+}
 
-        printf("%g\n", result);
-}
+// Local Variables: //
+// tab-width: 4 //
+// End: //

benchmark/ctxswitch/cfa_gen.cfa

@@ -3 +3 @@
 typedef struct {
         void * next;
-} GreatSuspender;
+} C;
 
-void comain( GreatSuspender * this ) {
-    if ( __builtin_expect(this->next != 0, 1) ) goto *(this->next);
-    this->next = &&s1;
+void comain( C * c ) {
+        if ( __builtin_expect(c->next != 0, 1) ) goto *(c->next);
+        c->next = &&s1;
         for () {
-            return;
+                return;
           s1: ;
         }
 }
 
-int main(int argc, char* argv[]) {
-    GreatSuspender s = { 0 };
-
+int main( int argc, char * argv[] ) {
+        BENCH_START()
+        C c = { 0 };
         BENCH(
-                for ( i; n ) {
-                        comain( &s );
+                for ( times ) {
+                        comain( &c );
                 },
                 result
         )
+        printf( "%g\n", result );
+}
 
-        printf("%g\n", result);
-}
+// Local Variables: //
+// tab-width: 4 //
+// End: //

benchmark/ctxswitch/cfa_thrd.cfa

@@ -3 +3 @@
 #include "bench.h"
 
-int main(int argc, char* argv[]) {
+int main( int argc, char * argv[] ) {
+        BENCH_START()
         BENCH(
-                for ( i; n ) {
+                for ( times ) {
                         yield();
                 },
                 result
         )
+        printf( "%g\n", result );
+}
 
-        printf("%g\n", result);
-}
+// Local Variables: //
+// tab-width: 4 //
+// End: //

benchmark/ctxswitch/cfa_thrd2.cfa

@@ -8 +8 @@
 
 void main(__attribute__((unused)) Fibre & this) {
-        while(!done) {
+        while ( ! done ) {
                 yield();
         }
 }
 
-int main(int argc, char* argv[]) {
+int main( int argc, char * argv[] ) {
+        BENCH_START()
         Fibre f1;
         BENCH(
-                for ( i; n ) {
+                for ( times ) {
                         yield();
                 },
                 result
         )
+        printf( "%g\n", result );
+        done = true;
+}
 
-        printf("%g\n", result);
-        done = true;
-        return 0;
-}
+// Local Variables: //
+// tab-width: 4 //
+// End: //

benchmark/ctxswitch/goroutine.go

@@ -2 +2 @@
 
 import (
-    "fmt"
-    "runtime"
-    "time"
+        "fmt"
+        "time"
+        "os"
+        "strconv"
+        "runtime"
 )
 
@@ -28 +30 @@
 
 func main() {
-        const NoOfTimes = 10000000
-        go ContextSwitch( NoOfTimes )           // context switch
+        var times int = 10000000
+        if len( os.Args ) > 2 { os.Exit( 1 ) }
+        if len( os.Args ) == 2 { times, _ = strconv.Atoi(os.Args[1]) }
+        go ContextSwitch( times )               // context switch
         <- shake
 }
+
+// Local Variables: //
+// tab-width: 4 //
+// End: //

benchmark/ctxswitch/kos_fibre.cpp

@@ -3 +3 @@
 #include "bench.h"
 
-int main(int argc, char* argv[]) {
+int main( int argc, char * argv[] ) {
+        BENCH_START()
         BENCH(
-                for (size_t i = 0; i < n; i++) {
+                for (size_t i = 0; i < times; i++) {
                         Fibre::yield();
                 },
                 result
         )
-        printf("%g\n", result);
-        return 0;
+        printf( "%g\n", result );
 }
+
+// Local Variables: //
+// tab-width: 4 //
+// End: //

benchmark/ctxswitch/kos_fibre2.cpp

@@ -11 +11 @@
 }
 
-int main(int argc, char* argv[]) {
+int main( int argc, char * argv[] ) {
+        BENCH_START()
         Fibre* f1 = (new Fibre)->run(f1main);
         BENCH(
-                for (size_t i = 0; i < n; i++) {
+                for (size_t i = 0; i < times; i++) {
                         Fibre::yield();
                 },
                 result
         )
-        printf("%g\n", result);
+        printf( "%g\n", result );
         done = true;
         Fibre::yield();
         f1->join();
-        return 0;
 }
+
+// Local Variables: //
+// tab-width: 4 //
+// End: //

benchmark/ctxswitch/pthreads.c

@@ -6 +6 @@
 #include "bench.h"
 
-int main(int argc, char* argv[]) {
+int main( int argc, char * argv[] ) {
+        BENCH_START()
         BENCH(
-                for (size_t i = 0; i < n; i++) {
+                for (size_t i = 0; i < times; i++) {
                         sched_yield();
                 },
                 result
         )
-
-        printf("%g\n", result);
+        printf( "%g\n", result );
 }

benchmark/ctxswitch/upp_cor.cc

@@ -3 +3 @@
 #include "bench.h"
 
-_Coroutine GreatSuspender {
-public:
-        GreatSuspender() {
-                resume();
-        }
-
-        void do_resume() {
-                resume();
-        }
-private:
+_Coroutine C {
         void main() {
                 while( true ) {
@@ -18 +9 @@
                 }
         }
-};
-
-int main(int argc, char* argv[]) {
-        GreatSuspender s;
-
+  public:
+        void do_resume() {
+                resume();
+        }
+} c;
+int main( int argc, char * argv[] ) {
+        BENCH_START()
         BENCH(
-                for (size_t i = 0; i < n; i++) {
-                        s.do_resume();
+                for (size_t i = 0; i < times; i++) {
+                        c.do_resume();
                 },
                 result
         )
+        printf( "%g\n", result );
+}
 
-        printf("%g\n", result);
-}
+// Local Variables: //
+// tab-width: 4 //
+// End: //

benchmark/ctxswitch/upp_thrd.cc

@@ -3 +3 @@
 #include "bench.h"
 
-int main(int argc, char* argv[]) {
+int main( int argc, char * argv[] ) {
+        BENCH_START()
         BENCH(
-                for (size_t i = 0; i < n; i++) {
+                for (size_t i = 0; i < times; i++) {
                         uThisTask().yield();
                 },
                 result
         )
+        printf( "%g\n", result );
+}
 
-        printf("%g\n", result);
-}
+// Local Variables: //
+// tab-width: 4 //
+// End: //

benchmark/mutex/JavaThread.java

@@ -26 +26 @@
         static int x = 2;
 
-        static private final int NoOfTimes = Integer.parseInt("100000000") ;
+        static private int times = Integer.parseInt("100000000");
 
         public synchronized void noop() {
@@ -35 +35 @@
                 // Inhibit biased locking ...
                 x = (j.hashCode() ^ System.identityHashCode(j)) | 1 ;     
-                for(int i = 1; i <= NoOfTimes; i += 1) {
+                for(int i = 1; i <= times; i += 1) {
                         x = nextRandom(x);
                         j.noop();
@@ -44 +44 @@
                 helper();
                 long end = System.nanoTime();
-                System.out.println( (end - start) / NoOfTimes );
+                System.out.println( (end - start) / times );
         }
         public static void main(String[] args) throws InterruptedException {
+                if ( args.length > 2 ) System.exit( 1 );
+                if ( args.length == 2 ) { times = Integer.parseInt(args[1]); }
+
                 for (int n = Integer.parseInt("5"); --n >= 0 ; ) { 
                         InnerMain();
@@ -55 +58 @@
         }
 }
+
+// Local Variables: //
+// tab-width: 4 //
+// End: //

benchmark/mutex/cfa1.cfa

@@ -4 +4 @@
 #include "bench.h"
 
-monitor M {};
-void __attribute__((noinline)) call( M & mutex m ) {}
+monitor M {} m1;
+void __attribute__((noinline)) call( M & mutex p1 ) {}
 
-int main(int argc, char* argv[]) {
-        M m;
+int main( int argc, char * argv[] ) {
+        BENCH_START()
         BENCH(
-                for ( i; n ) {
-                        call(m);
+                for ( times ) {
+                        call( m1 );
                 },
                 result
         )
+        printf( "%g\n", result );
+}
 
-        printf("%g\n", result);
-}
+// Local Variables: //
+// tab-width: 4 //
+// End: //

benchmark/mutex/cfa2.cfa

@@ -4 +4 @@
 #include "bench.h"
 
-monitor M {};
-void __attribute__((noinline)) call( M & mutex m1, M & mutex m2 ) {}
+monitor M {} m1, m2;
 
-int main(int argc, char* argv[]) {
-        M m1, m2;
+void __attribute__((noinline)) call( M & mutex p1, M & mutex p2 ) {}
+
+int main( int argc, char * argv[] ) {
+        BENCH_START()
         BENCH(
-                for ( i; n ) {
-                        call(m1, m2);
+                for ( times ) {
+                        call( m1, m2 );
                 },
                 result
         )
+        printf( "%g\n", result );
+}
 
-        printf("%g\n", result);
-}
+// Local Variables: //
+// tab-width: 4 //
+// End: //

benchmark/mutex/cfa4.cfa

@@ -5 +5 @@
 
 
-monitor M {};
-void __attribute__((noinline)) call( M & mutex m1, M & mutex m2, M & mutex m3, M & mutex m4 ) {}
+monitor M {} m1, m2, m3, m4;
+void __attribute__((noinline)) call( M & mutex p1, M & mutex p2, M & mutex p3, M & mutex p4 ) {}
 
-int main(int argc, char* argv[]) {
-        M m1, m2, m3, m4;
+int main( int argc, char * argv[] ) {
+        BENCH_START()
         BENCH(
-                for ( i; n ) {
-                        call(m1, m2, m3, m4);
+                for ( times ) {
+                        call( m1, m2, m3, m4 );
                 },
                 result
         )
+        printf( "%g\n", result );
+}
 
-        printf("%g\n", result);
-}
+// Local Variables: //
+// tab-width: 4 //
+// End: //

benchmark/mutex/pthreads.c

@@ -7 +7 @@
 
 void __attribute__((noinline)) call() {
-         pthread_mutex_lock  (&mutex);
-         pthread_mutex_unlock(&mutex);
+         pthread_mutex_lock( &mutex );
+         pthread_mutex_unlock( &mutex );
 }
-
-int main(int argc, char* argv[]) {
+int main( int argc, char * argv[] ) {
+        BENCH_START()
         BENCH(
-                for (size_t i = 0; i < n; i++) {
+                for ( size_t i = 0; i < times; i++ ) {
                         call();
                 },
                 result
         )
+        printf( "%g\n", result );
+}
 
-        printf("%g\n", result);
-}
+// Local Variables: //
+// tab-width: 4 //
+// End: //

benchmark/mutex/upp.cc

@@ -8 +8 @@
 };
 
-int main(int argc, char* argv[]) {
+int main( int argc, char * argv[] ) {
+        BENCH_START()
         MyMonitor m;
         BENCH(
-                for (size_t i = 0; i < n; i++) {
+                for ( size_t i = 0; i < times; i++ ) {
                         m.call();
                 },
                 result
         )
+        printf( "%g\n", result );
+}
 
-        printf("%g\n", result);
-}
+// Local Variables: //
+// tab-width: 4 //
+// End: //

benchmark/schedext/cfa1.cfa

@@ -4 +4 @@
 #include <stdio.h>
 
-#include "bench.h"
+#include "../bench.h"
 
-int argc;
-char** argv;
-volatile int go = 0;
+monitor M {} m1;
 
-monitor M {};
-M m1;
-
-void __attribute__((noinline)) call( M & mutex a1 ) {}
-
-int  __attribute__((noinline)) wait( M & mutex a1 ) {
-        go = 1;
-        BENCH(
-                for ( i; n ) {
-                        waitfor(call, a1);
-                },
-                result
-        )
-
-        printf("%g\n", result);
-        go = 0;
-        return 0;
+void __attribute__((noinline)) call( M & mutex p1 ) {}
+void __attribute__((noinline)) wait( M & mutex p1 ) {
+        for ( times ) {
+                waitfor( call : p1 );
+        }
 }
 
 thread T {};
-void ^?{}( T & mutex this ) {}
 void main( T & ) {
-        while(go == 0) { yield(); }
-        while(go == 1) { call(m1); }
-
+        BENCH(
+                for ( times ) { call( m1 ); },
+                result
+        )
+        printf( "%g\n", result );
 }
 
-int main(__attribute__((unused)) int argc, __attribute__((unused)) char* argv[]) {
+int main( int argc, char * argv[] ) {
+        BENCH_START()
         T t;
-        return wait(m1);
+        wait( m1 );
 }
+
+// Local Variables: //
+// tab-width: 4 //
+// End: //

benchmark/schedext/cfa2.cfa

@@ -4 +4 @@
 #include <stdio.h>
 
-#include "bench.h"
+#include "../bench.h"
 
-int argc;
-char** argv;
-volatile int go = 0;
+monitor M {} m1, m2;
 
-monitor M {};
-M m1, m2;
-
-void __attribute__((noinline)) call( M & mutex a1, M & mutex a2 ) {}
-
-int  __attribute__((noinline)) wait( M & mutex a1, M & mutex a2 ) {
-        go = 1;
+void __attribute__((noinline)) call( M & mutex p1, M & mutex p2 ) {}
+void __attribute__((noinline)) wait( M & mutex p1, M & mutex p2 ) {
+        for ( times ) {
+                waitfor( call : p1, p2 );
+        }
+}
+thread T {};
+void main( T & ) {
         BENCH(
-                for ( i; n ) {
-                        waitfor(call, a1, a2);
+                for ( times ) {
+                        call( m1, m2 );
                 },
                 result
         )
-
-        printf("%g\n", result);
-        go = 0;
-        return 0;
+        printf( "%g\n", result );
 }
 
-thread T {};
-void ^?{}( T & mutex this ) {}
-void main( T & ) {
-        while(go == 0) { yield(); }
-        while(go == 1) { call(m1, m2); }
-
+int main( int argc, char * argv[] ) {
+        BENCH_START()
+        T t;
+        wait( m1, m2 );
 }
 
-int main(__attribute__((unused)) int argc, __attribute__((unused)) char* argv[]) {
-        T t;
-        return wait(m1, m2);
-}
+// Local Variables: //
+// tab-width: 4 //
+// End: //

benchmark/schedext/cfa4.cfa

@@ -4 +4 @@
 #include <stdio.h>
 
-#include "bench.h"
+#include "../bench.h"
 
-int argc;
-char** argv;
-volatile int go = 0;
+monitor M {} m1, m2, m3, m4;
 
-monitor M {};
-M m1, m2, m3, m4;
-
-void __attribute__((noinline)) call( M & mutex a1, M & mutex a2, M & mutex a3, M & mutex a4 ) {}
-
-int  __attribute__((noinline)) wait( M & mutex a1, M & mutex a2, M & mutex a3, M & mutex a4 ) {
-        go = 1;
+void __attribute__((noinline)) call( M & mutex p1, M & mutex p2, M & mutex p3, M & mutex p4 ) {}
+void __attribute__((noinline)) wait( M & mutex p1, M & mutex p2, M & mutex p3, M & mutex p4 ) {
+        for ( times ) {
+                waitfor( call : p1, p2, p3, p4 );
+        }
+}
+thread T {};
+void main( T & ) {
         BENCH(
-                for ( i; n ) {
-                        waitfor(call, a1, a2, a3, a4);
+                for ( times ) {
+                        call( m1, m2, m3, m4 );
                 },
                 result
         )
-
-        printf("%g\n", result);
-        go = 0;
-        return 0;
+        printf( "%g\n", result );
 }
 
-thread T {};
-void ^?{}( T & mutex this ) {}
-void main( T & ) {
-        while(go == 0) { yield(); }
-        while(go == 1) { call(m1, m2, m3, m4); }
-
+int main( int argc, char * argv[] ) {
+        BENCH_START()
+        T t;
+        wait( m1, m2, m3, m4 );
 }
 
-int main(__attribute__((unused)) int argc, __attribute__((unused)) char* argv[]) {
-        T t;
-        return wait(m1, m2, m3, m4);
-}
+// Local Variables: //
+// tab-width: 4 //
+// End: //

benchmark/schedext/upp.cc

@@ -3 +3 @@
 #include "bench.h"
 
-int argc;
-char** argv;
-volatile int go = 0;
-
 _Monitor M {
 public:
         void __attribute__((noinline)) call() {}
+        void __attribute__((noinline)) wait() {
+                for ( size_t i = 0; i < times; i++ ) {
+                        _Accept(call);
+                }
+        }
+} m;
 
-        int __attribute__((noinline)) wait() {
-                go = 1;
+_Task T {
+        void main() {
                 BENCH(
-                        for (size_t i = 0; i < n; i++) {
-                                _Accept(call);
+                        for ( size_t i = 0; i < times; i++ ) {
+                                m.call();
                         },
                         result
                 )
-
-                printf("%g\n", result);
-                go = 0;
-                return 0;
+                printf( "%g\n", result );
         }
 };
 
-M m;
+int main( int argc, char * argv[] ) {
+        BENCH_START()
+        T t;
+        m.wait();
+}
 
-_Task T {
-        void main() {
-                while(go == 0) { yield(); }
-                while(go == 1) { m.call(); }
-
-        }
-};
-
-int main(int margc, char* margv[]) {
-        argc = margc;
-        argv = margv;
-        T t;
-        return m.wait();
-}
+// Local Variables: //
+// tab-width: 4 //
+// End: //

benchmark/schedint/JavaThread.java

@@ -49 +49 @@
         static int x = 2;
 
-        static private final int NoOfTimes = Integer.parseInt("1000000") ;
+        static private int times = Integer.parseInt("1000000");
 
         public static void helper( Monitor m ) throws InterruptedException {
-                for(int i = 1; i <= NoOfTimes; i += 1) {
+                for(int i = 1; i <= times; i += 1) {
                         m.wait();               // relase monitor lock
                         m.next = true;
@@ -63 +63 @@
                 synchronized(m) {
                         s.start();
-                        while( !Monitor.go ) {
+                        while( ! Monitor.go ) { // waiter must start first
                                 Thread.yield();
                         }
@@ -72 +72 @@
                 Monitor.go = false;
                 s.join();
-                System.out.println( (end - start) / NoOfTimes);
+                System.out.println( (end - start) / times);
         }
         public static void main(String[] args) throws InterruptedException {
+                if ( args.length > 2 ) System.exit( 1 );
+                if ( args.length == 2 ) { times = Integer.parseInt(args[1]); }
+
                 for (int n = Integer.parseInt("5"); --n >= 0 ; ) { 
                         InnerMain();
@@ -83 +86 @@
         }
 }
+
+// Local Variables: //
+// tab-width: 4 //
+// End: //

benchmark/schedint/cfa1.cfa

@@ -4 +4 @@
 #include <stdio.h>
 
-#include "bench.h"
+#include "../bench.h"
 
-int argc;
-char** argv;
 volatile int go = 0;
 
 condition c;
-monitor M {};
-M m1;
+monitor M {} m1;
 
-void __attribute__((noinline)) call( M & mutex a1 ) {
-        signal(c);
+void __attribute__((noinline)) call( M & mutex p1 ) {
+        signal( c );
 }
-
-int  __attribute__((noinline)) wait( M & mutex a1 ) {
+void __attribute__((noinline)) wait( M & mutex p1 ) {
         go = 1;
-        BENCH(
-                for ( i; n ) {
-                        wait(c);
-                },
-                result
-        )
-
-        printf("%g\n", result);
-        go = 0;
-        return 0;
+        for ( times ) {
+                wait( c );
+        }
 }
 
 thread T {};
-void ^?{}( T & mutex ) {}
 void main( T & ) {
-        while(go == 0) { yield(); }
-        while(go == 1) { call(m1); }
-
+        while ( go == 0 ) { yield(); } // waiter must start first
+        BENCH(
+                for ( times ) { call( m1 ); },
+                result
+        )
+        printf( "%g\n", result );
 }
 
-int main(__attribute__((unused)) int argc, __attribute__((unused)) char* argv[]) {
+int main( int argc, char * argv[] ) {
+        BENCH_START()
         T t;
-        return wait(m1);
+        wait( m1 );
 }
+
+// Local Variables: //
+// tab-width: 4 //
+// End: //

benchmark/schedint/cfa2.cfa

@@ -4 +4 @@
 #include <stdio.h>
 
-#include "bench.h"
+#include "../bench.h"
 
-int argc;
-char** argv;
 volatile int go = 0;
 
 condition c;
-monitor M {};
-M m1, m2;
+monitor M {} m1, m2;
 
-void __attribute__((noinline)) call( M & mutex a1, M & mutex a2 ) {
-        signal(c);
+void __attribute__((noinline)) call( M & mutex p1, M & mutex p2 ) {
+        signal( c );
 }
-
-int  __attribute__((noinline)) wait( M & mutex a1, M & mutex a2 ) {
+void __attribute__((noinline)) wait( M & mutex p1, M & mutex p2 ) {
         go = 1;
-        BENCH(
-                for ( i; n ) {
-                        wait(c);
-                },
-                result
-        )
-
-        printf("%g\n", result);
-        go = 0;
-        return 0;
+        for ( times ) {
+                wait( c );
+        }
 }
 
 thread T {};
-void ^?{}( T & mutex this ) {}
 void main( T & ) {
-        while(go == 0) { yield(); }
-        while(go == 1) { call(m1, m2); }
-
+        while ( go == 0 ) { yield(); } // waiter must start first
+        BENCH(
+                for ( times ) { call( m1, m2 ); },
+                result
+        )
+        printf( "%g\n", result );
 }
 
-int main(__attribute__((unused)) int argc, __attribute__((unused)) char* argv[]) {
+int main( int argc, char * argv[] ) {
+        BENCH_START()
         T t;
-        return wait(m1, m2);
+        wait( m1, m2 );
 }
+
+// Local Variables: //
+// tab-width: 4 //
+// End: //

benchmark/schedint/cfa4.cfa

@@ -4 +4 @@
 #include <stdio.h>
 
-#include "bench.h"
+#include "../bench.h"
 
-int argc;
-char** argv;
 volatile int go = 0;
 
 condition c;
-monitor M {};
-M m1, m2, m3, m4;
+monitor M {} m1, m2, m3, m4;
 
-void __attribute__((noinline)) call( M & mutex a1, M & mutex a2, M & mutex a3, M & mutex a4 ) {
-        signal(c);
+void __attribute__((noinline)) call( M & mutex p1, M & mutex p2, M & mutex p3, M & mutex p4 ) {
+        signal( c );
 }
-
-int  __attribute__((noinline)) wait( M & mutex a1, M & mutex a2, M & mutex a3, M & mutex a4 ) {
+void __attribute__((noinline)) wait( M & mutex p1, M & mutex p2, M & mutex p3, M & mutex p4 ) {
         go = 1;
-        BENCH(
-                for ( i; n ) {
-                        wait(c);
-                },
-                result
-        )
-
-        printf("%g\n", result);
-        go = 0;
-        return 0;
+        for ( times ) {
+                wait( c );
+        }
 }
 
 thread T {};
-void ^?{}( T & mutex this ) {}
 void main( T & ) {
-        while(go == 0) { yield(); }
-        while(go == 1) { call(m1, m2, m3, m4); }
-
+        while ( go == 0 ) { yield(); } // waiter must start first
+        BENCH(
+                for ( times ) { call( m1, m2, m3, m4 ); },
+                result
+        )
+        printf( "%g\n", result );
 }
 
-int main(__attribute__((unused)) int argc, __attribute__((unused)) char* argv[]) {
+int main( int argc, char * argv[] ) {
+        BENCH_START()
         T t;
-        return wait(m1, m2, m3, m4);
+        wait( m1, m2, m3, m4 );
 }
+
+// Local Variables: //
+// tab-width: 4 //
+// End: //

benchmark/schedint/pthreads.c

@@ -4 +4 @@
 #include "bench.h"
 
-int argc;
-char** argv;
 volatile int go = 0;
 
+pthread_mutex_t m;
 pthread_cond_t c;
-pthread_mutex_t m;
 
 void __attribute__((noinline)) call() {
-        pthread_mutex_lock(&m);
-        pthread_cond_signal(&c);
-        pthread_mutex_unlock(&m);
+        pthread_mutex_lock( &m );
+        pthread_cond_signal( &c );
+        pthread_mutex_unlock( &m );
 }
 
-int  __attribute__((noinline)) wait() {
+void __attribute__((noinline)) wait() {
         pthread_mutex_lock(&m);
         go = 1;
+        for ( size_t i = 0; i < times; i++ ) {
+                pthread_cond_wait( &c, &m );
+        }
+        go = 0;
+        pthread_mutex_unlock( &m );
+}
+
+void * thread_main( __attribute__((unused)) void * arg ) {
+        while ( go == 0 ) { sched_yield(); } // waiter must start first
+        // barging for lock acquire => may not execute N times
         BENCH(
-                for (size_t i = 0; i < n; i++) {
-                        pthread_cond_wait(&c, &m);
-                },
+                while ( go == 1 ) { call(); },
                 result
         )
-
-        printf("%g\n", result);
-        go = 0;
-        pthread_mutex_unlock(&m);
-        return 0;
-}
-
-void* thread_main(__attribute__((unused)) void * arg ) {
-        while(go == 0) { sched_yield(); }
-        while(go == 1) { call(); }
+        printf( "%g\n", result );
         return NULL;
 }
 
-int main(__attribute__((unused)) int argc, __attribute__((unused)) char* argv[]) {
+int main( int argc, char * argv[] ) {
+        BENCH_START()
         pthread_t thread;
-        if (pthread_create(&thread, NULL, thread_main, NULL) < 0) {
+        if ( pthread_create( &thread, NULL, thread_main, NULL ) < 0 ) {
                 perror( "failure" );
                 return 1;
         }
         wait();
-        if (pthread_join( thread, NULL) < 0) {
+        if ( pthread_join( thread, NULL ) < 0 ) {
                 perror( "failure" );
                 return 1;
         }
-        return 0;
 }
+
+// Local Variables: //
+// tab-width: 4 //
+// End: //

benchmark/schedint/upp.cc

@@ -3 +3 @@
 #include "bench.h"
 
-int argc;
-char** argv;
 volatile int go = 0;
 
@@ -13 +11 @@
                 cond.signal();
         }
+        void __attribute__((noinline)) wait() {
+                go = 1;
+                for ( size_t i = 0; i < times; i++ ) {
+                        cond.wait();
+                }
+        }
+} m;
 
-        int __attribute__((noinline)) wait() {
-                go = 1;
+_Task T {
+        void main() {
+                while ( go == 0 ) { yield(); } // waiter must start first
                 BENCH(
-                        for (size_t i = 0; i < n; i++) {
-                                cond.wait();
+                        for ( size_t i = 0; i < times; i++ ) {
+                                m.call();
                         },
                         result
                 )
-
-                printf("%g\n", result);
-                go = 0;
-                return 0;
+                printf( "%g\n", result );
         }
 };
 
-M m;
+int main( int argc, char * argv[] ) {
+        BENCH_START()
+        T t;
+        m.wait();
+}
 
-_Task T {
-        void main() {
-                while(go == 0) { yield(); }
-                while(go == 1) { m.call(); }
-
-        }
-};
-
-int main(__attribute__((unused)) int argc, __attribute__((unused)) char* argv[]) {
-        T t;
-        return m.wait();
-}
+// Local Variables: //
+// tab-width: 4 //
+// End: //

driver/cfa.cc

@@ -10 +10 @@
 // Created On       : Tue Aug 20 13:44:49 2002
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Sep 10 17:00:15 2019
-// Update Count     : 420
+// Last Modified On : Fri Jan 31 16:48:03 2020
+// Update Count     : 421
 //
 
@@ -187 +187 @@
                         } else if ( arg == "-XCFA" ) {                          // CFA pass through
                                 i += 1;
+                                if ( i == argc ) continue;                              // next argument available ?
                                 Putenv( argv, argv[i] );
 

libcfa/src/Makefile.in

@@ -425 +425 @@
 am__v_CFA_0 = @echo "  CFA     " $@;
 am__v_CFA_1 = 
-AM_V_JAVAC = $(am__v_JAVAC_@AM_V@)
-am__v_JAVAC_ = $(am__v_JAVAC_@AM_DEFAULT_V@)
-am__v_JAVAC_0 = @echo "  JAVAC   " $@;
-am__v_JAVAC_1 = 
-AM_V_GOC = $(am__v_GOC_@AM_V@)
-am__v_GOC_ = $(am__v_GOC_@AM_DEFAULT_V@)
-am__v_GOC_0 = @echo "  GOC     " $@;
-am__v_GOC_1 = 
 UPPCC = u++
 UPPCOMPILE = $(UPPCC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_UPPFLAGS) $(UPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_CFLAGS) $(CFLAGS)
@@ -439 +431 @@
 am__v_UPP_0 = @echo "  UPP     " $@;
 am__v_UPP_1 = 
+AM_V_GOC = $(am__v_GOC_@AM_V@)
+am__v_GOC_ = $(am__v_GOC_@AM_DEFAULT_V@)
+am__v_GOC_0 = @echo "  GOC     " $@;
+am__v_GOC_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_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_1 = 
+AM_V_JAVAC = $(am__v_JAVAC_@AM_V@)
+am__v_JAVAC_ = $(am__v_JAVAC_@AM_DEFAULT_V@)
+am__v_JAVAC_0 = @echo "  JAVAC   " $@;
+am__v_JAVAC_1 = 
 lib_LTLIBRARIES = libcfa.la libcfathread.la
 gdbwaittarget = ""

libcfa/src/bits/containers.hfa

@@ -10 +10 @@
 // Created On       : Tue Oct 31 16:38:50 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Jun 26 08:52:20 2019
-// Update Count     : 4
+// Last Modified On : Wed Jan 15 07:42:35 2020
+// Update Count     : 28
 
 #pragma once
@@ -44 +44 @@
 
         forall(dtype T | sized(T))
-        static inline T& ?[?]( __small_array(T) & this, __lock_size_t idx) {
+        static inline T & ?[?]( __small_array(T) & this, __lock_size_t idx ) {
                 return ((typeof(this.data))this.data)[idx];
         }
 
         forall(dtype T | sized(T))
-        static inline T& ?[?]( const __small_array(T) & this, __lock_size_t idx) {
+        static inline T & ?[?]( const __small_array(T) & this, __lock_size_t idx ) {
                 return ((typeof(this.data))this.data)[idx];
         }
 
+        forall(dtype T)
+        static inline T * begin( const __small_array(T) & this ) {
+                return ((typeof(this.data))this.data);
+        }
+
         forall(dtype T | sized(T))
-        static inline T* begin( const __small_array(T) & this ) {
-                return ((typeof(this.data))this.data);
-        }
-
-        forall(dtype T | sized(T))
-        static inline T* end( const __small_array(T) & this ) {
+        static inline T * end( const __small_array(T) & this ) {
                 return ((typeof(this.data))this.data) + this.size;
         }
@@ -70 +70 @@
 #ifdef __cforall
         trait is_node(dtype T) {
-                T*& get_next( T& );
+                T *& get_next( T & );
         };
 #endif
@@ -97 +97 @@
         forall(dtype T)
         static inline void ?{}( __stack(T) & this ) {
-                (this.top){ NULL };
-        }
-
-        forall(dtype T | is_node(T) | sized(T))
-        static inline void push( __stack(T) & this, T * val ) {
-                verify( !get_next( *val ) );
-                get_next( *val ) = this.top;
-                this.top = val;
-        }
-
-        forall(dtype T | is_node(T) | sized(T))
-        static inline T * pop( __stack(T) & this ) {
-                T * top = this.top;
-                if( top ) {
-                        this.top = get_next( *top );
-                        get_next( *top ) = NULL;
-                }
-                return top;
-        }
-
-        forall(dtype T | is_node(T))
-        static inline int ?!=?( const __stack(T) & this, __attribute__((unused)) zero_t zero ) {
-                return this.top != 0;
+                (this.top){ 0p };
+        }
+
+        static inline forall( dtype T | is_node(T) ) {
+                void push( __stack(T) & this, T * val ) {
+                        verify( !get_next( *val ) );
+                        get_next( *val ) = this.top;
+                        this.top = val;
+                }
+
+                T * pop( __stack(T) & this ) {
+                        T * top = this.top;
+                        if( top ) {
+                                this.top = get_next( *top );
+                                get_next( *top ) = 0p;
+                        }
+                        return top;
+                }
+
+                int ?!=?( const __stack(T) & this, __attribute__((unused)) zero_t zero ) {
+                        return this.top != 0;
+                }
         }
 #endif
@@ -145 +144 @@
 
 #ifdef __cforall
-
-        forall(dtype T)
-        static inline void ?{}( __queue(T) & this ) with( this ) {
-                head{ NULL };
-                tail{ &head };
-        }
-
-        forall(dtype T | is_node(T) | sized(T))
-        static inline void append( __queue(T) & this, T * val ) with( this ) {
-                verify(tail != NULL);
-                *tail = val;
-                tail = &get_next( *val );
-        }
-
-        forall(dtype T | is_node(T) | sized(T))
-        static inline T * pop_head( __queue(T) & this ) {
-                T * head = this.head;
-                if( head ) {
-                        this.head = get_next( *head );
-                        if( !get_next( *head ) ) {
-                                this.tail = &this.head;
-                        }
-                        get_next( *head ) = NULL;
-                }
-                return head;
-        }
-
-        forall(dtype T | is_node(T) | sized(T))
-        static inline T * remove( __queue(T) & this, T ** it ) with( this ) {
-                T * val = *it;
-                verify( val );
-
-                (*it) = get_next( *val );
-
-                if( tail == &get_next( *val ) ) {
-                        tail = it;
-                }
-
-                get_next( *val ) = NULL;
-
-                verify( (head == NULL) == (&head == tail) );
-                verify( *tail == NULL );
-                return val;
-        }
-
-        forall(dtype T | is_node(T))
-        static inline int ?!=?( const __queue(T) & this, __attribute__((unused)) zero_t zero ) {
-                return this.head != 0;
+        static inline forall( dtype T | is_node(T) ) {
+                void ?{}( __queue(T) & this ) with( this ) {
+                        head{ 0p };
+                        tail{ &head };
+                }
+
+                void append( __queue(T) & this, T * val ) with( this ) {
+                        verify(tail != 0p);
+                        *tail = val;
+                        tail = &get_next( *val );
+                }
+
+                T * pop_head( __queue(T) & this ) {
+                        T * head = this.head;
+                        if( head ) {
+                                this.head = get_next( *head );
+                                if( !get_next( *head ) ) {
+                                        this.tail = &this.head;
+                                }
+                                get_next( *head ) = 0p;
+                        }
+                        return head;
+                }
+
+                T * remove( __queue(T) & this, T ** it ) with( this ) {
+                        T * val = *it;
+                        verify( val );
+
+                        (*it) = get_next( *val );
+
+                        if( tail == &get_next( *val ) ) {
+                                tail = it;
+                        }
+
+                        get_next( *val ) = 0p;
+
+                        verify( (head == 0p) == (&head == tail) );
+                        verify( *tail == 0p );
+                        return val;
+                }
+
+                int ?!=?( const __queue(T) & this, __attribute__((unused)) zero_t zero ) {
+                        return this.head != 0;
+                }
         }
 #endif
@@ -223 +218 @@
 
 #ifdef __cforall
-
-        forall(dtype T | sized(T))
+        forall(dtype T )
         static inline [void] ?{}( __dllist(T) & this, * [T * & next, T * & prev] ( T & ) __get ) {
-                this.head{ NULL };
+                this.head{ 0p };
                 this.__get = __get;
         }
@@ -232 +226 @@
         #define next 0
         #define prev 1
-        forall(dtype T | sized(T))
-        static inline void push_front( __dllist(T) & this, T & node ) with( this ) {
-                verify(__get);
-                if ( head ) {
-                        __get( node ).next = head;
-                        __get( node ).prev = __get( *head ).prev;
-                        // inserted node must be consistent before it is seen
+        static inline forall(dtype T) {
+                void push_front( __dllist(T) & this, T & node ) with( this ) {
+                        verify(__get);
+                        if ( head ) {
+                                __get( node ).next = head;
+                                __get( node ).prev = __get( *head ).prev;
+                                // inserted node must be consistent before it is seen
+                                // prevent code movement across barrier
+                                asm( "" : : : "memory" );
+                                __get( *head ).prev = &node;
+                                T & _prev = *__get( node ).prev;
+                                __get( _prev ).next = &node;
+                        } else {
+                                __get( node ).next = &node;
+                                __get( node ).prev = &node;
+                        }
+
                         // prevent code movement across barrier
                         asm( "" : : : "memory" );
-                        __get( *head ).prev = &node;
-                        T & _prev = *__get( node ).prev;
-                        __get( _prev ).next = &node;
-                }
-                else {
-                        __get( node ).next = &node;
-                        __get( node ).prev = &node;
-                }
-
-                // prevent code movement across barrier
-                asm( "" : : : "memory" );
-                head = &node;
-        }
-
-        forall(dtype T | sized(T))
-        static inline void remove( __dllist(T) & this, T & node ) with( this ) {
-                verify(__get);
-                if ( &node == head ) {
-                        if ( __get( *head ).next == head ) {
-                                head = NULL;
-                        }
-                        else {
-                                head = __get( *head ).next;
-                        }
-                }
-                __get( *__get( node ).next ).prev = __get( node ).prev;
-                __get( *__get( node ).prev ).next = __get( node ).next;
-                __get( node ).next = NULL;
-                __get( node ).prev = NULL;
-        }
-
-        forall(dtype T | sized(T))
-        static inline int ?!=?( const __dllist(T) & this, __attribute__((unused)) zero_t zero ) {
-                return this.head != 0;
+                        head = &node;
+                }
+
+                void remove( __dllist(T) & this, T & node ) with( this ) {
+                        verify(__get);
+                        if ( &node == head ) {
+                                if ( __get( *head ).next == head ) {
+                                        head = 0p;
+                                } else {
+                                        head = __get( *head ).next;
+                                }
+                        }
+                        __get( *__get( node ).next ).prev = __get( node ).prev;
+                        __get( *__get( node ).prev ).next = __get( node ).next;
+                        __get( node ).next = 0p;
+                        __get( node ).prev = 0p;
+                }
+
+                int ?!=?( const __dllist(T) & this, __attribute__((unused)) zero_t zero ) {
+                        return this.head != 0;
+                }
         }
         #undef next
@@ -286 +277 @@
 
 #endif
+
+// Local Variables: //
+// tab-width: 4 //
+// End: //

libcfa/src/bits/defs.hfa

@@ -10 +10 @@
 // Created On       : Thu Nov  9 13:24:10 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Feb  8 16:22:41 2018
-// Update Count     : 8
+// Last Modified On : Tue Jan 28 22:38:27 2020
+// Update Count     : 9
 //
 
@@ -34 +34 @@
 
 #ifdef __cforall
-void abort ( const char fmt[], ... ) __attribute__ (( format(printf, 1, 2), __nothrow__, __leaf__, __noreturn__ ));
+void abort( const char fmt[], ... ) __attribute__ (( format(printf, 1, 2), __nothrow__, __leaf__, __noreturn__ ));
+void abort( bool signalAbort, const char fmt[], ... ) __attribute__ (( format(printf, 2, 3), __nothrow__, __leaf__, __noreturn__ ));
 extern "C" {
 #endif

libcfa/src/bits/signal.hfa

@@ -40 +40 @@
         sigaddset( &act.sa_mask, SIGALRM );             // disabled during signal handler
         sigaddset( &act.sa_mask, SIGUSR1 );
+        sigaddset( &act.sa_mask, SIGSEGV );
+        sigaddset( &act.sa_mask, SIGBUS );
+        sigaddset( &act.sa_mask, SIGILL );
+        sigaddset( &act.sa_mask, SIGFPE );
+        sigaddset( &act.sa_mask, SIGHUP );              // revert to default on second delivery
+        sigaddset( &act.sa_mask, SIGTERM );
+        sigaddset( &act.sa_mask, SIGINT );
         act.sa_flags = flags;
 
-        if ( sigaction( sig, &act, NULL ) == -1 ) {
+        if ( sigaction( sig, &act, 0p ) == -1 ) {
                 __cfaabi_dbg_print_buffer_decl(
                         " __cfaabi_sigaction( sig:%d, handler:%p, flags:%d ), problem installing signal handler, error(%d) %s.\n",
@@ -48 +55 @@
                 );
                 _exit( EXIT_FAILURE );
-        }
+        } // if
 }
-
-// Sigaction wrapper : restore default handler
-static void __cfaabi_sigdefault( int sig ) {
-        struct sigaction act;
-
-        act.sa_handler = SIG_DFL;
-        act.sa_flags = 0;
-        sigemptyset( &act.sa_mask );
-
-        if ( sigaction( sig, &act, NULL ) == -1 ) {
-                __cfaabi_dbg_print_buffer_decl(
-                        " __cfaabi_sigdefault( sig:%d ), problem reseting signal handler, error(%d) %s.\n",
-                        sig, errno, strerror( errno )
-                );
-                _exit( EXIT_FAILURE );
-        }
-}

libcfa/src/clock.hfa

@@ -10 +10 @@
 // Created On       : Thu Apr 12 14:36:06 2018
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Jun 13 21:21:13 2019
-// Update Count     : 8
+// Last Modified On : Mon Jan  6 12:49:58 2020
+// Update Count     : 9
 //
 
 #include <time.hfa>
-
 
 //######################### C time #########################
@@ -26 +25 @@
 static inline tm * localtime_r( time_t tp, tm * result ) { return localtime_r( &tp, result ); }
 
-
 //######################### Clock #########################
 
 struct Clock {                                                                                  // private
         Duration offset;                                                                        // for virtual clock: contains offset from real-time
-        int clocktype;                                                                          // implementation only -1 (virtual), CLOCK_REALTIME
 };
 
 static inline {
-        void resetClock( Clock & clk ) with( clk ) {
-                clocktype = CLOCK_REALTIME_COARSE;
-        } // Clock::resetClock
-
         void resetClock( Clock & clk, Duration adj ) with( clk ) {
-                clocktype = -1;
                 offset = adj + __timezone`s;                                    // timezone (global) is (UTC - local time) in seconds
         } // resetClock
 
-        void ?{}( Clock & clk ) { resetClock( clk ); }
         void ?{}( Clock & clk, Duration adj ) { resetClock( clk, adj ); }
 
@@ -89 +80 @@
                 return ret;
         } // getTime
+
+        Time getCPUTime() {
+                timespec ts;
+                clock_gettime( CLOCK_THREAD_CPUTIME_ID, &ts );
+                return (Time){ ts };
+    } // getCPUTime
 } // distribution
 

libcfa/src/concurrency/CtxSwitch-x86_64.S

@@ -87 +87 @@
 CtxInvokeStub:
         movq %rbx, %rdi
-        jmp *%r12
+        movq %r12, %rsi
+        jmp *%r13
         .size  CtxInvokeStub, .-CtxInvokeStub
 

libcfa/src/concurrency/alarm.cfa

@@ -10 +10 @@
 // Created On       : Fri Jun 2 11:31:25 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Dec  3 22:47:24 2019
-// Update Count     : 68
+// Last Modified On : Sun Jan  5 08:41:36 2020
+// Update Count     : 69
 //
 
@@ -39 +39 @@
 
 void __kernel_set_timer( Duration alarm ) {
-        verifyf(alarm >= 1`us || alarm == 0, "Setting timer to < 1us (%jins)", alarm.tv);
+        verifyf(alarm >= 1`us || alarm == 0, "Setting timer to < 1us (%jins)", alarm`ns);
         setitimer( ITIMER_REAL, &(itimerval){ alarm }, 0p );
 }

libcfa/src/concurrency/coroutine.cfa

@@ -187 +187 @@
 // is not inline (We can't inline Cforall in C)
 extern "C" {
-        void __suspend_internal(void) {
-                suspend();
-        }
-
-        void __leave_coroutine( coroutine_desc * src ) {
+        void __leave_coroutine( struct coroutine_desc * src ) {
                 coroutine_desc * starter = src->cancellation != 0 ? src->last : src->starter;
 
@@ -207 +203 @@
                 CoroutineCtxSwitch( src, starter );
         }
+
+        struct coroutine_desc * __finish_coroutine(void) {
+                struct coroutine_desc * cor = kernelTLS.this_thread->curr_cor;
+
+                if(cor->state == Primed) {
+                        suspend();
+                }
+
+                cor->state = Active;
+
+                return cor;
+        }
 }
 

libcfa/src/concurrency/coroutine.hfa

@@ -61 +61 @@
 // Start coroutine routines
 extern "C" {
-      forall(dtype T | is_coroutine(T))
-      void CtxInvokeCoroutine(T * this);
+        void CtxInvokeCoroutine(void (*main)(void *), void * this);
 
-      forall(dtype T | is_coroutine(T))
-      void CtxStart(T * this, void ( *invoke)(T *));
+        forall(dtype T)
+        void CtxStart(void (*main)(T &), struct coroutine_desc * cor, T & this, void (*invoke)(void (*main)(void *), void *));
 
         extern void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage, struct coroutine_desc *) __attribute__ ((__noreturn__));
@@ -129 +128 @@
 
         if( unlikely(dst->context.SP == 0p) ) {
+                TL_GET( this_thread )->curr_cor = dst;
                 __stack_prepare(&dst->stack, 65000);
-                CtxStart(&cor, CtxInvokeCoroutine);
+                CtxStart(main, dst, cor, CtxInvokeCoroutine);
+                TL_GET( this_thread )->curr_cor = src;
         }
 

libcfa/src/concurrency/invoke.c

@@ -29 +29 @@
 // Called from the kernel when starting a coroutine or task so must switch back to user mode.
 
-extern void __suspend_internal(void);
-extern void __leave_coroutine( struct coroutine_desc * );
-extern void __finish_creation( struct thread_desc * );
-extern void __leave_thread_monitor( struct thread_desc * this );
+extern void __leave_coroutine ( struct coroutine_desc * );
+extern struct coroutine_desc * __finish_coroutine(void);
+extern void __leave_thread_monitor();
 extern void disable_interrupts() OPTIONAL_THREAD;
 extern void enable_interrupts( __cfaabi_dbg_ctx_param );
@@ -38 +37 @@
 void CtxInvokeCoroutine(
         void (*main)(void *),
-        struct coroutine_desc *(*get_coroutine)(void *),
         void *this
 ) {
-        struct coroutine_desc* cor = get_coroutine( this );
+        // Finish setting up the coroutine by setting its state
+        struct coroutine_desc * cor = __finish_coroutine();
 
-        if(cor->state == Primed) {
-                __suspend_internal();
-        }
-
-        cor->state = Active;
-
+        // Call the main of the coroutine
         main( this );
 
@@ -83 +77 @@
 
 void CtxInvokeThread(
-        void (*dtor)(void *),
         void (*main)(void *),
-        struct thread_desc *(*get_thread)(void *),
         void *this
 ) {
-        // Fetch the thread handle from the user defined thread structure
-        struct thread_desc* thrd = get_thread( this );
-
-        // First suspend, once the thread arrives here,
-        // the function pointer to main can be invalidated without risk
-        __finish_creation( thrd );
-
         // Officially start the thread by enabling preemption
         enable_interrupts( __cfaabi_dbg_ctx );
@@ -108 +93 @@
         // The order of these 4 operations is very important
         //Final suspend, should never return
-        __leave_thread_monitor( thrd );
+        __leave_thread_monitor();
         __cabi_abort( "Resumed dead thread" );
 }
 
-
 void CtxStart(
         void (*main)(void *),
-        struct coroutine_desc *(*get_coroutine)(void *),
+        struct coroutine_desc * cor,
         void *this,
         void (*invoke)(void *)
 ) {
-        struct coroutine_desc * cor = get_coroutine( this );
         struct __stack_t * stack = cor->stack.storage;
 
@@ -138 +121 @@
 
         fs->dummyReturn = NULL;
-        fs->argument[0] = this;     // argument to invoke
+        fs->argument[0] = main;     // argument to invoke
+        fs->argument[1] = this;     // argument to invoke
         fs->rturn = invoke;
 
@@ -156 +140 @@
         fs->dummyReturn = NULL;
         fs->rturn = CtxInvokeStub;
-        fs->fixedRegisters[0] = this;
-        fs->fixedRegisters[1] = invoke;
+        fs->fixedRegisters[0] = main;
+        fs->fixedRegisters[1] = this;
+        fs->fixedRegisters[2] = invoke;
 
 #elif defined( __ARM_ARCH )
-
+#error ARM needs to be upgrade to use to parameters like X86/X64 (A.K.A. : I broke this and do not know how to fix it)
         struct FakeStack {
                 float fpRegs[16];                       // floating point registers

libcfa/src/concurrency/kernel.cfa

@@ -10 +10 @@
 // Created On       : Tue Jan 17 12:27:26 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Dec  5 16:25:52 2019
-// Update Count     : 52
+// Last Modified On : Thu Jan 30 22:55:50 2020
+// Update Count     : 56
 //
 
@@ -469 +469 @@
         );
 
-        Abort( pthread_attr_setstack( &attr, stack, stacksize ), "pthread_attr_setstack" ); 
+        Abort( pthread_attr_setstack( &attr, stack, stacksize ), "pthread_attr_setstack" );
 
         Abort( pthread_create( pthread, &attr, start, arg ), "pthread_create" );
@@ -490 +490 @@
         verify( ! kernelTLS.preemption_state.enabled );
 
+        kernelTLS.this_thread->curr_cor = dst;
         __stack_prepare( &dst->stack, 65000 );
-        CtxStart(&this->runner, CtxInvokeCoroutine);
+        CtxStart(main, dst, this->runner, CtxInvokeCoroutine);
 
         verify( ! kernelTLS.preemption_state.enabled );
@@ -505 +506 @@
         CtxSwitch( &src->context, &dst->context );
         // when CtxSwitch returns we are back in the src coroutine
+
+        mainThread->curr_cor = &mainThread->self_cor;
 
         // set state of new coroutine to active
@@ -841 +844 @@
                 sigemptyset( &mask );
                 sigaddset( &mask, SIGALRM );            // block SIGALRM signals
-                sigsuspend( &mask );                    // block the processor to prevent further damage during abort
-                _exit( EXIT_FAILURE );                  // if processor unblocks before it is killed, terminate it
+                sigaddset( &mask, SIGUSR1 );            // block SIGALRM signals
+                sigsuspend( &mask );                            // block the processor to prevent further damage during abort
+                _exit( EXIT_FAILURE );                          // if processor unblocks before it is killed, terminate it
         }
         else {

libcfa/src/concurrency/kernel_private.hfa

@@ -88 +88 @@
 // Threads
 extern "C" {
-      forall(dtype T | is_thread(T))
-      void CtxInvokeThread(T * this);
+      void CtxInvokeThread(void (*main)(void *), void * this);
 }
 

libcfa/src/concurrency/monitor.cfa

@@ -243 +243 @@
         // last routine called by a thread.
         // Should never return
-        void __leave_thread_monitor( thread_desc * thrd ) {
+        void __leave_thread_monitor() {
+                thread_desc * thrd = TL_GET( this_thread );
                 monitor_desc * this = &thrd->self_mon;
 

libcfa/src/concurrency/thread.cfa

@@ -58 +58 @@
 void ?{}( scoped(T)& this ) with( this ) {
         handle{};
-        __thrd_start(handle);
+        __thrd_start(handle, main);
 }
 
@@ -64 +64 @@
 void ?{}( scoped(T)& this, P params ) with( this ) {
         handle{ params };
-        __thrd_start(handle);
+        __thrd_start(handle, main);
 }
 
@@ -75 +75 @@
 // Starting and stopping threads
 forall( dtype T | is_thread(T) )
-void __thrd_start( T& this ) {
+void __thrd_start( T & this, void (*main_p)(T &) ) {
         thread_desc * this_thrd = get_thread(this);
         thread_desc * curr_thrd = TL_GET( this_thread );
 
         disable_interrupts();
-        CtxStart(&this, CtxInvokeThread);
+        CtxStart(main_p, get_coroutine(this), this, CtxInvokeThread);
+
         this_thrd->context.[SP, FP] = this_thrd->self_cor.context.[SP, FP];
         verify( this_thrd->context.SP );
-        CtxSwitch( &curr_thrd->context, &this_thrd->context );
+        // CtxSwitch( &curr_thrd->context, &this_thrd->context );
 
         ScheduleThread(this_thrd);
         enable_interrupts( __cfaabi_dbg_ctx );
-}
-
-extern "C" {
-        // KERNEL ONLY
-        void __finish_creation(thread_desc * this) {
-                // set new coroutine that the processor is executing
-                // and context switch to it
-                verify( kernelTLS.this_thread != this );
-                verify( kernelTLS.this_thread->context.SP );
-                CtxSwitch( &this->context, &kernelTLS.this_thread->context );
-        }
 }
 

libcfa/src/concurrency/thread.hfa

@@ -54 +54 @@
 
 forall( dtype T | is_thread(T) )
-void __thrd_start( T & this );
+void __thrd_start( T & this, void (*)(T &) );
 
 //-----------------------------------------------------------------------------

libcfa/src/executor.cfa

@@ -8 +8 @@
 #include <stdio.h>
 
-forall( otype T | is_node(T) | is_monitor(T) ) {
-    monitor Buffer {                                    // unbounded buffer
-        __queue_t( T ) queue;                           // unbounded list of work requests
-        condition delay;
-    }; // Buffer
-
+forall( dtype T )
+monitor Buffer {                                        // unbounded buffer
+    __queue_t( T ) queue;                               // unbounded list of work requests
+    condition delay;
+}; // Buffer
+forall( dtype T | is_node(T) ) {
     void insert( Buffer( T ) & mutex buf, T * elem ) with(buf) {
         append( queue, elem );                          // insert element into buffer
@@ -20 +20 @@
 
     T * remove( Buffer( T ) & mutex buf ) with(buf) {
-        if ( ! queue ) wait( delay );                   // no request to process ? => wait
-        return pop_head( queue );
+        if ( queue.head != 0 ) wait( delay );                   // no request to process ? => wait
+//      return pop_head( queue );
     } // remove
 } // distribution

libcfa/src/interpose.cfa

@@ -10 +10 @@
 // Created On       : Wed Mar 29 16:10:31 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Dec 13 13:45:21 2019
-// Update Count     : 121
+// Last Modified On : Thu Jan 30 17:47:32 2020
+// Update Count     : 156
 //
 
@@ -95 +95 @@
         void __cfaabi_interpose_startup(void)  __attribute__(( constructor( STARTUP_PRIORITY_CORE ) ));
         void __cfaabi_interpose_startup( void ) {
-                const char *version = NULL;
+                const char *version = 0p;
 
                 preload_libgcc();
@@ -105 +105 @@
 #pragma GCC diagnostic pop
 
+                // As a precaution (and necessity), errors that result in termination are delivered on a separate stack because
+                // task stacks might be very small (4K) and the signal delivery corrupts memory to the point that a clean
+                // shutdown is impossible. Also, when a stack overflow encounters the non-accessible sentinel page (debug only)
+                // and generates a segment fault, the signal cannot be delivered on the sentinel page. Finally, calls to abort
+                // print a stack trace that uses substantial stack space.
+
+                #define MINSTKSZ SIGSTKSZ * 8
+                static char stack[MINSTKSZ] __attribute__(( aligned (16) ));
+                static stack_t ss;
+
+                ss.ss_sp = stack;
+                ss.ss_size = MINSTKSZ;
+                ss.ss_flags = 0;
+                if ( sigaltstack( &ss, 0p ) == -1 ) {
+                        abort( "__cfaabi_interpose_startup : internal error, sigaltstack error(%d) %s.", errno, strerror( errno ) );
+                } // if
+
                 // Failure handler
-                __cfaabi_sigaction( SIGSEGV, sigHandler_segv , SA_SIGINFO );
-                __cfaabi_sigaction( SIGBUS , sigHandler_segv , SA_SIGINFO );
-                __cfaabi_sigaction( SIGILL , sigHandler_ill  , SA_SIGINFO );
-                __cfaabi_sigaction( SIGFPE , sigHandler_fpe  , SA_SIGINFO );
-                __cfaabi_sigaction( SIGABRT, sigHandler_abrt, SA_SIGINFO | SA_RESETHAND);
-                __cfaabi_sigaction( SIGTERM, sigHandler_term , SA_SIGINFO );
-                __cfaabi_sigaction( SIGINT , sigHandler_term , SA_SIGINFO );
+                __cfaabi_sigaction( SIGSEGV, sigHandler_segv, SA_SIGINFO | SA_ONSTACK );
+                __cfaabi_sigaction( SIGBUS , sigHandler_segv, SA_SIGINFO | SA_ONSTACK );
+                __cfaabi_sigaction( SIGILL , sigHandler_ill , SA_SIGINFO | SA_ONSTACK );
+                __cfaabi_sigaction( SIGFPE , sigHandler_fpe , SA_SIGINFO | SA_ONSTACK );
+                __cfaabi_sigaction( SIGTERM, sigHandler_term, SA_SIGINFO | SA_ONSTACK | SA_RESETHAND ); // one shot handler, return to default
+                __cfaabi_sigaction( SIGINT , sigHandler_term, SA_SIGINFO | SA_ONSTACK | SA_RESETHAND );
+                __cfaabi_sigaction( SIGABRT, sigHandler_term, SA_SIGINFO | SA_ONSTACK | SA_RESETHAND );
+                __cfaabi_sigaction( SIGHUP , sigHandler_term, SA_SIGINFO | SA_ONSTACK | SA_RESETHAND ); // terminal hangup
         }
 }
@@ -123 +141 @@
 void exit( int status, const char fmt[], ... ) __attribute__(( format(printf, 2, 3), __nothrow__, __leaf__, __noreturn__ ));
 void abort( const char fmt[], ... ) __attribute__(( format(printf, 1, 2), __nothrow__, __leaf__, __noreturn__ ));
+void abort( bool signalAbort, const char fmt[], ... ) __attribute__(( format(printf, 2, 3), __nothrow__, __leaf__, __noreturn__ ));
 
 extern "C" {
         void abort( void ) __attribute__(( __nothrow__, __leaf__, __noreturn__ )) {
-                abort( NULL );
+                abort( false, NULL ); // FIX ME: 0p does not work
         }
 
@@ -132 +151 @@
                 va_list argp;
                 va_start( argp, fmt );
-                abort( fmt, argp );
+                abort( false, fmt, argp );
                 va_end( argp );
         }
@@ -141 +160 @@
 }
 
-void * kernel_abort    ( void ) __attribute__(( __nothrow__, __leaf__, __weak__ )) { return NULL; }
-void   kernel_abort_msg( void * data, char * buffer, int size ) __attribute__(( __nothrow__, __leaf__, __weak__ )) {}
+void * kernel_abort( void ) __attribute__(( __nothrow__, __leaf__, __weak__ )) { return 0p; }
+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; }
 
 enum { abort_text_size = 1024 };
 static char abort_text[ abort_text_size ];
-static int abort_lastframe;
-
-void exit( int status, const char fmt[], ... ) __attribute__(( format(printf, 2, 3), __nothrow__, __leaf__, __noreturn__ )) {
-    va_list args;
-    va_start( args, fmt );
-    vfprintf( stderr, fmt, args );
-    va_end( args );
-        __cabi_libc.exit( status );
-}
-
-void abort( const char fmt[], ... ) __attribute__(( format(printf, 1, 2), __nothrow__, __leaf__, __noreturn__ )) {
-        void * kernel_data = kernel_abort();                    // must be done here to lock down kernel
-        int len;
-
-        abort_lastframe = kernel_abort_lastframe();
-        len = snprintf( abort_text, abort_text_size, "Cforall Runtime error (UNIX pid:%ld) ", (long int)getpid() ); // use UNIX pid (versus getPid)
-        __cfaabi_dbg_write( 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_dbg_write( 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 );
-                }
-        }
-
-        kernel_abort_msg( kernel_data, abort_text, abort_text_size );
-        __cabi_libc.abort();
-}
-
-static void __cfaabi_backtrace() {
+
+static void __cfaabi_backtrace( int start ) {
         enum {
                 Frames = 50,                                                                    // maximum number of stack frames
-                Start = 8,                                                                              // skip first N stack frames
         };
+        int last = kernel_abort_lastframe();                            // skip last N stack frames
 
         void * array[Frames];
@@ -192 +178 @@
         char ** messages = backtrace_symbols( array, size );
 
-        // find executable name
-        *index( messages[0], '(' ) = '\0';
+        *index( messages[0], '(' ) = '\0';                                      // find executable name
         __cfaabi_bits_print_nolock( STDERR_FILENO, "Stack back trace for: %s\n", messages[0]);
 
-        for ( int i = Start; i < size - abort_lastframe && messages != 0p; i += 1 ) {
+        for ( unsigned int i = start; i < size - last && messages != 0p; i += 1 ) {
                 char * name = 0p, * offset_begin = 0p, * offset_end = 0p;
 
-                for ( char * p = messages[i]; *p; ++p ) {
+                for ( char * p = messages[i]; *p; ++p ) {               // find parantheses and +offset
                         //__cfaabi_bits_print_nolock( "X %s\n", p);
-                        // find parantheses and +offset
                         if ( *p == '(' ) {
                                 name = p;
@@ -212 +196 @@
                 }
 
-                // if line contains symbol print it
-                int frameNo = i - Start;
+                // if line contains symbol, print it
+                int frameNo = i - start;
                 if ( name && offset_begin && offset_end && name < offset_begin ) {
-                        // delimit strings
-                        *name++ = '\0';
+                        *name++ = '\0';                                                         // delimit strings
                         *offset_begin++ = '\0';
                         *offset_end++ = '\0';
@@ -228 +211 @@
 }
 
+void exit( int status, const char fmt[], ... ) {
+        va_list args;
+        va_start( args, fmt );
+        vfprintf( stderr, fmt, args );
+        va_end( args );
+        __cabi_libc.exit( status );
+}
+
+void abort( bool signalAbort, const char fmt[], ... ) {
+        void * kernel_data = kernel_abort();                            // must be done here to lock down kernel
+        int len;
+
+        signal( SIGABRT, SIG_DFL );                                                     // prevent final "real" abort from recursing to handler
+
+        len = snprintf( abort_text, abort_text_size, "Cforall Runtime error (UNIX pid:%ld) ", (long int)getpid() ); // use UNIX pid (versus getPid)
+        __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 );
+                }
+        }
+
+        kernel_abort_msg( kernel_data, abort_text, abort_text_size );
+        __cfaabi_backtrace( signalAbort ? 4 : 3 );
+
+        __cabi_libc.abort();                                                            // print stack trace in handler
+}
+
+void abort( const char fmt[], ... ) {
+        va_list args;
+        va_start( args, fmt );
+        abort( false, fmt, args );
+        va_end( args );
+}
+
 void sigHandler_segv( __CFA_SIGPARMS__ ) {
-                if ( sfp->si_addr == NULL ) {
-                        abort( "Null pointer (0p) dereference.\n" );
+                if ( sfp->si_addr == 0p ) {
+                        abort( true, "Null pointer (0p) dereference.\n" );
                 } else {
-                        abort( "%s at memory location %p.\n"
+                        abort( true, "%s at memory location %p.\n"
                                    "Possible cause is reading outside the address space or writing to a protected area within the address space with an invalid pointer or subscript.\n",
                                    (sig == SIGSEGV ? "Segment fault" : "Bus error"), sfp->si_addr );
@@ -239 +265 @@
 
 void sigHandler_ill( __CFA_SIGPARMS__ ) {
-        abort( "Executing illegal instruction at location %p.\n"
+        abort( true, "Executing illegal instruction at location %p.\n"
                         "Possible cause is stack corruption.\n",
                         sfp->si_addr );
@@ -255 +281 @@
           default: msg = "unknown";
         } // choose
-        abort( "Computation error %s at location %p.\n", msg, sfp->si_addr );
-}
-
-void sigHandler_abrt( __CFA_SIGPARMS__ ) {
-        __cfaabi_backtrace();
-
-        // reset default signal handler
-        __cfaabi_sigdefault( SIGABRT );
-
-        raise( SIGABRT );
+        abort( true, "Computation error %s at location %p.\n", msg, sfp->si_addr );
 }
 
 void sigHandler_term( __CFA_SIGPARMS__ ) {
-        abort( "Application stopped by %s signal.", sig == SIGINT ? "an interrupt (SIGINT)" : "a terminate (SIGTERM)" );
+        abort( true, "Application interrupted by signal: %s.\n", strsignal( sig ) );
 }
 

libcfa/src/startup.cfa

@@ -10 +10 @@
 // Created On       : Tue Jul 24 16:21:57 2018
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Nov 30 07:07:56 2019
-// Update Count     : 13
+// Last Modified On : Fri Dec 13 13:16:45 2019
+// Update Count     : 29
 //
 
+#include <time.h>                                                                               // tzset
 #include "startup.hfa"
-#include <time.h>                                                                               // tzset
 
 extern "C" {
-    static void __cfaabi_appready_startup( void ) __attribute__(( constructor( STARTUP_PRIORITY_APPREADY ) ));
+    void __cfaabi_appready_startup( void ) __attribute__(( constructor( STARTUP_PRIORITY_APPREADY ) ));
     void __cfaabi_appready_startup( void ) {
                 tzset();                                                                                // initialize time global variables
@@ -27 +27 @@
     } // __cfaabi_appready_startup
 
-    static void __cfaabi_appready_shutdown( void ) __attribute__(( destructor( STARTUP_PRIORITY_APPREADY ) ));
+    void __cfaabi_appready_shutdown( void ) __attribute__(( destructor( STARTUP_PRIORITY_APPREADY ) ));
     void __cfaabi_appready_shutdown( void ) {
                 #ifdef __CFA_DEBUG__

libcfa/src/stdhdr/bfdlink.h

@@ -10 +10 @@
 // Created On       : Tue Jul 18 07:26:04 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Jul 22 13:49:30 2018
-// Update Count     : 4
+// Last Modified On : Sat Feb  1 07:15:29 2020
+// Update Count     : 5
 // 
 
 // 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

@@ -10 +10 @@
 // Created On       : Tue Jul 18 07:45:00 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Jul 22 13:49:58 2018
-// Update Count     : 4
+// Last Modified On : Sat Feb  1 07:15:39 2020
+// Update Count     : 5
 // 
 
 // 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

@@ -10 +10 @@
 // Created On       : Tue Jul 18 07:55:44 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Jul 22 13:50:24 2018
-// Update Count     : 4
+// Last Modified On : Sat Feb  1 07:15:47 2020
+// Update Count     : 5
 // 
 
 // 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

@@ -10 +10 @@
 // Created On       : Mon Jul  4 23:25:26 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Feb 22 18:16:07 2018
-// Update Count     : 13
+// Last Modified On : Sat Feb  1 07:15:58 2020
+// Update Count     : 14
 // 
 
 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

@@ -10 +10 @@
 // Created On       : Thu Feb  8 23:48:16 2018
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Feb  8 23:50:44 2018
-// Update Count     : 4
+// Last Modified On : Sat Feb  1 07:16:05 2020
+// Update Count     : 5
 // 
 
 #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/time.cfa

@@ -10 +10 @@
 // Created On       : Tue Mar 27 13:33:14 2018
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 13 08:41:55 2019
-// Update Count     : 65
+// Last Modified On : Sun Jan  5 17:27:40 2020
+// Update Count     : 69
 //
 
@@ -33 +33 @@
 forall( dtype ostype | ostream( ostype ) ) {
         ostype & ?|?( ostype & os, Duration dur ) with( dur ) {
-                (ostype &)(os | tv / TIMEGRAN);                                 // print seconds
-                long int ns = (tv < 0 ? -tv : tv) % TIMEGRAN;   // compute nanoseconds
+                (ostype &)(os | tn / TIMEGRAN);                                 // print seconds
+                long int ns = (tn < 0 ? -tn : tn) % TIMEGRAN;   // compute nanoseconds
                 if ( ns != 0 ) {                                                                // some ?
                         char buf[16];
@@ -52 +52 @@
 
 #ifdef __CFA_DEBUG__
-static void tabort( int year, int month, int day, int hour, int min, int sec, int nsec ) {
+static void tabort( int year, int month, int day, int hour, int min, int sec, int64_t nsec ) {
         abort | "Attempt to create Time( year=" | year | "(>=1970), month=" | month | "(1-12), day=" | day | "(1-31), hour=" | hour | "(0-23), min=" | min | "(0-59), sec=" | sec
-                  | "(0-60), nsec=" | nsec | "(0-999_999_999), which exceeds range 00:00:00 UTC, January 1, 1970 to 03:14:07 UTC, January 19, 2038.";
+                  | "(0-60), nsec=" | nsec | "(0-999_999_999), which is not in the range 00:00:00 UTC, January 1, 1970 to 03:14:07 UTC, January 19, 2038, where month and day have 1 origin.";
 } // tabort
 #endif // __CFA_DEBUG__
 
-void ?{}( Time & time, int year, int month, int day, int hour, int min, int sec, int nsec ) with( time ) {
+void ?{}( Time & time, int year, int month, int day, int hour, int min, int sec, int64_t nsec ) with( time ) {
         tm tm;
 
-        tm.tm_isdst = -1;                                                                       // let mktime determine if alternate timezone is in effect
+        // Values can be in any range (+/-) but result must be in the epoch.
         tm.tm_year = year - 1900;                                                       // mktime uses 1900 as its starting point
-#ifdef __CFA_DEBUG__
-        if ( month < 1 || 12 < month ) {
-                tabort( year, month, day, hour, min, sec, nsec );
-        } // if
-#endif // __CFA_DEBUG__
+        // Make month in range 1-12 to match with day.
         tm.tm_mon = month - 1;                                                          // mktime uses range 0-11
-#ifdef __CFA_DEBUG__
-        if ( day < 1 || 31 < day ) {
-                tabort( year, month, day, hour, min, sec, nsec );
-        } // if
-#endif // __CFA_DEBUG__
         tm.tm_mday = day;                                                                       // mktime uses range 1-31
         tm.tm_hour = hour;
         tm.tm_min = min;
         tm.tm_sec = sec;
+        tm.tm_isdst = -1;                                                                       // let mktime determine if alternate timezone is in effect
         time_t epochsec = mktime( &tm );
 #ifdef __CFA_DEBUG__
-        if ( epochsec == (time_t)-1 ) {
+        if ( epochsec <= (time_t)-1 ) {                                         // MUST BE LESS THAN OR EQUAL!
                 tabort( year, month, day, hour, min, sec, nsec );
         } // if
 #endif // __CFA_DEBUG__
-        tv = (int64_t)(epochsec) * TIMEGRAN + nsec;                     // convert to nanoseconds
+        tn = (int64_t)(epochsec) * TIMEGRAN + nsec;                     // convert to nanoseconds
 #ifdef __CFA_DEBUG__
-        if ( tv > 2147483647LL * TIMEGRAN ) {                           // between 00:00:00 UTC, January 1, 1970 and 03:14:07 UTC, January 19, 2038.
+        if ( tn > 2147483647LL * TIMEGRAN ) {                           // between 00:00:00 UTC, January 1, 1970 and 03:14:07 UTC, January 19, 2038.
                 tabort( year, month, day, hour, min, sec, nsec );
         } // if
@@ -93 +85 @@
 
 char * yy_mm_dd( Time time, char * buf ) with( time ) {
-        time_t s = tv / TIMEGRAN;
+        time_t s = tn / TIMEGRAN;
         tm tm;
         gmtime_r( &s, &tm );                                                            // tm_mon <= 11, tm_mday <= 31
@@ -108 +100 @@
 
 char * mm_dd_yy( Time time, char * buf ) with( time ) {
-        time_t s = tv / TIMEGRAN;
+        time_t s = tn / TIMEGRAN;
         tm tm;
         gmtime_r( &s, &tm );                                                            // tm_mon <= 11, tm_mday <= 31
@@ -123 +115 @@
 
 char * dd_mm_yy( Time time, char * buf ) with( time ) {
-        time_t s = tv / TIMEGRAN;
+        time_t s = tn / TIMEGRAN;
         tm tm;
         gmtime_r( &s, &tm );                                                            // tm_mon <= 11, tm_mday <= 31
@@ -138 +130 @@
 
 size_t strftime( char * buf, size_t size, const char * fmt, Time time ) with( time ) {
-        time_t s = tv / TIMEGRAN;
+        time_t s = tn / TIMEGRAN;
         tm tm;
         gmtime_r( &s, &tm );
@@ -147 +139 @@
         ostype & ?|?( ostype & os, Time time ) with( time ) {
                 char buf[32];                                                                   // at least 26
-                time_t s = tv / TIMEGRAN;
+                time_t s = tn / TIMEGRAN;
                 ctime_r( &s, (char *)&buf );                                    // 26 characters: "Wed Jun 30 21:49:08 1993\n"
                 buf[24] = '\0';                                                                 // remove trailing '\n'
-                long int ns = (tv < 0 ? -tv : tv) % TIMEGRAN;   // compute nanoseconds
+                long int ns = (tn < 0 ? -tn : tn) % TIMEGRAN;   // compute nanoseconds
                 if ( ns == 0 ) {                                                                // none ?
                         (ostype &)(os | buf);                                           // print date/time/year

libcfa/src/time.hfa

@@ -10 +10 @@
 // Created On       : Wed Mar 14 23:18:57 2018
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Sep 22 12:25:34 2018
-// Update Count     : 643
+// Last Modified On : Mon Jan  6 12:50:16 2020
+// Update Count     : 653
 //
 
@@ -32 +32 @@
         Duration ?=?( Duration & dur, __attribute__((unused)) zero_t ) { return dur{ 0 }; }
 
-        Duration +?( Duration rhs ) with( rhs ) {       return (Duration)@{ +tv }; }
-        Duration ?+?( Duration & lhs, Duration rhs ) { return (Duration)@{ lhs.tv + rhs.tv }; }
+        Duration +?( Duration rhs ) with( rhs ) { return (Duration)@{ +tn }; }
+        Duration ?+?( Duration & lhs, Duration rhs ) { return (Duration)@{ lhs.tn + rhs.tn }; }
         Duration ?+=?( Duration & lhs, Duration rhs ) { lhs = lhs + rhs; return lhs; }
 
-        Duration -?( Duration rhs ) with( rhs ) { return (Duration)@{ -tv }; }
-        Duration ?-?( Duration & lhs, Duration rhs ) { return (Duration)@{ lhs.tv - rhs.tv }; }
+        Duration -?( Duration rhs ) with( rhs ) { return (Duration)@{ -tn }; }
+        Duration ?-?( Duration & lhs, Duration rhs ) { return (Duration)@{ lhs.tn - rhs.tn }; }
         Duration ?-=?( Duration & lhs, Duration rhs ) { lhs = lhs - rhs; return lhs; }
 
-        Duration ?*?( Duration lhs, int64_t rhs ) { return (Duration)@{ lhs.tv * rhs }; }
-        Duration ?*?( int64_t lhs, Duration rhs ) { return (Duration)@{ lhs * rhs.tv }; }
+        Duration ?*?( Duration lhs, int64_t rhs ) { return (Duration)@{ lhs.tn * rhs }; }
+        Duration ?*?( int64_t lhs, Duration rhs ) { return (Duration)@{ lhs * rhs.tn }; }
         Duration ?*=?( Duration & lhs, int64_t rhs ) { lhs = lhs * rhs; return lhs; }
 
-        int64_t ?/?( Duration lhs, Duration rhs ) { return lhs.tv / rhs.tv; }
-        Duration ?/?( Duration lhs, int64_t rhs ) { return (Duration)@{ lhs.tv / rhs }; }
+        int64_t ?/?( Duration lhs, Duration rhs ) { return lhs.tn / rhs.tn; }
+        Duration ?/?( Duration lhs, int64_t rhs ) { return (Duration)@{ lhs.tn / rhs }; }
         Duration ?/=?( Duration & lhs, int64_t rhs ) { lhs = lhs / rhs; return lhs; }
-        double div( Duration lhs, Duration rhs ) { return (double)lhs.tv / (double)rhs.tv; }
-
-        Duration ?%?( Duration lhs, Duration rhs ) { return (Duration)@{ lhs.tv % rhs.tv }; }
+        double div( Duration lhs, Duration rhs ) { return (double)lhs.tn / (double)rhs.tn; }
+
+        Duration ?%?( Duration lhs, Duration rhs ) { return (Duration)@{ lhs.tn % rhs.tn }; }
         Duration ?%=?( Duration & lhs, Duration rhs ) { lhs = lhs % rhs; return lhs; }
 
-        bool ?==?( Duration lhs, Duration rhs ) { return lhs.tv == rhs.tv; }
-        bool ?!=?( Duration lhs, Duration rhs ) { return lhs.tv != rhs.tv; }
-        bool ?<? ( Duration lhs, Duration rhs ) { return lhs.tv <  rhs.tv; }
-        bool ?<=?( Duration lhs, Duration rhs ) { return lhs.tv <= rhs.tv; }
-        bool ?>? ( Duration lhs, Duration rhs ) { return lhs.tv >  rhs.tv; }
-        bool ?>=?( Duration lhs, Duration rhs ) { return lhs.tv >= rhs.tv; }
-
-        bool ?==?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tv == 0; }
-        bool ?!=?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tv != 0; }
-        bool ?<? ( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tv <  0; }
-        bool ?<=?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tv <= 0; }
-        bool ?>? ( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tv >  0; }
-        bool ?>=?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tv >= 0; }
-
-        Duration abs( Duration rhs ) { return rhs.tv >= 0 ? rhs : -rhs; }
+        bool ?==?( Duration lhs, Duration rhs ) { return lhs.tn == rhs.tn; }
+        bool ?!=?( Duration lhs, Duration rhs ) { return lhs.tn != rhs.tn; }
+        bool ?<? ( Duration lhs, Duration rhs ) { return lhs.tn <  rhs.tn; }
+        bool ?<=?( Duration lhs, Duration rhs ) { return lhs.tn <= rhs.tn; }
+        bool ?>? ( Duration lhs, Duration rhs ) { return lhs.tn >  rhs.tn; }
+        bool ?>=?( Duration lhs, Duration rhs ) { return lhs.tn >= rhs.tn; }
+
+        bool ?==?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn == 0; }
+        bool ?!=?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn != 0; }
+        bool ?<? ( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn <  0; }
+        bool ?<=?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn <= 0; }
+        bool ?>? ( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn >  0; }
+        bool ?>=?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn >= 0; }
+
+        Duration abs( Duration rhs ) { return rhs.tn >= 0 ? rhs : -rhs; }
 
         Duration ?`ns( int64_t nsec ) { return (Duration)@{ nsec }; }
@@ -82 +82 @@
         Duration ?`w( double weeks ) { return (Duration)@{ weeks * (7LL * 24LL * 60LL * 60LL * TIMEGRAN) }; }
 
-        int64_t ?`ns( Duration dur ) { return dur.tv; }
-        int64_t ?`us( Duration dur ) { return dur.tv / (TIMEGRAN / 1_000_000LL); }
-        int64_t ?`ms( Duration dur ) { return dur.tv / (TIMEGRAN / 1_000LL); }
-        int64_t ?`s( Duration dur ) { return dur.tv / TIMEGRAN; }
-        int64_t ?`m( Duration dur ) { return dur.tv / (60LL * TIMEGRAN); }
-        int64_t ?`h( Duration dur ) { return dur.tv / (60LL * 60LL * TIMEGRAN); }
-        int64_t ?`d( Duration dur ) { return dur.tv / (24LL * 60LL * 60LL * TIMEGRAN); }
-        int64_t ?`w( Duration dur ) { return dur.tv / (7LL * 24LL * 60LL * 60LL * TIMEGRAN); }
-
-        Duration max( Duration lhs, Duration rhs ) { return  (lhs.tv < rhs.tv) ? rhs : lhs;}
-        Duration min( Duration lhs, Duration rhs ) { return !(rhs.tv < lhs.tv) ? lhs : rhs;}
+        int64_t ?`ns( Duration dur ) { return dur.tn; }
+        int64_t ?`us( Duration dur ) { return dur.tn / (TIMEGRAN / 1_000_000LL); }
+        int64_t ?`ms( Duration dur ) { return dur.tn / (TIMEGRAN / 1_000LL); }
+        int64_t ?`s( Duration dur ) { return dur.tn / TIMEGRAN; }
+        int64_t ?`m( Duration dur ) { return dur.tn / (60LL * TIMEGRAN); }
+        int64_t ?`h( Duration dur ) { return dur.tn / (60LL * 60LL * TIMEGRAN); }
+        int64_t ?`d( Duration dur ) { return dur.tn / (24LL * 60LL * 60LL * TIMEGRAN); }
+        int64_t ?`w( Duration dur ) { return dur.tn / (7LL * 24LL * 60LL * 60LL * TIMEGRAN); }
+
+        Duration max( Duration lhs, Duration rhs ) { return  (lhs.tn < rhs.tn) ? rhs : lhs;}
+        Duration min( Duration lhs, Duration rhs ) { return !(rhs.tn < lhs.tn) ? lhs : rhs;}
 } // distribution
 
@@ -143 +143 @@
 //######################### Time #########################
 
-void ?{}( Time & time, int year, int month = 0, int day = 0, int hour = 0, int min = 0, int sec = 0, int nsec = 0 );
+void ?{}( Time & time, int year, int month = 1, int day = 1, int hour = 0, int min = 0, int sec = 0, int64_t nsec = 0 );
 static inline {
         Time ?=?( Time & time, __attribute__((unused)) zero_t ) { return time{ 0 }; }
 
-        void ?{}( Time & time, timeval t ) with( time ) { tv = (int64_t)t.tv_sec * TIMEGRAN + t.tv_usec * 1000; }
+        void ?{}( Time & time, timeval t ) with( time ) { tn = (int64_t)t.tv_sec * TIMEGRAN + t.tv_usec * 1000; }
         Time ?=?( Time & time, timeval t ) with( time ) {
-                tv = (int64_t)t.tv_sec * TIMEGRAN + t.tv_usec * (TIMEGRAN / 1_000_000LL);
+                tn = (int64_t)t.tv_sec * TIMEGRAN + t.tv_usec * (TIMEGRAN / 1_000_000LL);
                 return time;
         } // ?=?
 
-        void ?{}( Time & time, timespec t ) with( time ) { tv = (int64_t)t.tv_sec * TIMEGRAN + t.tv_nsec; }
+        void ?{}( Time & time, timespec t ) with( time ) { tn = (int64_t)t.tv_sec * TIMEGRAN + t.tv_nsec; }
         Time ?=?( Time & time, timespec t ) with( time ) {
-                tv = (int64_t)t.tv_sec * TIMEGRAN + t.tv_nsec;
+                tn = (int64_t)t.tv_sec * TIMEGRAN + t.tv_nsec;
                 return time;
         } // ?=?
 
-        Time ?+?( Time & lhs, Duration rhs ) { return (Time)@{ lhs.tv + rhs.tv }; }
+        Time ?+?( Time & lhs, Duration rhs ) { return (Time)@{ lhs.tn + rhs.tn }; }
         Time ?+?( Duration lhs, Time rhs ) { return rhs + lhs; }
         Time ?+=?( Time & lhs, Duration rhs ) { lhs = lhs + rhs; return lhs; }
 
-        Duration ?-?( Time lhs, Time rhs ) { return (Duration)@{ lhs.tv - rhs.tv }; }
-        Time ?-?( Time lhs, Duration rhs ) { return (Time)@{ lhs.tv - rhs.tv }; }
+        Duration ?-?( Time lhs, Time rhs ) { return (Duration)@{ lhs.tn - rhs.tn }; }
+        Time ?-?( Time lhs, Duration rhs ) { return (Time)@{ lhs.tn - rhs.tn }; }
         Time ?-=?( Time & lhs, Duration rhs ) { lhs = lhs - rhs; return lhs; }
-        bool ?==?( Time lhs, Time rhs ) { return lhs.tv == rhs.tv; }
-        bool ?!=?( Time lhs, Time rhs ) { return lhs.tv != rhs.tv; }
-        bool ?<?( Time lhs, Time rhs ) { return lhs.tv < rhs.tv; }
-        bool ?<=?( Time lhs, Time rhs ) { return lhs.tv <= rhs.tv; }
-        bool ?>?( Time lhs, Time rhs ) { return lhs.tv > rhs.tv; }
-        bool ?>=?( Time lhs, Time rhs ) { return lhs.tv >= rhs.tv; }
+        bool ?==?( Time lhs, Time rhs ) { return lhs.tn == rhs.tn; }
+        bool ?!=?( Time lhs, Time rhs ) { return lhs.tn != rhs.tn; }
+        bool ?<?( Time lhs, Time rhs ) { return lhs.tn < rhs.tn; }
+        bool ?<=?( Time lhs, Time rhs ) { return lhs.tn <= rhs.tn; }
+        bool ?>?( Time lhs, Time rhs ) { return lhs.tn > rhs.tn; }
+        bool ?>=?( Time lhs, Time rhs ) { return lhs.tn >= rhs.tn; }
+
+        int64_t ?`ns( Time t ) { return t.tn; }
 } // distribution
 
@@ -194 +196 @@
 
 static inline void ?{}( timeval & t, Time time ) with( t, time ) {
-        tv_sec = tv / TIMEGRAN;                                                         // seconds
-        tv_usec = tv % TIMEGRAN / (TIMEGRAN / 1_000_000LL);     // microseconds
+        tv_sec = tn / TIMEGRAN;                                                         // seconds
+        tv_usec = tn % TIMEGRAN / (TIMEGRAN / 1_000_000LL);     // microseconds
 } // ?{}
 
@@ -201 +203 @@
 
 static inline void ?{}( timespec & t, Time time ) with( t, time ) {
-        tv_sec = tv / TIMEGRAN;                                                         // seconds
-        tv_nsec = tv % TIMEGRAN;                                                        // nanoseconds
+        tv_sec = tn / TIMEGRAN;                                                         // seconds
+        tv_nsec = tn % TIMEGRAN;                                                        // nanoseconds
 } // ?{}
 

libcfa/src/time_t.hfa

@@ -10 +10 @@
 // Created On       : Tue Apr 10 14:42:03 2018
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Apr 13 07:51:47 2018
-// Update Count     : 6
+// Last Modified On : Sun Jan  5 08:22:46 2020
+// Update Count     : 7
 //
 
@@ -20 +20 @@
 
 struct Duration {                                                                               // private
-        int64_t tv;                                                                                     // nanoseconds
+        int64_t tn;                                                                                     // nanoseconds
 }; // Duration
 
-static inline void ?{}( Duration & dur ) with( dur ) { tv = 0; }
-static inline void ?{}( Duration & dur, __attribute__((unused)) zero_t ) with( dur ) { tv = 0; }
+static inline void ?{}( Duration & dur ) with( dur ) { tn = 0; }
+static inline void ?{}( Duration & dur, __attribute__((unused)) zero_t ) with( dur ) { tn = 0; }
 
 
@@ -30 +30 @@
 
 struct Time {                                                                                   // private
-        uint64_t tv;                                                                            // nanoseconds since UNIX epoch
+        uint64_t tn;                                                                            // nanoseconds since UNIX epoch
 }; // Time
 
-static inline void ?{}( Time & time ) with( time ) { tv = 0; }
-static inline void ?{}( Time & time, __attribute__((unused)) zero_t ) with( time ) { tv = 0; }
+static inline void ?{}( Time & time ) with( time ) { tn = 0; }
+static inline void ?{}( Time & time, __attribute__((unused)) zero_t ) with( time ) { tn = 0; }
 
 // Local Variables: //

longrun_tests/Makefile.in

@@ -492 +492 @@
 am__v_CFA_0 = @echo "  CFA     " $@;
 am__v_CFA_1 = 
-AM_V_JAVAC = $(am__v_JAVAC_@AM_V@)
-am__v_JAVAC_ = $(am__v_JAVAC_@AM_DEFAULT_V@)
-am__v_JAVAC_0 = @echo "  JAVAC   " $@;
-am__v_JAVAC_1 = 
-AM_V_GOC = $(am__v_GOC_@AM_V@)
-am__v_GOC_ = $(am__v_GOC_@AM_DEFAULT_V@)
-am__v_GOC_0 = @echo "  GOC     " $@;
-am__v_GOC_1 = 
 UPPCC = u++
 UPPCOMPILE = $(UPPCC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_UPPFLAGS) $(UPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_CFLAGS) $(CFLAGS)
@@ -506 +498 @@
 am__v_UPP_0 = @echo "  UPP     " $@;
 am__v_UPP_1 = 
+AM_V_GOC = $(am__v_GOC_@AM_V@)
+am__v_GOC_ = $(am__v_GOC_@AM_DEFAULT_V@)
+am__v_GOC_0 = @echo "  GOC     " $@;
+am__v_GOC_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_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_1 = 
+AM_V_JAVAC = $(am__v_JAVAC_@AM_V@)
+am__v_JAVAC_ = $(am__v_JAVAC_@AM_DEFAULT_V@)
+am__v_JAVAC_0 = @echo "  JAVAC   " $@;
+am__v_JAVAC_1 = 
 repeats = 10
 max_time = 600

src/Common/Stats/Time.h

@@ -9 +9 @@
 // Author           : Thierry Delisle
 // Created On       : Fri Mar 01 15:14:11 2019
-// Last Modified By :
+// Last Modified By : Andrew Beach
 // Last Modified On :
 // Update Count     :
@@ -41 +41 @@
                                 f();
                         }
+
+                        template<typename ret_t = void, typename func_t, typename... arg_t>
+                        inline ret_t TimeCall(
+                                        const char *, func_t func, arg_t&&... arg) {
+                                return func(std::forward<arg_t>(arg)...);
+                        }
 #               else
                         void StartGlobal();
@@ -59 +65 @@
                                 func();
                         }
+
+                        template<typename ret_t = void, typename func_t, typename... arg_t>
+                        inline ret_t TimeCall(
+                                        const char * name, func_t func, arg_t&&... arg) {
+                                BlockGuard guard(name);
+                                return func(std::forward<arg_t>(arg)...);
+                        }
 #               endif
         }

src/Concurrency/Keywords.cc

@@ -716 +716 @@
                                 new UntypedExpr(
                                         new NameExpr( "__thrd_start" ),
-                                        { new VariableExpr( param ) }
+                                        { new VariableExpr( param ), new NameExpr("main") }
                                 )
                         )

src/Concurrency/Waitfor.cc

@@ -11 +11 @@
 // Last Modified By :
 // Last Modified On :
-// Update Count     : 11
+// Update Count     : 12
 //
 
@@ -42 +42 @@
 void foo() {
         while( true ) {
-                when( a < 1 ) waitfor( f, a ) { bar(); }
+                when( a < 1 ) waitfor( f : a ) { bar(); }
                 or timeout( swagl() );
-                or waitfor( g, a ) { baz(); }
-                or waitfor( ^?{}, a ) { break; }
+                or waitfor( g : a ) { baz(); }
+                or waitfor( ^?{} : a ) { break; }
                 or waitfor( ^?{} ) { break; }
         }

src/ControlStruct/LabelFixer.cc

@@ -9 +9 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Mar 11 22:26:02 2019
-// Update Count     : 159
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue Jan 21 10:32:00 2020
+// Update Count     : 160
 //
 
@@ -21 +21 @@
 #include "ControlStruct/LabelGenerator.h"  // for LabelGenerator
 #include "LabelFixer.h"
-#include "MLEMutator.h"                    // for MLEMutator
+#include "MLEMutator.h"                    // for MultiLevelExitMutator
 #include "SynTree/Declaration.h"           // for FunctionDecl
 #include "SynTree/Expression.h"            // for NameExpr, Expression, Unty...
@@ -44 +44 @@
 
         void LabelFixer::postvisit( FunctionDecl * functionDecl ) {
-                PassVisitor<MLEMutator> mlemut( resolveJumps(), generator );
-                functionDecl->acceptMutator( mlemut );
+                PassVisitor<MultiLevelExitMutator> mlem( resolveJumps(), generator );
+                // We start in the body so we can stop when we hit another FunctionDecl.
+                maybeMutate( functionDecl->statements, mlem );
         }
 
@@ -75 +76 @@
 
 
-        // sets the definition of the labelTable entry to be the provided statement for every label in the list
-        // parameter. Happens for every kind of statement
+        // Sets the definition of the labelTable entry to be the provided statement for every label in
+        // the list parameter. Happens for every kind of statement.
         Label LabelFixer::setLabelsDef( std::list< Label > & llabel, Statement * definition ) {
                 assert( definition != 0 );
                 assert( llabel.size() > 0 );
-
-                Entry * e = new Entry( definition );
 
                 for ( std::list< Label >::iterator i = llabel.begin(); i != llabel.end(); i++ ) {
@@ -87 +86 @@
                         l.set_statement( definition ); // attach statement to the label to be used later
                         if ( labelTable.find( l ) == labelTable.end() ) {
-                                // all labels on this statement need to use the same entry, so this should only be created once
+                                // All labels on this statement need to use the same entry,
+                                // so this should only be created once.
                                 // undefined and unused until now, add an entry
-                                labelTable[ l ] =  e;
+                                labelTable[ l ] = new Entry( definition );
                         } else if ( labelTable[ l ]->defined() ) {
                                 // defined twice, error
-                                SemanticError( l.get_statement()->location, "Duplicate definition of label: " + l.get_name() );
-                        }       else {
+                                SemanticError( l.get_statement()->location,
+                                        "Duplicate definition of label: " + l.get_name() );
+                        } else {
                                 // used previously, but undefined until now -> link with this entry
+                                // Question: Is changing objects important?
                                 delete labelTable[ l ];
-                                labelTable[ l ] = e;
+                                labelTable[ l ] = new Entry( definition );
                         } // if
                 } // for
 
-                // produce one of the labels attached to this statement to be temporarily used as the canonical label
+                // Produce one of the labels attached to this statement to be temporarily used as the
+                // canonical label.
                 return labelTable[ llabel.front() ]->get_label();
         }

src/ControlStruct/MLEMutator.cc

@@ -9 +9 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Oct 22 17:22:44 2019
-// Update Count     : 220
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Jan 22 11:50:00 2020
+// Update Count     : 223
 //
 
@@ -33 +33 @@
 
 namespace ControlStruct {
-        MLEMutator::~MLEMutator() {
+        MultiLevelExitMutator::~MultiLevelExitMutator() {
                 delete targetTable;
                 targetTable = 0;
         }
         namespace {
-                bool isLoop( const MLEMutator::Entry & e ) { return dynamic_cast< WhileStmt * >( e.get_controlStructure() ) || dynamic_cast< ForStmt * >( e.get_controlStructure() ); }
-                bool isSwitch( const MLEMutator::Entry & e ) { return dynamic_cast< SwitchStmt *>( e.get_controlStructure() ); }
-
-                bool isBreakTarget( const MLEMutator::Entry & e ) { return isLoop( e ) || isSwitch( e ) || dynamic_cast< CompoundStmt *>( e.get_controlStructure() ); }
-                bool isContinueTarget( const MLEMutator::Entry & e ) { return isLoop( e ); }
-                bool isFallthroughTarget( const MLEMutator::Entry & e ) { return dynamic_cast< CaseStmt *>( e.get_controlStructure() );; }
-                bool isFallthroughDefaultTarget( const MLEMutator::Entry & e ) { return isSwitch( e ); }
+                bool isLoop( const MultiLevelExitMutator::Entry & e ) {
+                        return dynamic_cast< WhileStmt * >( e.get_controlStructure() )
+                                || dynamic_cast< ForStmt * >( e.get_controlStructure() );
+                }
+                bool isSwitch( const MultiLevelExitMutator::Entry & e ) {
+                        return dynamic_cast< SwitchStmt *>( e.get_controlStructure() );
+                }
+
+                bool isBreakTarget( const MultiLevelExitMutator::Entry & e ) {
+                        return isLoop( e ) || isSwitch( e )
+                                || dynamic_cast< CompoundStmt *>( e.get_controlStructure() );
+                }
+                bool isContinueTarget( const MultiLevelExitMutator::Entry & e ) {
+                        return isLoop( e );
+                }
+                bool isFallthroughTarget( const MultiLevelExitMutator::Entry & e ) {
+                        return dynamic_cast< CaseStmt *>( e.get_controlStructure() );
+                }
+                bool isFallthroughDefaultTarget( const MultiLevelExitMutator::Entry & e ) {
+                        return isSwitch( e );
+                }
         } // namespace
+
+        void MultiLevelExitMutator::premutate( FunctionDecl * ) {
+                visit_children = false;
+        }
 
         // break labels have to come after the statement they break out of, so mutate a statement, then if they inform us
         // through the breakLabel field tha they need a place to jump to on a break statement, add the break label to the
         // body of statements
-        void MLEMutator::fixBlock( std::list< Statement * > &kids, bool caseClause ) {
+        void MultiLevelExitMutator::fixBlock( std::list< Statement * > &kids, bool caseClause ) {
                 SemanticErrorException errors;
 
@@ -81 +99 @@
         }
 
-        void MLEMutator::premutate( CompoundStmt *cmpndStmt ) {
+        void MultiLevelExitMutator::premutate( CompoundStmt *cmpndStmt ) {
                 visit_children = false;
                 bool labeledBlock = !(cmpndStmt->labels.empty());
@@ -118 +136 @@
                         }
                 }
-                assertf( false, "Could not find label '%s' on statement %s", originalTarget.get_name().c_str(), toString( stmt ).c_str() );
-        }
-
-
-        Statement *MLEMutator::postmutate( BranchStmt *branchStmt ) throw ( SemanticErrorException ) {
+                assertf( false, "Could not find label '%s' on statement %s",
+                        originalTarget.get_name().c_str(), toString( stmt ).c_str() );
+        }
+
+
+        Statement *MultiLevelExitMutator::postmutate( BranchStmt *branchStmt )
+                        throw ( SemanticErrorException ) {
                 std::string originalTarget = branchStmt->originalTarget;
 
@@ -230 +250 @@
         }
 
-        Statement *MLEMutator::mutateLoop( Statement *bodyLoop, Entry &e ) {
+        Statement *MultiLevelExitMutator::mutateLoop( Statement *bodyLoop, Entry &e ) {
                 // only generate these when needed
                 if( !e.isContUsed() && !e.isBreakUsed() ) return bodyLoop;
@@ -253 +273 @@
 
         template< typename LoopClass >
-        void MLEMutator::prehandleLoopStmt( LoopClass * loopStmt ) {
+        void MultiLevelExitMutator::prehandleLoopStmt( LoopClass * loopStmt ) {
                 // remember this as the most recent enclosing loop, then mutate the body of the loop -- this will determine
                 // whether brkLabel and contLabel are used with branch statements and will recursively do the same to nested
@@ -264 +284 @@
 
         template< typename LoopClass >
-        Statement * MLEMutator::posthandleLoopStmt( LoopClass * loopStmt ) {
+        Statement * MultiLevelExitMutator::posthandleLoopStmt( LoopClass * loopStmt ) {
                 assert( ! enclosingControlStructures.empty() );
                 Entry &e = enclosingControlStructures.back();
@@ -275 +295 @@
         }
 
-        void MLEMutator::premutate( WhileStmt * whileStmt ) {
+        void MultiLevelExitMutator::premutate( WhileStmt * whileStmt ) {
                 return prehandleLoopStmt( whileStmt );
         }
 
-        void MLEMutator::premutate( ForStmt * forStmt ) {
+        void MultiLevelExitMutator::premutate( ForStmt * forStmt ) {
                 return prehandleLoopStmt( forStmt );
         }
 
-        Statement * MLEMutator::postmutate( WhileStmt * whileStmt ) {
+        Statement * MultiLevelExitMutator::postmutate( WhileStmt * whileStmt ) {
                 return posthandleLoopStmt( whileStmt );
         }
 
-        Statement * MLEMutator::postmutate( ForStmt * forStmt ) {
+        Statement * MultiLevelExitMutator::postmutate( ForStmt * forStmt ) {
                 return posthandleLoopStmt( forStmt );
         }
 
-        void MLEMutator::premutate( IfStmt * ifStmt ) {
+        void MultiLevelExitMutator::premutate( IfStmt * ifStmt ) {
                 // generate a label for breaking out of a labeled if
                 bool labeledBlock = !(ifStmt->get_labels().empty());
@@ -301 +321 @@
         }
 
-        Statement * MLEMutator::postmutate( IfStmt * ifStmt ) {
+        Statement * MultiLevelExitMutator::postmutate( IfStmt * ifStmt ) {
                 bool labeledBlock = !(ifStmt->get_labels().empty());
                 if ( labeledBlock ) {
@@ -311 +331 @@
         }
 
-        void MLEMutator::premutate( TryStmt * tryStmt ) {
+        void MultiLevelExitMutator::premutate( TryStmt * tryStmt ) {
                 // generate a label for breaking out of a labeled if
                 bool labeledBlock = !(tryStmt->get_labels().empty());
@@ -321 +341 @@
         }
 
-        Statement * MLEMutator::postmutate( TryStmt * tryStmt ) {
+        Statement * MultiLevelExitMutator::postmutate( TryStmt * tryStmt ) {
                 bool labeledBlock = !(tryStmt->get_labels().empty());
                 if ( labeledBlock ) {
@@ -331 +351 @@
         }
 
-        void MLEMutator::premutate( CaseStmt *caseStmt ) {
+        void MultiLevelExitMutator::premutate( FinallyStmt * ) {
+                GuardAction([this, old = std::move(enclosingControlStructures)]() {
+                        enclosingControlStructures = std::move(old);
+                });
+                enclosingControlStructures = std::list<Entry>();
+                GuardValue( inFinally );
+                inFinally = true;
+        }
+
+        void MultiLevelExitMutator::premutate( ReturnStmt *returnStmt ) {
+                if ( inFinally ) {
+                        SemanticError( returnStmt->location, "'return' may not appear in a finally clause" );
+                }
+        }
+
+        void MultiLevelExitMutator::premutate( CaseStmt *caseStmt ) {
                 visit_children = false;
 
@@ -370 +405 @@
         }
 
-        void MLEMutator::premutate( SwitchStmt *switchStmt ) {
+        void MultiLevelExitMutator::premutate( SwitchStmt *switchStmt ) {
                 // generate a label for breaking out of a labeled switch
                 Label brkLabel = generator->newLabel("switchBreak", switchStmt);
@@ -396 +431 @@
         }
 
-        Statement * MLEMutator::postmutate( SwitchStmt * switchStmt ) {
+        Statement * MultiLevelExitMutator::postmutate( SwitchStmt * switchStmt ) {
                 Entry &e = enclosingControlStructures.back();
                 assert ( e == switchStmt );

src/ControlStruct/MLEMutator.h

@@ -9 +9 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Oct 22 17:22:47 2019
-// Update Count     : 45
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Jan 22 11:50:00 2020
+// Update Count     : 48
 //
 
@@ -30 +30 @@
         class LabelGenerator;
 
-        class MLEMutator : public WithVisitorRef<MLEMutator>, public WithShortCircuiting, public WithGuards {
+        class MultiLevelExitMutator : public WithVisitorRef<MultiLevelExitMutator>,
+                        public WithShortCircuiting, public WithGuards {
           public:
                 class Entry;
-                MLEMutator( std::map<Label, Statement *> *t, LabelGenerator *gen = 0 ) : targetTable( t ), breakLabel(std::string("")), generator( gen ) {}
-                ~MLEMutator();
+                MultiLevelExitMutator( std::map<Label, Statement *> *t, LabelGenerator *gen = 0 ) :
+                        targetTable( t ), breakLabel(std::string("")), generator( gen ) {}
+                ~MultiLevelExitMutator();
+
+                void premutate( FunctionDecl * );
 
                 void premutate( CompoundStmt *cmpndStmt );
@@ -47 +51 @@
                 void premutate( SwitchStmt *switchStmt );
                 Statement * postmutate( SwitchStmt *switchStmt );
+                void premutate( ReturnStmt *returnStmt );
                 void premutate( TryStmt *tryStmt );
                 Statement * postmutate( TryStmt *tryStmt );
+                void premutate( FinallyStmt *finallyStmt );
 
                 Statement *mutateLoop( Statement *bodyLoop, Entry &e );
@@ -110 +116 @@
                 Label breakLabel;
                 LabelGenerator *generator;
+                bool inFinally = false;
 
                 template< typename LoopClass >

src/Parser/lex.ll

@@ -10 +10 @@
  * Created On       : Sat Sep 22 08:58:10 2001
  * Last Modified By : Peter A. Buhr
- * Last Modified On : Sun Aug  4 20:53:47 2019
- * Update Count     : 719
+ * Last Modified On : Sat Feb  1 07:16:44 2020
+ * Update Count     : 724
  */
 
@@ -330 +330 @@
                                 /* identifier */
 {identifier}    { IDENTIFIER_RETURN(); }
-"`"{identifier}"`" {                                                                    // CFA
-        yytext[yyleng - 1] = '\0'; yytext += 1;                         // SKULLDUGGERY: remov