Changes in / [bdfc032:aefb247]

Files:

• benchmark/Makefile.am (modified) (10 diffs)
• benchmark/Makefile.in (modified) (9 diffs)
• benchmark/basic/fetch_add.c (deleted)
• benchmark/basic/function.c (deleted)
• benchmark/basic/loop.c (deleted)
• benchmark/basic/tls_fetch_add.c (deleted)
• benchmark/basic/ttst_lock.c (deleted)
• 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 (deleted)
• benchmark/creation/cfa_thrd.cfa (modified) (1 diff)
• benchmark/creation/goroutine.go (modified) (2 diffs)
• benchmark/creation/node_cor.js (deleted)
• benchmark/creation/pthreads.c (modified) (3 diffs)
• benchmark/creation/python_cor.py (deleted)
• benchmark/creation/rust_thrd.rs (deleted)
• 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 (deleted)
• benchmark/ctxswitch/node_cor.js (deleted)
• benchmark/ctxswitch/pthreads.c (modified) (1 diff)
• benchmark/ctxswitch/python_cor.py (deleted)
• benchmark/ctxswitch/rust_thrd.rs (deleted)
• benchmark/ctxswitch/upp_cor.cc (modified) (2 diffs)
• benchmark/ctxswitch/upp_thrd.cc (modified) (1 diff)
• benchmark/exclude (deleted)
• benchmark/fetch_add.c (added)
• benchmark/function.c (added)
• benchmark/loop.c (added)
• 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 (deleted)
• benchmark/mutex/pthreads.c (modified) (1 diff)
• benchmark/mutex/rust.rs (deleted)
• benchmark/mutex/upp.cc (modified) (1 diff)
• benchmark/mutexC/JavaThread.java (deleted)
• benchmark/mutexC/cfa1.cfa (deleted)
• benchmark/mutexC/cfa2.cfa (deleted)
• benchmark/mutexC/cfa4.cfa (deleted)
• benchmark/mutexC/pthreads.c (deleted)
• benchmark/mutexC/rust.rs (deleted)
• benchmark/mutexC/upp.cc (deleted)
• 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 (deleted)
• 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 (deleted)
• benchmark/schedint/upp.cc (modified) (2 diffs)
• benchmark/tls-fetch_add.c (added)
• benchmark/ttst_lock.c (added)
• 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 (added)
• tests/except-1.cfa (added)
• tests/except-2.cfa (added)
• tests/except-3.cfa (added)
• tests/except-mac.hfa (added)
• tests/exceptions/.expect/finally-error.txt (deleted)
• tests/exceptions/except-0.cfa (deleted)
• tests/exceptions/except-1.cfa (deleted)
• tests/exceptions/except-2.cfa (deleted)
• tests/exceptions/except-3.cfa (deleted)
• tests/exceptions/except-mac.hfa (deleted)
• tests/exceptions/finally-error.cfa (deleted)
• 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 : Sat Jan 25 09:20:44 2020
-## Update Count     : 255
+## Last Modified On : Mon Jul 29 18:02:19 2019
+## Update Count     : 54
 ###############################################################################
 
@@ -28 +28 @@
 BENCH_V_CFA = $(__bench_v_CFA_$(__quiet))
 BENCH_V_CXX = $(__bench_v_CXX_$(__quiet))
+BENCH_V_GOC = $(__bench_v_GOC_$(__quiet))
+BENCH_V_JAVAC = $(__bench_v_JAVAC_$(__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))
 
 __quiet = verbose
@@ -38 +36 @@
 __bench_v_CFA_quiet = @
 __bench_v_CXX_quiet = @
+__bench_v_GOC_quiet = @
+__bench_v_JAVAC_quiet = @
 __bench_v_UPP_quiet = @
-__bench_v_GOC_quiet = @
-__bench_v_RUSTC_quiet = @
-__bench_v_JAVAC_quiet = @
 __bench_v_CC_verbose = $(AM_V_CC)
 __bench_v_CFA_verbose = $(AM_V_CFA)
 __bench_v_CXX_verbose = $(AM_V_CXX)
+__bench_v_GOC_verbose = $(AM_V_GOC)
+__bench_v_JAVAC_verbose = $(AM_V_JAVAC)
 __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)
 
 
@@ -56 +51 @@
 STATS    = ${abs_top_srcdir}/tools/stat.py
 # NEED AT LEAST 4 DATA VALUES FOR BENCHMARKS BECAUSE THE MAX AND MIN VALUES ARE REMOVED
-repeats  = 13 # 31 for benchmarks
+repeats  = 5 # 31 for benchmarks
 arch     = x64
 skipcompile = no
@@ -67 +62 @@
 
 dummyC.c:
-        echo "int main() { return 0; }" > ${@}
+        @echo "int main() { return 0; }" > ${@}
 
 dummyCXX.cpp:
-        echo "int main() { return 0; }" > ${@}
-
-#.SILENT:               # do not print recipe
-.ONESHELL:              # use one shell to execute recipe
+        @echo "int main() { return 0; }" > ${@}
+
 .NOTPARALLEL:
-.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
+.PHONY: compile.csv ctxswitch.csv mutex.csv signal.csv
+
+## =========================================================================================================
+all : ctxswitch$(EXEEXT) mutex$(EXEEXT) signal$(EXEEXT) waitfor$(EXEEXT) creation$(EXEEXT)
 
 %.run : %$(EXEEXT) ${REPEAT}
-        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
+        @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
 
 %.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
 
 ## =========================================================================================================
@@ -144 +100 @@
 jenkins$(EXEEXT):
 @DOifskipcompile@
-        +make compile.csv
-        -+make compile.diff.csv
+        @+make compile.csv
+        @-+make compile.diff.csv
 @DOendif@
-        +make basic.csv
-        -+make basic.diff.csv
-        +make ctxswitch.csv
-        -+make ctxswitch.diff.csv
-        +make mutex.csv
-        -+make mutex.diff.csv
-        +make schedint.csv
-        -+make schedint.diff.csv
+        @+make ctxswitch.csv
+        @-+make ctxswitch.diff.csv
+        @+make mutex.csv
+        @-+make mutex.diff.csv
+        @+make signal.csv
+        @-+make signal.diff.csv
 @DOifskipcompile@
         cat compile.csv
         -cat compile.diff.csv
 @DOendif@
-        cat basic.csv
-        -cat basic.diff.csv
         cat ctxswitch.csv
         -cat ctxswitch.diff.csv
         cat mutex.csv
         -cat mutex.diff.csv
-        cat schedint.csv
-        -cat schedint.diff.csv
+        cat signal.csv
+        -cat signal.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 $@
-
-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 $@
+        @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 $@
 
 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 $@
-
-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 $@
+        @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 $@
 
 %.diff.csv: %.csv
-        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  =                     \
+        @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           \
         ctxswitch-cfa_generator.run     \
         ctxswitch-cfa_coroutine.run     \
@@ -247 +188 @@
         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
+        ctxswitch-goroutine.run         \
+        ctxswitch-java_thread.run
+
 
 if WITH_LIBFIBRE
-CTXSWITCH_DEPEND  +=                    \
-        ctxswitch-kos_fibre.run         \
+CTXSWITCH_DEPEND  +=           \
+        ctxswitch-kos_fibre.run  \
         ctxswitch-kos_fibre2.run
+
 
 ctxswitch-kos_fibre$(EXEEXT):
@@ -270 +207 @@
 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) $(srcdir)/ctxswitch/cfa_gen.cfa
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_gen.cfa
 
 ctxswitch-cfa_coroutine$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/ctxswitch/cfa_cor.cfa
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_cor.cfa
 
 ctxswitch-cfa_thread$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/ctxswitch/cfa_thrd.cfa
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_thrd.cfa
 
 ctxswitch-cfa_thread2$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/ctxswitch/cfa_thrd2.cfa
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_thrd2.cfa
 
 ctxswitch-upp_coroutine$(EXEEXT):
-        $(BENCH_V_UPP)$(UPPCOMPILE) $(srcdir)/ctxswitch/upp_cor.cc
+        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/upp_cor.cc
 
 ctxswitch-upp_thread$(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_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/upp_thrd.cc
+
+ctxswitch-goroutine$(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
-
-ctxswitch-pthread$(EXEEXT):
-        $(BENCH_V_CC)$(COMPILE) $(srcdir)/ctxswitch/pthreads.c
-
-## =========================================================================================================
-
-mutex$(EXEEXT) :                \
+        @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           \
         mutex-cfa1.run          \
         mutex-cfa2.run          \
         mutex-cfa4.run          \
-        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-java_thread.run
+
+mutex-pthread_lock$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE)    -DBENCH_N=50000000 $(srcdir)/mutex/pthreads.c
+
+mutex-upp$(EXEEXT):
+        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/mutex/upp.cc
 
 mutex-cfa1$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/mutex/cfa1.cfa
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=5000000  $(srcdir)/mutex/cfa1.cfa
 
 mutex-cfa2$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/mutex/cfa2.cfa
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=5000000  $(srcdir)/mutex/cfa2.cfa
 
 mutex-cfa4$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/mutex/cfa4.cfa
-
-mutex-upp$(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_CFA)$(CFACOMPILE) -DBENCH_N=5000000  $(srcdir)/mutex/cfa4.cfa
+
+mutex-java_thread$(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
-
-## =========================================================================================================
-
-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):
+        @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):
         $(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
-
-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              \
+        @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                    \
         creation-cfa_coroutine.run              \
         creation-cfa_coroutine_eager.run        \
@@ -426 +328 @@
         creation-upp_coroutine.run              \
         creation-upp_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-goroutine.run                  \
+        creation-java_thread.run
 
 creation-cfa_coroutine$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/creation/cfa_cor.cfa
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=10000000 $(srcdir)/creation/cfa_cor.cfa
 
 creation-cfa_coroutine_eager$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/creation/cfa_cor.cfa  -DEAGER
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=10000000 $(srcdir)/creation/cfa_cor.cfa  -DEAGER
 
 creation-cfa_thread$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/creation/cfa_thrd.cfa
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=10000000 $(srcdir)/creation/cfa_thrd.cfa
 
 creation-upp_coroutine$(EXEEXT):
-        $(BENCH_V_UPP)$(UPPCOMPILE) $(srcdir)/creation/upp_cor.cc
+        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/creation/upp_cor.cc
 
 creation-upp_thread$(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_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_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
-
-creation-pthread$(EXEEXT):
-        $(BENCH_V_CC)$(COMPILE) $(srcdir)/creation/pthreads.c
-
-## =========================================================================================================
-
-compile$(EXEEXT) :              \
+        @echo "#!/bin/sh" > a.out
+        @echo "java JavaThread" >> a.out
+        @chmod a+x a.out
+
+## =========================================================================================================
+
+compile$(EXEEXT) :\
         compile-array.make      \
         compile-attributes.make \
@@ -488 +370 @@
         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)
@@ -364 +372 @@
 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
@@ -388 +380 @@
 BENCH_V_CFA = $(__bench_v_CFA_$(__quiet))
 BENCH_V_CXX = $(__bench_v_CXX_$(__quiet))
+BENCH_V_GOC = $(__bench_v_GOC_$(__quiet))
+BENCH_V_JAVAC = $(__bench_v_JAVAC_$(__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))
 __quiet = verbose
 __bench_v_CC_quiet = @
 __bench_v_CFA_quiet = @
 __bench_v_CXX_quiet = @
+__bench_v_GOC_quiet = @
+__bench_v_JAVAC_quiet = @
 __bench_v_UPP_quiet = @
-__bench_v_GOC_quiet = @
-__bench_v_RUSTC_quiet = @
-__bench_v_JAVAC_quiet = @
 __bench_v_CC_verbose = $(AM_V_CC)
 __bench_v_CFA_verbose = $(AM_V_CFA)
 __bench_v_CXX_verbose = $(AM_V_CXX)
+__bench_v_GOC_verbose = $(AM_V_GOC)
+__bench_v_JAVAC_verbose = $(AM_V_JAVAC)
 __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)
 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 = 13 # 31 for benchmarks
+repeats = 5 # 31 for benchmarks
 arch = x64
 skipcompile = no
@@ -419 +406 @@
 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" > $@
-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)
+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)
 testdir = $(top_srcdir)/tests
 all: all-am
@@ -779 +732 @@
 
 dummyC.c:
-        echo "int main() { return 0; }" > ${@}
+        @echo "int main() { return 0; }" > ${@}
 
 dummyCXX.cpp:
-        echo "int main() { return 0; }" > ${@}
-
-#.SILENT:               # do not print recipe
-.ONESHELL:              # use one shell to execute recipe
+        @echo "int main() { return 0; }" > ${@}
+
 .NOTPARALLEL:
-.PHONY: compile.csv basic.csv ctxswitch.csv mutex.csv schedint.csv
-
-all : basic$(EXEEXT) ctxswitch$(EXEEXT) mutex$(EXEEXT) schedint$(EXEEXT) schedext$(EXEEXT) creation$(EXEEXT)
+.PHONY: compile.csv ctxswitch.csv mutex.csv signal.csv
+
+all : ctxswitch$(EXEEXT) mutex$(EXEEXT) signal$(EXEEXT) waitfor$(EXEEXT) creation$(EXEEXT)
 
 %.run : %$(EXEEXT) ${REPEAT}
-        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
+        @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
 
 %.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 basic.csv
-        -+make basic.diff.csv
-        +make ctxswitch.csv
-        -+make ctxswitch.diff.csv
-        +make mutex.csv
-        -+make mutex.diff.csv
-        +make schedint.csv
-        -+make schedint.diff.csv
+        @+make ctxswitch.csv
+        @-+make ctxswitch.diff.csv
+        @+make mutex.csv
+        @-+make mutex.diff.csv
+        @+make signal.csv
+        @-+make signal.diff.csv
 @DOifskipcompile@
         cat compile.csv
         -cat compile.diff.csv
 @DOendif@
-        cat basic.csv
-        -cat basic.diff.csv
         cat ctxswitch.csv
         -cat ctxswitch.diff.csv
         cat mutex.csv
         -cat mutex.diff.csv
-        cat schedint.csv
-        -cat schedint.diff.csv
+        cat signal.csv
+        -cat signal.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 $@
-
-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 $@
+        @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 $@
 
 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 $@
-
-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 $@
+        @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 $@
 
 %.diff.csv: %.csv
-        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)
+        @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
 
 @WITH_LIBFIBRE_TRUE@ctxswitch-kos_fibre$(EXEEXT):
@@ -912 +845 @@
 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) $(srcdir)/ctxswitch/cfa_gen.cfa
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_gen.cfa
 
 ctxswitch-cfa_coroutine$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/ctxswitch/cfa_cor.cfa
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_cor.cfa
 
 ctxswitch-cfa_thread$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/ctxswitch/cfa_thrd.cfa
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_thrd.cfa
 
 ctxswitch-cfa_thread2$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/ctxswitch/cfa_thrd2.cfa
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_thrd2.cfa
 
 ctxswitch-upp_coroutine$(EXEEXT):
-        $(BENCH_V_UPP)$(UPPCOMPILE) $(srcdir)/ctxswitch/upp_cor.cc
+        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/upp_cor.cc
 
 ctxswitch-upp_thread$(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_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/upp_thrd.cc
+
+ctxswitch-goroutine$(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
-
-ctxswitch-pthread$(EXEEXT):
-        $(BENCH_V_CC)$(COMPILE) $(srcdir)/ctxswitch/pthreads.c
-
-mutex$(EXEEXT) :                \
+        @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           \
         mutex-cfa1.run          \
         mutex-cfa2.run          \
         mutex-cfa4.run          \
-        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-java_thread.run
+
+mutex-pthread_lock$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE)    -DBENCH_N=50000000 $(srcdir)/mutex/pthreads.c
+
+mutex-upp$(EXEEXT):
+        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/mutex/upp.cc
 
 mutex-cfa1$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/mutex/cfa1.cfa
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=5000000  $(srcdir)/mutex/cfa1.cfa
 
 mutex-cfa2$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/mutex/cfa2.cfa
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=5000000  $(srcdir)/mutex/cfa2.cfa
 
 mutex-cfa4$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/mutex/cfa4.cfa
-
-mutex-upp$(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_CFA)$(CFACOMPILE) -DBENCH_N=5000000  $(srcdir)/mutex/cfa4.cfa
+
+mutex-java_thread$(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
-
-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):
+        @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):
         $(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
-
-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              \
+        @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                    \
         creation-cfa_coroutine.run              \
         creation-cfa_coroutine_eager.run        \
@@ -1059 +961 @@
         creation-upp_coroutine.run              \
         creation-upp_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-goroutine.run                  \
+        creation-java_thread.run
 
 creation-cfa_coroutine$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/creation/cfa_cor.cfa
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=10000000 $(srcdir)/creation/cfa_cor.cfa
 
 creation-cfa_coroutine_eager$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/creation/cfa_cor.cfa  -DEAGER
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=10000000 $(srcdir)/creation/cfa_cor.cfa  -DEAGER
 
 creation-cfa_thread$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/creation/cfa_thrd.cfa
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=10000000 $(srcdir)/creation/cfa_thrd.cfa
 
 creation-upp_coroutine$(EXEEXT):
-        $(BENCH_V_UPP)$(UPPCOMPILE) $(srcdir)/creation/upp_cor.cc
+        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/creation/upp_cor.cc
 
 creation-upp_thread$(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_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_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
-
-creation-pthread$(EXEEXT):
-        $(BENCH_V_CC)$(COMPILE) $(srcdir)/creation/pthreads.c
-
-compile$(EXEEXT) :              \
+        @echo "#!/bin/sh" > a.out
+        @echo "java JavaThread" >> a.out
+        @chmod a+x a.out
+
+compile$(EXEEXT) :\
         compile-array.make      \
         compile-attributes.make \
@@ -1120 +1002 @@
 
 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 <stdint.h>                             // uint64_t
-        #include <unistd.h>                             // sysconf
+        #include <unistd.h>                                     // sysconf
 #if ! defined(__cforall)
         #include <time.h>
@@ -16 +15 @@
 
 
-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
+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
 
 #ifndef BENCH_N
-#define BENCH_N 10000000
+#define BENCH_N 500 //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)                \
-        uint64_t StartTime, EndTime;            \
+        size_t n = BENCH_N;                     \
+        if( argc > 2 ) return 1;                \
+        if( argc == 2 ) {                               \
+                n = atoi(argv[1]);              \
+        }                                               \
+        long long int StartTime, EndTime;       \
         StartTime = bench_time();               \
-        statement;                              \
+        statement;                                      \
         EndTime = bench_time();                 \
-        double output = (double)( EndTime - StartTime ) / times;
-
+        double output =         \
+            (double)( EndTime - StartTime ) / n;
 
 #if defined(__cforall)
@@ -47 +53 @@
 }
 #endif
-#if defined(__U_CPLUSPLUS__)
-unsigned int uDefaultPreemption() {
-        return 0;
-}
-#endif

benchmark/creation/JavaThread.java

@@ -26 +26 @@
         static int x = 2;
 
-        static private int times = Integer.parseInt("10000") ;
+        static private final int NoOfTimes = Integer.parseInt("10000") ;
 
         public static class MyThread extends Thread {
@@ -33 +33 @@
         }
         public static void helper() throws InterruptedException {
-                for(int i = 1; i <= times; i += 1) {
+                for(int i = 1; i <= NoOfTimes; i += 1) {
                         MyThread m = new MyThread();
                         x = nextRandom( x );
@@ -44 +44 @@
                 helper();
                 long end = System.nanoTime();
-                System.out.println( (end - start) / times );
+                System.out.println( (end - start) / NoOfTimes );
         }
         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 i = Integer.parseInt("5"); --i >= 0 ; ) { 
+                for (int n = Integer.parseInt("5"); --n >= 0 ; ) { 
                         InnerMain();
-                        Thread.sleep(2000);             // 2 seconds
+                        Thread.sleep(2000);     // 2 seconds
                         x = nextRandom(x);
                 }
@@ -58 +55 @@
         }
 }
-
-// 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[] ) {
-        BENCH_START()
+int main(int argc, char* argv[]) {
         BENCH(
-                for ( times ) {
-                        MyCoroutine c;
+                for ( i; n ) {
+                        MyCoroutine m;
                 },
                 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[] ) {
-        BENCH_START()
+int main(int argc, char* argv[]) {
         BENCH(
-                for ( times ) {
+                for ( i; n ) {
                         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"
-        "os"
-        "strconv"
+    "fmt"
+    "time"
 )
 
@@ -19 +17 @@
 
 func main() {
-        var times int = 10000000
-        if len( os.Args ) > 2 { os.Exit( 1 ) }
-        if len( os.Args ) == 2 { times, _ = strconv.Atoi(os.Args[1]) }
-
+        const NoOfTimes = 500000
         start := time.Now()
-        for i := 1; i <= times; i += 1 {
+        for i := 1; i <= NoOfTimes; i += 1 {
                 go noop()               // creation
-                <- shake                // wait for completion
         }
         end := time.Now()
-        fmt.Printf( "%d\n", end.Sub(start) / time.Duration(times) )
+        fmt.Printf("%d\n", end.Sub(start) / time.Duration(NoOfTimes))
+        <- shake
 }
-
-// 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[] ) {
-        BENCH_START()
+int main(int argc, char* argv[]) {
         BENCH(
-                for (size_t i = 0; i < times; i++) {
+                for (size_t i = 0; i < n; i++) {
                         pthread_t thread;
                         if (pthread_create(&thread, NULL, foo, NULL) < 0) {
@@ -17 +16 @@
                                 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[] ) {
-        BENCH_START()
+int main(int argc, char* argv[]) {
         BENCH(
-                for (size_t i = 0; i < times; i++) {
+                for (size_t i = 0; i < n; 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[] ) {
-        BENCH_START()
+int main(int argc, char* argv[]) {
         BENCH(
-                for (size_t i = 0; i < times; i++) {
+                for (size_t i = 0; i < n; 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 int times = Integer.parseInt("100000");
+        static private final int NoOfTimes = Integer.parseInt("1000000") ;
 
         public static void helper() {
-                for(int i = 1; i <= times; i += 1) {
+                for(int i = 1; i <= NoOfTimes; i += 1) {
                         Thread.yield();
                 }
@@ -37 +37 @@
                 helper();
                 long end = System.nanoTime();
-                System.out.println( (end - start) / times );
+                System.out.println( (end - start) / NoOfTimes );
         }
         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 i = Integer.parseInt("5"); --i >= 0 ; ) {
+                for (int n = Integer.parseInt("5"); --n >= 0 ; ) { 
                         InnerMain();
-                        Thread.sleep(2000);     // 2 seconds
+                        Thread.sleep(2000);     // 2 seconds
                         x = nextRandom(x);
                 }
@@ -51 +48 @@
         }
 }
-
-// Local Variables: //
-// tab-width: 4 //
-// End: //

benchmark/ctxswitch/cfa_cor.cfa

@@ -4 +4 @@
 #include "bench.h"
 
-coroutine C {} c;
-void main( __attribute__((unused)) C & ) {
-        while () {
+coroutine GreatSuspender {};
+
+void ?{}( GreatSuspender & this ) {
+        prime(this);
+}
+
+void main( __attribute__((unused)) GreatSuspender & this ) {
+        while( true ) {
                 suspend();
         }
 }
-int main( int argc, char * argv[] ) {
-        BENCH_START()
+
+int main(int argc, char* argv[]) {
+        GreatSuspender s;
+
         BENCH(
-                for ( times ) {
-                        resume( c );
+                for ( i; n ) {
+                        resume( s );
                 },
                 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 C {} c;
+coroutine GreatSuspender {};
 
-void ?{}( C & this ) {
+void ?{}( GreatSuspender & this ) {
         prime(this);
 }
 
-void main( __attribute__((unused)) C & this ) {
-        while () {
+void main( __attribute__((unused)) GreatSuspender & this ) {
+        while( true ) {
                 suspend_then(noOp);
         }
 }
 
-int main( int argc, char * argv[] ) {
-        BENCH_START()
+int main(int argc, char* argv[]) {
+        GreatSuspender s;
+
         BENCH(
-                for ( times ) {
-                        resume( c );
+                for ( i; n ) {
+                        resume( s );
                 },
                 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;
-} C;
+} GreatSuspender;
 
-void comain( C * c ) {
-        if ( __builtin_expect(c->next != 0, 1) ) goto *(c->next);
-        c->next = &&s1;
+void comain( GreatSuspender * this ) {
+    if ( __builtin_expect(this->next != 0, 1) ) goto *(this->next);
+    this->next = &&s1;
         for () {
-                return;
+            return;
           s1: ;
         }
 }
 
-int main( int argc, char * argv[] ) {
-        BENCH_START()
-        C c = { 0 };
+int main(int argc, char* argv[]) {
+    GreatSuspender s = { 0 };
+
         BENCH(
-                for ( times ) {
-                        comain( &c );
+                for ( i; n ) {
+                        comain( &s );
                 },
                 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[] ) {
-        BENCH_START()
+int main(int argc, char* argv[]) {
         BENCH(
-                for ( times ) {
+                for ( i; n ) {
                         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[] ) {
-        BENCH_START()
+int main(int argc, char* argv[]) {
         Fibre f1;
         BENCH(
-                for ( times ) {
+                for ( i; n ) {
                         yield();
                 },
                 result
         )
-        printf( "%g\n", result );
+
+        printf("%g\n", result);
         done = true;
+        return 0;
 }
-
-// Local Variables: //
-// tab-width: 4 //
-// End: //

benchmark/ctxswitch/goroutine.go

@@ -2 +2 @@
 
 import (
-        "fmt"
-        "time"
-        "os"
-        "strconv"
-        "runtime"
+    "fmt"
+    "runtime"
+    "time"
 )
 
@@ -30 +28 @@
 
 func main() {
-        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
+        const NoOfTimes = 10000000
+        go ContextSwitch( NoOfTimes )           // 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[] ) {
-        BENCH_START()
+int main(int argc, char* argv[]) {
         BENCH(
-                for (size_t i = 0; i < times; i++) {
+                for (size_t i = 0; i < n; i++) {
                         Fibre::yield();
                 },
                 result
         )
-        printf( "%g\n", result );
+        printf("%g\n", result);
+        return 0;
 }
-
-// Local Variables: //
-// tab-width: 4 //
-// End: //

benchmark/ctxswitch/kos_fibre2.cpp

@@ -11 +11 @@
 }
 
-int main( int argc, char * argv[] ) {
-        BENCH_START()
+int main(int argc, char* argv[]) {
         Fibre* f1 = (new Fibre)->run(f1main);
         BENCH(
-                for (size_t i = 0; i < times; i++) {
+                for (size_t i = 0; i < n; 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[] ) {
-        BENCH_START()
+int main(int argc, char* argv[]) {
         BENCH(
-                for (size_t i = 0; i < times; i++) {
+                for (size_t i = 0; i < n; i++) {
                         sched_yield();
                 },
                 result
         )
-        printf( "%g\n", result );
+
+        printf("%g\n", result);
 }

benchmark/ctxswitch/upp_cor.cc

@@ -3 +3 @@
 #include "bench.h"
 
-_Coroutine C {
+_Coroutine GreatSuspender {
+public:
+        GreatSuspender() {
+                resume();
+        }
+
+        void do_resume() {
+                resume();
+        }
+private:
         void main() {
                 while( true ) {
@@ -9 +18 @@
                 }
         }
-  public:
-        void do_resume() {
-                resume();
-        }
-} c;
-int main( int argc, char * argv[] ) {
-        BENCH_START()
+};
+
+int main(int argc, char* argv[]) {
+        GreatSuspender s;
+
         BENCH(
-                for (size_t i = 0; i < times; i++) {
-                        c.do_resume();
+                for (size_t i = 0; i < n; i++) {
+                        s.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[] ) {
-        BENCH_START()
+int main(int argc, char* argv[]) {
         BENCH(
-                for (size_t i = 0; i < times; i++) {
+                for (size_t i = 0; i < n; 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 int times = Integer.parseInt("100000000");
+        static private final int NoOfTimes = Integer.parseInt("100000000") ;
 
         public synchronized void noop() {
@@ -35 +35 @@
                 // Inhibit biased locking ...
                 x = (j.hashCode() ^ System.identityHashCode(j)) | 1 ;     
-                for(int i = 1; i <= times; i += 1) {
+                for(int i = 1; i <= NoOfTimes; i += 1) {
                         x = nextRandom(x);
                         j.noop();
@@ -44 +44 @@
                 helper();
                 long end = System.nanoTime();
-                System.out.println( (end - start) / times );
+                System.out.println( (end - start) / NoOfTimes );
         }
         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();
@@ -58 +55 @@
         }
 }
-
-// Local Variables: //
-// tab-width: 4 //
-// End: //

benchmark/mutex/cfa1.cfa

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

benchmark/schedext/cfa2.cfa

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

benchmark/schedext/cfa4.cfa

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

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);
-                }
+
+        int __attribute__((noinline)) wait() {
+                go = 1;
+                BENCH(
+                        for (size_t i = 0; i < n; i++) {
+                                _Accept(call);
+                        },
+                        result
+                )
+
+                printf("%g\n", result);
+                go = 0;
+                return 0;
         }
-} m;
+};
+
+M m;
 
 _Task T {
         void main() {
-                BENCH(
-                        for ( size_t i = 0; i < times; i++ ) {
-                                m.call();
-                        },
-                        result
-                )
-                printf( "%g\n", result );
+                while(go == 0) { yield(); }
+                while(go == 1) { m.call(); }
+
         }
 };
 
-int main( int argc, char * argv[] ) {
-        BENCH_START()
+int main(int margc, char* margv[]) {
+        argc = margc;
+        argv = margv;
         T t;
-        m.wait();
+        return m.wait();
 }
-
-// Local Variables: //
-// tab-width: 4 //
-// End: //

benchmark/schedint/JavaThread.java

@@ -49 +49 @@
         static int x = 2;
 
-        static private int times = Integer.parseInt("1000000");
+        static private final int NoOfTimes = Integer.parseInt("1000000") ;
 
         public static void helper( Monitor m ) throws InterruptedException {
-                for(int i = 1; i <= times; i += 1) {
+                for(int i = 1; i <= NoOfTimes; i += 1) {
                         m.wait();               // relase monitor lock
                         m.next = true;
@@ -63 +63 @@
                 synchronized(m) {
                         s.start();
-                        while( ! Monitor.go ) { // waiter must start first
+                        while( !Monitor.go ) {
                                 Thread.yield();
                         }
@@ -72 +72 @@
                 Monitor.go = false;
                 s.join();
-                System.out.println( (end - start) / times);
+                System.out.println( (end - start) / NoOfTimes);
         }
         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();
@@ -86 +83 @@
         }
 }
-
-// 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 {} m1;
+monitor M {};
+M m1;
 
-void __attribute__((noinline)) call( M & mutex p1 ) {
-        signal( c );
+void __attribute__((noinline)) call( M & mutex a1 ) {
+        signal(c);
 }
-void __attribute__((noinline)) wait( M & mutex p1 ) {
+
+int  __attribute__((noinline)) wait( M & mutex a1 ) {
         go = 1;
-        for ( times ) {
-                wait( c );
-        }
+        BENCH(
+                for ( i; n ) {
+                        wait(c);
+                },
+                result
+        )
+
+        printf("%g\n", result);
+        go = 0;
+        return 0;
 }
 
 thread T {};
+void ^?{}( T & mutex ) {}
 void main( T & ) {
-        while ( go == 0 ) { yield(); } // waiter must start first
-        BENCH(
-                for ( times ) { call( m1 ); },
-                result
-        )
-        printf( "%g\n", result );
+        while(go == 0) { yield(); }
+        while(go == 1) { call(m1); }
+
 }
 
-int main( int argc, char * argv[] ) {
-        BENCH_START()
+int main(__attribute__((unused)) int argc, __attribute__((unused)) char* argv[]) {
         T t;
-        wait( m1 );
+        return 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 {} m1, m2;
+monitor M {};
+M m1, m2;
 
-void __attribute__((noinline)) call( M & mutex p1, M & mutex p2 ) {
-        signal( c );
+void __attribute__((noinline)) call( M & mutex a1, M & mutex a2 ) {
+        signal(c);
 }
-void __attribute__((noinline)) wait( M & mutex p1, M & mutex p2 ) {
+
+int  __attribute__((noinline)) wait( M & mutex a1, M & mutex a2 ) {
         go = 1;
-        for ( times ) {
-                wait( c );
-        }
+        BENCH(
+                for ( i; n ) {
+                        wait(c);
+                },
+                result
+        )
+
+        printf("%g\n", result);
+        go = 0;
+        return 0;
 }
 
 thread T {};
+void ^?{}( T & mutex this ) {}
 void main( T & ) {
-        while ( go == 0 ) { yield(); } // waiter must start first
-        BENCH(
-                for ( times ) { call( m1, m2 ); },
-                result
-        )
-        printf( "%g\n", result );
+        while(go == 0) { yield(); }
+        while(go == 1) { call(m1, m2); }
+
 }
 
-int main( int argc, char * argv[] ) {
-        BENCH_START()
+int main(__attribute__((unused)) int argc, __attribute__((unused)) char* argv[]) {
         T t;
-        wait( m1, m2 );
+        return 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 {} m1, m2, m3, m4;
+monitor M {};
+M m1, m2, m3, m4;
 
-void __attribute__((noinline)) call( M & mutex p1, M & mutex p2, M & mutex p3, M & mutex p4 ) {
-        signal( c );
+void __attribute__((noinline)) call( M & mutex a1, M & mutex a2, M & mutex a3, M & mutex a4 ) {
+        signal(c);
 }
-void __attribute__((noinline)) wait( M & mutex p1, M & mutex p2, M & mutex p3, M & mutex p4 ) {
+
+int  __attribute__((noinline)) wait( M & mutex a1, M & mutex a2, M & mutex a3, M & mutex a4 ) {
         go = 1;
-        for ( times ) {
-                wait( c );
-        }
+        BENCH(
+                for ( i; n ) {
+                        wait(c);
+                },
+                result
+        )
+
+        printf("%g\n", result);
+        go = 0;
+        return 0;
 }
 
 thread T {};
+void ^?{}( T & mutex this ) {}
 void main( T & ) {
-        while ( go == 0 ) { yield(); } // waiter must start first
-        BENCH(
-                for ( times ) { call( m1, m2, m3, m4 ); },
-                result
-        )
-        printf( "%g\n", result );
+        while(go == 0) { yield(); }
+        while(go == 1) { call(m1, m2, m3, m4); }
+
 }
 
-int main( int argc, char * argv[] ) {
-        BENCH_START()
+int main(__attribute__((unused)) int argc, __attribute__((unused)) char* argv[]) {
         T t;
-        wait( m1, m2, m3, m4 );
+        return 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_cond_t c;
 pthread_mutex_t m;
-pthread_cond_t c;
 
 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);
 }
 
-void __attribute__((noinline)) wait() {
+int  __attribute__((noinline)) wait() {
         pthread_mutex_lock(&m);
         go = 1;
-        for ( size_t i = 0; i < times; i++ ) {
-                pthread_cond_wait( &c, &m );
-        }
+        BENCH(
+                for (size_t i = 0; i < n; i++) {
+                        pthread_cond_wait(&c, &m);
+                },
+                result
+        )
+
+        printf("%g\n", result);
         go = 0;
-        pthread_mutex_unlock( &m );
+        pthread_mutex_unlock(&m);
+        return 0;
 }
 
-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(
-                while ( go == 1 ) { call(); },
-                result
-        )
-        printf( "%g\n", result );
+void* thread_main(__attribute__((unused)) void * arg ) {
+        while(go == 0) { sched_yield(); }
+        while(go == 1) { call(); }
         return NULL;
 }
 
-int main( int argc, char * argv[] ) {
-        BENCH_START()
+int main(__attribute__((unused)) int argc, __attribute__((unused)) char* argv[]) {
         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;
 
@@ -11 +13 @@
                 cond.signal();
         }
-        void __attribute__((noinline)) wait() {
+
+        int __attribute__((noinline)) wait() {
                 go = 1;
-                for ( size_t i = 0; i < times; i++ ) {
-                        cond.wait();
-                }
+                BENCH(
+                        for (size_t i = 0; i < n; i++) {
+                                cond.wait();
+                        },
+                        result
+                )
+
+                printf("%g\n", result);
+                go = 0;
+                return 0;
         }
-} m;
+};
+
+M m;
 
 _Task T {
         void main() {
-                while ( go == 0 ) { yield(); } // waiter must start first
-                BENCH(
-                        for ( size_t i = 0; i < times; i++ ) {
-                                m.call();
-                        },
-                        result
-                )
-                printf( "%g\n", result );
+                while(go == 0) { yield(); }
+                while(go == 1) { m.call(); }
+
         }
 };
 
-int main( int argc, char * argv[] ) {
-        BENCH_START()
+int main(__attribute__((unused)) int argc, __attribute__((unused)) char* argv[]) {
         T t;
-        m.wait();
+        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 : Fri Jan 31 16:48:03 2020
-// Update Count     : 421
+// Last Modified On : Tue Sep 10 17:00:15 2019
+// Update Count     : 420
 //
 
@@ -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)
@@ -431 +439 @@
 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 Jan 15 07:42:35 2020
-// Update Count     : 28
+// Last Modified On : Wed Jun 26 08:52:20 2019
+// Update Count     : 4
 
 #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 ) {
+        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){ 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;
-                }
+                (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;
         }
 #endif
@@ -144 +145 @@
 
 #ifdef __cforall
-        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;
+
+        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;
                         }
-                        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;
-                }
+                        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;
         }
 #endif
@@ -218 +223 @@
 
 #ifdef __cforall
-        forall(dtype T )
+
+        forall(dtype T | sized(T))
         static inline [void] ?{}( __dllist(T) & this, * [T * & next, T * & prev] ( T & ) __get ) {
-                this.head{ 0p };
+                this.head{ NULL };
                 this.__get = __get;
         }
@@ -226 +232 @@
         #define next 0
         #define prev 1
-        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;
-                        }
-
+        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
                         // prevent code movement across barrier
                         asm( "" : : : "memory" );
-                        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( *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;
                         }
-                        __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;
-                }
+                        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;
         }
         #undef next
@@ -277 +286 @@
 
 #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 : Tue Jan 28 22:38:27 2020
-// Update Count     : 9
+// Last Modified On : Thu Feb  8 16:22:41 2018
+// Update Count     : 8
 //
 
@@ -34 +34 @@
 
 #ifdef __cforall
-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__ ));
+void abort ( const char fmt[], ... ) __attribute__ (( format(printf, 1, 2), __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, 0p ) == -1 ) {
+        if ( sigaction( sig, &act, NULL ) == -1 ) {
                 __cfaabi_dbg_print_buffer_decl(
                         " __cfaabi_sigaction( sig:%d, handler:%p, flags:%d ), problem installing signal handler, error(%d) %s.\n",
@@ -55 +48 @@
                 );
                 _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 : Mon Jan  6 12:49:58 2020
-// Update Count     : 9
+// Last Modified On : Thu Jun 13 21:21:13 2019
+// Update Count     : 8
 //
 
 #include <time.hfa>
+
 
 //######################### C time #########################
@@ -25 +26 @@
 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 ); }
 
@@ -80 +89 @@
                 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
-        movq %r12, %rsi
-        jmp *%r13
+        jmp *%r12
         .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 : Sun Jan  5 08:41:36 2020
-// Update Count     : 69
+// Last Modified On : Tue Dec  3 22:47:24 2019
+// Update Count     : 68
 //
 
@@ -39 +39 @@
 
 void __kernel_set_timer( Duration alarm ) {
-        verifyf(alarm >= 1`us || alarm == 0, "Setting timer to < 1us (%jins)", alarm`ns);
+        verifyf(alarm >= 1`us || alarm == 0, "Setting timer to < 1us (%jins)", alarm.tv);
         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 __leave_coroutine( struct coroutine_desc * src ) {
+        void __suspend_internal(void) {
+                suspend();
+        }
+
+        void __leave_coroutine( coroutine_desc * src ) {
                 coroutine_desc * starter = src->cancellation != 0 ? src->last : src->starter;
 
@@ -203 +207 @@
                 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" {
-        void CtxInvokeCoroutine(void (*main)(void *), void * this);
+      forall(dtype T | is_coroutine(T))
+      void CtxInvokeCoroutine(T * this);
 
-        forall(dtype T)
-        void CtxStart(void (*main)(T &), struct coroutine_desc * cor, T & this, void (*invoke)(void (*main)(void *), void *));
+      forall(dtype T | is_coroutine(T))
+      void CtxStart(T * this, void ( *invoke)(T *));
 
         extern void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage, struct coroutine_desc *) __attribute__ ((__noreturn__));
@@ -128 +129 @@
 
         if( unlikely(dst->context.SP == 0p) ) {
-                TL_GET( this_thread )->curr_cor = dst;
                 __stack_prepare(&dst->stack, 65000);
-                CtxStart(main, dst, cor, CtxInvokeCoroutine);
-                TL_GET( this_thread )->curr_cor = src;
+                CtxStart(&cor, CtxInvokeCoroutine);
         }
 

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 __leave_coroutine ( struct coroutine_desc * );
-extern struct coroutine_desc * __finish_coroutine(void);
-extern void __leave_thread_monitor();
+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 disable_interrupts() OPTIONAL_THREAD;
 extern void enable_interrupts( __cfaabi_dbg_ctx_param );
@@ -37 +38 @@
 void CtxInvokeCoroutine(
         void (*main)(void *),
+        struct coroutine_desc *(*get_coroutine)(void *),
         void *this
 ) {
-        // Finish setting up the coroutine by setting its state
-        struct coroutine_desc * cor = __finish_coroutine();
+        struct coroutine_desc* cor = get_coroutine( this );
 
-        // Call the main of the coroutine
+        if(cor->state == Primed) {
+                __suspend_internal();
+        }
+
+        cor->state = Active;
+
         main( this );
 
@@ -77 +83 @@
 
 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 );
@@ -93 +108 @@
         // The order of these 4 operations is very important
         //Final suspend, should never return
-        __leave_thread_monitor();
+        __leave_thread_monitor( thrd );
         __cabi_abort( "Resumed dead thread" );
 }
 
+
 void CtxStart(
         void (*main)(void *),
-        struct coroutine_desc * cor,
+        struct coroutine_desc *(*get_coroutine)(void *),
         void *this,
         void (*invoke)(void *)
 ) {
+        struct coroutine_desc * cor = get_coroutine( this );
         struct __stack_t * stack = cor->stack.storage;
 
@@ -121 +138 @@
 
         fs->dummyReturn = NULL;
-        fs->argument[0] = main;     // argument to invoke
-        fs->argument[1] = this;     // argument to invoke
+        fs->argument[0] = this;     // argument to invoke
         fs->rturn = invoke;
 
@@ -140 +156 @@
         fs->dummyReturn = NULL;
         fs->rturn = CtxInvokeStub;
-        fs->fixedRegisters[0] = main;
-        fs->fixedRegisters[1] = this;
-        fs->fixedRegisters[2] = invoke;
+        fs->fixedRegisters[0] = this;
+        fs->fixedRegisters[1] = 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 Jan 30 22:55:50 2020
-// Update Count     : 56
+// Last Modified On : Thu Dec  5 16:25:52 2019
+// Update Count     : 52
 //
 
@@ -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(main, dst, this->runner, CtxInvokeCoroutine);
+        CtxStart(&this->runner, CtxInvokeCoroutine);
 
         verify( ! kernelTLS.preemption_state.enabled );
@@ -506 +505 @@
         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
@@ -844 +841 @@
                 sigemptyset( &mask );
                 sigaddset( &mask, SIGALRM );            // block SIGALRM signals
-                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
+                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" {
-      void CtxInvokeThread(void (*main)(void *), void * this);
+      forall(dtype T | is_thread(T))
+      void CtxInvokeThread(T * this);
 }
 

libcfa/src/concurrency/monitor.cfa

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

libcfa/src/concurrency/thread.cfa

@@ -58 +58 @@
 void ?{}( scoped(T)& this ) with( this ) {
         handle{};
-        __thrd_start(handle, main);
+        __thrd_start(handle);
 }
 
@@ -64 +64 @@
 void ?{}( scoped(T)& this, P params ) with( this ) {
         handle{ params };
-        __thrd_start(handle, main);
+        __thrd_start(handle);
 }
 
@@ -75 +75 @@
 // Starting and stopping threads
 forall( dtype T | is_thread(T) )
-void __thrd_start( T & this, void (*main_p)(T &) ) {
+void __thrd_start( T& this ) {
         thread_desc * this_thrd = get_thread(this);
         thread_desc * curr_thrd = TL_GET( this_thread );
 
         disable_interrupts();
-        CtxStart(main_p, get_coroutine(this), this, CtxInvokeThread);
-
+        CtxStart(&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 (*)(T &) );
+void __thrd_start( T & this );
 
 //-----------------------------------------------------------------------------

libcfa/src/executor.cfa

@@ -8 +8 @@
 #include <stdio.h>
 
-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) ) {
+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
+
     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.head != 0 ) wait( delay );                   // no request to process ? => wait
-//      return pop_head( queue );
+        if ( ! queue ) 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 : Thu Jan 30 17:47:32 2020
-// Update Count     : 156
+// Last Modified On : Fri Dec 13 13:45:21 2019
+// Update Count     : 121
 //
 
@@ -95 +95 @@
         void __cfaabi_interpose_startup(void)  __attribute__(( constructor( STARTUP_PRIORITY_CORE ) ));
         void __cfaabi_interpose_startup( void ) {
-                const char *version = 0p;
+                const char *version = NULL;
 
                 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 | 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
+                __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 );
         }
 }
@@ -141 +123 @@
 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( false, NULL ); // FIX ME: 0p does not work
+                abort( NULL );
         }
 
@@ -151 +132 @@
                 va_list argp;
                 va_start( argp, fmt );
-                abort( false, fmt, argp );
+                abort( fmt, argp );
                 va_end( argp );
         }
@@ -160 +141 @@
 }
 
-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.
+void * kernel_abort    ( void ) __attribute__(( __nothrow__, __leaf__, __weak__ )) { return NULL; }
+void   kernel_abort_msg( void * data, char * buffer, int size ) __attribute__(( __nothrow__, __leaf__, __weak__ )) {}
 int kernel_abort_lastframe( void ) __attribute__(( __nothrow__, __leaf__, __weak__ )) { return 4; }
 
 enum { abort_text_size = 1024 };
 static char abort_text[ abort_text_size ];
-
-static void __cfaabi_backtrace( int start ) {
+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() {
         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];
@@ -178 +192 @@
         char ** messages = backtrace_symbols( array, size );
 
-        *index( messages[0], '(' ) = '\0';                                      // find executable name
+        // find executable name
+        *index( messages[0], '(' ) = '\0';
         __cfaabi_bits_print_nolock( STDERR_FILENO, "Stack back trace for: %s\n", messages[0]);
 
-        for ( unsigned int i = start; i < size - last && messages != 0p; i += 1 ) {
+        for ( int i = Start; i < size - abort_lastframe && messages != 0p; i += 1 ) {
                 char * name = 0p, * offset_begin = 0p, * offset_end = 0p;
 
-                for ( char * p = messages[i]; *p; ++p ) {               // find parantheses and +offset
+                for ( char * p = messages[i]; *p; ++p ) {
                         //__cfaabi_bits_print_nolock( "X %s\n", p);
+                        // find parantheses and +offset
                         if ( *p == '(' ) {
                                 name = p;
@@ -196 +212 @@
                 }
 
-                // 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 ) {
-                        *name++ = '\0';                                                         // delimit strings
+                        // delimit strings
+                        *name++ = '\0';
                         *offset_begin++ = '\0';
                         *offset_end++ = '\0';
@@ -211 +228 @@
 }
 
-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 == 0p ) {
-                        abort( true, "Null pointer (0p) dereference.\n" );
+                if ( sfp->si_addr == NULL ) {
+                        abort( "Null pointer (0p) dereference.\n" );
                 } else {
-                        abort( true, "%s at memory location %p.\n"
+                        abort( "%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 );
@@ -265 +239 @@
 
 void sigHandler_ill( __CFA_SIGPARMS__ ) {
-        abort( true, "Executing illegal instruction at location %p.\n"
+        abort( "Executing illegal instruction at location %p.\n"
                         "Possible cause is stack corruption.\n",
                         sfp->si_addr );
@@ -281 +255 @@
           default: msg = "unknown";
         } // choose
-        abort( true, "Computation error %s at location %p.\n", msg, sfp->si_addr );
+        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 );
 }
 
 void sigHandler_term( __CFA_SIGPARMS__ ) {
-        abort( true, "Application interrupted by signal: %s.\n", strsignal( sig ) );
+        abort( "Application stopped by %s signal.", sig == SIGINT ? "an interrupt (SIGINT)" : "a terminate (SIGTERM)" );
 }
 

libcfa/src/startup.cfa

@@ -10 +10 @@
 // Created On       : Tue Jul 24 16:21:57 2018
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Dec 13 13:16:45 2019
-// Update Count     : 29
+// Last Modified On : Sat Nov 30 07:07:56 2019
+// Update Count     : 13
 //
 
+#include "startup.hfa"
 #include <time.h>                                                                               // tzset
-#include "startup.hfa"
 
 extern "C" {
-    void __cfaabi_appready_startup( void ) __attribute__(( constructor( STARTUP_PRIORITY_APPREADY ) ));
+    static 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
 
-    void __cfaabi_appready_shutdown( void ) __attribute__(( destructor( STARTUP_PRIORITY_APPREADY ) ));
+    static 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 : Sat Feb  1 07:15:29 2020
-// Update Count     : 5
+// Last Modified On : Sun Jul 22 13:49:30 2018
+// Update Count     : 4
 // 
 
 // 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 : Sat Feb  1 07:15:39 2020
-// Update Count     : 5
+// Last Modified On : Sun Jul 22 13:49:58 2018
+// Update Count     : 4
 // 
 
 // 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 : Sat Feb  1 07:15:47 2020
-// Update Count     : 5
+// Last Modified On : Sun Jul 22 13:50:24 2018
+// Update Count     : 4
 // 
 
 // 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 : Sat Feb  1 07:15:58 2020
-// Update Count     : 14
+// Last Modified On : Thu Feb 22 18:16:07 2018
+// Update Count     : 13
 // 
 
 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 : Sat Feb  1 07:16:05 2020
-// Update Count     : 5
+// Last Modified On : Thu Feb  8 23:50:44 2018
+// Update Count     : 4
 // 
 
 #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 : Sun Jan  5 17:27:40 2020
-// Update Count     : 69
+// Last Modified On : Sat Jul 13 08:41:55 2019
+// Update Count     : 65
 //
 
@@ -33 +33 @@
 forall( dtype ostype | ostream( ostype ) ) {
         ostype & ?|?( ostype & os, Duration dur ) with( dur ) {
-                (ostype &)(os | tn / TIMEGRAN);                                 // print seconds
-                long int ns = (tn < 0 ? -tn : tn) % TIMEGRAN;   // compute nanoseconds
+                (ostype &)(os | tv / TIMEGRAN);                                 // print seconds
+                long int ns = (tv < 0 ? -tv : tv) % 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, int64_t nsec ) {
+static void tabort( int year, int month, int day, int hour, int min, int sec, int 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 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.";
+                  | "(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.";
 } // tabort
 #endif // __CFA_DEBUG__
 
-void ?{}( Time & time, int year, int month, int day, int hour, int min, int sec, int64_t nsec ) with( time ) {
+void ?{}( Time & time, int year, int month, int day, int hour, int min, int sec, int nsec ) with( time ) {
         tm tm;
 
-        // Values can be in any range (+/-) but result must be in the epoch.
+        tm.tm_isdst = -1;                                                                       // let mktime determine if alternate timezone is in effect
         tm.tm_year = year - 1900;                                                       // mktime uses 1900 as its starting point
-        // Make month in range 1-12 to match with day.
+#ifdef __CFA_DEBUG__
+        if ( month < 1 || 12 < month ) {
+                tabort( year, month, day, hour, min, sec, nsec );
+        } // if
+#endif // __CFA_DEBUG__
         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 ) {                                         // MUST BE LESS THAN OR EQUAL!
+        if ( epochsec == (time_t)-1 ) {
                 tabort( year, month, day, hour, min, sec, nsec );
         } // if
 #endif // __CFA_DEBUG__
-        tn = (int64_t)(epochsec) * TIMEGRAN + nsec;                     // convert to nanoseconds
+        tv = (int64_t)(epochsec) * TIMEGRAN + nsec;                     // convert to nanoseconds
 #ifdef __CFA_DEBUG__
-        if ( tn > 2147483647LL * TIMEGRAN ) {                           // between 00:00:00 UTC, January 1, 1970 and 03:14:07 UTC, January 19, 2038.
+        if ( tv > 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
@@ -85 +93 @@
 
 char * yy_mm_dd( Time time, char * buf ) with( time ) {
-        time_t s = tn / TIMEGRAN;
+        time_t s = tv / TIMEGRAN;
         tm tm;
         gmtime_r( &s, &tm );                                                            // tm_mon <= 11, tm_mday <= 31
@@ -100 +108 @@
 
 char * mm_dd_yy( Time time, char * buf ) with( time ) {
-        time_t s = tn / TIMEGRAN;
+        time_t s = tv / TIMEGRAN;
         tm tm;
         gmtime_r( &s, &tm );                                                            // tm_mon <= 11, tm_mday <= 31
@@ -115 +123 @@
 
 char * dd_mm_yy( Time time, char * buf ) with( time ) {
-        time_t s = tn / TIMEGRAN;
+        time_t s = tv / TIMEGRAN;
         tm tm;
         gmtime_r( &s, &tm );                                                            // tm_mon <= 11, tm_mday <= 31
@@ -130 +138 @@
 
 size_t strftime( char * buf, size_t size, const char * fmt, Time time ) with( time ) {
-        time_t s = tn / TIMEGRAN;
+        time_t s = tv / TIMEGRAN;
         tm tm;
         gmtime_r( &s, &tm );
@@ -139 +147 @@
         ostype & ?|?( ostype & os, Time time ) with( time ) {
                 char buf[32];                                                                   // at least 26
-                time_t s = tn / TIMEGRAN;
+                time_t s = tv / 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 = (tn < 0 ? -tn : tn) % TIMEGRAN;   // compute nanoseconds
+                long int ns = (tv < 0 ? -tv : tv) % 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 : Mon Jan  6 12:50:16 2020
-// Update Count     : 653
+// Last Modified On : Sat Sep 22 12:25:34 2018
+// Update Count     : 643
 //
 
@@ -32 +32 @@
         Duration ?=?( Duration & dur, __attribute__((unused)) zero_t ) { return dur{ 0 }; }
 
-        Duration +?( Duration rhs ) with( rhs ) { return (Duration)@{ +tn }; }
-        Duration ?+?( Duration & lhs, Duration rhs ) { return (Duration)@{ lhs.tn + rhs.tn }; }
+        Duration +?( Duration rhs ) with( rhs ) {       return (Duration)@{ +tv }; }
+        Duration ?+?( Duration & lhs, Duration rhs ) { return (Duration)@{ lhs.tv + rhs.tv }; }
         Duration ?+=?( Duration & lhs, Duration rhs ) { lhs = lhs + rhs; return lhs; }
 
-        Duration -?( Duration rhs ) with( rhs ) { return (Duration)@{ -tn }; }
-        Duration ?-?( Duration & lhs, Duration rhs ) { return (Duration)@{ lhs.tn - rhs.tn }; }
+        Duration -?( Duration rhs ) with( rhs ) { return (Duration)@{ -tv }; }
+        Duration ?-?( Duration & lhs, Duration rhs ) { return (Duration)@{ lhs.tv - rhs.tv }; }
         Duration ?-=?( Duration & lhs, Duration rhs ) { lhs = lhs - rhs; return lhs; }
 
-        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 ) { return (Duration)@{ lhs.tv * rhs }; }
+        Duration ?*?( int64_t lhs, Duration rhs ) { return (Duration)@{ lhs * rhs.tv }; }
         Duration ?*=?( Duration & lhs, int64_t rhs ) { lhs = lhs * rhs; return lhs; }
 
-        int64_t ?/?( Duration lhs, Duration rhs ) { return lhs.tn / rhs.tn; }
-        Duration ?/?( Duration lhs, int64_t rhs ) { return (Duration)@{ lhs.tn / rhs }; }
+        int64_t ?/?( Duration lhs, Duration rhs ) { return lhs.tv / rhs.tv; }
+        Duration ?/?( Duration lhs, int64_t rhs ) { return (Duration)@{ lhs.tv / rhs }; }
         Duration ?/=?( Duration & lhs, int64_t rhs ) { lhs = lhs / rhs; return lhs; }
-        double div( Duration lhs, Duration rhs ) { return (double)lhs.tn / (double)rhs.tn; }
-
-        Duration ?%?( Duration lhs, Duration rhs ) { return (Duration)@{ lhs.tn % rhs.tn }; }
+        double div( Duration lhs, Duration rhs ) { return (double)lhs.tv / (double)rhs.tv; }
+
+        Duration ?%?( Duration lhs, Duration rhs ) { return (Duration)@{ lhs.tv % rhs.tv }; }
         Duration ?%=?( Duration & lhs, Duration rhs ) { lhs = lhs % rhs; return lhs; }
 
-        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; }
+        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; }
 
         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.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;}
+        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;}
 } // distribution
 
@@ -143 +143 @@
 //######################### Time #########################
 
-void ?{}( Time & time, int year, int month = 1, int day = 1, int hour = 0, int min = 0, int sec = 0, int64_t nsec = 0 );
+void ?{}( Time & time, int year, int month = 0, int day = 0, int hour = 0, int min = 0, int sec = 0, int nsec = 0 );
 static inline {
         Time ?=?( Time & time, __attribute__((unused)) zero_t ) { return time{ 0 }; }
 
-        void ?{}( Time & time, timeval t ) with( time ) { tn = (int64_t)t.tv_sec * TIMEGRAN + t.tv_usec * 1000; }
+        void ?{}( Time & time, timeval t ) with( time ) { tv = (int64_t)t.tv_sec * TIMEGRAN + t.tv_usec * 1000; }
         Time ?=?( Time & time, timeval t ) with( time ) {
-                tn = (int64_t)t.tv_sec * TIMEGRAN + t.tv_usec * (TIMEGRAN / 1_000_000LL);
+                tv = (int64_t)t.tv_sec * TIMEGRAN + t.tv_usec * (TIMEGRAN / 1_000_000LL);
                 return time;
         } // ?=?
 
-        void ?{}( Time & time, timespec t ) with( time ) { tn = (int64_t)t.tv_sec * TIMEGRAN + t.tv_nsec; }
+        void ?{}( Time & time, timespec t ) with( time ) { tv = (int64_t)t.tv_sec * TIMEGRAN + t.tv_nsec; }
         Time ?=?( Time & time, timespec t ) with( time ) {
-                tn = (int64_t)t.tv_sec * TIMEGRAN + t.tv_nsec;
+                tv = (int64_t)t.tv_sec * TIMEGRAN + t.tv_nsec;
                 return time;
         } // ?=?
 
-        Time ?+?( Time & lhs, Duration rhs ) { return (Time)@{ lhs.tn + rhs.tn }; }
+        Time ?+?( Time & lhs, Duration rhs ) { return (Time)@{ lhs.tv + rhs.tv }; }
         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.tn - rhs.tn }; }
-        Time ?-?( Time lhs, Duration rhs ) { return (Time)@{ lhs.tn - rhs.tn }; }
+        Duration ?-?( Time lhs, Time rhs ) { return (Duration)@{ lhs.tv - rhs.tv }; }
+        Time ?-?( Time lhs, Duration rhs ) { return (Time)@{ lhs.tv - rhs.tv }; }
         Time ?-=?( Time & lhs, Duration rhs ) { lhs = lhs - rhs; return lhs; }
-        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; }
+        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; }
 } // distribution
 
@@ -196 +194 @@
 
 static inline void ?{}( timeval & t, Time time ) with( t, time ) {
-        tv_sec = tn / TIMEGRAN;                                                         // seconds
-        tv_usec = tn % TIMEGRAN / (TIMEGRAN / 1_000_000LL);     // microseconds
+        tv_sec = tv / TIMEGRAN;                                                         // seconds
+        tv_usec = tv % TIMEGRAN / (TIMEGRAN / 1_000_000LL);     // microseconds
 } // ?{}
 
@@ -203 +201 @@
 
 static inline void ?{}( timespec & t, Time time ) with( t, time ) {
-        tv_sec = tn / TIMEGRAN;                                                         // seconds
-        tv_nsec = tn % TIMEGRAN;                                                        // nanoseconds
+        tv_sec = tv / TIMEGRAN;                                                         // seconds
+        tv_nsec = tv % 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 : Sun Jan  5 08:22:46 2020
-// Update Count     : 7
+// Last Modified On : Fri Apr 13 07:51:47 2018
+// Update Count     : 6
 //
 
@@ -20 +20 @@
 
 struct Duration {                                                                               // private
-        int64_t tn;                                                                                     // nanoseconds
+        int64_t tv;                                                                                     // nanoseconds
 }; // Duration
 
-static inline void ?{}( Duration & dur ) with( dur ) { tn = 0; }
-static inline void ?{}( Duration & dur, __attribute__((unused)) zero_t ) with( dur ) { tn = 0; }
+static inline void ?{}( Duration & dur ) with( dur ) { tv = 0; }
+static inline void ?{}( Duration & dur, __attribute__((unused)) zero_t ) with( dur ) { tv = 0; }
 
 
@@ -30 +30 @@
 
 struct Time {                                                                                   // private
-        uint64_t tn;                                                                            // nanoseconds since UNIX epoch
+        uint64_t tv;                                                                            // nanoseconds since UNIX epoch
 }; // Time
 
-static inline void ?{}( Time & time ) with( time ) { tn = 0; }
-static inline void ?{}( Time & time, __attribute__((unused)) zero_t ) with( time ) { tn = 0; }
+static inline void ?{}( Time & time ) with( time ) { tv = 0; }
+static inline void ?{}( Time & time, __attribute__((unused)) zero_t ) with( time ) { tv = 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)
@@ -498 +506 @@
 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 : Andrew Beach
+// Last Modified By :
 // 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();
@@ -65 +59 @@
                                 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 NameExpr("main") }
+                                        { new VariableExpr( param ) }
                                 )
                         )

src/Concurrency/Waitfor.cc

@@ -11 +11 @@
 // Last Modified By :
 // Last Modified On :
-// Update Count     : 12
+// Update Count     : 11
 //
 
@@ -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 : Andrew Beach
-// Last Modified On : Tue Jan 21 10:32:00 2020
-// Update Count     : 160
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Mar 11 22:26:02 2019
+// Update Count     : 159
 //
 
@@ -21 +21 @@
 #include "ControlStruct/LabelGenerator.h"  // for LabelGenerator
 #include "LabelFixer.h"
-#include "MLEMutator.h"                    // for MultiLevelExitMutator
+#include "MLEMutator.h"                    // for MLEMutator
 #include "SynTree/Declaration.h"           // for FunctionDecl
 #include "SynTree/Expression.h"            // for NameExpr, Expression, Unty...
@@ -44 +44 @@
 
         void LabelFixer::postvisit( FunctionDecl * functionDecl ) {
-                PassVisitor<MultiLevelExitMutator> mlem( resolveJumps(), generator );
-                // We start in the body so we can stop when we hit another FunctionDecl.
-                maybeMutate( functionDecl->statements, mlem );
+                PassVisitor<MLEMutator> mlemut( resolveJumps(), generator );
+                functionDecl->acceptMutator( mlemut );
         }
 
@@ -76 +75 @@
 
 
-        // 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++ ) {
@@ -86 +87 @@
                         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 ] = new Entry( definition );
+                                labelTable[ l ] =  e;
                         } 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 ] = new Entry( definition );
+                                labelTable[ l ] = e;
                         } // 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 : Andrew Beach
-// Last Modified On : Wed Jan 22 11:50:00 2020
-// Update Count     : 223
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue Oct 22 17:22:44 2019
+// Update Count     : 220
 //
 
@@ -33 +33 @@
 
 namespace ControlStruct {
-        MultiLevelExitMutator::~MultiLevelExitMutator() {
+        MLEMutator::~MLEMutator() {
                 delete targetTable;
                 targetTable = 0;
         }
         namespace {
-                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 );
-                }
+                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 ); }
         } // 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 MultiLevelExitMutator::fixBlock( std::list< Statement * > &kids, bool caseClause ) {
+        void MLEMutator::fixBlock( std::list< Statement * > &kids, bool caseClause ) {
                 SemanticErrorException errors;
 
@@ -99 +81 @@
         }
 
-        void MultiLevelExitMutator::premutate( CompoundStmt *cmpndStmt ) {
+        void MLEMutator::premutate( CompoundStmt *cmpndStmt ) {
                 visit_children = false;
                 bool labeledBlock = !(cmpndStmt->labels.empty());
@@ -136 +118 @@
                         }
                 }
-                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 ) {
+                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 ) {
                 std::string originalTarget = branchStmt->originalTarget;
 
@@ -250 +230 @@
         }
 
-        Statement *MultiLevelExitMutator::mutateLoop( Statement *bodyLoop, Entry &e ) {
+        Statement *MLEMutator::mutateLoop( Statement *bodyLoop, Entry &e ) {
                 // only generate these when needed
                 if( !e.isContUsed() && !e.isBreakUsed() ) return bodyLoop;
@@ -273 +253 @@
 
         template< typename LoopClass >
-        void MultiLevelExitMutator::prehandleLoopStmt( LoopClass * loopStmt ) {
+        void MLEMutator::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
@@ -284 +264 @@
 
         template< typename LoopClass >
-        Statement * MultiLevelExitMutator::posthandleLoopStmt( LoopClass * loopStmt ) {
+        Statement * MLEMutator::posthandleLoopStmt( LoopClass * loopStmt ) {
                 assert( ! enclosingControlStructures.empty() );
                 Entry &e = enclosingControlStructures.back();
@@ -295 +275 @@
         }
 
-        void MultiLevelExitMutator::premutate( WhileStmt * whileStmt ) {
+        void MLEMutator::premutate( WhileStmt * whileStmt ) {
                 return prehandleLoopStmt( whileStmt );
         }
 
-        void MultiLevelExitMutator::premutate( ForStmt * forStmt ) {
+        void MLEMutator::premutate( ForStmt * forStmt ) {
                 return prehandleLoopStmt( forStmt );
         }
 
-        Statement * MultiLevelExitMutator::postmutate( WhileStmt * whileStmt ) {
+        Statement * MLEMutator::postmutate( WhileStmt * whileStmt ) {
                 return posthandleLoopStmt( whileStmt );
         }
 
-        Statement * MultiLevelExitMutator::postmutate( ForStmt * forStmt ) {
+        Statement * MLEMutator::postmutate( ForStmt * forStmt ) {
                 return posthandleLoopStmt( forStmt );
         }
 
-        void MultiLevelExitMutator::premutate( IfStmt * ifStmt ) {
+        void MLEMutator::premutate( IfStmt * ifStmt ) {
                 // generate a label for breaking out of a labeled if
                 bool labeledBlock = !(ifStmt->get_labels().empty());
@@ -321 +301 @@
         }
 
-        Statement * MultiLevelExitMutator::postmutate( IfStmt * ifStmt ) {
+        Statement * MLEMutator::postmutate( IfStmt * ifStmt ) {
                 bool labeledBlock = !(ifStmt->get_labels().empty());
                 if ( labeledBlock ) {
@@ -331 +311 @@
         }
 
-        void MultiLevelExitMutator::premutate( TryStmt * tryStmt ) {
+        void MLEMutator::premutate( TryStmt * tryStmt ) {
                 // generate a label for breaking out of a labeled if
                 bool labeledBlock = !(tryStmt->get_labels().empty());
@@ -341 +321 @@
         }
 
-        Statement * MultiLevelExitMutator::postmutate( TryStmt * tryStmt ) {
+        Statement * MLEMutator::postmutate( TryStmt * tryStmt ) {
                 bool labeledBlock = !(tryStmt->get_labels().empty());
                 if ( labeledBlock ) {
@@ -351 +331 @@
         }
 
-        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 ) {
+        void MLEMutator::premutate( CaseStmt *caseStmt ) {
                 visit_children = false;
 
@@ -405 +370 @@
         }
 
-        void MultiLevelExitMutator::premutate( SwitchStmt *switchStmt ) {
+        void MLEMutator::premutate( SwitchStmt *switchStmt ) {
                 // generate a label for breaking out of a labeled switch
                 Label brkLabel = generator->newLabel("switchBreak", switchStmt);
@@ -431 +396 @@
         }
 
-        Statement * MultiLevelExitMutator::postmutate( SwitchStmt * switchStmt ) {
+        Statement * MLEMutator::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 : Andrew Beach
-// Last Modified On : Wed Jan 22 11:50:00 2020
-// Update Count     : 48
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue Oct 22 17:22:47 2019
+// Update Count     : 45
 //
 
@@ -30 +30 @@
         class LabelGenerator;
 
-        class MultiLevelExitMutator : public WithVisitorRef<MultiLevelExitMutator>,
-                        public WithShortCircuiting, public WithGuards {
+        class MLEMutator : public WithVisitorRef<MLEMutator>, public WithShortCircuiting, public WithGuards {
           public:
                 class Entry;
-                MultiLevelExitMutator( std::map<Label, Statement *> *t, LabelGenerator *gen = 0 ) :
-                        targetTable( t ), breakLabel(std::string("")), generator( gen ) {}
-                ~MultiLevelExitMutator();
-
-                void premutate( FunctionDecl * );
+                MLEMutator( std::map<Label, Statement *> *t, LabelGenerator *gen = 0 ) : targetTable( t ), breakLabel(std::string("")), generator( gen ) {}
+                ~MLEMutator();
 
                 void premutate( CompoundStmt *cmpndStmt );
@@ -51 +47 @@
                 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 );
@@ -116 +110 @@
                 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 : Sat Feb  1 07:16:44 2020
- * Update Count     : 724
+ * Last Modified On : Sun Aug  4 20:53:47 2019
+ * Update Count     : 719
  */
 
@@ -330 +330 @@
                                 /* identifier */
 {identifier}    { IDENTIFIER_RETURN(); }
-"``"{identifier}"``" {                                                                  // CFA
-        yytext[yyleng - 2] = '\0'; yytext += 2;                         // SKULLDUGGERY: remove backquotes (ok to shorten?)
+"`"{identifier}"`" {                                                                    // CFA
+        yytext[yyleng - 1] = '\0'; yytext += 1;                         // SKULLDUGGERY: remove backquotes (ok to shorten?)
         IDENTIFIER_RETURN();
 }

src/Parser/parser.yy

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Feb  1 10:04:40 2020
-// Update Count     : 4440
+// Last Modified On : Mon Dec 16 15:32:58 2019
+// Update Count     : 4409
 //
 
@@ -323 +323 @@
 %type<op> ptrref_operator                               unary_operator                          assignment_operator
 %type<en> primary_expression                    postfix_expression                      unary_expression
-%type<en> cast_expression_list                  cast_expression                         exponential_expression          multiplicative_expression       additive_expression
+%type<en> cast_expression                               exponential_expression          multiplicative_expression       additive_expression
 %type<en> shift_expression                              relational_expression           equality_expression
 %type<en> AND_expression                                exclusive_OR_expression         inclusive_OR_expression
@@ -579 +579 @@
         | '(' compound_statement ')'                                            // GCC, lambda expression
                 { $$ = new ExpressionNode( new StmtExpr( dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >($2) ) ) ); }
+        | constant '`' IDENTIFIER                                                       // CFA, postfix call
+                { $$ = new ExpressionNode( build_func( new ExpressionNode( build_postfix_name( $3 ) ), $1 ) ); }
+        | string_literal '`' IDENTIFIER                                         // CFA, postfix call
+                { $$ = new ExpressionNode( build_func( new ExpressionNode( build_postfix_name( $3 ) ), new ExpressionNode( $1 ) ) ); }
+        | IDENTIFIER '`' IDENTIFIER                                                     // CFA, postfix call
+                { $$ = new ExpressionNode( build_func( new ExpressionNode( build_postfix_name( $3 ) ), new ExpressionNode( build_varref( $1 ) ) ) ); }
+        | tuple '`' IDENTIFIER                                                          // CFA, postfix call
+                { $$ = new ExpressionNode( build_func( new ExpressionNode( build_postfix_name( $3 ) ), $1 ) ); }
+        | '(' comma_expression ')' '`' IDENTIFIER                       // CFA, postfix call
+                { $$ = new ExpressionNode( build_func( new ExpressionNode( build_postfix_name( $5 ) ), $2 ) ); }
         | type_name '.' identifier                                                      // CFA, nested type
                 { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
@@ -632 +642 @@
         | postfix_expression '(' argument_expression_list ')'
                 { $$ = new ExpressionNode( build_func( $1, $3 ) ); }
-        | postfix_expression '`' identifier                                     // CFA, postfix call
-                { $$ = new ExpressionNode( build_func( new ExpressionNode( build_postfix_name( $3 ) ), $1 ) ); }
-        | constant '`' identifier                                                       // CFA, postfix call
-                { $$ = new ExpressionNode( build_func( new ExpressionNode( build_postfix_name( $3 ) ), $1 ) ); }
-        | string_literal '`' identifier                                         // CFA, postfix call
-                { $$ = new ExpressionNode( build_func( new ExpressionNode( build_postfix_name( $3 ) ), new ExpressionNode( $1 ) ) ); }
         | postfix_expression '.' identifier
                 { $$ = new ExpressionNode( build_fieldSel( $1, build_varref( $3 ) ) ); }
@@ -662 +666 @@
         | '(' type_no_function ')' '@' '{' initializer_list_opt comma_opt '}' // CFA, explicit C compound-literal
                 { $$ = new ExpressionNode( build_compoundLiteral( $2, (new InitializerNode( $6, true ))->set_maybeConstructed( false ) ) ); }
-        | '^' primary_expression '{' argument_expression_list '}' // CFA, destructor call
+        | '^' primary_expression '{' argument_expression_list '}' // CFA
                 {
                         Token fn;
@@ -675 +679 @@
         | argument_expression
         | argument_expression_list ',' argument_expression
-                { $$ = (ExpressionNode *)($1->set_last( $3 )); }
+                { $$ = (ExpressionNode *)( $1->set_last( $3 )); }
         ;
 
@@ -687 +691 @@
 field_name_list:                                                                                // CFA, tuple field selector
         field
-        | field_name_list ',' field                                     { $$ = (ExpressionNode *)($1->set_last( $3 )); }
+        | field_name_list ',' field                                     { $$ = (ExpressionNode *)$1->set_last( $3 ); }
         ;
 
@@ -956 +960 @@
                 { $$ = new ExpressionNode( build_tuple( (ExpressionNode *)(new ExpressionNode( nullptr ) )->set_last( $3 ) ) ); }
         | '[' push assignment_expression pop ',' tuple_expression_list ']'
-                { $$ = new ExpressionNode( build_tuple( (ExpressionNode *)($3->set_last( $6 ) ) )); }
+                { $$ = new ExpressionNode( build_tuple( (ExpressionNode *)$3->set_last( $6 ) ) ); }
         ;
 
@@ -962 +966 @@
         assignment_expression_opt
         | tuple_expression_list ',' assignment_expression_opt
-                { $$ = (ExpressionNode *)($1->set_last( $3 )); }
+                { $$ = (ExpressionNode *)$1->set_last( $3 ); }
         ;
 
@@ -1303 +1307 @@
         WAITFOR '(' cast_expression ')'
                 { $$ = $3; }
-//      | WAITFOR '(' cast_expression ',' argument_expression_list ')'
-//              { $$ = (ExpressionNode *)$3->set_last( $5 ); }
-        | WAITFOR '(' cast_expression_list ':' argument_expression_list ')'
-                { $$ = (ExpressionNode *)($3->set_last( $5 )); }
-        ;
-
-cast_expression_list:
-        cast_expression
-        | cast_expression_list ',' cast_expression
-                { $$ = (ExpressionNode *)($1->set_last( $3 )); }
+        | WAITFOR '(' cast_expression ',' argument_expression_list ')'
+                { $$ = (ExpressionNode *)$3->set_last( $5 ); }
         ;
 
@@ -1423 +1419 @@
         asm_operand
         | asm_operands_list ',' asm_operand
-                { $$ = (ExpressionNode *)($1->set_last( $3 )); }
+                { $$ = (ExpressionNode *)$1->set_last( $3 ); }
         ;
 
@@ -1439 +1435 @@
                 { $$ = new ExpressionNode( $1 ); }
         | asm_clobbers_list_opt ',' string_literal
-                { $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( $3 ) )); }
+                // set_last returns ParseNode *
+                { $$ = (ExpressionNode *)$1->set_last( new ExpressionNode( $3 ) ); }
         ;
 
@@ -2362 +2359 @@
         | initializer_list_opt ',' initializer          { $$ = (InitializerNode *)( $1->set_last( $3 ) ); }
         | initializer_list_opt ',' designation initializer
-                { $$ = (InitializerNode *)($1->set_last( $4->set_designators( $3 ) )); }
+                { $$ = (InitializerNode *)( $1->set_last( $4->set_designators( $3 ) ) ); }
         ;
 
@@ -2384 +2381 @@
         designator
         | designator_list designator
-                { $$ = (ExpressionNode *)($1->set_last( $2 )); }
+                { $$ = (ExpressionNode *)( $1->set_last( $2 ) ); }
         //| designator_list designator                                          { $$ = new ExpressionNode( $1, $2 ); }
         ;
@@ -2481 +2478 @@
                 { SemanticError( yylloc, toString("Expression generic parameters are currently unimplemented: ", $1->build()) ); $$ = nullptr; }
         | type_list ',' type
-                { $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( new TypeExpr( maybeMoveBuildType( $3 ) ) ) )); }
+                { $$ = (ExpressionNode *)( $1->set_last( new ExpressionNode( new TypeExpr( maybeMoveBuildType( $3 ) ) ) ) ); }
         | type_list ',' assignment_expression
                 { SemanticError( yylloc, toString("Expression generic parameters are currently unimplemented: ", $3->build()) ); $$ = nullptr; }

src/SymTab/Validate.cc

@@ -375 +375 @@
                         Stats::Heap::newPass("validate-F");
                         Stats::Time::BlockGuard guard("validate-F");
-                        Stats::Time::TimeCall("Fix Object Type",
-                                FixObjectType::fix, translationUnit);
-                        Stats::Time::TimeCall("Array Length",
-                                ArrayLength::computeLength, translationUnit);
-                        Stats::Time::TimeCall("Find Special Declarations",
-                                Validate::findSpecialDecls, translationUnit);
-                        Stats::Time::TimeCall("Fix Label Address",
-                                mutateAll<LabelAddressFixer>, translationUnit, labelAddrFixer);
-                        Stats::Time::TimeCall("Handle Attributes",
-                                Validate::handleAttributes, translationUnit);
+                        Stats::Time::TimeBlock("Fix Object Type", [&]() {
+                                FixObjectType::fix( translationUnit );
+                        });
+                        Stats::Time::TimeBlock("Array Length", [&]() {
+                                ArrayLength::computeLength( translationUnit );
+                        });
+                        Stats::Time::TimeBlock("Find Special Declarations", [&]() {
+                                Validate::findSpecialDecls( translationUnit );
+                        });
+                        Stats::Time::TimeBlock("Fix Label Address", [&]() {
+                                mutateAll( translationUnit, labelAddrFixer );
+                        });
+                        Stats::Time::TimeBlock("Handle Attributes", [&]() {
+                                Validate::handleAttributes( translationUnit );
+                        });
                 }
         }

src/SynTree/Statement.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Andrew Beach
-// Last Modified On : Mon Jan 20 16:03:00 2020
-// Update Count     : 71
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sun Sep  3 20:46:44 2017
+// Update Count     : 68
 //
 
@@ -46 +46 @@
 Statement::~Statement() {}
 
-ExprStmt::ExprStmt( Expression * expr ) : Statement(), expr( expr ) {}
-
-ExprStmt::ExprStmt( const ExprStmt & other ) : Statement( other ), expr( maybeClone( other.expr ) ) {}
+ExprStmt::ExprStmt( Expression *expr ) : Statement(), expr( expr ) {}
+
+ExprStmt::ExprStmt( const ExprStmt &other ) : Statement( other ), expr( maybeClone( other.expr ) ) {}
 
 ExprStmt::~ExprStmt() {
@@ -54 +54 @@
 }
 
-void ExprStmt::print( std::ostream & os, Indenter indent ) const {
+void ExprStmt::print( std::ostream &os, Indenter indent ) const {
         os << "Expression Statement:" << endl << indent+1;
         expr->print( os, indent+1 );
@@ -60 +60 @@
 
 
-AsmStmt::AsmStmt( bool voltile, Expression * instruction, std::list<Expression *> output, std::list<Expression *> input, std::list<ConstantExpr *> clobber, std::list<Label> gotolabels ) : Statement(), voltile( voltile ), instruction( instruction ), output( output ), input( input ), clobber( clobber ), gotolabels( gotolabels ) {}
+AsmStmt::AsmStmt( bool voltile, Expression *instruction, std::list<Expression *> output, std::list<Expression *> input, std::list<ConstantExpr *> clobber, std::list<Label> gotolabels ) : Statement(), voltile( voltile ), instruction( instruction ), output( output ), input( input ), clobber( clobber ), gotolabels( gotolabels ) {}
 
 AsmStmt::AsmStmt( const AsmStmt & other ) : Statement( other ), voltile( other.voltile ), instruction( maybeClone( other.instruction ) ), gotolabels( other.gotolabels ) {
@@ -75 +75 @@
 }
 
-void AsmStmt::print( std::ostream & os, Indenter indent ) const {
+void AsmStmt::print( std::ostream &os, Indenter indent ) const {
         os << "Assembler Statement:" << endl;
         os << indent+1 << "instruction: " << endl << indent;
@@ -96 +96 @@
 DirectiveStmt::DirectiveStmt( const std::string & directive ) : Statement(), directive( directive ) {}
 
-void DirectiveStmt::print( std::ostream & os, Indenter ) const {
+void DirectiveStmt::print( std::ostream &os, Indenter ) const {
         os << "GCC Directive:" << directive << endl;
 }
 
 
-const char * BranchStmt::brType[] = {
-        "Goto", "Break", "Continue", "Fall Through", "Fall Through Default",
-};
+const char *BranchStmt::brType[] = { "Goto", "Break", "Continue" };
 
 BranchStmt::BranchStmt( Label target, Type type ) throw ( SemanticErrorException ) :
@@ -113 +111 @@
 }
 
-BranchStmt::BranchStmt( Expression * computedTarget, Type type ) throw ( SemanticErrorException ) :
+BranchStmt::BranchStmt( Expression *computedTarget, Type type ) throw ( SemanticErrorException ) :
         Statement(), computedTarget( computedTarget ), type( type ) {
         if ( type != BranchStmt::Goto || computedTarget == nullptr ) {
@@ -120 +118 @@
 }
 
-void BranchStmt::print( std::ostream & os, Indenter indent ) const {
-        assert(type < 5);
+void BranchStmt::print( std::ostream &os, Indenter indent ) const {
         os << "Branch (" << brType[type] << ")" << endl ;
         if ( target != "" ) os << indent+1 << "with target: " << target << endl;
@@ -128 +125 @@
 }
 
-ReturnStmt::ReturnStmt( Expression * expr ) : Statement(), expr( expr ) {}
+ReturnStmt::ReturnStmt( Expression *expr ) : Statement(), expr( expr ) {}
 
 ReturnStmt::ReturnStmt( const ReturnStmt & other ) : Statement( other ), expr( maybeClone( other.expr ) ) {}
@@ -136 +133 @@
 }
 
-void ReturnStmt::print( std::ostream & os, Indenter indent ) const {
+void ReturnStmt::print( std::ostream &os, Indenter indent ) const {
         os << "Return Statement, returning: ";
         if ( expr != nullptr ) {
@@ -145 +142 @@
 }
 
-IfStmt::IfStmt( Expression * condition, Statement * thenPart, Statement * elsePart, std::list<Statement *> initialization ):
+IfStmt::IfStmt( Expression *condition, Statement *thenPart, Statement *elsePart, std::list<Statement *> initialization ):
         Statement(), condition( condition ), thenPart( thenPart ), elsePart( elsePart ), initialization( initialization ) {}
 
@@ -160 +157 @@
 }
 
-void IfStmt::print( std::ostream & os, Indenter indent ) const {
+void IfStmt::print( std::ostream &os, Indenter indent ) const {
         os << "If on condition: " << endl;
         os << indent+1;
@@ -179 +176 @@
         thenPart->print( os, indent+1 );
 
-        if ( elsePart != nullptr ) {
+        if ( elsePart != 0 ) {
                 os << indent << "... else: " << endl;
                 os << indent+1;
@@ -186 +183 @@
 }
 
-SwitchStmt::SwitchStmt( Expression * condition, const std::list<Statement *> & statements ):
+SwitchStmt::SwitchStmt( Expression * condition, const std::list<Statement *> &statements ):
         Statement(), condition( condition ), statements( statements ) {
 }
@@ -201 +198 @@
 }
 
-void SwitchStmt::print( std::ostream & os, Indenter indent ) const {
+void SwitchStmt::print( std::ostream &os, Indenter indent ) const {
         os << "Switch on condition: ";
         condition->print( os );
@@ -211 +208 @@
 }
 
-CaseStmt::CaseStmt( Expression * condition, const std::list<Statement *> & statements, bool deflt ) throw ( SemanticErrorException ) :
+CaseStmt::CaseStmt( Expression *condition, const std::list<Statement *> &statements, bool deflt ) throw ( SemanticErrorException ) :
         Statement(), condition( condition ), stmts( statements ), _isDefault( deflt ) {
-        if ( isDefault() && condition != nullptr ) SemanticError( condition, "default case with condition: " );
+        if ( isDefault() && condition != 0 ) SemanticError( condition, "default case with condition: " );
 }
 
@@ -232 +229 @@
 }
 
-void CaseStmt::print( std::ostream & os, Indenter indent ) const {
+void CaseStmt::print( std::ostream &os, Indenter indent ) const {
         if ( isDefault() ) os << indent << "Default ";
         else {
@@ -246 +243 @@
 }
 
-WhileStmt::WhileStmt( Expression * condition, Statement * body, std::list< Statement * > & initialization, bool isDoWhile ):
+WhileStmt::WhileStmt( Expression *condition, Statement *body, std::list< Statement * > & initialization, bool isDoWhile ):
         Statement(), condition( condition), body( body), initialization( initialization ), isDoWhile( isDoWhile) {
 }
@@ -259 +256 @@
 }
 
-void WhileStmt::print( std::ostream & os, Indenter indent ) const {
+void WhileStmt::print( std::ostream &os, Indenter indent ) const {
         os << "While on condition: " << endl ;
         condition->print( os, indent+1 );
@@ -265 +262 @@
         os << indent << "... with body: " << endl;
 
-        if ( body != nullptr ) body->print( os, indent+1 );
-}
-
-ForStmt::ForStmt( std::list<Statement *> initialization, Expression * condition, Expression * increment, Statement * body ):
+        if ( body != 0 ) body->print( os, indent+1 );
+}
+
+ForStmt::ForStmt( std::list<Statement *> initialization, Expression *condition, Expression *increment, Statement *body ):
         Statement(), initialization( initialization ), condition( condition ), increment( increment ), body( body ) {
 }
@@ -285 +282 @@
 }
 
-void ForStmt::print( std::ostream & os, Indenter indent ) const {
+void ForStmt::print( std::ostream &os, Indenter indent ) const {
         Statement::print( os, indent ); // print labels
 
@@ -308 +305 @@
         }
 
-        if ( body != nullptr ) {
+        if ( body != 0 ) {
                 os << "\n" << indent << "... with body: \n" << indent+1;
                 body->print( os, indent+1 );
@@ -320 +317 @@
 }
 
-ThrowStmt::ThrowStmt( const ThrowStmt & other ) :
+ThrowStmt::ThrowStmt( const ThrowStmt &other ) :
         Statement ( other ), kind( other.kind ), expr( maybeClone( other.expr ) ), target( maybeClone( other.target ) ) {
 }
@@ -329 +326 @@
 }
 
-void ThrowStmt::print( std::ostream & os, Indenter indent) const {
+void ThrowStmt::print( std::ostream &os, Indenter indent) const {
         if ( target ) os << "Non-Local ";
         os << "Throw Statement, raising: ";
@@ -339 +336 @@
 }
 
-TryStmt::TryStmt( CompoundStmt * tryBlock, std::list<CatchStmt *> & handlers, FinallyStmt * finallyBlock ) :
+TryStmt::TryStmt( CompoundStmt *tryBlock, std::list<CatchStmt *> &handlers, FinallyStmt *finallyBlock ) :
         Statement(), block( tryBlock ),  handlers( handlers ), finallyBlock( finallyBlock ) {
 }
 
-TryStmt::TryStmt( const TryStmt & other ) : Statement( other ), block( maybeClone( other.block ) ), finallyBlock( maybeClone( other.finallyBlock ) ) {
+TryStmt::TryStmt( const TryStmt &other ) : Statement( other ), block( maybeClone( other.block ) ), finallyBlock( maybeClone( other.finallyBlock ) ) {
         cloneAll( other.handlers, handlers );
 }
@@ -353 +350 @@
 }
 
-void TryStmt::print( std::ostream & os, Indenter indent ) const {
+void TryStmt::print( std::ostream &os, Indenter indent ) const {
         os << "Try Statement" << endl;
         os << indent << "... with block:" << endl << indent+1;
@@ -366 +363 @@
 
         // finally block
-        if ( finallyBlock != nullptr ) {
+        if ( finallyBlock != 0 ) {
                 os << indent << "... and finally:" << endl << indent+1;
                 finallyBlock->print( os, indent+1 );
@@ -372 +369 @@
 }
 
-CatchStmt::CatchStmt( Kind kind, Declaration * decl, Expression * cond, Statement * body ) :
+CatchStmt::CatchStmt( Kind kind, Declaration *decl, Expression *cond, Statement *body ) :
         Statement(), kind ( kind ), decl ( decl ), cond ( cond ), body( body ) {
                 assertf( decl, "Catch clause must have a declaration." );
@@ -386 +383 @@
 }
 
-void CatchStmt::print( std::ostream & os, Indenter indent ) const {
+void CatchStmt::print( std::ostream &os, Indenter indent ) const {
         os << "Catch " << ((Terminate == kind) ? "Terminate" : "Resume") << " Statement" << endl;
 
@@ -404 +401 @@
 
 
-FinallyStmt::FinallyStmt( CompoundStmt * block ) : Statement(), block( block ) {
+FinallyStmt::FinallyStmt( CompoundStmt *block ) : Statement(), block( block ) {
 }
 
@@ -414 +411 @@
 }
 
-void FinallyStmt::print( std::ostream & os, Indenter indent ) const {
+void FinallyStmt::print( std::ostream &os, Indenter indent ) const {
         os << "Finally Statement" << endl;
         os << indent << "... with block:" << endl << indent+1;
@@ -461 +458 @@
 }
 
-void WaitForStmt::print( std::ostream & os, Indenter indent ) const {
+void WaitForStmt::print( std::ostream &os, Indenter indent ) const {
         os << "Waitfor Statement" << endl;
         indent += 1;
@@ -517 +514 @@
 }
 
-void NullStmt::print( std::ostream & os, Indenter indent ) const {
+void NullStmt::print( std::ostream &os, Indenter indent ) const {
         os << "Null Statement" << endl;
         Statement::print( os, indent );
@@ -533 +530 @@
 }
 
-void ImplicitCtorDtorStmt::print( std::ostream & os, Indenter indent ) const {
+void ImplicitCtorDtorStmt::print( std::ostream &os, Indenter indent ) const {
         os << "Implicit Ctor Dtor Statement" << endl;
         os << indent << "... with Ctor/Dtor: ";

src/SynTree/Statement.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Jan 10 14:13:24 2020
-// Update Count     : 85
+// Last Modified On : Tue Mar 12 09:01:53 2019
+// Update Count     : 83
 //
 
@@ -257 +257 @@
         Statement * body;
 
-        ForStmt( std::list<Statement *> initialization, Expression * condition = nullptr, Expression * increment = nullptr, Statement * body = nullptr );
+        ForStmt( std::list<Statement *> initialization, Expression * condition = 0, Expression * increment = 0, Statement * body = 0 );
         ForStmt( const ForStmt & other );
         virtual ~ForStmt();
@@ -357 +357 @@
         FinallyStmt * finallyBlock;
 
-        TryStmt( CompoundStmt * tryBlock, std::list<CatchStmt *> & handlers, FinallyStmt * finallyBlock = nullptr );
+        TryStmt( CompoundStmt * tryBlock, std::list<CatchStmt *> & handlers, FinallyStmt * finallyBlock = 0 );
         TryStmt( const TryStmt & other );
         virtual ~TryStmt();

src/cfa.make

@@ +1 @@
+
+
 CFACOMPILE = $(CFACC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CFAFLAGS) $(CFAFLAGS) $(AM_CFLAGS) $(CFLAGS)
 LTCFACOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
@@ -19 +21 @@
         $(am__mv) $$depbase.Tpo $$depbase.Plo
 
+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)
@@ -26 +38 @@
 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 =

tests/.expect/time.txt

@@ -18 +18 @@
 Dividing that by 2 gives 2403.5 seconds
 4807 seconds is 1 hours, 20 minutes, 7 seconds
-2020 Jan  5 14:01:40 (GMT)
-1970 Jan  5 14:00:00 (GMT)
-1973 Jan  2 06:59:00 (GMT)

tests/Makefile.in

@@ -364 +364 @@
 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)
@@ -370 +378 @@
 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 = 
 debug = yes
 installed = no

tests/concurrent/examples/boundedBufferEXT.cfa

@@ -10 +10 @@
 // Created On       : Wed Apr 18 22:52:12 2018
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Jan 16 22:36:34 2020
-// Update Count     : 15
+// Last Modified On : Fri Jun 21 08:19:20 2019
+// Update Count     : 14
 //
 
@@ -37 +37 @@
 
         void insert( Buffer(T) & mutex buffer, T elem ) with( buffer ) {
-                if ( count == BufferSize ) waitfor( remove : buffer );
+                if ( count == BufferSize ) waitfor( remove, buffer );
                 elements[back] = elem;
                 back = ( back + 1 ) % BufferSize;
@@ -44 +44 @@
 
         T remove( Buffer(T) & mutex buffer ) with( buffer ) {
-                if ( count == 0 ) waitfor( insert : buffer );
+                if ( count == 0 ) waitfor( insert, buffer );
                 T elem = elements[front];
                 front = ( front + 1 ) % BufferSize;

tests/concurrent/examples/boundedBufferTHREAD.cfa

@@ -10 +10 @@
 // Created On       : Wed Apr 18 22:52:12 2018
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Jan 16 23:09:43 2020
-// Update Count     : 25
+// Last Modified On : Fri Jun 21 11:50:12 2019
+// Update Count     : 24
 //
 
@@ -44 +44 @@
         void main( Buffer & buffer ) with( buffer ) {
                 for () {
-                        waitfor( ^?{} : buffer ) {
+                        waitfor( ^?{}, buffer ) {
                                 break;
-                        } or when ( count != 20 ) waitfor( insert : buffer ) {
+                        } or when ( count != 20 ) waitfor( insert, buffer ) {
                                 back = (back + 1) % 20;
                                 count += 1;
-                        } or when ( count != 0 ) waitfor( remove : buffer ) {
+                        } or when ( count != 0 ) waitfor( remove, buffer ) {
                                 front = (front + 1) % 20;
                                 count -= 1;

tests/concurrent/examples/gortn.cfa

@@ -10 +10 @@
 // Created On       : Wed Feb 20 08:02:37 2019
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Jan 16 22:43:40 2020
-// Update Count     : 5
+// Last Modified On : Fri Jun 21 08:25:03 2019
+// Update Count     : 4
 // 
 
@@ -26 +26 @@
 void main( GoRtn & gortn ) with( gortn ) {
         for () {
-                waitfor( mem1 : gortn ) sout | i;
-                or waitfor( mem2 : gortn ) sout | f;
-                or waitfor( mem3 : gortn ) sout | m.i | m.j;
-                or waitfor( ^?{} : gortn ) break;
+                waitfor( mem1, gortn ) sout | i;
+                or waitfor( mem2, gortn ) sout | f;
+                or waitfor( mem3, gortn ) sout | m.i | m.j;
+                or waitfor( ^?{}, gortn ) break;
         }
 }

tests/concurrent/waitfor/barge.cfa

@@ -65 +65 @@
                 yield(random( 10 ));
                 this.state = WAITFOR;
-                waitfor(do_call : this) {
+                waitfor(do_call, this) {
                         sout | i;
                 }

tests/concurrent/waitfor/dtor.cfa

@@ -47 +47 @@
         yield(random( 10 ));
         set_state( this, MAIN );
-        waitfor( ^?{} : this ) {
+        waitfor( ^?{}, this ) {
                 set_state( this, AFTER );
         }

tests/concurrent/waitfor/else.cfa

@@ -14 +14 @@
         sout | "Starting";
 
-        when( false ) waitfor( notcalled : m );
+        when( false ) waitfor( notcalled, m );
 
         sout | "Step" | i++;
 
-        waitfor( notcalled : m ); or else {
+        waitfor( notcalled, m ); or else {
                 sout | "else called";
         }
@@ -24 +24 @@
         sout | "Step" | i++;
 
-        when( true ) waitfor( notcalled : m ); or when( true ) else {
+        when( true ) waitfor( notcalled, m ); or when( true ) else {
                 sout | "else called";
         }
@@ -30 +30 @@
         sout | "Step" | i++;
 
-        when( false ) waitfor( notcalled : m ); or when( true ) else {
+        when( false ) waitfor( notcalled, m ); or when( true ) else {
                 sout | "else called";
         }
@@ -36 +36 @@
         sout | "Step" | i++;
 
-        when( false ) waitfor( notcalled : m ); or when( false ) else {
+        when( false ) waitfor( notcalled, m ); or when( false ) else {
                 sout | "else called";
         }

tests/concurrent/waitfor/parse.cfa

@@ -24 +24 @@
 
         //---------------------------------------
-        waitfor( f1 : a ) {
+        waitfor( f1, a ) {
                 1;
         }
 
         //---------------------------------------
-        waitfor( f1 : a ) {
+        waitfor( f1, a ) {
                 2;
         }
-        waitfor( f2 : a ) {
+        waitfor( f2, a ) {
                 3;
         }
 
         //---------------------------------------
-        when( 1 < 3 ) waitfor( f2 : a, a ) {
+        when( 1 < 3 ) waitfor( f2, a, a ) {
                 4;
         }
@@ -45 +45 @@
 
         //---------------------------------------
-        when( 2 < 3 ) waitfor( f3 : a ) {
+        when( 2 < 3 ) waitfor( f3, a ) {
                 5;
         }
@@ -53 +53 @@
 
         //---------------------------------------
-        when( 3 < 3 ) waitfor( f3 : a, a ) {
+        when( 3 < 3 ) waitfor( f3, a, a ) {
                 7;
         }
@@ -64 +64 @@
 
         //---------------------------------------
-        when( 6 < 3 ) waitfor( f3 : a, a, a ) {
+        when( 6 < 3 ) waitfor( f3, a, a, a ) {
                 10;
         }
-        or when( 7 < 3 ) waitfor( f1 : a  ) {
+        or when( 7 < 3 ) waitfor( f1, a  ) {
                 11;
         }
@@ -75 +75 @@
 
         //---------------------------------------
-        when( 8 < 3 ) waitfor( f3 : a, a ) {
+        when( 8 < 3 ) waitfor( f3, a, a ) {
                 13;
         }
-        or waitfor( f1 : a  ) {
+        or waitfor( f1, a  ) {
                 14;
         }
@@ -86 +86 @@
 
         //---------------------------------------
-        when( 10 < 3 ) waitfor( f1 : a ) {
+        when( 10 < 3 ) waitfor( f1, a ) {
                 16;
         }
-        or waitfor( f2 : a, a ) {
+        or waitfor( f2, a, a ) {
                 17;
         }
@@ -100 +100 @@
 }
 
-int main() {}
+int main() {
+
+}

tests/concurrent/waitfor/parse2.cfa

@@ -10 +10 @@
 // Created On       : Wed Aug 30 17:53:29 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Jan 16 23:13:37 2020
-// Update Count     : 6
+// Last Modified On : Fri Mar 22 13:42:11 2019
+// Update Count     : 3
 // 
 
@@ -26 +26 @@
         }
 
-        waitfor( x : z ) {
+        waitfor( x, z ) {
         }
 
@@ -37 +37 @@
         or waitfor( y );
 
-        waitfor( x : z );
+        waitfor( x, z );
         or waitfor( y );
 
@@ -43 +43 @@
         or when( true ) waitfor( y );
 
-        when( true ) waitfor( x : z );
+        when( true ) waitfor( x, z );
         or when( true ) waitfor( y );
 
@@ -50 +50 @@
         }
 
-        waitfor( x : z ) {
+        waitfor( x, z ) {
         } or waitfor( y ) {
         }
@@ -80 +80 @@
         or else;
 
-        when( true ) waitfor( x : z );
+        when( true ) waitfor( x, z );
         or else;
 
@@ -99 +99 @@
         }
 
-        when( true ) waitfor( x : z );
+        when( true ) waitfor( x, z );
         or else {
         }
@@ -115 +115 @@
         or when( true ) else;
 
-        when( true ) waitfor( x : z );
+        when( true ) waitfor( x, z );
         or when( true ) else;
 
@@ -134 +134 @@
         }
 
-        when( true ) waitfor( x : z );
+        when( true ) waitfor( x, z );
         or when( true ) else {
         }
@@ -149 +149 @@
         or timeout( 3 );
 
-        waitfor( x : z );
+        waitfor( x, z );
         or timeout( 3 );
 
@@ -163 +163 @@
         }
 
-        when( true ) waitfor( x : z ) {
+        when( true ) waitfor( x, z ) {
         } or timeout( 3 ) {
         }
@@ -171 +171 @@
         }
 
-        when( true ) waitfor( x : z ) {
+        when( true ) waitfor( x, z ) {
         } or when ( true ) timeout( 3 ) {
         }
@@ -229 +229 @@
 
         int or, timeout;
-        waitfor( timeout : 7 ) 3;
-        waitfor( timeout : 7 ) 3; or waitfor( timeout : 7 ) 3;
-        when( or ) waitfor( or : ) { 4; } or timeout( 1 ) 3;
-        when( 3 ) waitfor( or : 2 ) 4; or else 4;
-        when( 3 ) waitfor( or : 3 ) 4; or when( or ) timeout( or ) 4; or when( or ) else timeout;
-        when( 3 ) waitfor( or : or ) 3; or when( or ) waitfor( or : timeout ) 4; or else 4;
-        when( 3 ) waitfor( or : or ) 3; or waitfor( or : 9 ) 4; or when( or ) timeout( timeout ) 4;
-        when( 3 ) waitfor( or : 3 ) 3; or waitfor( or : 7 ) or; or timeout( 1 ) or; or when( 3 ) else or;
+        waitfor( timeout, 7 ) 3;
+        waitfor( timeout, 7 ) 3; or waitfor( timeout, 7 ) 3;
+        when( or ) waitfor( or, ) { 4; } or timeout( 1 ) 3;
+        when( 3 ) waitfor( or, 2 ) 4; or else 4;
+        when( 3 ) waitfor( or, 3 ) 4; or when( or ) timeout( or ) 4; or when( or ) else timeout;
+        when( 3 ) waitfor( or, or ) 3; or when( or ) waitfor( or, timeout ) 4; or else 4;
+        when( 3 ) waitfor( or, or ) 3; or waitfor( or, 9 ) 4; or when( or ) timeout( timeout ) 4;
+        when( 3 ) waitfor( or, 3 ) 3; or waitfor( or, 7 ) or; or timeout( 1 ) or; or when( 3 ) else or;
 
         // test else selection

tests/concurrent/waitfor/recurse.cfa

@@ -66 +66 @@
 
         rand_yield();
-        waitfor( call4 : this );
+        waitfor( call4, this );
         rand_yield();
 
@@ -78 +78 @@
 
         rand_yield();
-        waitfor( call3 : this );
+        waitfor( call3, this );
         rand_yield();
 
@@ -92 +92 @@
 
         rand_yield();
-        waitfor( call2 : this );
+        waitfor( call2, this );
         rand_yield();
 

tests/concurrent/waitfor/statment.cfa

@@ -101 +101 @@
 
         while( !done ) {
-                   waitfor( get_index : this );
-                or waitfor( call1 : this ) { sout | "Statement"; if( this.last_val != 1 ) { serr | "Incorrect index: expected" | 1 | "got" | this.last_val; } }
-                or waitfor( call2 : this ) { sout | "Statement"; if( this.last_val != 2 ) { serr | "Incorrect index: expected" | 2 | "got" | this.last_val; } }
-                or waitfor( call3 : this ) { sout | "Statement"; if( this.last_val != 3 ) { serr | "Incorrect index: expected" | 3 | "got" | this.last_val; } }
-                or waitfor( call4 : this ) { sout | "Statement"; if( this.last_val != 4 ) { serr | "Incorrect index: expected" | 4 | "got" | this.last_val; } }
-                or waitfor( call5 : this ) { sout | "Statement"; if( this.last_val != 5 ) { serr | "Incorrect index: expected" | 5 | "got" | this.last_val; } }
-                or waitfor( call6 : this ) { sout | "Statement"; if( this.last_val != 6 ) { serr | "Incorrect index: expected" | 6 | "got" | this.last_val; } }
-                or waitfor( call7 : this ) { sout | "Statement"; if( this.last_val != 7 ) { serr | "Incorrect index: expected" | 7 | "got" | this.last_val; } }
+                   waitfor( get_index, this );
+                or waitfor( call1, this ) { sout | "Statement"; if( this.last_val != 1 ) { serr | "Incorrect index: expected" | 1 | "got" | this.last_val; } }
+                or waitfor( call2, this ) { sout | "Statement"; if( this.last_val != 2 ) { serr | "Incorrect index: expected" | 2 | "got" | this.last_val; } }
+                or waitfor( call3, this ) { sout | "Statement"; if( this.last_val != 3 ) { serr | "Incorrect index: expected" | 3 | "got" | this.last_val; } }
+                or waitfor( call4, this ) { sout | "Statement"; if( this.last_val != 4 ) { serr | "Incorrect index: expected" | 4 | "got" | this.last_val; } }
+                or waitfor( call5, this ) { sout | "Statement"; if( this.last_val != 5 ) { serr | "Incorrect index: expected" | 5 | "got" | this.last_val; } }
+                or waitfor( call6, this ) { sout | "Statement"; if( this.last_val != 6 ) { serr | "Incorrect index: expected" | 6 | "got" | this.last_val; } }
+                or waitfor( call7, this ) { sout | "Statement"; if( this.last_val != 7 ) { serr | "Incorrect index: expected" | 7 | "got" | this.last_val; } }
 
                 done = true;

tests/concurrent/waitfor/when.cfa

@@ -58 +58 @@
 void arbiter( global_t & mutex this ) {
         for( int i = 0; i < N; i++ ) {
-                   when( this.last_call == 6 ) waitfor( call1 : this ) { if( this.last_call != 1) { serr | "Expected last_call to be 1 got" | this.last_call; } }
-                or when( this.last_call == 1 ) waitfor( call2 : this ) { if( this.last_call != 2) { serr | "Expected last_call to be 2 got" | this.last_call; } }
-                or when( this.last_call == 2 ) waitfor( call3 : this ) { if( this.last_call != 3) { serr | "Expected last_call to be 3 got" | this.last_call; } }
-                or when( this.last_call == 3 ) waitfor( call4 : this ) { if( this.last_call != 4) { serr | "Expected last_call to be 4 got" | this.last_call; } }
-                or when( this.last_call == 4 ) waitfor( call5 : this ) { if( this.last_call != 5) { serr | "Expected last_call to be 5 got" | this.last_call; } }
-                or when( this.last_call == 5 ) waitfor( call6 : this ) { if( this.last_call != 6) { serr | "Expected last_call to be 6 got" | this.last_call; } }
+                   when( this.last_call == 6 ) waitfor( call1, this ) { if( this.last_call != 1) { serr | "Expected last_call to be 1 got" | this.last_call; } }
+                or when( this.last_call == 1 ) waitfor( call2, this ) { if( this.last_call != 2) { serr | "Expected last_call to be 2 got" | this.last_call; } }
+                or when( this.last_call == 2 ) waitfor( call3, this ) { if( this.last_call != 3) { serr | "Expected last_call to be 3 got" | this.last_call; } }
+                or when( this.last_call == 3 ) waitfor( call4, this ) { if( this.last_call != 4) { serr | "Expected last_call to be 4 got" | this.last_call; } }
+                or when( this.last_call == 4 ) waitfor( call5, this ) { if( this.last_call != 5) { serr | "Expected last_call to be 5 got" | this.last_call; } }
+                or when( this.last_call == 5 ) waitfor( call6, this ) { if( this.last_call != 6) { serr | "Expected last_call to be 6 got" | this.last_call; } }
 
                 sout | this.last_call;

tests/expression.cfa

@@ -1 @@
-struct S { int i; };
-void ?{}( S & s, int i ) { s.i = i; }
-int ?`mary( int );
-int ?`mary( S );
-[int] ?`mary( [int, int] );
-int & ?`jane( int & );
-int jack( int );
-
 int main() {
-    int a[3] = { 0, 0, 0 };
-    S s = { 3 }, * ps = &s;
-    [int] t = { 3 };
-    * [int] pt = &t;
-    int i = 1, j = 2;
+    struct s { int i; } x, *p = &x;
+    int i = 3;
 
     // operators
 
-    !i;
+    ! i;
     ~i;
     +i;
     -i;
-    *ps;
-    ++ps;
-    --ps;
-    ps++;
-    ps--;
+    *p;
+    ++p;
+    --p;
+    p++;
+    p--;
 
-    i + j;
-    i - j;
-    i * j;
+    i+i;
+    i-i;
+    i*i;
 
-    i / j;
-    i % j;
-    i ^ j;
-    i & j;
-    i | j;
-    i < j;
-    i > j;
-    i = j;
+    i/i;
+    i%i;
+    i^i;
+    i&i;
+    i|i;
+    i<i;
+    i>i;
+    i=i;
 
-    i == j;
-    i != j;
-    i << j;
-    i >> j;
-    i <= j;
-    i >= j;
-    i && j;
-    i || j;
-    ps->i;
+    i==i;
+    i!=i;
+    i<<i;
+    i>>i;
+    i<=i;
+    i>=i;
+    i&&i;
+    i||i;
+    p->i;
+    i*=i;
+    i/=i;
+    i%=i;
+    i+=i;
+    i-=i;
+    i&=i;
+    i|=i;
+    i^=i;
+    i<<=i;
+    i>>=i;
 
-    i *= j;
-    i /= j;
-    i %= j;
-    i += j;
-    i -= j;
-    i &= j;
-    i |= j;
-    i ^= j;
-    i <<= j;
-    i >>= j;
-
-    i ? i : j;
-
-    // postfix function call
-
-    (3 + 4)`mary;
-    ({3 + 4;})`mary;
-    [3, 4]`mary;
-    3`mary;
-    a[0]`mary;
-    a[0]`mary`mary;
-    s{0}`mary;
-    a[3]`jane++;
-    jack(3)`mary;
-    s.i`mary;
-    t.0`mary;
-    s.[i]`mary;
-    ps->i`mary;
-    pt->0`mary;
-    ps->[i]`mary;
-    i++`mary;
-    i--`mary;
-    (S){2}`mary;
-    (S)@{2}`mary;
+    i?i:i;
 } // main

tests/quotedKeyword.cfa

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Feb  1 00:02:22 2020
-// Update Count     : 24
+// Last Modified On : Tue Dec  4 21:45:53 2018
+// Update Count     : 23
 //
 
@@ -17 +17 @@
 
 struct {
-        int ``otype``;
-        int ``struct``;
+        int `otype`;
+        int `struct`;
 } st = { 10, 10 };
 
-typedef int ``forall``;
-``forall`` xxx = 10;
+typedef int `forall`;
+`forall` xxx = 10;
 
-int ``_Alignas``, ``_Alignof``, ``__alignof``, ``__alignof__``, ``asm``, ``__asm``, ``__asm__``, ``_At``, ``_Atomic``, ``__attribute``,
-        ``__attribute__``, ``auto``, ``_Bool``, ``break``, ``case``, ``catch``, ``catchResume``, ``char``, ``choose``, ``_Complex``, ``__complex``,
-        ``__complex__``, ``const``, ``__const``, ``__const__``, ``continue``, ``default``, ``disable``, ``do``, ``double``, ``dtype``, ``else``,
-        ``enable``, ``enum``, ``__extension__``, ``extern``, ``fallthru``, ``finally``, ``float``, ``__float128``, ``for``, ``forall``, ``fortran``,
-        ``ftype``, ``_Generic``, ``goto``, ``if``, ``_Imaginary``, ``__imag``, ``__imag__``, ``inline``, ``__inline``, ``__inline__``, ``int``,
-        ``__int128``, ``__label__``, ``long``, ``lvalue``, ``_Noreturn``, ``__builtin_offsetof``, ``otype``, ``register``, ``restrict``,
-        ``__restrict``, ``__restrict__``, ``return``, ``short``, ``signed``, ``__signed``, ``__signed__``, ``sizeof``, ``static``,
-        ``_Static_assert``, ``struct``, ``switch``, ``_Thread_local``, ``throw``, ``throwResume``, ``trait``, ``try``, ``typedef``,
-        ``typeof``, ``__typeof``, ``__typeof__``, ``union``, ``unsigned``, ``__builtin_va_list``, ``void``, ``volatile``, ``__volatile``,
-        ``__volatile__``, ``while``;
+int `_Alignas`, `_Alignof`, `__alignof`, `__alignof__`, `asm`, `__asm`, `__asm__`, `_At`, `_Atomic`, `__attribute`,
+        `__attribute__`, `auto`, `_Bool`, `break`, `case`, `catch`, `catchResume`, `char`, `choose`, `_Complex`, `__complex`,
+        `__complex__`, `const`, `__const`, `__const__`, `continue`, `default`, `disable`, `do`, `double`, `dtype`, `else`,
+        `enable`, `enum`, `__extension__`, `extern`, `fallthru`, `finally`, `float`, `__float128`, `for`, `forall`, `fortran`,
+        `ftype`, `_Generic`, `goto`, `if`, `_Imaginary`, `__imag`, `__imag__`, `inline`, `__inline`, `__inline__`, `int`,
+        `__int128`, `__label__`, `long`, `lvalue`, `_Noreturn`, `__builtin_offsetof`, `otype`, `register`, `restrict`,
+        `__restrict`, `__restrict__`, `return`, `short`, `signed`, `__signed`, `__signed__`, `sizeof`, `static`,
+        `_Static_assert`, `struct`, `switch`, `_Thread_local`, `throw`, `throwResume`, `trait`, `try`, `typedef`,
+        `typeof`, `__typeof`, `__typeof__`, `union`, `unsigned`, `__builtin_va_list`, `void`, `volatile`, `__volatile`,
+        `__volatile__`, `while`;
 
 int main() {
-        int ``if`` = 0;
-        ``catch`` = 1;
-        st.``otype`` = 2;
-        st.``struct`` = 3;
-        ``throw`` = 4;
-        sout | ``catch`` + st.``otype`` + st.``struct`` + ``throw``;
+        int `if` = 0;
+        `catch` = 1;
+        st.`otype` = 2;
+        st.`struct` = 3;
+        `throw` = 4;
+        sout | `catch` + st.`otype` + st.`struct` + `throw`;
 }
 

tests/time.cfa

@@ -10 +10 @@
 // Created On       : Tue Mar 27 17:24:56 2018
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Jan  5 18:27:37 2020
-// Update Count     : 34
+// Last Modified On : Fri Nov 29 23:05:30 2019
+// Update Count     : 24
 //
 
@@ -34 +34 @@
         sout | t;
         t = t + d1;
-        sout | t | t`ns;
+        sout | t | t.tv;
         Time t1 = (timespec){ 104_414, 10_000_000 };
-        sout | t1 | t1`ns;
-        sout | t - t  | t + d5 | t`ns;
-        char buf[64];
+        sout | t1 | t1.tv;
+        sout | t - t  | t + d5 | t.tv;
+        char buf[16];
         sout | "yy/mm/dd" | [t, buf]`ymd | nonl;                        // shared buf => separate calls
         sout | "mm/dd/yy" | mm_dd_yy( t, buf ) | nonl;
@@ -45 +45 @@
         sout | "dd/yy/mm" | [t, buf]`dmy;
         Time t2 = { 2001, 7, 4, 0, 0, 1, 0 }, t3 = (timeval){ 994_219_201 };
-        sout | t2 | t2`ns | nl | t3 | t3`ns;
+        sout | t2 | t2.tv | nl | t3 | t3.tv;
         sout | nl;
 
@@ -62 +62 @@
         sout | "Dividing that by 2 gives" | s / 2 | "seconds";
         sout | s | "seconds is" | s`h | "hours," | (s % 1`h)`m | "minutes," | (s % 1`m)`s | "seconds";
-
-    t1 = (Time){ 2020, 1, 5, 9, 0, 0, 100000000000LL };
-    t2 = (Time){ 1969, 13, 5, 9 };
-    t3 = (Time){ 1970, 25, 366, 48, 120, -120, 60000000000LL };
-    strftime( buf, 128, "%Y %b %e %H:%M:%S (GMT)", t1 );
-    sout | buf;
-    strftime( buf, 128, "%Y %b %e %H:%M:%S (GMT)", t2 );
-    sout | buf;
-    strftime( buf, 128, "%Y %b %e %H:%M:%S (GMT)", t3 );
-    sout | buf;
 } // main
 

tools/stat.py

@@ -17 +17 @@
                 avg = numpy.mean  (content)
                 std = numpy.std   (content)
-                print "median {0:.1f} avg {1:.1f} stddev {2:.1f}".format( med, avg, std )
+                print "median {0:.1f} avg {1:.1f} stddev {2:.2f}".format( med, avg, std )