Changeset 6a490b2 for libcfa

Timestamp:

May 11, 2020, 1:53:29 PM (5 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

504a7dc

Parents:

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

Message:

Merge branch 'master' into relaxed_ready

Location:

libcfa

Files:

• Makefile.in (modified) (1 diff)
• configure (modified) (17 diffs)
• configure.ac (modified) (3 diffs)
• prelude/Makefile.am (modified) (1 diff)
• prelude/Makefile.in (modified) (11 diffs)
• prelude/builtins.c (modified) (1 diff)
• prelude/defines.hfa.in (added)
• src/Makefile.am (modified) (4 diffs)
• src/Makefile.in (modified) (9 diffs)
• src/bitmanip.hfa (added)
• src/bits/containers.hfa (modified) (3 diffs)
• src/bits/debug.hfa (modified) (6 diffs)
• src/bits/locks.hfa (modified) (5 diffs)
• src/bits/signal.hfa (modified) (1 diff)
• src/concurrency/CtxSwitch-arm.S (modified) (2 diffs)
• src/concurrency/CtxSwitch-i386.S (modified) (2 diffs)
• src/concurrency/CtxSwitch-x86_64.S (modified) (3 diffs)
• src/concurrency/alarm.cfa (modified) (6 diffs)
• src/concurrency/alarm.hfa (modified) (3 diffs)
• src/concurrency/asyncio.hfa (added)
• src/concurrency/coroutine.cfa (modified) (7 diffs)
• src/concurrency/coroutine.hfa (modified) (10 diffs)
• src/concurrency/invoke.c (modified) (7 diffs)
• src/concurrency/invoke.h (modified) (11 diffs)
• src/concurrency/io.cfa (added)
• src/concurrency/iofwd.hfa (added)
• src/concurrency/kernel.cfa (modified) (43 diffs)
• src/concurrency/kernel.hfa (modified) (9 diffs)
• src/concurrency/kernel_private.hfa (modified) (5 diffs)
• src/concurrency/monitor.cfa (modified) (41 diffs)
• src/concurrency/monitor.hfa (modified) (7 diffs)
• src/concurrency/mutex.cfa (modified) (8 diffs)
• src/concurrency/mutex.hfa (modified) (3 diffs)
• src/concurrency/preemption.cfa (modified) (12 diffs)
• src/concurrency/thread.cfa (modified) (3 diffs)
• src/concurrency/thread.hfa (modified) (3 diffs)
• src/containers/list.hfa (added)
• src/exception.c (modified) (24 diffs)
• src/exception.h (modified) (3 diffs)
• src/exception.hfa (added)
• src/heap.cfa (modified) (47 diffs)
• src/interpose.cfa (modified) (6 diffs)
• src/iostream.cfa (modified) (5 diffs)
• src/startup.cfa (modified) (3 diffs)
• src/stdhdr/malloc.h (modified) (2 diffs)
• src/stdlib.cfa (modified) (4 diffs)
• src/stdlib.hfa (modified) (10 diffs)

libcfa/Makefile.in

@@ -106 +106 @@
  configure.lineno config.status.lineno
 mkinstalldirs = $(install_sh) -d
+CONFIG_HEADER = $(top_builddir)/prelude/defines.hfa
 CONFIG_CLEAN_FILES =
 CONFIG_CLEAN_VPATH_FILES =

libcfa/configure

@@ -790 +790 @@
 enable_distcc
 with_cfa_name
+enable_static
 enable_shared
-enable_static
 with_pic
 enable_fast_install
@@ -1452 +1452 @@
   --disable-silent-rules  verbose build output (undo: "make V=0")
   --enable-distcc     whether or not to enable distributed compilation
+  --enable-static[=PKGS]  build static libraries [default=no]
   --enable-shared[=PKGS]  build shared libraries [default=yes]
-  --enable-static[=PKGS]  build static libraries [default=yes]
   --enable-fast-install[=PKGS]
                           optimize for fast installation [default=yes]
@@ -1960 +1960 @@
 
 } # ac_fn_cxx_try_link
+
+# ac_fn_c_check_header_mongrel LINENO HEADER VAR INCLUDES
+# -------------------------------------------------------
+# Tests whether HEADER exists, giving a warning if it cannot be compiled using
+# the include files in INCLUDES and setting the cache variable VAR
+# accordingly.
+ac_fn_c_check_header_mongrel ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  if eval \${$3+:} false; then :
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+$as_echo_n "checking for $2... " >&6; }
+if eval \${$3+:} false; then :
+  $as_echo_n "(cached) " >&6
+fi
+eval ac_res=\$$3
+               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+else
+  # Is the header compilable?
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
+$as_echo_n "checking $2 usability... " >&6; }
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$4
+#include <$2>
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_header_compiler=yes
+else
+  ac_header_compiler=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
+$as_echo "$ac_header_compiler" >&6; }
+
+# Is the header present?
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
+$as_echo_n "checking $2 presence... " >&6; }
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <$2>
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+  ac_header_preproc=yes
+else
+  ac_header_preproc=no
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
+$as_echo "$ac_header_preproc" >&6; }
+
+# So?  What about this header?
+case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in #((
+  yes:no: )
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
+$as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
+$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
+    ;;
+  no:yes:* )
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
+$as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     check for missing prerequisite headers?" >&5
+$as_echo "$as_me: WARNING: $2:     check for missing prerequisite headers?" >&2;}
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
+$as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&5
+$as_echo "$as_me: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&2;}
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
+$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
+( $as_echo "## --------------------------------------- ##
+## Report this to cforall@plg.uwaterloo.ca ##
+## --------------------------------------- ##"
+     ) | sed "s/^/$as_me: WARNING:     /" >&2
+    ;;
+esac
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+$as_echo_n "checking for $2... " >&6; }
+if eval \${$3+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  eval "$3=\$ac_header_compiler"
+fi
+eval ac_res=\$$3
+               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+fi
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+
+} # ac_fn_c_check_header_mongrel
 cat >config.log <<_ACEOF
 This file contains any messages produced by compilers while
@@ -7939 +8030 @@
 
 # Set options
+# Check whether --enable-static was given.
+if test "${enable_static+set}" = set; then :
+  enableval=$enable_static; p=${PACKAGE-default}
+    case $enableval in
+    yes) enable_static=yes ;;
+    no) enable_static=no ;;
+    *)
+     enable_static=no
+      # Look at the argument we got.  We use all the common list separators.
+      lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
+      for pkg in $enableval; do
+        IFS=$lt_save_ifs
+        if test "X$pkg" = "X$p"; then
+          enable_static=yes
+        fi
+      done
+      IFS=$lt_save_ifs
+      ;;
+    esac
+else
+  enable_static=no
+fi
+
+
+
+
+
+
+
 
 
@@ -7971 +8091 @@
 fi
 
-
-
-
-
-
-
-
-
-  # Check whether --enable-static was given.
-if test "${enable_static+set}" = set; then :
-  enableval=$enable_static; p=${PACKAGE-default}
-    case $enableval in
-    yes) enable_static=yes ;;
-    no) enable_static=no ;;
-    *)
-     enable_static=no
-      # Look at the argument we got.  We use all the common list separators.
-      lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
-      for pkg in $enableval; do
-        IFS=$lt_save_ifs
-        if test "X$pkg" = "X$p"; then
-          enable_static=yes
-        fi
-      done
-      IFS=$lt_save_ifs
-      ;;
-    esac
-else
-  enable_static=yes
-fi
 
 
@@ -16859 +16949 @@
 
 
+for ac_header in linux/io_uring.h
+do :
+  ac_fn_c_check_header_mongrel "$LINENO" "linux/io_uring.h" "ac_cv_header_linux_io_uring_h" "$ac_includes_default"
+if test "x$ac_cv_header_linux_io_uring_h" = xyes; then :
+  cat >>confdefs.h <<_ACEOF
+#define HAVE_LINUX_IO_URING_H 1
+_ACEOF
+
+fi
+
+done
+
+for ac_func in preadv2 pwritev2
+do :
+  as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
+ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
+if eval test \"x\$"$as_ac_var"\" = x"yes"; then :
+  cat >>confdefs.h <<_ACEOF
+#define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1
+_ACEOF
+
+fi
+done
+
+
 ac_config_files="$ac_config_files Makefile src/Makefile prelude/Makefile"
+
+
+ac_config_headers="$ac_config_headers prelude/defines.hfa"
 
 
@@ -16952 +17070 @@
 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
 
-# Transform confdefs.h into DEFS.
-# Protect against shell expansion while executing Makefile rules.
-# Protect against Makefile macro expansion.
-#
-# If the first sed substitution is executed (which looks for macros that
-# take arguments), then branch to the quote section.  Otherwise,
-# look for a macro that doesn't take arguments.
-ac_script='
-:mline
-/\\$/{
- N
- s,\\\n,,
- b mline
-}
-t clear
-:clear
-s/^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\)/-D\1=\2/g
-t quote
-s/^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\)/-D\1=\2/g
-t quote
-b any
-:quote
-s/[      `~#$^&*(){}\\|;'\''"<>?]/\\&/g
-s/\[/\\&/g
-s/\]/\\&/g
-s/\$/$$/g
-H
-:any
-${
-        g
-        s/^\n//
-        s/\n/ /g
-        p
-}
-'
-DEFS=`sed -n "$ac_script" confdefs.h`
-
+DEFS=-DHAVE_CONFIG_H
 
 ac_libobjs=
@@ -17466 +17548 @@
 esac
 
+case $ac_config_headers in *"
+"*) set x $ac_config_headers; shift; ac_config_headers=$*;;
+esac
 
 
@@ -17471 +17556 @@
 # Files that config.status was made for.
 config_files="$ac_config_files"
+config_headers="$ac_config_headers"
 config_commands="$ac_config_commands"
 
@@ -17492 +17578 @@
       --file=FILE[:TEMPLATE]
                    instantiate the configuration file FILE
+      --header=FILE[:TEMPLATE]
+                   instantiate the configuration header FILE
 
 Configuration files:
 $config_files
+
+Configuration headers:
+$config_headers
 
 Configuration commands:
@@ -17562 +17653 @@
     as_fn_append CONFIG_FILES " '$ac_optarg'"
     ac_need_defaults=false;;
-  --he | --h |  --help | --hel | -h )
+  --header | --heade | --head | --hea )
+    $ac_shift
+    case $ac_optarg in
+    *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
+    esac
+    as_fn_append CONFIG_HEADERS " '$ac_optarg'"
+    ac_need_defaults=false;;
+  --he | --h)
+    # Conflict between --help and --header
+    as_fn_error $? "ambiguous option: \`$1'
+Try \`$0 --help' for more information.";;
+  --help | --hel | -h )
     $as_echo "$ac_cs_usage"; exit ;;
   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
@@ -17625 +17727 @@
 macro_version='`$ECHO "$macro_version" | $SED "$delay_single_quote_subst"`'
 macro_revision='`$ECHO "$macro_revision" | $SED "$delay_single_quote_subst"`'
+enable_static='`$ECHO "$enable_static" | $SED "$delay_single_quote_subst"`'
 enable_shared='`$ECHO "$enable_shared" | $SED "$delay_single_quote_subst"`'
-enable_static='`$ECHO "$enable_static" | $SED "$delay_single_quote_subst"`'
 pic_mode='`$ECHO "$pic_mode" | $SED "$delay_single_quote_subst"`'
 enable_fast_install='`$ECHO "$enable_fast_install" | $SED "$delay_single_quote_subst"`'
@@ -18009 +18111 @@
     "src/Makefile") CONFIG_FILES="$CONFIG_FILES src/Makefile" ;;
     "prelude/Makefile") CONFIG_FILES="$CONFIG_FILES prelude/Makefile" ;;
+    "prelude/defines.hfa") CONFIG_HEADERS="$CONFIG_HEADERS prelude/defines.hfa" ;;
 
   *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
@@ -18021 +18124 @@
 if $ac_need_defaults; then
   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
+  test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers
   test "${CONFIG_COMMANDS+set}" = set || CONFIG_COMMANDS=$config_commands
 fi
@@ -18209 +18313 @@
 fi # test -n "$CONFIG_FILES"
 
-
-eval set X "  :F $CONFIG_FILES      :C $CONFIG_COMMANDS"
+# Set up the scripts for CONFIG_HEADERS section.
+# No need to generate them if there are no CONFIG_HEADERS.
+# This happens for instance with `./config.status Makefile'.
+if test -n "$CONFIG_HEADERS"; then
+cat >"$ac_tmp/defines.awk" <<\_ACAWK ||
+BEGIN {
+_ACEOF
+
+# Transform confdefs.h into an awk script `defines.awk', embedded as
+# here-document in config.status, that substitutes the proper values into
+# config.h.in to produce config.h.
+
+# Create a delimiter string that does not exist in confdefs.h, to ease
+# handling of long lines.
+ac_delim='%!_!# '
+for ac_last_try in false false :; do
+  ac_tt=`sed -n "/$ac_delim/p" confdefs.h`
+  if test -z "$ac_tt"; then
+    break
+  elif $ac_last_try; then
+    as_fn_error $? "could not make $CONFIG_HEADERS" "$LINENO" 5
+  else
+    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
+  fi
+done
+
+# For the awk script, D is an array of macro values keyed by name,
+# likewise P contains macro parameters if any.  Preserve backslash
+# newline sequences.
+
+ac_word_re=[_$as_cr_Letters][_$as_cr_alnum]*
+sed -n '
+s/.\{148\}/&'"$ac_delim"'/g
+t rset
+:rset
+s/^[     ]*#[    ]*define[       ][      ]*/ /
+t def
+d
+:def
+s/\\$//
+t bsnl
+s/["\\]/\\&/g
+s/^ \('"$ac_word_re"'\)\(([^()]*)\)[     ]*\(.*\)/P["\1"]="\2"\
+D["\1"]=" \3"/p
+s/^ \('"$ac_word_re"'\)[         ]*\(.*\)/D["\1"]=" \2"/p
+d
+:bsnl
+s/["\\]/\\&/g
+s/^ \('"$ac_word_re"'\)\(([^()]*)\)[     ]*\(.*\)/P["\1"]="\2"\
+D["\1"]=" \3\\\\\\n"\\/p
+t cont
+s/^ \('"$ac_word_re"'\)[         ]*\(.*\)/D["\1"]=" \2\\\\\\n"\\/p
+t cont
+d
+:cont
+n
+s/.\{148\}/&'"$ac_delim"'/g
+t clear
+:clear
+s/\\$//
+t bsnlc
+s/["\\]/\\&/g; s/^/"/; s/$/"/p
+d
+:bsnlc
+s/["\\]/\\&/g; s/^/"/; s/$/\\\\\\n"\\/p
+b cont
+' <confdefs.h | sed '
+s/'"$ac_delim"'/"\\\
+"/g' >>$CONFIG_STATUS || ac_write_fail=1
+
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+  for (key in D) D_is_set[key] = 1
+  FS = ""
+}
+/^[\t ]*#[\t ]*(define|undef)[\t ]+$ac_word_re([\t (]|\$)/ {
+  line = \$ 0
+  split(line, arg, " ")
+  if (arg[1] == "#") {
+    defundef = arg[2]
+    mac1 = arg[3]
+  } else {
+    defundef = substr(arg[1], 2)
+    mac1 = arg[2]
+  }
+  split(mac1, mac2, "(") #)
+  macro = mac2[1]
+  prefix = substr(line, 1, index(line, defundef) - 1)
+  if (D_is_set[macro]) {
+    # Preserve the white space surrounding the "#".
+    print prefix "define", macro P[macro] D[macro]
+    next
+  } else {
+    # Replace #undef with comments.  This is necessary, for example,
+    # in the case of _POSIX_SOURCE, which is predefined and required
+    # on some systems where configure will not decide to define it.
+    if (defundef == "undef") {
+      print "/*", prefix defundef, macro, "*/"
+      next
+    }
+  }
+}
+{ print }
+_ACAWK
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+  as_fn_error $? "could not setup config headers machinery" "$LINENO" 5
+fi # test -n "$CONFIG_HEADERS"
+
+
+eval set X "  :F $CONFIG_FILES  :H $CONFIG_HEADERS    :C $CONFIG_COMMANDS"
 shift
 for ac_tag
@@ -18429 +18641 @@
   || as_fn_error $? "could not create $ac_file" "$LINENO" 5
  ;;
-
+  :H)
+  #
+  # CONFIG_HEADER
+  #
+  if test x"$ac_file" != x-; then
+    {
+      $as_echo "/* $configure_input  */" \
+      && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs"
+    } >"$ac_tmp/config.h" \
+      || as_fn_error $? "could not create $ac_file" "$LINENO" 5
+    if diff "$ac_file" "$ac_tmp/config.h" >/dev/null 2>&1; then
+      { $as_echo "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5
+$as_echo "$as_me: $ac_file is unchanged" >&6;}
+    else
+      rm -f "$ac_file"
+      mv "$ac_tmp/config.h" "$ac_file" \
+        || as_fn_error $? "could not create $ac_file" "$LINENO" 5
+    fi
+  else
+    $as_echo "/* $configure_input  */" \
+      && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" \
+      || as_fn_error $? "could not create -" "$LINENO" 5
+  fi
+# Compute "$ac_file"'s index in $config_headers.
+_am_arg="$ac_file"
+_am_stamp_count=1
+for _am_header in $config_headers :; do
+  case $_am_header in
+    $_am_arg | $_am_arg:* )
+      break ;;
+    * )
+      _am_stamp_count=`expr $_am_stamp_count + 1` ;;
+  esac
+done
+echo "timestamp for $_am_arg" >`$as_dirname -- "$_am_arg" ||
+$as_expr X"$_am_arg" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+         X"$_am_arg" : 'X\(//\)[^/]' \| \
+         X"$_am_arg" : 'X\(//\)$' \| \
+         X"$_am_arg" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$_am_arg" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+            s//\1/
+            q
+          }
+          /^X\(\/\/\)[^/].*/{
+            s//\1/
+            q
+          }
+          /^X\(\/\/\)$/{
+            s//\1/
+            q
+          }
+          /^X\(\/\).*/{
+            s//\1/
+            q
+          }
+          s/.*/./; q'`/stamp-h$_am_stamp_count
+ ;;
 
   :C)  { $as_echo "$as_me:${as_lineno-$LINENO}: executing $ac_file commands" >&5
@@ -18587 +18856 @@
 macro_revision=$macro_revision
 
+# Whether or not to build static libraries.
+build_old_libs=$enable_static
+
 # Whether or not to build shared libraries.
 build_libtool_libs=$enable_shared
-
-# Whether or not to build static libraries.
-build_old_libs=$enable_static
 
 # What type of objects to build.

libcfa/configure.ac

@@ -109 +109 @@
 
 # Checks for programs.
-LT_INIT
+LT_INIT([disable-static])
 
 AC_PROG_CXX
@@ -118 +118 @@
 AC_PROG_MAKE_SET
 
+AC_CHECK_HEADERS([linux/io_uring.h])
+AC_CHECK_FUNCS([preadv2 pwritev2])
+
 AC_CONFIG_FILES([
         Makefile
@@ -124 +127 @@
         ])
 
+AC_CONFIG_HEADERS(prelude/defines.hfa)
+
 AC_OUTPUT()
 

libcfa/prelude/Makefile.am

@@ -21 +21 @@
 # put into lib for now
 cfalibdir = ${CFA_LIBDIR}
-cfalib_DATA = gcc-builtins.cf builtins.cf extras.cf prelude.cfa bootloader.c
+cfalib_DATA = gcc-builtins.cf builtins.cf extras.cf prelude.cfa bootloader.c defines.hfa
 
 CC = @LOCAL_CFACC@

libcfa/prelude/Makefile.in

@@ -1 @@
-# Makefile.in generated by automake 1.16.1 from Makefile.am.
+# Makefile.in generated by automake 1.15 from Makefile.am.
 # @configure_input@
 
-# Copyright (C) 1994-2018 Free Software Foundation, Inc.
+# Copyright (C) 1994-2014 Free Software Foundation, Inc.
 
 # This Makefile.in is free software; the Free Software Foundation
@@ -104 +104 @@
 DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON)
 mkinstalldirs = $(install_sh) -d
+CONFIG_HEADER = defines.hfa
 CONFIG_CLEAN_FILES =
 CONFIG_CLEAN_VPATH_FILES =
@@ -154 +155 @@
 am__installdirs = "$(DESTDIR)$(cfalibdir)"
 DATA = $(cfalib_DATA)
-am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
-am__DIST_COMMON = $(srcdir)/Makefile.in
+am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) \
+        $(LISP)defines.hfa.in
+# Read a list of newline-separated strings from the standard input,
+# and print each of them once, without duplicates.  Input order is
+# *not* preserved.
+am__uniquify_input = $(AWK) '\
+  BEGIN { nonempty = 0; } \
+  { items[$$0] = 1; nonempty = 1; } \
+  END { if (nonempty) { for (i in items) print i; }; } \
+'
+# Make sure the list of sources is unique.  This is necessary because,
+# e.g., the same source file might be shared among _SOURCES variables
+# for different programs/libraries.
+am__define_uniq_tagged_files = \
+  list='$(am__tagged_files)'; \
+  unique=`for i in $$list; do \
+    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+  done | $(am__uniquify_input)`
+ETAGS = etags
+CTAGS = ctags
+am__DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/defines.hfa.in
 DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
 ACLOCAL = @ACLOCAL@
@@ -306 +326 @@
 # put into lib for now
 cfalibdir = ${CFA_LIBDIR}
-cfalib_DATA = gcc-builtins.cf builtins.cf extras.cf prelude.cfa bootloader.c
+cfalib_DATA = gcc-builtins.cf builtins.cf extras.cf prelude.cfa bootloader.c defines.hfa
 AM_CFLAGS = -g -Wall -Wno-unused-function -fPIC @ARCH_FLAGS@ @CONFIG_CFLAGS@
 AM_CFAFLAGS = @CONFIG_CFAFLAGS@
 MOSTLYCLEANFILES = bootloader.c builtins.cf extras.cf gcc-builtins.c gcc-builtins.cf prelude.cfa
 MAINTAINERCLEANFILES = ${addprefix ${libdir}/,${cfalib_DATA}} ${addprefix ${libdir}/,${lib_LIBRARIES}}
-all: all-am
+all: defines.hfa
+        $(MAKE) $(AM_MAKEFLAGS) all-am
 
 .SUFFIXES:
@@ -331 +352 @@
             cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
           *) \
-            echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles)'; \
-            cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \
+            echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
+            cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
         esac;
 
@@ -343 +364 @@
         cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
 $(am__aclocal_m4_deps):
+
+defines.hfa: stamp-h1
+        @test -f $@ || rm -f stamp-h1
+        @test -f $@ || $(MAKE) $(AM_MAKEFLAGS) stamp-h1
+
+stamp-h1: $(srcdir)/defines.hfa.in $(top_builddir)/config.status
+        @rm -f stamp-h1
+        cd $(top_builddir) && $(SHELL) ./config.status prelude/defines.hfa
+$(srcdir)/defines.hfa.in:  $(am__configure_deps) 
+        ($(am__cd) $(top_srcdir) && $(AUTOHEADER))
+        rm -f stamp-h1
+        touch $@
+
+distclean-hdr:
+        -rm -f defines.hfa stamp-h1
 
 mostlyclean-libtool:
@@ -370 +406 @@
         files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \
         dir='$(DESTDIR)$(cfalibdir)'; $(am__uninstall_files_from_dir)
-tags TAGS:
-
-ctags CTAGS:
-
-cscope cscopelist:
-
-
-distdir: $(BUILT_SOURCES)
-        $(MAKE) $(AM_MAKEFLAGS) distdir-am
-
-distdir-am: $(DISTFILES)
+
+ID: $(am__tagged_files)
+        $(am__define_uniq_tagged_files); mkid -fID $$unique
+tags: tags-am
+TAGS: tags
+
+tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+        set x; \
+        here=`pwd`; \
+        $(am__define_uniq_tagged_files); \
+        shift; \
+        if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
+          test -n "$$unique" || unique=$$empty_fix; \
+          if test $$# -gt 0; then \
+            $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+              "$$@" $$unique; \
+          else \
+            $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+              $$unique; \
+          fi; \
+        fi
+ctags: ctags-am
+
+CTAGS: ctags
+ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+        $(am__define_uniq_tagged_files); \
+        test -z "$(CTAGS_ARGS)$$unique" \
+          || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+             $$unique
+
+GTAGS:
+        here=`$(am__cd) $(top_builddir) && pwd` \
+          && $(am__cd) $(top_srcdir) \
+          && gtags -i $(GTAGS_ARGS) "$$here"
+cscopelist: cscopelist-am
+
+cscopelist-am: $(am__tagged_files)
+        list='$(am__tagged_files)'; \
+        case "$(srcdir)" in \
+          [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
+          *) sdir=$(subdir)/$(srcdir) ;; \
+        esac; \
+        for i in $$list; do \
+          if test -f "$$i"; then \
+            echo "$(subdir)/$$i"; \
+          else \
+            echo "$$sdir/$$i"; \
+          fi; \
+        done >> $(top_builddir)/cscope.files
+
+distclean-tags:
+        -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
+distdir: $(DISTFILES)
         @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
         topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
@@ -412 +491 @@
 check-am: all-am
 check: check-am
-all-am: Makefile $(DATA)
+all-am: Makefile $(DATA) defines.hfa
 installdirs:
         for dir in "$(DESTDIR)$(cfalibdir)"; do \
@@ -455 +534 @@
 distclean: distclean-am
         -rm -f Makefile
-distclean-am: clean-am distclean-generic
+distclean-am: clean-am distclean-generic distclean-hdr distclean-tags
 
 dvi: dvi-am
@@ -516 +595 @@
 uninstall-am: uninstall-cfalibDATA
 
-.MAKE: install-am install-strip
-
-.PHONY: all all-am check check-am clean clean-generic clean-libtool \
-        cscopelist-am ctags-am distclean distclean-generic \
-        distclean-libtool distdir dvi dvi-am html html-am info info-am \
+.MAKE: all install-am install-strip
+
+.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean clean-generic \
+        clean-libtool cscopelist-am ctags ctags-am distclean \
+        distclean-generic distclean-hdr distclean-libtool \
+        distclean-tags distdir dvi dvi-am html html-am info info-am \
         install install-am install-cfalibDATA install-data \
         install-data-am install-dvi install-dvi-am install-exec \
@@ -529 +609 @@
         maintainer-clean-generic maintainer-clean-local mostlyclean \
         mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
-        tags-am uninstall uninstall-am uninstall-cfalibDATA
+        tags tags-am uninstall uninstall-am uninstall-cfalibDATA
 
 .PRECIOUS: Makefile

libcfa/prelude/builtins.c

@@ -48 +48 @@
 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__ ));
+
+forall(dtype T)
+static inline T & identity(T & i) {
+        return i;
+}
+
+// generator support
+struct $generator {
+        inline int;
+};
+
+static inline void  ?{}($generator & this) { ((int&)this) = 0; }
+static inline void ^?{}($generator &) {}
+
+trait is_generator(dtype T) {
+      void main(T & this);
+      $generator * get_generator(T & this);
+};
+
+forall(dtype T | is_generator(T))
+static inline T & resume(T & gen) {
+        main(gen);
+        return gen;
+}
 
 // implicit increment, decrement if += defined, and implicit not if != defined

libcfa/src/Makefile.am

@@ -11 +11 @@
 ## Created On       : Sun May 31 08:54:01 2015
 ## Last Modified By : Peter A. Buhr
-## Last Modified On : Mon Jul 15 22:43:27 2019
-## Update Count     : 241
+## Last Modified On : Mon Mar 16 18:07:59 2020
+## Update Count     : 242
 ###############################################################################
 
@@ -33 +33 @@
 # The built sources must not depend on the installed headers
 AM_CFAFLAGS = -quiet -cfalib -I$(srcdir)/stdhdr $(if $(findstring ${gdbwaittarget}, ${@}), -XCFA --gdb) @CONFIG_CFAFLAGS@
-AM_CFLAGS = -g -Wall -Wno-unused-function -fPIC -pthread @ARCH_FLAGS@ @CONFIG_CFLAGS@
+AM_CFLAGS = -g -Wall -Wno-unused-function -fPIC -fexceptions -pthread @ARCH_FLAGS@ @CONFIG_CFLAGS@
 AM_CCASFLAGS = -g -Wall -Wno-unused-function @ARCH_FLAGS@ @CONFIG_CFLAGS@
 CFACC = @CFACC@
@@ -39 +39 @@
 #----------------------------------------------------------------------------------------------------------------
 if BUILDLIB
-headers_nosrc = math.hfa gmp.hfa time_t.hfa bits/align.hfa bits/containers.hfa bits/defs.hfa bits/debug.hfa bits/locks.hfa
+headers_nosrc = bitmanip.hfa math.hfa gmp.hfa time_t.hfa bits/align.hfa bits/containers.hfa bits/defs.hfa bits/debug.hfa bits/locks.hfa containers/list.hfa
 headers = fstream.hfa iostream.hfa iterator.hfa limits.hfa rational.hfa time.hfa stdlib.hfa common.hfa \
           containers/maybe.hfa containers/pair.hfa containers/result.hfa containers/vector.hfa
@@ -48 +48 @@
 thread_headers_nosrc = concurrency/invoke.h
 thread_headers = concurrency/coroutine.hfa concurrency/thread.hfa concurrency/kernel.hfa concurrency/monitor.hfa concurrency/mutex.hfa
-thread_libsrc = concurrency/CtxSwitch-@ARCHITECTURE@.S concurrency/alarm.cfa concurrency/invoke.c concurrency/preemption.cfa concurrency/ready_queue.cfa ${thread_headers:.hfa=.cfa}
+thread_libsrc = concurrency/CtxSwitch-@ARCHITECTURE@.S concurrency/alarm.cfa concurrency/invoke.c concurrency/io.cfa concurrency/preemption.cfa concurrency/ready_queue.cfa ${thread_headers:.hfa=.cfa}
 else
 headers =

libcfa/src/Makefile.in

@@ -105 +105 @@
         $(am__nobase_cfa_include_HEADERS_DIST) $(am__DIST_COMMON)
 mkinstalldirs = $(install_sh) -d
+CONFIG_HEADER = $(top_builddir)/prelude/defines.hfa
 CONFIG_CLEAN_FILES =
 CONFIG_CLEAN_VPATH_FILES =
@@ -164 +165 @@
 am__libcfathread_la_SOURCES_DIST =  \
         concurrency/CtxSwitch-@ARCHITECTURE@.S concurrency/alarm.cfa \
-        concurrency/invoke.c concurrency/preemption.cfa \
-        concurrency/ready_queue.cfa concurrency/coroutine.cfa \
-        concurrency/thread.cfa concurrency/kernel.cfa \
-        concurrency/monitor.cfa concurrency/mutex.cfa
+        concurrency/invoke.c concurrency/io.cfa \
+        concurrency/preemption.cfa concurrency/ready_queue.cfa \
+        concurrency/coroutine.cfa concurrency/thread.cfa \
+        concurrency/kernel.cfa concurrency/monitor.cfa \
+        concurrency/mutex.cfa
 @BUILDLIB_TRUE@am__objects_3 = concurrency/coroutine.lo \
 @BUILDLIB_TRUE@ concurrency/thread.lo concurrency/kernel.lo \
@@ -174 +176 @@
 @BUILDLIB_TRUE@ concurrency/CtxSwitch-@ARCHITECTURE@.lo \
 @BUILDLIB_TRUE@ concurrency/alarm.lo concurrency/invoke.lo \
-@BUILDLIB_TRUE@ concurrency/preemption.lo \
+@BUILDLIB_TRUE@ concurrency/io.lo concurrency/preemption.lo \
 @BUILDLIB_TRUE@ concurrency/ready_queue.lo $(am__objects_3)
 am_libcfathread_la_OBJECTS = $(am__objects_4)
@@ -194 +196 @@
 am__v_at_0 = @
 am__v_at_1 = 
-DEFAULT_INCLUDES = -I.@am__isrc@
+DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir)/prelude
 depcomp = $(SHELL) $(top_srcdir)/automake/depcomp
 am__depfiles_maybe = depfiles
@@ -238 +240 @@
         limits.hfa rational.hfa time.hfa stdlib.hfa common.hfa \
         containers/maybe.hfa containers/pair.hfa containers/result.hfa \
-        containers/vector.hfa math.hfa gmp.hfa time_t.hfa \
+        containers/vector.hfa bitmanip.hfa math.hfa gmp.hfa time_t.hfa \
         bits/align.hfa bits/containers.hfa bits/defs.hfa \
-        bits/debug.hfa bits/locks.hfa concurrency/coroutine.hfa \
-        concurrency/thread.hfa concurrency/kernel.hfa \
-        concurrency/monitor.hfa concurrency/mutex.hfa \
-        concurrency/invoke.h
+        bits/debug.hfa bits/locks.hfa containers/list.hfa \
+        concurrency/coroutine.hfa concurrency/thread.hfa \
+        concurrency/kernel.hfa concurrency/monitor.hfa \
+        concurrency/mutex.hfa concurrency/invoke.h
 HEADERS = $(nobase_cfa_include_HEADERS)
 am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
@@ -433 +435 @@
 am__v_GOC_0 = @echo "  GOC     " $@;
 am__v_GOC_1 = 
+AM_V_PY = $(am__v_PY_@AM_V@)
+am__v_PY_ = $(am__v_PY_@AM_DEFAULT_V@)
+am__v_PY_0 = @echo "  PYTHON  " $@;
+am__v_PY_1 = 
 AM_V_RUST = $(am__v_RUST_@AM_V@)
 am__v_RUST_ = $(am__v_RUST_@AM_DEFAULT_V@)
-am__v_RUST_0 = @echo "  RUST     " $@;
+am__v_RUST_0 = @echo "  RUST    " $@;
 am__v_RUST_1 = 
 AM_V_NODEJS = $(am__v_NODEJS_@AM_V@)
 am__v_NODEJS_ = $(am__v_NODEJS_@AM_DEFAULT_V@)
-am__v_NODEJS_0 = @echo "  NODEJS     " $@;
+am__v_NODEJS_0 = @echo "  NODEJS  " $@;
 am__v_NODEJS_1 = 
 AM_V_JAVAC = $(am__v_JAVAC_@AM_V@)
@@ -453 +459 @@
 # The built sources must not depend on the installed headers
 AM_CFAFLAGS = -quiet -cfalib -I$(srcdir)/stdhdr $(if $(findstring ${gdbwaittarget}, ${@}), -XCFA --gdb) @CONFIG_CFAFLAGS@
-AM_CFLAGS = -g -Wall -Wno-unused-function -fPIC -pthread @ARCH_FLAGS@ @CONFIG_CFLAGS@
+AM_CFLAGS = -g -Wall -Wno-unused-function -fPIC -fexceptions -pthread @ARCH_FLAGS@ @CONFIG_CFLAGS@
 AM_CCASFLAGS = -g -Wall -Wno-unused-function @ARCH_FLAGS@ @CONFIG_CFLAGS@
 @BUILDLIB_FALSE@headers_nosrc = 
 
 #----------------------------------------------------------------------------------------------------------------
-@BUILDLIB_TRUE@headers_nosrc = math.hfa gmp.hfa time_t.hfa bits/align.hfa bits/containers.hfa bits/defs.hfa bits/debug.hfa bits/locks.hfa
+@BUILDLIB_TRUE@headers_nosrc = bitmanip.hfa math.hfa gmp.hfa time_t.hfa bits/align.hfa bits/containers.hfa bits/defs.hfa bits/debug.hfa bits/locks.hfa containers/list.hfa
 @BUILDLIB_FALSE@headers = 
 @BUILDLIB_TRUE@headers = fstream.hfa iostream.hfa iterator.hfa limits.hfa rational.hfa time.hfa stdlib.hfa common.hfa \
@@ -471 +477 @@
 @BUILDLIB_FALSE@thread_headers = 
 @BUILDLIB_TRUE@thread_headers = concurrency/coroutine.hfa concurrency/thread.hfa concurrency/kernel.hfa concurrency/monitor.hfa concurrency/mutex.hfa
-@BUILDLIB_TRUE@thread_libsrc = concurrency/CtxSwitch-@ARCHITECTURE@.S concurrency/alarm.cfa concurrency/invoke.c concurrency/preemption.cfa concurrency/ready_queue.cfa ${thread_headers:.hfa=.cfa}
+@BUILDLIB_TRUE@thread_libsrc = concurrency/CtxSwitch-@ARCHITECTURE@.S concurrency/alarm.cfa concurrency/invoke.c concurrency/io.cfa concurrency/preemption.cfa concurrency/ready_queue.cfa ${thread_headers:.hfa=.cfa}
 
 #----------------------------------------------------------------------------------------------------------------
@@ -605 +611 @@
         concurrency/$(DEPDIR)/$(am__dirstamp)
 concurrency/invoke.lo: concurrency/$(am__dirstamp) \
+        concurrency/$(DEPDIR)/$(am__dirstamp)
+concurrency/io.lo: concurrency/$(am__dirstamp) \
         concurrency/$(DEPDIR)/$(am__dirstamp)
 concurrency/preemption.lo: concurrency/$(am__dirstamp) \

libcfa/src/bits/containers.hfa

@@ -146 +146 @@
         static inline forall( dtype T | is_node(T) ) {
                 void ?{}( __queue(T) & this ) with( this ) {
-                        head{ 0p };
+                        head{ 1p };
                         tail{ &head };
+                        verify(*tail == 1p);
                 }
 
                 void append( __queue(T) & this, T * val ) with( this ) {
                         verify(tail != 0p);
+                        verify(*tail == 1p);
                         *tail = val;
                         tail = &get_next( *val );
+                        *tail = 1p;
                 }
 
                 T * pop_head( __queue(T) & this ) {
+                        verify(*this.tail == 1p);
                         T * head = this.head;
-                        if( head ) {
+                        if( head != 1p ) {
                                 this.head = get_next( *head );
-                                if( !get_next( *head ) ) {
+                                if( get_next( *head ) == 1p ) {
                                         this.tail = &this.head;
                                 }
                                 get_next( *head ) = 0p;
-                        }
-                        return head;
+                                verify(*this.tail == 1p);
+                                verify( get_next(*head) == 0p );
+                                return head;
+                        }
+                        verify(*this.tail == 1p);
+                        return 0p;
                 }
 
@@ -180 +188 @@
                         get_next( *val ) = 0p;
 
-                        verify( (head == 0p) == (&head == tail) );
-                        verify( *tail == 0p );
+                        verify( (head == 1p) == (&head == tail) );
+                        verify( *tail == 1p );
                         return val;
                 }
@@ -266 +274 @@
                         return this.head != 0;
                 }
+
+                void move_to_front( __dllist(T) & src, __dllist(T) & dst, T & node ) {
+                        remove    (src, node);
+                        push_front(dst, node);
+                }
         }
         #undef next

libcfa/src/bits/debug.hfa

@@ -9 +9 @@
 // Author           : Thierry Delisle
 // Created On       : Mon Nov 28 12:27:26 2016
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Feb  4 12:29:21 2020
-// Update Count     : 9
+// Last Modified By : Andrew Beach
+// Last Modified On : Mon Apr 27 10:15:00 2020
+// Update Count     : 10
 //
 
@@ -23 +23 @@
         #define __cfaabi_dbg_ctx_param const char caller[]
         #define __cfaabi_dbg_ctx_param2 , const char caller[]
+        #define __cfaabi_dbg_ctx_fwd caller
+        #define __cfaabi_dbg_ctx_fwd2 , caller
 #else
         #define __cfaabi_dbg_debug_do(...)
@@ -30 +32 @@
         #define __cfaabi_dbg_ctx_param
         #define __cfaabi_dbg_ctx_param2
+        #define __cfaabi_dbg_ctx_fwd
+        #define __cfaabi_dbg_ctx_fwd2
 #endif
 
@@ -36 +40 @@
 #endif
         #include <stdarg.h>
-        #include <stdio.h>
-        #include <unistd.h>
 
         extern void __cfaabi_bits_write( int fd, const char buffer[], int len );
@@ -46 +48 @@
         extern void __cfaabi_bits_print_vararg( int fd, const char fmt[], va_list arg );
         extern void __cfaabi_bits_print_buffer( int fd, char buffer[], int buffer_size, const char fmt[], ... ) __attribute__(( format(printf, 4, 5) ));
+
+#if defined(__CFA_DEBUG_PRINT__) \
+                || defined(__CFA_DEBUG_PRINT_IO__) || defined(__CFA_DEBUG_PRINT_IO_CORE__) \
+                || defined(__CFA_DEBUG_PRINT_MONITOR__) || defined(__CFA_DEBUG_PRINT_PREEMPTION__) \
+                || defined(__CFA_DEBUG_PRINT_RUNTIME_CORE__) || defined(__CFA_DEBUG_PRINT_EXCEPTION__)
+        #include <stdio.h>
+        #include <unistd.h>
+#endif
 #ifdef __cforall
 }
 #endif
 
-// #define __CFA_DEBUG_PRINT__
-
+// Deprecated: Use the versions with the new module names.
 #ifdef __CFA_DEBUG_PRINT__
         #define __cfaabi_dbg_write( buffer, len )         __cfaabi_bits_write( STDERR_FILENO, buffer, len )
         #define __cfaabi_dbg_acquire()                    __cfaabi_bits_acquire()
         #define __cfaabi_dbg_release()                    __cfaabi_bits_release()
-        #define __cfaabi_dbg_print_safe(...)              __cfaabi_bits_print_safe  ( STDERR_FILENO, __VA_ARGS__ )
-        #define __cfaabi_dbg_print_nolock(...)            __cfaabi_bits_print_nolock( STDERR_FILENO, __VA_ARGS__ )
-        #define __cfaabi_dbg_print_buffer(...)            __cfaabi_bits_print_buffer( STDERR_FILENO, __VA_ARGS__ )
+        #define __cfaabi_dbg_print_safe(...)              __cfaabi_bits_print_safe   ( STDERR_FILENO, __VA_ARGS__ )
+        #define __cfaabi_dbg_print_nolock(...)            __cfaabi_bits_print_nolock ( STDERR_FILENO, __VA_ARGS__ )
+        #define __cfaabi_dbg_print_buffer(...)            __cfaabi_bits_print_buffer ( STDERR_FILENO, __VA_ARGS__ )
         #define __cfaabi_dbg_print_buffer_decl(...)       char __dbg_text[256]; int __dbg_len = snprintf( __dbg_text, 256, __VA_ARGS__ ); __cfaabi_bits_write( STDERR_FILENO, __dbg_text, __dbg_len );
-        #define __cfaabi_dbg_print_buffer_local(...)      __dbg_len = snprintf( __dbg_text, 256, __VA_ARGS__ ); __cfaabi_bits_write( STDERR_FILENO, __dbg_text, __dbg_len );
+        #define __cfaabi_dbg_print_buffer_local(...)      __dbg_len = snprintf( __dbg_text, 256, __VA_ARGS__ ); __cfaabi_dbg_write( STDERR_FILENO, __dbg_text, __dbg_len );
 #else
         #define __cfaabi_dbg_write(...)               ((void)0)
@@ -72 +81 @@
 #endif
 
+// Debug print functions and statements:
+// Most are wrappers around the bits printing function but are not always used.
+// If they are used depends if the group (first argument) is active or not. The group must be one
+// defined belowe. The other arguments depend on the wrapped function.
+#define __cfadbg_write(group, buffer, len) \
+        __CFADBG_PRINT_GROUP_##group(__cfaabi_bits_write(STDERR_FILENO, buffer, len))
+#define __cfadbg_acquire(group) \
+        __CFADBG_PRINT_GROUP_##group(__cfaabi_bits_acquire())
+#define __cfadbg_release(group) \
+        __CFADBG_PRINT_GROUP_##group(__cfaabi_bits_release())
+#define __cfadbg_print_safe(group, ...) \
+        __CFADBG_PRINT_GROUP_##group(__cfaabi_bits_print_safe(STDERR_FILENO, __VA_ARGS__))
+#define __cfadbg_print_nolock(group, ...) \
+        __CFADBG_PRINT_GROUP_##group(__cfaabi_bits_print_nolock(STDERR_FILENO, __VA_ARGS__))
+#define __cfadbg_print_buffer(group, ...) \
+        __CFADBG_PRINT_GROUP_##group(__cfaabi_bits_print_buffer(STDERR_FILENO, __VA_ARGS__))
+#define __cfadbg_print_buffer_decl(group, ...) \
+        __CFADBG_PRINT_GROUP_##group(char __dbg_text[256]; int __dbg_len = snprintf( __dbg_text, 256, __VA_ARGS__ ); __cfaabi_bits_write( __dbg_text, __dbg_len ))
+#define __cfadbg_print_buffer_local(group, ...) \
+        __CFADBG_PRINT_GROUP_##group(__dbg_len = snprintf( __dbg_text, 256, __VA_ARGS__ ); __cfaabi_bits_write(STDERR_FILENO, __dbg_text, __dbg_len))
+
+// The debug print groups:
+#if defined(__CFA_DEBUG_PRINT__) || defined(__CFA_DEBUG_PRINT_IO__)
+#       define __CFADBG_PRINT_GROUP_io(...) __VA_ARGS__
+#else
+#       define __CFADBG_PRINT_GROUP_io(...) ((void)0)
+#endif
+#if defined(__CFA_DEBUG_PRINT__) || defined(__CFA_DEBUG_PRINT_IO__) || defined(__CFA_DEBUG_PRINT_IO_CORE__)
+#       define __CFADBG_PRINT_GROUP_io_core(...) __VA_ARGS__
+#else
+#       define __CFADBG_PRINT_GROUP_io_core(...) ((void)0)
+#endif
+#if defined(__CFA_DEBUG_PRINT__) || defined(__CFA_DEBUG_PRINT_MONITOR__)
+#       define __CFADBG_PRINT_GROUP_monitor(...) __VA_ARGS__
+#else
+#       define __CFADBG_PRINT_GROUP_monitor(...) ((void)0)
+#endif
+#if defined(__CFA_DEBUG_PRINT__) || defined(__CFA_DEBUG_PRINT_PREEMPTION__)
+#       define __CFADBG_PRINT_GROUP_preemption(...) __VA_ARGS__
+#else
+#       define __CFADBG_PRINT_GROUP_preemption(...) ((void)0)
+#endif
+#if defined(__CFA_DEBUG_PRINT__) || defined(__CFA_DEBUG_PRINT_RUNTIME_CORE__)
+#       define __CFADBG_PRINT_GROUP_runtime_core(...) __VA_ARGS__
+#else
+#       define __CFADBG_PRINT_GROUP_runtime_core(...) ((void)0)
+#endif
+#if defined(__CFA_DEBUG_PRINT__) || defined(__CFA_DEBUG_PRINT_READY_QUEUE__)
+#       define __CFADBG_PRINT_GROUP_ready_queue(...) __VA_ARGS__
+#else
+#       define __CFADBG_PRINT_GROUP_ready_queue(...) ((void)0)
+#endif
+#if defined(__CFA_DEBUG_PRINT__) || defined(__CFA_DEBUG_PRINT_EXCEPTION__)
+#       define __CFADBG_PRINT_GROUP_exception(...) __VA_ARGS__
+#else
+#       define __CFADBG_PRINT_GROUP_exception(...) ((void)0)
+#endif
+
 // Local Variables: //
 // mode: c //

libcfa/src/bits/locks.hfa

@@ -54 +54 @@
 
                 #ifdef __CFA_DEBUG__
-                        void __cfaabi_dbg_record(__spinlock_t & this, const char prev_name[]);
+                        void __cfaabi_dbg_record_lock(__spinlock_t & this, const char prev_name[]);
                 #else
-                        #define __cfaabi_dbg_record(x, y)
+                        #define __cfaabi_dbg_record_lock(x, y)
                 #endif
         }
-
-        extern void yield( unsigned int );
 
         static inline void ?{}( __spinlock_t & this ) {
@@ -68 +66 @@
         // Lock the spinlock, return false if already acquired
         static inline bool try_lock  ( __spinlock_t & this __cfaabi_dbg_ctx_param2 ) {
+                disable_interrupts();
                 bool result = (this.lock == 0) && (__atomic_test_and_set( &this.lock, __ATOMIC_ACQUIRE ) == 0);
                 if( result ) {
-                        disable_interrupts();
-                        __cfaabi_dbg_record( this, caller );
+                        __cfaabi_dbg_record_lock( this, caller );
+                } else {
+                        enable_interrupts_noPoll();
                 }
                 return result;
@@ -83 +83 @@
                 #endif
 
+                disable_interrupts();
                 for ( unsigned int i = 1;; i += 1 ) {
                         if ( (this.lock == 0) && (__atomic_test_and_set( &this.lock, __ATOMIC_ACQUIRE ) == 0) ) break;
@@ -98 +99 @@
                         #endif
                 }
-                disable_interrupts();
-                __cfaabi_dbg_record( this, caller );
+                __cfaabi_dbg_record_lock( this, caller );
         }
 
         static inline void unlock( __spinlock_t & this ) {
+                __atomic_clear( &this.lock, __ATOMIC_RELEASE );
                 enable_interrupts_noPoll();
-                __atomic_clear( &this.lock, __ATOMIC_RELEASE );
         }
 
@@ -112 +112 @@
         #endif
 
+        extern "C" {
+                char * strerror(int);
+        }
+        #define CHECKED(x) { int err = x; if( err != 0 ) abort("KERNEL ERROR: Operation \"" #x "\" return error %d - %s\n", err, strerror(err)); }
+
         struct __bin_sem_t {
-                bool                    signaled;
                 pthread_mutex_t         lock;
                 pthread_cond_t          cond;
+                int                     val;
         };
 
         static inline void ?{}(__bin_sem_t & this) with( this ) {
-                signaled = false;
-                pthread_mutex_init(&lock, NULL);
-                pthread_cond_init (&cond, NULL);
+                // Create the mutex with error checking
+                pthread_mutexattr_t mattr;
+                pthread_mutexattr_init( &mattr );
+                pthread_mutexattr_settype( &mattr, PTHREAD_MUTEX_ERRORCHECK_NP);
+                pthread_mutex_init(&lock, &mattr);
+
+                pthread_cond_init (&cond, 0p);
+                val = 0;
         }
 
         static inline void ^?{}(__bin_sem_t & this) with( this ) {
-                pthread_mutex_destroy(&lock);
-                pthread_cond_destroy (&cond);
+                CHECKED( pthread_mutex_destroy(&lock) );
+                CHECKED( pthread_cond_destroy (&cond) );
         }
 
         static inline void wait(__bin_sem_t & this) with( this ) {
                 verify(__cfaabi_dbg_in_kernel());
-                pthread_mutex_lock(&lock);
-                        if(!signaled) {   // this must be a loop, not if!
+                CHECKED( pthread_mutex_lock(&lock) );
+                        while(val < 1) {
                                 pthread_cond_wait(&cond, &lock);
                         }
-                        signaled = false;
-                pthread_mutex_unlock(&lock);
+                        val -= 1;
+                CHECKED( pthread_mutex_unlock(&lock) );
         }
 
-        static inline void post(__bin_sem_t & this) with( this ) {
-                verify(__cfaabi_dbg_in_kernel());
+        static inline bool post(__bin_sem_t & this) with( this ) {
+                bool needs_signal = false;
 
-                pthread_mutex_lock(&lock);
-                        bool needs_signal = !signaled;
-                        signaled = true;
-                pthread_mutex_unlock(&lock);
+                CHECKED( pthread_mutex_lock(&lock) );
+                        if(val < 1) {
+                                val += 1;
+                                pthread_cond_signal(&cond);
+                                needs_signal = true;
+                        }
+                CHECKED( pthread_mutex_unlock(&lock) );
 
-                if (needs_signal)
-                        pthread_cond_signal(&cond);
+                return needs_signal;
         }
+
+        #undef CHECKED
 #endif

libcfa/src/bits/signal.hfa

@@ -54 +54 @@
                         sig, handler, flags, errno, strerror( errno )
                 );
-                _exit( EXIT_FAILURE );
+                _Exit( EXIT_FAILURE );
         } // if
 }

libcfa/src/concurrency/CtxSwitch-arm.S

@@ -13 +13 @@
         .text
         .align  2
-        .global CtxSwitch
-        .type   CtxSwitch, %function
+        .global __cfactx_switch
+        .type   __cfactx_switch, %function
 
-CtxSwitch:
+__cfactx_switch:
         @ save callee-saved registers: r4-r8, r10, r11, r13(sp) (plus r9 depending on platform specification)
         @ I've seen reference to 31 registers on 64-bit, if this is the case, more need to be saved
@@ -52 +52 @@
         mov r15, r14
         #endif // R9_SPECIAL
-        
+
         .text
         .align  2
-        .global CtxInvokeStub
-        .type   CtxInvokeStub, %function
+        .global __cfactx_invoke_stub
+        .type   __cfactx_invoke_stub, %function
 
-CtxInvokeStub:
+__cfactx_invoke_stub:
         ldmfd r13!, {r0-r1}
         mov r15, r1

libcfa/src/concurrency/CtxSwitch-i386.S

@@ -43 +43 @@
         .text
         .align 2
-        .globl CtxSwitch
-        .type  CtxSwitch, @function
-CtxSwitch:
+        .globl __cfactx_switch
+        .type  __cfactx_switch, @function
+__cfactx_switch:
 
         // Copy the "from" context argument from the stack to register eax
@@ -83 +83 @@
 
         ret
-        .size  CtxSwitch, .-CtxSwitch
+        .size  __cfactx_switch, .-__cfactx_switch
 
 // Local Variables: //

libcfa/src/concurrency/CtxSwitch-x86_64.S

@@ -44 +44 @@
         .text
         .align 2
-        .globl CtxSwitch
-        .type  CtxSwitch, @function
-CtxSwitch:
+        .globl __cfactx_switch
+        .type  __cfactx_switch, @function
+__cfactx_switch:
 
         // Save volatile registers on the stack.
@@ -77 +77 @@
 
         ret
-        .size  CtxSwitch, .-CtxSwitch
+        .size  __cfactx_switch, .-__cfactx_switch
 
 //-----------------------------------------------------------------------------
@@ -83 +83 @@
         .text
         .align 2
-        .globl CtxInvokeStub
-        .type    CtxInvokeStub, @function
-CtxInvokeStub:
+        .globl __cfactx_invoke_stub
+        .type    __cfactx_invoke_stub, @function
+__cfactx_invoke_stub:
         movq %rbx, %rdi
         movq %r12, %rsi
         jmp *%r13
-        .size  CtxInvokeStub, .-CtxInvokeStub
+        .size  __cfactx_invoke_stub, .-__cfactx_invoke_stub
 
 // Local Variables: //

libcfa/src/concurrency/alarm.cfa

@@ -47 +47 @@
 //=============================================================================================
 
-void ?{}( alarm_node_t & this, thread_desc * thrd, Time alarm, Duration period ) with( this ) {
+void ?{}( alarm_node_t & this, $thread * thrd, Time alarm, Duration period ) with( this ) {
         this.thrd = thrd;
         this.alarm = alarm;
         this.period = period;
-        next = 0;
         set = false;
         kernel_alarm = false;
@@ -60 +59 @@
         this.alarm = alarm;
         this.period = period;
-        next = 0;
         set = false;
         kernel_alarm = true;
@@ -71 +69 @@
 }
 
-#if !defined(NDEBUG) && (defined(__CFA_DEBUG__) || defined(__CFA_VERIFY__))
-bool validate( alarm_list_t * this ) {
-        alarm_node_t ** it = &this->head;
-        while( (*it) ) {
-                it = &(*it)->next;
+void insert( alarm_list_t * this, alarm_node_t * n ) {
+        alarm_node_t * it = & (*this)`first;
+        while( it && (n->alarm > it->alarm) ) {
+                it = & (*it)`next;
+        }
+        if ( it ) {
+                insert_before( *it, *n );
+        } else {
+                insert_last(*this, *n);
         }
 
-        return it == this->tail;
-}
-#endif
-
-static inline void insert_at( alarm_list_t * this, alarm_node_t * n, __alarm_it_t p ) {
-        verify( !n->next );
-        if( p == this->tail ) {
-                this->tail = &n->next;
-        }
-        else {
-                n->next = *p;
-        }
-        *p = n;
-
-        verify( validate( this ) );
-}
-
-void insert( alarm_list_t * this, alarm_node_t * n ) {
-        alarm_node_t ** it = &this->head;
-        while( (*it) && (n->alarm > (*it)->alarm) ) {
-                it = &(*it)->next;
-        }
-
-        insert_at( this, n, it );
-
-        verify( validate( this ) );
+        verify( validate( *this ) );
 }
 
 alarm_node_t * pop( alarm_list_t * this ) {
-        alarm_node_t * head = this->head;
+        verify( validate( *this ) );
+        alarm_node_t * head = & (*this)`first;
         if( head ) {
-                this->head = head->next;
-                if( !head->next ) {
-                        this->tail = &this->head;
-                }
-                head->next = 0p;
+                remove(*head);
         }
-        verify( validate( this ) );
+        verify( validate( *this ) );
         return head;
 }
 
-static inline void remove_at( alarm_list_t * this, alarm_node_t * n, __alarm_it_t it ) {
-        verify( it );
-        verify( (*it) == n );
-
-        (*it) = n->next;
-        if( !n-> next ) {
-                this->tail = it;
-        }
-        n->next = 0p;
-
-        verify( validate( this ) );
-}
-
-static inline void remove( alarm_list_t * this, alarm_node_t * n ) {
-        alarm_node_t ** it = &this->head;
-        while( (*it) && (*it) != n ) {
-                it = &(*it)->next;
-        }
-
-        verify( validate( this ) );
-
-        if( *it ) { remove_at( this, n, it ); }
-
-        verify( validate( this ) );
-}
-
 void register_self( alarm_node_t * this ) {
-        alarm_list_t * alarms = &event_kernel->alarms;
+        alarm_list_t & alarms = event_kernel->alarms;
 
         disable_interrupts();
@@ -152 +100 @@
         {
                 verify( validate( alarms ) );
-                bool first = !alarms->head;
+                bool first = ! & alarms`first;
 
-                insert( alarms, this );
+                insert( &alarms, this );
                 if( first ) {
-                        __kernel_set_timer( alarms->head->alarm - __kernel_get_time() );
+                        __kernel_set_timer( alarms`first.alarm - __kernel_get_time() );
                 }
         }
@@ -168 +116 @@
         lock( event_kernel->lock __cfaabi_dbg_ctx2 );
         {
-                verify( validate( &event_kernel->alarms ) );
-                remove( &event_kernel->alarms, this );
+                verify( validate( event_kernel->alarms ) );
+                remove( *this );
         }
         unlock( event_kernel->lock );
@@ -176 +124 @@
 }
 
+//=============================================================================================
+// Utilities
+//=============================================================================================
+
+void sleep( Duration duration ) {
+        alarm_node_t node = { active_thread(), __kernel_get_time() + duration, 0`s };
+
+        register_self( &node );
+        park( __cfaabi_dbg_ctx );
+
+        /* paranoid */ verify( !node.set );
+        /* paranoid */ verify( & node`next == 0p );
+        /* paranoid */ verify( & node`prev == 0p );
+}
+
 // Local Variables: //
 // mode: c //

libcfa/src/concurrency/alarm.hfa

@@ -23 +23 @@
 #include "time.hfa"
 
-struct thread_desc;
+#include <containers/list.hfa>
+
+struct $thread;
 struct processor;
 
@@ -40 +42 @@
         Time alarm;                             // time when alarm goes off
         Duration period;                        // if > 0 => period of alarm
-        alarm_node_t * next;            // intrusive link list field
+
+        DLISTED_MGD_IMPL_IN(alarm_node_t)
 
         union {
-                thread_desc * thrd;     // thrd who created event
+                $thread * thrd; // thrd who created event
                 processor * proc;               // proc who created event
         };
@@ -50 +53 @@
         bool kernel_alarm       :1;             // true if this is not a user defined alarm
 };
+DLISTED_MGD_IMPL_OUT(alarm_node_t)
 
-typedef alarm_node_t ** __alarm_it_t;
-
-void ?{}( alarm_node_t & this, thread_desc * thrd, Time alarm, Duration period );
+void ?{}( alarm_node_t & this, $thread * thrd, Time alarm, Duration period );
 void ?{}( alarm_node_t & this, processor   * proc, Time alarm, Duration period );
 void ^?{}( alarm_node_t & this );
 
-struct alarm_list_t {
-        alarm_node_t * head;
-        __alarm_it_t tail;
-};
-
-static inline void ?{}( alarm_list_t & this ) with( this ) {
-        head = 0;
-        tail = &head;
-}
+typedef dlist(alarm_node_t, alarm_node_t) alarm_list_t;
 
 void insert( alarm_list_t * this, alarm_node_t * n );

libcfa/src/concurrency/coroutine.cfa

@@ -37 +37 @@
 
 extern "C" {
-        void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage, struct coroutine_desc *) __attribute__ ((__noreturn__));
+        void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage, struct $coroutine *) __attribute__ ((__noreturn__));
         static void _CtxCoroutine_UnwindCleanup(_Unwind_Reason_Code, struct _Unwind_Exception *) __attribute__ ((__noreturn__));
         static void _CtxCoroutine_UnwindCleanup(_Unwind_Reason_Code, struct _Unwind_Exception *) {
@@ -89 +89 @@
 }
 
-void ?{}( coroutine_desc & this, const char name[], void * storage, size_t storageSize ) with( this ) {
+void ?{}( $coroutine & this, const char name[], void * storage, size_t storageSize ) with( this ) {
         (this.context){0p, 0p};
         (this.stack){storage, storageSize};
@@ -99 +99 @@
 }
 
-void ^?{}(coroutine_desc& this) {
+void ^?{}($coroutine& this) {
         if(this.state != Halted && this.state != Start && this.state != Primed) {
-                coroutine_desc * src = TL_GET( this_thread )->curr_cor;
-                coroutine_desc * dst = &this;
+                $coroutine * src = TL_GET( this_thread )->curr_cor;
+                $coroutine * dst = &this;
 
                 struct _Unwind_Exception storage;
@@ -115 +115 @@
                 }
 
-                CoroutineCtxSwitch( src, dst );
+                $ctx_switch( src, dst );
         }
 }
@@ -123 +123 @@
 forall(dtype T | is_coroutine(T))
 void prime(T& cor) {
-        coroutine_desc* this = get_coroutine(cor);
+        $coroutine* this = get_coroutine(cor);
         assert(this->state == Start);
 
@@ -187 +187 @@
 // is not inline (We can't inline Cforall in C)
 extern "C" {
-        void __leave_coroutine( struct coroutine_desc * src ) {
-                coroutine_desc * starter = src->cancellation != 0 ? src->last : src->starter;
+        void __cfactx_cor_leave( struct $coroutine * src ) {
+                $coroutine * starter = src->cancellation != 0 ? src->last : src->starter;
 
                 src->state = Halted;
@@ -201 +201 @@
                         src->name, src, starter->name, starter );
 
-                CoroutineCtxSwitch( src, starter );
-        }
-
-        struct coroutine_desc * __finish_coroutine(void) {
-                struct coroutine_desc * cor = kernelTLS.this_thread->curr_cor;
+                $ctx_switch( src, starter );
+        }
+
+        struct $coroutine * __cfactx_cor_finish(void) {
+                struct $coroutine * cor = kernelTLS.this_thread->curr_cor;
 
                 if(cor->state == Primed) {
-                        suspend();
+                        __cfactx_suspend();
                 }
 

libcfa/src/concurrency/coroutine.hfa

@@ -25 +25 @@
 trait is_coroutine(dtype T) {
       void main(T & this);
-      coroutine_desc * get_coroutine(T & this);
+      $coroutine * get_coroutine(T & this);
 };
 
-#define DECL_COROUTINE(X) static inline coroutine_desc* get_coroutine(X& this) { return &this.__cor; } void main(X& this)
+#define DECL_COROUTINE(X) static inline $coroutine* get_coroutine(X& this) { return &this.__cor; } void main(X& this)
 
 //-----------------------------------------------------------------------------
@@ -35 +35 @@
 // void ^?{}( coStack_t & this );
 
-void ?{}( coroutine_desc & this, const char name[], void * storage, size_t storageSize );
-void ^?{}( coroutine_desc & this );
+void  ?{}( $coroutine & this, const char name[], void * storage, size_t storageSize );
+void ^?{}( $coroutine & this );
 
-static inline void ?{}( coroutine_desc & this)                                       { this{ "Anonymous Coroutine", 0p, 0 }; }
-static inline void ?{}( coroutine_desc & this, size_t stackSize)                     { this{ "Anonymous Coroutine", 0p, stackSize }; }
-static inline void ?{}( coroutine_desc & this, void * storage, size_t storageSize )  { this{ "Anonymous Coroutine", storage, storageSize }; }
-static inline void ?{}( coroutine_desc & this, const char name[])                    { this{ name, 0p, 0 }; }
-static inline void ?{}( coroutine_desc & this, const char name[], size_t stackSize ) { this{ name, 0p, stackSize }; }
+static inline void ?{}( $coroutine & this)                                       { this{ "Anonymous Coroutine", 0p, 0 }; }
+static inline void ?{}( $coroutine & this, size_t stackSize)                     { this{ "Anonymous Coroutine", 0p, stackSize }; }
+static inline void ?{}( $coroutine & this, void * storage, size_t storageSize )  { this{ "Anonymous Coroutine", storage, storageSize }; }
+static inline void ?{}( $coroutine & this, const char name[])                    { this{ name, 0p, 0 }; }
+static inline void ?{}( $coroutine & this, const char name[], size_t stackSize ) { this{ name, 0p, stackSize }; }
 
 //-----------------------------------------------------------------------------
 // Public coroutine API
-static inline void suspend(void);
-
-forall(dtype T | is_coroutine(T))
-static inline T & resume(T & cor);
-
 forall(dtype T | is_coroutine(T))
 void prime(T & cor);
 
-static inline struct coroutine_desc * active_coroutine() { return TL_GET( this_thread )->curr_cor; }
+static inline struct $coroutine * active_coroutine() { return TL_GET( this_thread )->curr_cor; }
 
 //-----------------------------------------------------------------------------
@@ -61 +56 @@
 // Start coroutine routines
 extern "C" {
-        void CtxInvokeCoroutine(void (*main)(void *), void * this);
+        void __cfactx_invoke_coroutine(void (*main)(void *), void * this);
 
         forall(dtype T)
-        void CtxStart(void (*main)(T &), struct coroutine_desc * cor, T & this, void (*invoke)(void (*main)(void *), void *));
+        void __cfactx_start(void (*main)(T &), struct $coroutine * cor, T & this, void (*invoke)(void (*main)(void *), void *));
 
-        extern void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage, struct coroutine_desc *) __attribute__ ((__noreturn__));
+        extern void __cfactx_coroutine_unwind(struct _Unwind_Exception * storage, struct $coroutine *) __attribute__ ((__noreturn__));
 
-        extern void CtxSwitch( struct __stack_context_t * from, struct __stack_context_t * to ) asm ("CtxSwitch");
+        extern void __cfactx_switch( struct __stack_context_t * from, struct __stack_context_t * to ) asm ("__cfactx_switch");
 }
 
 // Private wrappers for context switch and stack creation
 // Wrapper for co
-static inline void CoroutineCtxSwitch(coroutine_desc* src, coroutine_desc* dst) {
+static inline void $ctx_switch( $coroutine * src, $coroutine * dst ) __attribute__((nonnull (1, 2))) {
         // set state of current coroutine to inactive
-        src->state = src->state == Halted ? Halted : Inactive;
+        src->state = src->state == Halted ? Halted : Blocked;
 
         // set new coroutine that task is executing
@@ -82 +77 @@
         // context switch to specified coroutine
         verify( dst->context.SP );
-        CtxSwitch( &src->context, &dst->context );
-        // when CtxSwitch returns we are back in the src coroutine
+        __cfactx_switch( &src->context, &dst->context );
+        // when __cfactx_switch returns we are back in the src coroutine
 
         // set state of new coroutine to active
@@ -89 +84 @@
 
         if( unlikely(src->cancellation != 0p) ) {
-                _CtxCoroutine_Unwind(src->cancellation, src);
+                __cfactx_coroutine_unwind(src->cancellation, src);
         }
 }
@@ -96 +91 @@
 
 // Suspend implementation inlined for performance
-static inline void suspend(void) {
-        // optimization : read TLS once and reuse it
-        // Safety note: this is preemption safe since if
-        // preemption occurs after this line, the pointer
-        // will also migrate which means this value will
-        // stay in syn with the TLS
-        coroutine_desc * src = TL_GET( this_thread )->curr_cor;
+extern "C" {
+        static inline void __cfactx_suspend(void) {
+                // optimization : read TLS once and reuse it
+                // Safety note: this is preemption safe since if
+                // preemption occurs after this line, the pointer
+                // will also migrate which means this value will
+                // stay in syn with the TLS
+                $coroutine * src = TL_GET( this_thread )->curr_cor;
 
-        assertf( src->last != 0,
-                "Attempt to suspend coroutine \"%.256s\" (%p) that has never been resumed.\n"
-                "Possible cause is a suspend executed in a member called by a coroutine user rather than by the coroutine main.",
-                src->name, src );
-        assertf( src->last->state != Halted,
-                "Attempt by coroutine \"%.256s\" (%p) to suspend back to terminated coroutine \"%.256s\" (%p).\n"
-                "Possible cause is terminated coroutine's main routine has already returned.",
-                src->name, src, src->last->name, src->last );
+                assertf( src->last != 0,
+                        "Attempt to suspend coroutine \"%.256s\" (%p) that has never been resumed.\n"
+                        "Possible cause is a suspend executed in a member called by a coroutine user rather than by the coroutine main.",
+                        src->name, src );
+                assertf( src->last->state != Halted,
+                        "Attempt by coroutine \"%.256s\" (%p) to suspend back to terminated coroutine \"%.256s\" (%p).\n"
+                        "Possible cause is terminated coroutine's main routine has already returned.",
+                        src->name, src, src->last->name, src->last );
 
-        CoroutineCtxSwitch( src, src->last );
+                $ctx_switch( src, src->last );
+        }
 }
 
@@ -124 +121 @@
         // will also migrate which means this value will
         // stay in syn with the TLS
-        coroutine_desc * src = TL_GET( this_thread )->curr_cor;
-        coroutine_desc * dst = get_coroutine(cor);
+        $coroutine * src = TL_GET( this_thread )->curr_cor;
+        $coroutine * dst = get_coroutine(cor);
 
         if( unlikely(dst->context.SP == 0p) ) {
                 TL_GET( this_thread )->curr_cor = dst;
                 __stack_prepare(&dst->stack, 65000);
-                CtxStart(main, dst, cor, CtxInvokeCoroutine);
+                __cfactx_start(main, dst, cor, __cfactx_invoke_coroutine);
                 TL_GET( this_thread )->curr_cor = src;
         }
@@ -147 +144 @@
 
         // always done for performance testing
-        CoroutineCtxSwitch( src, dst );
+        $ctx_switch( src, dst );
 
         return cor;
 }
 
-static inline void resume(coroutine_desc * dst) {
+static inline void resume( $coroutine * dst ) __attribute__((nonnull (1))) {
         // optimization : read TLS once and reuse it
         // Safety note: this is preemption safe since if
@@ -158 +155 @@
         // will also migrate which means this value will
         // stay in syn with the TLS
-        coroutine_desc * src = TL_GET( this_thread )->curr_cor;
+        $coroutine * src = TL_GET( this_thread )->curr_cor;
 
         // not resuming self ?
@@ -172 +169 @@
 
         // always done for performance testing
-        CoroutineCtxSwitch( src, dst );
+        $ctx_switch( src, dst );
 }
 

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 struct $coroutine * __cfactx_cor_finish(void);
+extern void __cfactx_cor_leave ( struct $coroutine * );
+extern void __cfactx_thrd_leave();
+
 extern void disable_interrupts() OPTIONAL_THREAD;
 extern void enable_interrupts( __cfaabi_dbg_ctx_param );
 
-void CtxInvokeCoroutine(
+void __cfactx_invoke_coroutine(
         void (*main)(void *),
         void *this
 ) {
         // Finish setting up the coroutine by setting its state
-        struct coroutine_desc * cor = __finish_coroutine();
+        struct $coroutine * cor = __cfactx_cor_finish();
 
         // Call the main of the coroutine
@@ -46 +47 @@
 
         //Final suspend, should never return
-        __leave_coroutine( cor );
+        __cfactx_cor_leave( cor );
         __cabi_abort( "Resumed dead coroutine" );
 }
 
-static _Unwind_Reason_Code _CtxCoroutine_UnwindStop(
+static _Unwind_Reason_Code __cfactx_coroutine_unwindstop(
         __attribute((__unused__)) int version,
         _Unwind_Action actions,
@@ -61 +62 @@
                 // We finished unwinding the coroutine,
                 // leave it
-                __leave_coroutine( param );
+                __cfactx_cor_leave( param );
                 __cabi_abort( "Resumed dead coroutine" );
         }
@@ -69 +70 @@
 }
 
-void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage, struct coroutine_desc * cor) __attribute__ ((__noreturn__));
-void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage, struct coroutine_desc * cor) {
-        _Unwind_Reason_Code ret = _Unwind_ForcedUnwind( storage, _CtxCoroutine_UnwindStop, cor );
+void __cfactx_coroutine_unwind(struct _Unwind_Exception * storage, struct $coroutine * cor) __attribute__ ((__noreturn__));
+void __cfactx_coroutine_unwind(struct _Unwind_Exception * storage, struct $coroutine * cor) {
+        _Unwind_Reason_Code ret = _Unwind_ForcedUnwind( storage, __cfactx_coroutine_unwindstop, cor );
         printf("UNWIND ERROR %d after force unwind\n", ret);
         abort();
 }
 
-void CtxInvokeThread(
+void __cfactx_invoke_thread(
         void (*main)(void *),
         void *this
@@ -93 +94 @@
         // The order of these 4 operations is very important
         //Final suspend, should never return
-        __leave_thread_monitor();
+        __cfactx_thrd_leave();
         __cabi_abort( "Resumed dead thread" );
 }
 
-void CtxStart(
+void __cfactx_start(
         void (*main)(void *),
-        struct coroutine_desc * cor,
+        struct $coroutine * cor,
         void *this,
         void (*invoke)(void *)
@@ -139 +140 @@
 
         fs->dummyReturn = NULL;
-        fs->rturn = CtxInvokeStub;
+        fs->rturn = __cfactx_invoke_stub;
         fs->fixedRegisters[0] = main;
         fs->fixedRegisters[1] = this;
@@ -157 +158 @@
         struct FakeStack *fs = (struct FakeStack *)cor->context.SP;
 
-        fs->intRegs[8] = CtxInvokeStub;
+        fs->intRegs[8] = __cfactx_invoke_stub;
         fs->arg[0] = this;
         fs->arg[1] = invoke;

libcfa/src/concurrency/invoke.h

@@ -47 +47 @@
         extern "Cforall" {
                 extern __attribute__((aligned(128))) thread_local struct KernelThreadData {
-                        struct thread_desc    * volatile this_thread;
+                        struct $thread    * volatile this_thread;
                         struct processor      * volatile this_processor;
 
@@ -92 +92 @@
         };
 
-        enum coroutine_state { Halted, Start, Inactive, Active, Primed };
-
-        struct coroutine_desc {
-                // context that is switch during a CtxSwitch
+        enum coroutine_state { Halted, Start, Primed, Blocked, Ready, Active, Rerun };
+        enum __Preemption_Reason { __NO_PREEMPTION, __ALARM_PREEMPTION, __POLL_PREEMPTION, __MANUAL_PREEMPTION };
+
+        struct $coroutine {
+                // context that is switch during a __cfactx_switch
                 struct __stack_context_t context;
 
@@ -108 +109 @@
 
                 // first coroutine to resume this one
-                struct coroutine_desc * starter;
+                struct $coroutine * starter;
 
                 // last coroutine to resume this one
-                struct coroutine_desc * last;
+                struct $coroutine * last;
 
                 // If non-null stack must be unwound with this exception
@@ -117 +118 @@
 
         };
+
+        static inline struct __stack_t * __get_stack( struct $coroutine * cor ) { return (struct __stack_t*)(((uintptr_t)cor->stack.storage) & ((uintptr_t)-2)); }
 
         // struct which calls the monitor is accepting
@@ -127 +130 @@
         };
 
-        struct monitor_desc {
+        struct $monitor {
                 // spinlock to protect internal data
                 struct __spinlock_t lock;
 
                 // current owner of the monitor
-                struct thread_desc * owner;
+                struct $thread * owner;
 
                 // queue of threads that are blocked waiting for the monitor
-                __queue_t(struct thread_desc) entry_queue;
+                __queue_t(struct $thread) entry_queue;
 
                 // stack of conditions to run next once we exit the monitor
@@ -152 +155 @@
         struct __monitor_group_t {
                 // currently held monitors
-                __cfa_anonymous_object( __small_array_t(monitor_desc*) );
+                __cfa_anonymous_object( __small_array_t($monitor*) );
 
                 // last function that acquired monitors
@@ -161 +164 @@
         // instrusive link field for threads
         struct __thread_desc_link {
-                struct thread_desc * next;
-                struct thread_desc * prev;
+                struct $thread * next;
+                struct $thread * prev;
                 unsigned long long ts;
         };
 
-        struct thread_desc {
+        struct $thread {
                 // Core threading fields
-                // context that is switch during a CtxSwitch
+                // context that is switch during a __cfactx_switch
                 struct __stack_context_t context;
 
                 // current execution status for coroutine
-                enum coroutine_state state;
+                volatile int state;
+                enum __Preemption_Reason preempted;
 
                 //SKULLDUGGERY errno is not save in the thread data structure because returnToKernel appears to be the only function to require saving and restoring it
 
                 // coroutine body used to store context
-                struct coroutine_desc  self_cor;
+                struct $coroutine  self_cor;
 
                 // current active context
-                struct coroutine_desc * curr_cor;
+                struct $coroutine * curr_cor;
 
                 // monitor body used for mutual exclusion
-                struct monitor_desc    self_mon;
+                struct $monitor    self_mon;
 
                 // pointer to monitor with sufficient lifetime for current monitors
-                struct monitor_desc *  self_mon_p;
+                struct $monitor *  self_mon_p;
 
                 // pointer to the cluster on which the thread is running
@@ -199 +203 @@
 
                 struct {
-                        struct thread_desc * next;
-                        struct thread_desc * prev;
+                        struct $thread * next;
+                        struct $thread * prev;
                 } node;
-        };
+
+                #ifdef __CFA_DEBUG__
+                        // previous function to park/unpark the thread
+                        const char * park_caller;
+                        enum coroutine_state park_result;
+                        bool park_stale;
+                        const char * unpark_caller;
+                        enum coroutine_state unpark_result;
+                        bool unpark_stale;
+                #endif
+        };
+
+        #ifdef __CFA_DEBUG__
+                void __cfaabi_dbg_record_thrd($thread & this, bool park, const char prev_name[]);
+        #else
+                #define __cfaabi_dbg_record_thrd(x, y, z)
+        #endif
 
         #ifdef __cforall
         extern "Cforall" {
-                static inline thread_desc *& get_next( thread_desc & this ) {
+
+                static inline $thread *& get_next( $thread & this ) __attribute__((const)) {
                         return this.link.next;
                 }
 
-                static inline [thread_desc *&, thread_desc *& ] __get( thread_desc & this ) {
+                static inline [$thread *&, $thread *& ] __get( $thread & this ) __attribute__((const)) {
                         return this.node.[next, prev];
                 }
@@ -220 +241 @@
                 }
 
-                static inline void ?{}(__monitor_group_t & this, struct monitor_desc ** data, __lock_size_t size, fptr_t func) {
+                static inline void ?{}(__monitor_group_t & this, struct $monitor ** data, __lock_size_t size, fptr_t func) {
                         (this.data){data};
                         (this.size){size};
@@ -226 +247 @@
                 }
 
-                static inline bool ?==?( const __monitor_group_t & lhs, const __monitor_group_t & rhs ) {
+                static inline bool ?==?( const __monitor_group_t & lhs, const __monitor_group_t & rhs ) __attribute__((const)) {
                         if( (lhs.data != 0) != (rhs.data != 0) ) return false;
                         if( lhs.size != rhs.size ) return false;
@@ -260 +281 @@
 
         // assembler routines that performs the context switch
-        extern void CtxInvokeStub( void );
-        extern void CtxSwitch( struct __stack_context_t * from, struct __stack_context_t * to ) asm ("CtxSwitch");
+        extern void __cfactx_invoke_stub( void );
+        extern void __cfactx_switch( struct __stack_context_t * from, struct __stack_context_t * to ) asm ("__cfactx_switch");
         // void CtxStore ( void * this ) asm ("CtxStore");
         // void CtxRet   ( void * dst  ) asm ("CtxRet");

libcfa/src/concurrency/kernel.cfa

@@ -15 +15 @@
 
 #define __cforall_thread__
+// #define __CFA_DEBUG_PRINT_RUNTIME_CORE__
 
 //C Includes
@@ -40 +41 @@
 #include "invoke.h"
 
+
 //-----------------------------------------------------------------------------
 // Some assembly required
@@ -110 +112 @@
 //-----------------------------------------------------------------------------
 //Start and stop routine for the kernel, declared first to make sure they run first
-static void kernel_startup(void)  __attribute__(( constructor( STARTUP_PRIORITY_KERNEL ) ));
-static void kernel_shutdown(void) __attribute__(( destructor ( STARTUP_PRIORITY_KERNEL ) ));
+static void __kernel_startup (void) __attribute__(( constructor( STARTUP_PRIORITY_KERNEL ) ));
+static void __kernel_shutdown(void) __attribute__(( destructor ( STARTUP_PRIORITY_KERNEL ) ));
+
+//-----------------------------------------------------------------------------
+// Kernel Scheduling logic
+static $thread * __next_thread(cluster * this);
+static void __run_thread(processor * this, $thread * dst);
+static $thread * __halt(processor * this);
+static bool __wake_one(cluster * cltr, bool was_empty);
+static bool __wake_proc(processor *);
 
 //-----------------------------------------------------------------------------
@@ -117 +127 @@
 KERNEL_STORAGE(cluster,         mainCluster);
 KERNEL_STORAGE(processor,       mainProcessor);
-KERNEL_STORAGE(thread_desc,     mainThread);
+KERNEL_STORAGE($thread, mainThread);
 KERNEL_STORAGE(__stack_t,       mainThreadCtx);
 
 cluster     * mainCluster;
 processor   * mainProcessor;
-thread_desc * mainThread;
+$thread * mainThread;
 
 extern "C" {
@@ -164 +174 @@
 // Main thread construction
 
-void ?{}( coroutine_desc & this, current_stack_info_t * info) with( this ) {
+void ?{}( $coroutine & this, current_stack_info_t * info) with( this ) {
         stack.storage = info->storage;
         with(*stack.storage) {
@@ -179 +189 @@
 }
 
-void ?{}( thread_desc & this, current_stack_info_t * info) with( this ) {
+void ?{}( $thread & this, current_stack_info_t * info) with( this ) {
         state = Start;
         self_cor{ info };
@@ -209 +219 @@
 }
 
-static void start(processor * this);
+static void * __invoke_processor(void * arg);
+
 void ?{}(processor & this, const char name[], cluster & cltr) with( this ) {
         this.name = name;
@@ -215 +226 @@
         id = -1u;
         terminated{ 0 };
+        destroyer = 0p;
         do_terminate = false;
         preemption_alarm = 0p;
@@ -220 +232 @@
         runner.proc = &this;
 
-        idleLock{};
-
-        start( &this );
+        idle{};
+
+        __cfadbg_print_safe(runtime_core, "Kernel : Starting core %p\n", &this);
+
+        this.stack = __create_pthread( &this.kernel_thread, __invoke_processor, (void *)&this );
+
+        __cfadbg_print_safe(runtime_core, "Kernel : core %p created\n", &this);
 }
 
 void ^?{}(processor & this) with( this ){
         if( ! __atomic_load_n(&do_terminate, __ATOMIC_ACQUIRE) ) {
-                __cfaabi_dbg_print_safe("Kernel : core %p signaling termination\n", &this);
+                __cfadbg_print_safe(runtime_core, "Kernel : core %p signaling termination\n", &this);
 
                 __atomic_store_n(&do_terminate, true, __ATOMIC_RELAXED);
-                wake( &this );
+                __wake_proc( &this );
 
                 P( terminated );
@@ -236 +252 @@
         }
 
-        pthread_join( kernel_thread, 0p );
+        int err = pthread_join( kernel_thread, 0p );
+        if( err != 0 ) abort("KERNEL ERROR: joining processor %p caused error %s\n", &this, strerror(err));
+
         free( this.stack );
 }
 
-void ?{}(cluster & this, const char name[], Duration preemption_rate) with( this ) {
+void ?{}(cluster & this, const char name[], Duration preemption_rate, int io_flags) with( this ) {
         this.name = name;
         this.preemption_rate = preemption_rate;
@@ -246 +264 @@
         ready_lock{};
 
+        #if !defined(__CFA_NO_STATISTICS__)
+                print_stats = false;
+        #endif
+
+        procs{ __get };
         idles{ __get };
         threads{ __get };
 
+        __kernel_io_startup( this, io_flags, &this == mainCluster );
+
         doregister(this);
 }
 
 void ^?{}(cluster & this) {
+        __kernel_io_shutdown( this, &this == mainCluster );
+
         unregister(this);
 }
@@ -259 +286 @@
 // Kernel Scheduling logic
 //=============================================================================================
-static void runThread(processor * this, thread_desc * dst);
-static void finishRunning(processor * this);
-static void halt(processor * this);
-
 //Main of the processor contexts
 void main(processorCtx_t & runner) {
@@ -272 +295 @@
         verify(this);
 
-        __cfaabi_dbg_print_safe("Kernel : core %p starting\n", this);
+        __cfadbg_print_safe(runtime_core, "Kernel : core %p starting\n", this);
 
         // register the processor unless it's the main thread which is handled in the boot sequence
@@ -285 +308 @@
                 preemption_scope scope = { this };
 
-                __cfaabi_dbg_print_safe("Kernel : core %p started\n", this);
-
-                thread_desc * readyThread = 0p;
+                __cfadbg_print_safe(runtime_core, "Kernel : core %p started\n", this);
+
+                $thread * readyThread = 0p;
                 for( unsigned int spin_count = 0; ! __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST); spin_count++ ) {
-                        readyThread = nextThread( this->cltr );
-
-                        if(readyThread) {
-                                verify( ! kernelTLS.preemption_state.enabled );
-
-                                runThread(this, readyThread);
-
-                                verify( ! kernelTLS.preemption_state.enabled );
-
-                                //Some actions need to be taken from the kernel
-                                finishRunning(this);
-
-                                spin_count = 0;
-                        } else {
-                                // spin(this, &spin_count);
-                                halt(this);
+                        // Try to get the next thread
+                        readyThread = __next_thread( this->cltr );
+
+                        // If no ready thread
+                        if( readyThread == 0p ) {
+                                // Block until a thread is ready
+                                readyThread = __halt(this);
+                        }
+
+                        // Check if we actually found a thread
+                        if( readyThread ) {
+                                /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+                                /* paranoid */ verifyf( readyThread->state == Ready || readyThread->preempted != __NO_PREEMPTION, "state : %d, preempted %d\n", readyThread->state, readyThread->preempted);
+                                /* paranoid */ verifyf( readyThread->next == 0p, "Expected null got %p", readyThread->next );
+
+                                // We found a thread run it
+                                __run_thread(this, readyThread);
+
+                                /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
                         }
                 }
 
-                __cfaabi_dbg_print_safe("Kernel : core %p stopping\n", this);
+                __cfadbg_print_safe(runtime_core, "Kernel : core %p stopping\n", this);
         }
 
         V( this->terminated );
-
 
         // unregister the processor unless it's the main thread which is handled in the boot sequence
@@ -319 +344 @@
                 unregister(this->cltr, this);
         }
-
-        __cfaabi_dbg_print_safe("Kernel : core %p terminated\n", this);
+        else {
+                // HACK : the coroutine context switch expects this_thread to be set
+                // and it make sense for it to be set in all other cases except here
+                // fake it
+                kernelTLS.this_thread = mainThread;
+        }
+
+        __cfadbg_print_safe(runtime_core, "Kernel : core %p terminated\n", this);
 
         stats_tls_tally(this->cltr);
@@ -331 +362 @@
 // runThread runs a thread by context switching
 // from the processor coroutine to the target thread
-static void runThread(processor * this, thread_desc * thrd_dst) {
-        coroutine_desc * proc_cor = get_coroutine(this->runner);
-
-        // Reset the terminating actions here
-        this->finish.action_code = No_Action;
+static void __run_thread(processor * this, $thread * thrd_dst) {
+        $coroutine * proc_cor = get_coroutine(this->runner);
 
         // Update global state
         kernelTLS.this_thread = thrd_dst;
 
-        // set state of processor coroutine to inactive and the thread to active
-        proc_cor->state = proc_cor->state == Halted ? Halted : Inactive;
-        thrd_dst->state = Active;
-
-        // set context switch to the thread that the processor is executing
-        verify( thrd_dst->context.SP );
-        CtxSwitch( &proc_cor->context, &thrd_dst->context );
-        // when CtxSwitch returns we are back in the processor coroutine
-
-        // set state of processor coroutine to active and the thread to inactive
-        thrd_dst->state = thrd_dst->state == Halted ? Halted : Inactive;
+        // set state of processor coroutine to inactive
+        verify(proc_cor->state == Active);
+        proc_cor->state = Blocked;
+
+        // Actually run the thread
+        RUNNING:  while(true) {
+                if(unlikely(thrd_dst->preempted)) {
+                        thrd_dst->preempted = __NO_PREEMPTION;
+                        verify(thrd_dst->state == Active  || thrd_dst->state == Rerun);
+                } else {
+                        verify(thrd_dst->state == Blocked || thrd_dst->state == Ready); // Ready means scheduled normally, blocked means rerun
+                        thrd_dst->state = Active;
+                }
+
+                __cfaabi_dbg_debug_do(
+                        thrd_dst->park_stale   = true;
+                        thrd_dst->unpark_stale = true;
+                )
+
+                /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+                /* paranoid */ verify( kernelTLS.this_thread == thrd_dst );
+                /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) < ((uintptr_t)__get_stack(thrd_dst->curr_cor)->base ) || thrd_dst->curr_cor == proc_cor, "ERROR : Destination $thread %p has been corrupted.\n StackPointer too small.\n", thrd_dst ); // add escape condition if we are setting up the processor
+                /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) > ((uintptr_t)__get_stack(thrd_dst->curr_cor)->limit) || thrd_dst->curr_cor == proc_cor, "ERROR : Destination $thread %p has been corrupted.\n StackPointer too large.\n", thrd_dst ); // add escape condition if we are setting up the processor
+
+                // set context switch to the thread that the processor is executing
+                verify( thrd_dst->context.SP );
+                __cfactx_switch( &proc_cor->context, &thrd_dst->context );
+                // when __cfactx_switch returns we are back in the processor coroutine
+
+                /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) > ((uintptr_t)__get_stack(thrd_dst->curr_cor)->limit), "ERROR : Destination $thread %p has been corrupted.\n StackPointer too large.\n", thrd_dst );
+                /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) < ((uintptr_t)__get_stack(thrd_dst->curr_cor)->base ), "ERROR : Destination $thread %p has been corrupted.\n StackPointer too small.\n", thrd_dst );
+                /* paranoid */ verify( kernelTLS.this_thread == thrd_dst );
+                /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+
+
+                // We just finished running a thread, there are a few things that could have happened.
+                // 1 - Regular case : the thread has blocked and now one has scheduled it yet.
+                // 2 - Racy case    : the thread has blocked but someone has already tried to schedule it.
+                // 4 - Preempted
+                // In case 1, we may have won a race so we can't write to the state again.
+                // In case 2, we lost the race so we now own the thread.
+
+                if(unlikely(thrd_dst->preempted != __NO_PREEMPTION)) {
+                        // The thread was preempted, reschedule it and reset the flag
+                        __schedule_thread( thrd_dst );
+                        break RUNNING;
+                }
+
+                // set state of processor coroutine to active and the thread to inactive
+                static_assert(sizeof(thrd_dst->state) == sizeof(int));
+                enum coroutine_state old_state = __atomic_exchange_n(&thrd_dst->state, Blocked, __ATOMIC_SEQ_CST);
+                __cfaabi_dbg_debug_do( thrd_dst->park_result = old_state; )
+                switch(old_state) {
+                        case Halted:
+                                // The thread has halted, it should never be scheduled/run again, leave it back to Halted and move on
+                                thrd_dst->state = Halted;
+
+                                // We may need to wake someone up here since
+                                unpark( this->destroyer __cfaabi_dbg_ctx2 );
+                                this->destroyer = 0p;
+                                break RUNNING;
+                        case Active:
+                                // This is case 1, the regular case, nothing more is needed
+                                break RUNNING;
+                        case Rerun:
+                                // This is case 2, the racy case, someone tried to run this thread before it finished blocking
+                                // In this case, just run it again.
+                                continue RUNNING;
+                        default:
+                                // This makes no sense, something is wrong abort
+                                abort("Finished running a thread that was Blocked/Start/Primed %d\n", old_state);
+                }
+        }
+
+        // Just before returning to the processor, set the processor coroutine to active
         proc_cor->state = Active;
+        kernelTLS.this_thread = 0p;
 }
 
 // KERNEL_ONLY
-static void returnToKernel() {
-        coroutine_desc * proc_cor = get_coroutine(kernelTLS.this_processor->runner);
-        thread_desc * thrd_src = kernelTLS.this_thread;
-
-        // set state of current coroutine to inactive
-        thrd_src->state = thrd_src->state == Halted ? Halted : Inactive;
-        proc_cor->state = Active;
-        int local_errno = *__volatile_errno();
-        #if defined( __i386 ) || defined( __x86_64 )
-                __x87_store;
-        #endif
-
-        // set new coroutine that the processor is executing
-        // and context switch to it
-        verify( proc_cor->context.SP );
-        CtxSwitch( &thrd_src->context, &proc_cor->context );
-
-        // set state of new coroutine to active
-        proc_cor->state = proc_cor->state == Halted ? Halted : Inactive;
-        thrd_src->state = Active;
-
-        #if defined( __i386 ) || defined( __x86_64 )
-                __x87_load;
-        #endif
-        *__volatile_errno() = local_errno;
-}
-
-// KERNEL_ONLY
-// Once a thread has finished running, some of
-// its final actions must be executed from the kernel
-static void finishRunning(processor * this) with( this->finish ) {
-        verify( ! kernelTLS.preemption_state.enabled );
-        choose( action_code ) {
-        case No_Action:
-                break;
-        case Release:
-                unlock( *lock );
-        case Schedule:
-                ScheduleThread( thrd );
-        case Release_Schedule:
-                unlock( *lock );
-                ScheduleThread( thrd );
-        case Release_Multi:
-                for(int i = 0; i < lock_count; i++) {
-                        unlock( *locks[i] );
-                }
-        case Release_Multi_Schedule:
-                for(int i = 0; i < lock_count; i++) {
-                        unlock( *locks[i] );
-                }
-                for(int i = 0; i < thrd_count; i++) {
-                        ScheduleThread( thrds[i] );
-                }
-        case Callback:
-                callback();
-        default:
-                abort("KERNEL ERROR: Unexpected action to run after thread");
-        }
+void returnToKernel() {
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+        $coroutine * proc_cor = get_coroutine(kernelTLS.this_processor->runner);
+        $thread * thrd_src = kernelTLS.this_thread;
+
+        // Run the thread on this processor
+        {
+                int local_errno = *__volatile_errno();
+                #if defined( __i386 ) || defined( __x86_64 )
+                        __x87_store;
+                #endif
+                verify( proc_cor->context.SP );
+                __cfactx_switch( &thrd_src->context, &proc_cor->context );
+                #if defined( __i386 ) || defined( __x86_64 )
+                        __x87_load;
+                #endif
+                *__volatile_errno() = local_errno;
+        }
+
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+        /* paranoid */ verifyf( ((uintptr_t)thrd_src->context.SP) < ((uintptr_t)__get_stack(thrd_src->curr_cor)->base ), "ERROR : Returning $thread %p has been corrupted.\n StackPointer too small.\n", thrd_src );
+        /* paranoid */ verifyf( ((uintptr_t)thrd_src->context.SP) > ((uintptr_t)__get_stack(thrd_src->curr_cor)->limit), "ERROR : Returning $thread %p has been corrupted.\n StackPointer too large.\n", thrd_src );
 }
 
@@ -419 +476 @@
 // This is the entry point for processors (kernel threads)
 // It effectively constructs a coroutine by stealing the pthread stack
-static void * CtxInvokeProcessor(void * arg) {
+static void * __invoke_processor(void * arg) {
         processor * proc = (processor *) arg;
         kernelTLS.this_processor = proc;
@@ -438 +495 @@
 
         //We now have a proper context from which to schedule threads
-        __cfaabi_dbg_print_safe("Kernel : core %p created (%p, %p)\n", proc, &proc->runner, &ctx);
+        __cfadbg_print_safe(runtime_core, "Kernel : core %p created (%p, %p)\n", proc, &proc->runner, &ctx);
 
         // SKULLDUGGERY: Since the coroutine doesn't have its own stack, we can't
@@ -449 +506 @@
 
         // Main routine of the core returned, the core is now fully terminated
-        __cfaabi_dbg_print_safe("Kernel : core %p main ended (%p)\n", proc, &proc->runner);
+        __cfadbg_print_safe(runtime_core, "Kernel : core %p main ended (%p)\n", proc, &proc->runner);
 
         return 0p;
@@ -460 +517 @@
 } // Abort
 
-void * create_pthread( pthread_t * pthread, void * (*start)(void *), void * arg ) {
+void * __create_pthread( pthread_t * pthread, void * (*start)(void *), void * arg ) {
         pthread_attr_t attr;
 
@@ -488 +545 @@
 }
 
-static void start(processor * this) {
-        __cfaabi_dbg_print_safe("Kernel : Starting core %p\n", this);
-
-        this->stack = create_pthread( &this->kernel_thread, CtxInvokeProcessor, (void *)this );
-
-        __cfaabi_dbg_print_safe("Kernel : core %p started\n", this);
-}
-
 // KERNEL_ONLY
-void kernel_first_resume( processor * this ) {
-        thread_desc * src = mainThread;
-        coroutine_desc * dst = get_coroutine(this->runner);
+static void __kernel_first_resume( processor * this ) {
+        $thread * src = mainThread;
+        $coroutine * dst = get_coroutine(this->runner);
 
         verify( ! kernelTLS.preemption_state.enabled );
@@ -505 +554 @@
         kernelTLS.this_thread->curr_cor = dst;
         __stack_prepare( &dst->stack, 65000 );
-        CtxStart(main, dst, this->runner, CtxInvokeCoroutine);
+        __cfactx_start(main, dst, this->runner, __cfactx_invoke_coroutine);
 
         verify( ! kernelTLS.preemption_state.enabled );
@@ -512 +561 @@
         dst->starter = dst->starter ? dst->starter : &src->self_cor;
 
-        // set state of current coroutine to inactive
-        src->state = src->state == Halted ? Halted : Inactive;
+        // make sure the current state is still correct
+        /* paranoid */ verify(src->state == Ready);
 
         // context switch to specified coroutine
         verify( dst->context.SP );
-        CtxSwitch( &src->context, &dst->context );
-        // when CtxSwitch returns we are back in the src coroutine
+        __cfactx_switch( &src->context, &dst->context );
+        // when __cfactx_switch returns we are back in the src coroutine
 
         mainThread->curr_cor = &mainThread->self_cor;
 
-        // set state of new coroutine to active
-        src->state = Active;
+        // make sure the current state has been update
+        /* paranoid */ verify(src->state == Active);
 
         verify( ! kernelTLS.preemption_state.enabled );
@@ -529 +578 @@
 
 // KERNEL_ONLY
-void kernel_last_resume( processor * this ) {
-        coroutine_desc * src = &mainThread->self_cor;
-        coroutine_desc * dst = get_coroutine(this->runner);
+static void __kernel_last_resume( processor * this ) {
+        $coroutine * src = &mainThread->self_cor;
+        $coroutine * dst = get_coroutine(this->runner);
 
         verify( ! kernelTLS.preemption_state.enabled );
@@ -537 +586 @@
         verify( dst->context.SP );
 
+        // SKULLDUGGERY in debug the processors check that the
+        // stack is still within the limit of the stack limits after running a thread.
+        // that check doesn't make sense if we context switch to the processor using the
+        // coroutine semantics. Since this is a special case, use the current context
+        // info to populate these fields.
+        __cfaabi_dbg_debug_do(
+                __stack_context_t ctx;
+                CtxGet( ctx );
+                mainThread->context.SP = ctx.SP;
+                mainThread->context.FP = ctx.FP;
+        )
+
         // context switch to the processor
-        CtxSwitch( &src->context, &dst->context );
+        __cfactx_switch( &src->context, &dst->context );
 }
 
 //-----------------------------------------------------------------------------
 // Scheduler routines
-
 // KERNEL ONLY
-void ScheduleThread( thread_desc * thrd ) {
-        verify( thrd );
-        verify( thrd->state != Halted );
-
-        verify( ! kernelTLS.preemption_state.enabled );
-
-        verifyf( thrd->link.next == 0p, "Expected null got %p", thrd->link.next );
-
+void __schedule_thread( $thread * thrd ) {
+        /* paranoid */ verify( thrd );
+        /* paranoid */ verify( thrd->state != Halted );
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+        /* paranoid */ #if defined( __CFA_WITH_VERIFY__ )
+        /* paranoid */ if( thrd->state == Blocked || thrd->state == Start ) assertf( thrd->preempted == __NO_PREEMPTION,
+                          "Error inactive thread marked as preempted, state %d, preemption %d\n", thrd->state, thrd->preempted );
+        /* paranoid */ if( thrd->preempted != __NO_PREEMPTION ) assertf(thrd->state == Active || thrd->state == Rerun,
+                          "Error preempted thread marked as not currently running, state %d, preemption %d\n", thrd->state, thrd->preempted );
+        /* paranoid */ #endif
+        /* paranoid */ verifyf( thrd->link.next == 0p, "Expected null got %p", thrd->link.next );
+
+        if (thrd->preempted == __NO_PREEMPTION) thrd->state = Ready;
 
         ready_schedule_lock(thrd->curr_cluster, kernelTLS.this_processor);
@@ -558 +623 @@
         ready_schedule_unlock(thrd->curr_cluster, kernelTLS.this_processor);
 
-        with( *thrd->curr_cluster ) {
-                // if(was_empty) {
-                //      lock      (proc_list_lock __cfaabi_dbg_ctx2);
-                //      if(idles) {
-                //              wake_fast(idles.head);
-                //      }
-                //      unlock    (proc_list_lock);
-                // }
-                // else if( struct processor * idle = idles.head ) {
-                //      wake_fast(idle);
-                // }
-        }
-
-        verify( ! kernelTLS.preemption_state.enabled );
+        __wake_one(thrd->curr_cluster, was_empty);
+
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
 }
 
 // KERNEL ONLY
-thread_desc * nextThread(cluster * this) with( *this ) {
-        verify( ! kernelTLS.preemption_state.enabled );
+static $thread * __next_thread(cluster * this) with( *this ) {
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
 
         ready_schedule_lock(this, kernelTLS.this_processor);
-                thread_desc * head = pop( this );
+                $thread * head = pop( this );
         ready_schedule_unlock(this, kernelTLS.this_processor);
 
-        verify( ! kernelTLS.preemption_state.enabled );
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
         return head;
 }
 
-void BlockInternal() {
+// KERNEL ONLY unpark with out disabling interrupts
+void __unpark( $thread * thrd __cfaabi_dbg_ctx_param2 ) {
+        static_assert(sizeof(thrd->state) == sizeof(int));
+
+        // record activity
+        __cfaabi_dbg_record_thrd( *thrd, false, caller );
+
+        enum coroutine_state old_state = __atomic_exchange_n(&thrd->state, Rerun, __ATOMIC_SEQ_CST);
+        __cfaabi_dbg_debug_do( thrd->unpark_result = old_state; )
+        switch(old_state) {
+                case Active:
+                        // Wake won the race, the thread will reschedule/rerun itself
+                        break;
+                case Blocked:
+                        /* paranoid */ verify( ! thrd->preempted != __NO_PREEMPTION );
+
+                        // Wake lost the race,
+                        thrd->state = Blocked;
+                        __schedule_thread( thrd );
+                        break;
+                case Rerun:
+                        abort("More than one thread attempted to schedule thread %p\n", thrd);
+                        break;
+                case Halted:
+                case Start:
+                case Primed:
+                default:
+                        // This makes no sense, something is wrong abort
+                        abort();
+        }
+}
+
+void unpark( $thread * thrd __cfaabi_dbg_ctx_param2 ) {
+        if( !thrd ) return;
+
         disable_interrupts();
-        verify( ! kernelTLS.preemption_state.enabled );
+        __unpark( thrd __cfaabi_dbg_ctx_fwd2 );
+        enable_interrupts( __cfaabi_dbg_ctx );
+}
+
+void park( __cfaabi_dbg_ctx_param ) {
+        /* paranoid */ verify( kernelTLS.preemption_state.enabled );
+        disable_interrupts();
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+        /* paranoid */ verify( kernelTLS.this_thread->preempted == __NO_PREEMPTION );
+
+        // record activity
+        __cfaabi_dbg_record_thrd( *kernelTLS.this_thread, true, caller );
+
         returnToKernel();
-        verify( ! kernelTLS.preemption_state.enabled );
+
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
         enable_interrupts( __cfaabi_dbg_ctx );
-}
-
-void BlockInternal( __spinlock_t * lock ) {
+        /* paranoid */ verify( kernelTLS.preemption_state.enabled );
+
+}
+
+// KERNEL ONLY
+void __leave_thread() {
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+        returnToKernel();
+        abort();
+}
+
+// KERNEL ONLY
+bool force_yield( __Preemption_Reason reason ) {
+        /* paranoid */ verify( kernelTLS.preemption_state.enabled );
         disable_interrupts();
-        with( *kernelTLS.this_processor ) {
-                finish.action_code = Release;
-                finish.lock        = lock;
-        }
-
-        verify( ! kernelTLS.preemption_state.enabled );
-        returnToKernel();
-        verify( ! kernelTLS.preemption_state.enabled );
-
-        enable_interrupts( __cfaabi_dbg_ctx );
-}
-
-void BlockInternal( thread_desc * thrd ) {
-        disable_interrupts();
-        with( * kernelTLS.this_processor ) {
-                finish.action_code = Schedule;
-                finish.thrd        = thrd;
-        }
-
-        verify( ! kernelTLS.preemption_state.enabled );
-        returnToKernel();
-        verify( ! kernelTLS.preemption_state.enabled );
-
-        enable_interrupts( __cfaabi_dbg_ctx );
-}
-
-void BlockInternal( __spinlock_t * lock, thread_desc * thrd ) {
-        assert(thrd);
-        disable_interrupts();
-        with( * kernelTLS.this_processor ) {
-                finish.action_code = Release_Schedule;
-                finish.lock        = lock;
-                finish.thrd        = thrd;
-        }
-
-        verify( ! kernelTLS.preemption_state.enabled );
-        returnToKernel();
-        verify( ! kernelTLS.preemption_state.enabled );
-
-        enable_interrupts( __cfaabi_dbg_ctx );
-}
-
-void BlockInternal(__spinlock_t * locks [], unsigned short count) {
-        disable_interrupts();
-        with( * kernelTLS.this_processor ) {
-                finish.action_code = Release_Multi;
-                finish.locks       = locks;
-                finish.lock_count  = count;
-        }
-
-        verify( ! kernelTLS.preemption_state.enabled );
-        returnToKernel();
-        verify( ! kernelTLS.preemption_state.enabled );
-
-        enable_interrupts( __cfaabi_dbg_ctx );
-}
-
-void BlockInternal(__spinlock_t * locks [], unsigned short lock_count, thread_desc * thrds [], unsigned short thrd_count) {
-        disable_interrupts();
-        with( *kernelTLS.this_processor ) {
-                finish.action_code = Release_Multi_Schedule;
-                finish.locks       = locks;
-                finish.lock_count  = lock_count;
-                finish.thrds       = thrds;
-                finish.thrd_count  = thrd_count;
-        }
-
-        verify( ! kernelTLS.preemption_state.enabled );
-        returnToKernel();
-        verify( ! kernelTLS.preemption_state.enabled );
-
-        enable_interrupts( __cfaabi_dbg_ctx );
-}
-
-void BlockInternal(__finish_callback_fptr_t callback) {
-        disable_interrupts();
-        with( *kernelTLS.this_processor ) {
-                finish.action_code = Callback;
-                finish.callback    = callback;
-        }
-
-        verify( ! kernelTLS.preemption_state.enabled );
-        returnToKernel();
-        verify( ! kernelTLS.preemption_state.enabled );
-
-        enable_interrupts( __cfaabi_dbg_ctx );
-}
-
-// KERNEL ONLY
-void LeaveThread(__spinlock_t * lock, thread_desc * thrd) {
-        verify( ! kernelTLS.preemption_state.enabled );
-        with( * kernelTLS.this_processor ) {
-                finish.action_code = thrd ? Release_Schedule : Release;
-                finish.lock        = lock;
-                finish.thrd        = thrd;
-        }
-
-        returnToKernel();
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+
+        $thread * thrd = kernelTLS.this_thread;
+        /* paranoid */ verify(thrd->state == Active || thrd->state == Rerun);
+
+        // SKULLDUGGERY: It is possible that we are preempting this thread just before
+        // it was going to park itself. If that is the case and it is already using the
+        // intrusive fields then we can't use them to preempt the thread
+        // If that is the case, abandon the preemption.
+        bool preempted = false;
+        if(thrd->next == 0p) {
+                preempted = true;
+                thrd->preempted = reason;
+                returnToKernel();
+        }
+
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+        enable_interrupts_noPoll();
+        /* paranoid */ verify( kernelTLS.preemption_state.enabled );
+
+        return preempted;
 }
 
@@ -701 +736 @@
 //-----------------------------------------------------------------------------
 // Kernel boot procedures
-static void kernel_startup(void) {
+static void __kernel_startup(void) {
         verify( ! kernelTLS.preemption_state.enabled );
-        __cfaabi_dbg_print_safe("Kernel : Starting\n");
+        __cfadbg_print_safe(runtime_core, "Kernel : Starting\n");
 
         __page_size = sysconf( _SC_PAGESIZE );
@@ -714 +749 @@
         (*mainCluster){"Main Cluster"};
 
-        __cfaabi_dbg_print_safe("Kernel : Main cluster ready\n");
+        __cfadbg_print_safe(runtime_core, "Kernel : Main cluster ready\n");
 
         // Start by initializing the main thread
         // SKULLDUGGERY: the mainThread steals the process main thread
         // which will then be scheduled by the mainProcessor normally
-        mainThread = (thread_desc *)&storage_mainThread;
+        mainThread = ($thread *)&storage_mainThread;
         current_stack_info_t info;
         info.storage = (__stack_t*)&storage_mainThreadCtx;
         (*mainThread){ &info };
 
-        __cfaabi_dbg_print_safe("Kernel : Main thread ready\n");
+        __cfadbg_print_safe(runtime_core, "Kernel : Main thread ready\n");
 
 
@@ -746 +781 @@
 
                 runner{ &this };
-                __cfaabi_dbg_print_safe("Kernel : constructed main processor context %p\n", &runner);
+                __cfadbg_print_safe(runtime_core, "Kernel : constructed main processor context %p\n", &runner);
         }
 
@@ -765 +800 @@
         // Add the main thread to the ready queue
         // once resume is called on mainProcessor->runner the mainThread needs to be scheduled like any normal thread
-        ScheduleThread(mainThread);
+        __schedule_thread(mainThread);
 
         // SKULLDUGGERY: Force a context switch to the main processor to set the main thread's context to the current UNIX
-        // context. Hence, the main thread does not begin through CtxInvokeThread, like all other threads. The trick here is that
+        // context. Hence, the main thread does not begin through __cfactx_invoke_thread, like all other threads. The trick here is that
         // mainThread is on the ready queue when this call is made.
-        kernel_first_resume( kernelTLS.this_processor );
-
+        __kernel_first_resume( kernelTLS.this_processor );
 
 
         // THE SYSTEM IS NOW COMPLETELY RUNNING
-        __cfaabi_dbg_print_safe("Kernel : Started\n--------------------------------------------------\n\n");
+
+
+        // Now that the system is up, finish creating systems that need threading
+        __kernel_io_finish_start( *mainCluster );
+
+
+        __cfadbg_print_safe(runtime_core, "Kernel : Started\n--------------------------------------------------\n\n");
 
         verify( ! kernelTLS.preemption_state.enabled );
@@ -782 +822 @@
 }
 
-static void kernel_shutdown(void) {
-        __cfaabi_dbg_print_safe("\n--------------------------------------------------\nKernel : Shutting down\n");
-
-        verify( TL_GET( preemption_state.enabled ) );
+static void __kernel_shutdown(void) {
+        //Before we start shutting things down, wait for systems that need threading to shutdown
+        __kernel_io_prepare_stop( *mainCluster );
+
+        /* paranoid */ verify( TL_GET( preemption_state.enabled ) );
         disable_interrupts();
-        verify( ! kernelTLS.preemption_state.enabled );
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+
+        __cfadbg_print_safe(runtime_core, "\n--------------------------------------------------\nKernel : Shutting down\n");
 
         // SKULLDUGGERY: Notify the mainProcessor it needs to terminates.
@@ -793 +836 @@
         // which is currently here
         __atomic_store_n(&mainProcessor->do_terminate, true, __ATOMIC_RELEASE);
-        kernel_last_resume( kernelTLS.this_processor );
+        __kernel_last_resume( kernelTLS.this_processor );
         mainThread->self_cor.state = Halted;
 
@@ -805 +848 @@
         // Destroy the main processor and its context in reverse order of construction
         // These were manually constructed so we need manually destroy them
-        void ^?{}(processor & this) with( this ) {
-                //don't join the main thread here, that wouldn't make any sense
+        void ^?{}(processor & this) with( this ){
+                /* paranoid */ verify( this.do_terminate == true );
                 __cfaabi_dbg_print_safe("Kernel : destroyed main processor context %p\n", &runner);
         }
@@ -813 +856 @@
 
         // Final step, destroy the main thread since it is no longer needed
-        // Since we provided a stack to this task it will not destroy anything
+
+        // Since we provided a stack to this taxk it will not destroy anything
+        /* paranoid */ verify(mainThread->self_cor.stack.storage == (__stack_t*)(((uintptr_t)&storage_mainThreadCtx)| 0x1));
         ^(*mainThread){};
 
@@ -821 +866 @@
         ^(__cfa_dbg_global_clusters.lock){};
 
-        __cfaabi_dbg_print_safe("Kernel : Shutdown complete\n");
+        __cfadbg_print_safe(runtime_core, "Kernel : Shutdown complete\n");
 }
 
 //=============================================================================================
-// Kernel Quiescing
+// Kernel Idle Sleep
 //=============================================================================================
-static void halt(processor * this) with( *this ) {
-        // // verify( ! __atomic_load_n(&do_terminate, __ATOMIC_SEQ_CST) );
-
-        // with( *cltr ) {
-        //      lock      (proc_list_lock __cfaabi_dbg_ctx2);
-        //      push_front(idles, *this);
-        //      unlock    (proc_list_lock);
-        // }
-
-        // __cfaabi_dbg_print_safe("Kernel : Processor %p ready to sleep\n", this);
-
-        // wait( idleLock );
-
-        // __cfaabi_dbg_print_safe("Kernel : Processor %p woke up and ready to run\n", this);
-
-        // with( *cltr ) {
-        //      lock      (proc_list_lock __cfaabi_dbg_ctx2);
-        //      remove    (idles, *this);
-        //      unlock    (proc_list_lock);
-        // }
+static $thread * __halt(processor * this) with( *this ) {
+        if( do_terminate ) return 0p;
+
+        // First, lock the cluster idle
+        lock( cltr->idle_lock __cfaabi_dbg_ctx2 );
+
+        // Check if we can find a thread
+        if( $thread * found = __next_thread( cltr ) ) {
+                unlock( cltr->idle_lock );
+                return found;
+        }
+
+        // Move this processor from the active list to the idle list
+        move_to_front(cltr->procs, cltr->idles, *this);
+
+        // Unlock the idle lock so we don't go to sleep with a lock
+        unlock    (cltr->idle_lock);
+
+        // We are ready to sleep
+        __cfadbg_print_safe(runtime_core, "Kernel : Processor %p ready to sleep\n", this);
+        wait( idle );
+
+        // We have woken up
+        __cfadbg_print_safe(runtime_core, "Kernel : Processor %p woke up and ready to run\n", this);
+
+        // Get ourself off the idle list
+        with( *cltr ) {
+                lock  (idle_lock __cfaabi_dbg_ctx2);
+                move_to_front(idles, procs, *this);
+                unlock(idle_lock);
+        }
+
+        // Don't check the ready queue again, we may not be in a position to run a thread
+        return 0p;
+}
+
+// Wake a thread from the front if there are any
+static bool __wake_one(cluster * this, __attribute__((unused)) bool force) {
+        // if we don't want to force check if we know it's false
+        // if( !this->idles.head && !force ) return false;
+
+        // First, lock the cluster idle
+        lock( this->idle_lock __cfaabi_dbg_ctx2 );
+
+        // Check if there is someone to wake up
+        if( !this->idles.head ) {
+                // Nope unlock and return false
+                unlock( this->idle_lock );
+                return false;
+        }
+
+        // Wake them up
+        __cfadbg_print_safe(runtime_core, "Kernel : waking Processor %p\n", this->idles.head);
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+        post( this->idles.head->idle );
+
+        // Unlock and return true
+        unlock( this->idle_lock );
+        return true;
+}
+
+// Unconditionnaly wake a thread
+static bool __wake_proc(processor * this) {
+        __cfadbg_print_safe(runtime_core, "Kernel : waking Processor %p\n", this);
+
+        disable_interrupts();
+                /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+                bool ret = post( this->idle );
+        enable_interrupts( __cfaabi_dbg_ctx );
+
+        return ret;
 }
 
@@ -880 +976 @@
 
 void kernel_abort_msg( void * kernel_data, char * abort_text, int abort_text_size ) {
-        thread_desc * thrd = kernel_data;
+        $thread * thrd = kernel_data;
 
         if(thrd) {
@@ -928 +1024 @@
 void ^?{}(semaphore & this) {}
 
-void P(semaphore & this) with( this ){
+bool P(semaphore & this) with( this ){
         lock( lock __cfaabi_dbg_ctx2 );
         count -= 1;
@@ -936 +1032 @@
 
                 // atomically release spin lock and block
-                BlockInternal( &lock );
+                unlock( lock );
+                park( __cfaabi_dbg_ctx );
+                return true;
         }
         else {
             unlock( lock );
-        }
-}
-
-void V(semaphore & this) with( this ) {
-        thread_desc * thrd = 0p;
+            return false;
+        }
+}
+
+bool V(semaphore & this) with( this ) {
+        $thread * thrd = 0p;
         lock( lock __cfaabi_dbg_ctx2 );
         count += 1;
@@ -955 +1054 @@
 
         // make new owner
-        WakeThread( thrd );
+        unpark( thrd __cfaabi_dbg_ctx2 );
+
+        return thrd != 0p;
+}
+
+bool V(semaphore & this, unsigned diff) with( this ) {
+        $thread * thrd = 0p;
+        lock( lock __cfaabi_dbg_ctx2 );
+        int release = max(-count, (int)diff);
+        count += diff;
+        for(release) {
+                unpark( pop_head( waiting ) __cfaabi_dbg_ctx2 );
+        }
+
+        unlock( lock );
+
+        return thrd != 0p;
 }
 
@@ -972 +1087 @@
 }
 
-void doregister( cluster * cltr, thread_desc & thrd ) {
+void doregister( cluster * cltr, $thread & thrd ) {
         lock      (cltr->thread_list_lock __cfaabi_dbg_ctx2);
         cltr->nthreads += 1;
@@ -979 +1094 @@
 }
 
-void unregister( cluster * cltr, thread_desc & thrd ) {
+void unregister( cluster * cltr, $thread & thrd ) {
         lock  (cltr->thread_list_lock __cfaabi_dbg_ctx2);
         remove(cltr->threads, thrd );
@@ -990 +1105 @@
 __cfaabi_dbg_debug_do(
         extern "C" {
-                void __cfaabi_dbg_record(__spinlock_t & this, const char prev_name[]) {
+                void __cfaabi_dbg_record_lock(__spinlock_t & this, const char prev_name[]) {
                         this.prev_name = prev_name;
                         this.prev_thrd = kernelTLS.this_thread;
                 }
+
+                void __cfaabi_dbg_record_thrd($thread & this, bool park, const char prev_name[]) {
+                        if(park) {
+                                this.park_caller   = prev_name;
+                                this.park_stale    = false;
+                        }
+                        else {
+                                this.unpark_caller = prev_name;
+                                this.unpark_stale  = false;
+                        }
+                }
         }
 )
@@ -999 +1125 @@
 //-----------------------------------------------------------------------------
 // Debug
-bool threading_enabled(void) {
+bool threading_enabled(void) __attribute__((const)) {
         return true;
 }

libcfa/src/concurrency/kernel.hfa

@@ -17 +17 @@
 
 #include <stdbool.h>
+#include <stdint.h>
 
 #include "invoke.h"
@@ -32 +33 @@
         __spinlock_t lock;
         int count;
-        __queue_t(thread_desc) waiting;
+        __queue_t($thread) waiting;
 };
 
 void  ?{}(semaphore & this, int count = 1);
 void ^?{}(semaphore & this);
-void   P (semaphore & this);
-void   V (semaphore & this);
+bool   P (semaphore & this);
+bool   V (semaphore & this);
+bool   V (semaphore & this, unsigned count);
 
 
@@ -44 +46 @@
 // Processor
 extern struct cluster * mainCluster;
-
-enum FinishOpCode { No_Action, Release, Schedule, Release_Schedule, Release_Multi, Release_Multi_Schedule, Callback };
-
-typedef void (*__finish_callback_fptr_t)(void);
-
-//TODO use union, many of these fields are mutually exclusive (i.e. MULTI vs NOMULTI)
-struct FinishAction {
-        FinishOpCode action_code;
-        /*
-        // Union of possible actions
-        union {
-                // Option 1 : locks and threads
-                struct {
-                        // 1 thread or N thread
-                        union {
-                                thread_desc * thrd;
-                                struct {
-                                        thread_desc ** thrds;
-                                        unsigned short thrd_count;
-                                };
-                        };
-                        // 1 lock or N lock
-                        union {
-                                __spinlock_t * lock;
-                                struct {
-                                        __spinlock_t ** locks;
-                                        unsigned short lock_count;
-                                };
-                        };
-                };
-                // Option 2 : action pointer
-                __finish_callback_fptr_t callback;
-        };
-        /*/
-        thread_desc * thrd;
-        thread_desc ** thrds;
-        unsigned short thrd_count;
-        __spinlock_t * lock;
-        __spinlock_t ** locks;
-        unsigned short lock_count;
-        __finish_callback_fptr_t callback;
-        //*/
-};
-static inline void ?{}(FinishAction & this) {
-        this.action_code = No_Action;
-        this.thrd = 0p;
-        this.lock = 0p;
-}
-static inline void ^?{}(FinishAction &) {}
 
 // Processor
@@ -117 +70 @@
         // RunThread data
         // Action to do after a thread is ran
-        struct FinishAction finish;
+        $thread * destroyer;
 
         // Preemption data
@@ -126 +79 @@
         bool pending_preemption;
 
-        // Idle lock
-        __bin_sem_t idleLock;
+        // Idle lock (kernel semaphore)
+        __bin_sem_t idle;
 
         // Termination
@@ -133 +86 @@
         volatile bool do_terminate;
 
-        // Termination synchronisation
+        // Termination synchronisation (user semaphore)
         semaphore terminated;
 
@@ -158 +111 @@
 static inline void  ?{}(processor & this, const char name[]) { this{name, *mainCluster }; }
 
-static inline [processor *&, processor *& ] __get( processor & this ) {
-        return this.node.[next, prev];
-}
+static inline [processor *&, processor *& ] __get( processor & this ) __attribute__((const)) { return this.node.[next, prev]; }
+
+//-----------------------------------------------------------------------------
+// I/O
+struct __io_data;
+
+#define CFA_CLUSTER_IO_POLLER_USER_THREAD 1 << 0
+// #define CFA_CLUSTER_IO_POLLER_KERNEL_SIDE 1 << 1
 
 
@@ -333 +291 @@
         // List of threads
         __spinlock_t thread_list_lock;
-        __dllist_t(struct thread_desc) threads;
+        __dllist_t(struct $thread) threads;
         unsigned int nthreads;
 
@@ -341 +299 @@
                 cluster * prev;
         } node;
+
+        struct __io_data * io;
+
+        #if !defined(__CFA_NO_STATISTICS__)
+                bool print_stats;
+        #endif
 };
 extern Duration default_preemption();
 
-void ?{} (cluster & this, const char name[], Duration preemption_rate);
+void ?{} (cluster & this, const char name[], Duration preemption_rate, int flags);
 void ^?{}(cluster & this);
 
-static inline void ?{} (cluster & this)                           { this{"Anonymous Cluster", default_preemption()}; }
-static inline void ?{} (cluster & this, Duration preemption_rate) { this{"Anonymous Cluster", preemption_rate}; }
-static inline void ?{} (cluster & this, const char name[])        { this{name, default_preemption()}; }
-
-static inline [cluster *&, cluster *& ] __get( cluster & this ) {
-        return this.node.[next, prev];
-}
+static inline void ?{} (cluster & this)                                      { this{"Anonymous Cluster", default_preemption(), 0}; }
+static inline void ?{} (cluster & this, Duration preemption_rate)            { this{"Anonymous Cluster", preemption_rate, 0}; }
+static inline void ?{} (cluster & this, const char name[])                   { this{name, default_preemption(), 0}; }
+static inline void ?{} (cluster & this, int flags)                           { this{"Anonymous Cluster", default_preemption(), flags}; }
+static inline void ?{} (cluster & this, Duration preemption_rate, int flags) { this{"Anonymous Cluster", preemption_rate, flags}; }
+static inline void ?{} (cluster & this, const char name[], int flags)        { this{name, default_preemption(), flags}; }
+
+static inline [cluster *&, cluster *& ] __get( cluster & this ) __attribute__((const)) { return this.node.[next, prev]; }
 
 static inline struct processor * active_processor() { return TL_GET( this_processor ); } // UNSAFE
 static inline struct cluster   * active_cluster  () { return TL_GET( this_processor )->cltr; }
+
+#if !defined(__CFA_NO_STATISTICS__)
+        static inline void print_stats_at_exit( cluster & this ) {
+                this.print_stats = true;
+        }
+#endif
 
 // Local Variables: //

libcfa/src/concurrency/kernel_private.hfa

@@ -31 +31 @@
 }
 
-void ScheduleThread( thread_desc * );
-static inline void WakeThread( thread_desc * thrd ) {
-        if( !thrd ) return;
-
-        verify(thrd->state == Inactive);
-
-        disable_interrupts();
-        ScheduleThread( thrd );
-        enable_interrupts( __cfaabi_dbg_ctx );
-}
-thread_desc * nextThread(cluster * this);
+void __schedule_thread( $thread * ) __attribute__((nonnull (1)));
 
 //Block current thread and release/wake-up the following resources
-void BlockInternal(void);
-void BlockInternal(__spinlock_t * lock);
-void BlockInternal(thread_desc * thrd);
-void BlockInternal(__spinlock_t * lock, thread_desc * thrd);
-void BlockInternal(__spinlock_t * locks [], unsigned short count);
-void BlockInternal(__spinlock_t * locks [], unsigned short count, thread_desc * thrds [], unsigned short thrd_count);
-void BlockInternal(__finish_callback_fptr_t callback);
-void LeaveThread(__spinlock_t * lock, thread_desc * thrd);
+void __leave_thread() __attribute__((noreturn));
 
 //-----------------------------------------------------------------------------
@@ -57 +40 @@
 void main(processorCtx_t *);
 
-void * create_pthread( pthread_t *, void * (*)(void *), void * );
-
-static inline void wake_fast(processor * this) {
-        __cfaabi_dbg_print_safe("Kernel : Waking up processor %p\n", this);
-        post( this->idleLock );
-}
-
-static inline void wake(processor * this) {
-        disable_interrupts();
-        wake_fast(this);
-        enable_interrupts( __cfaabi_dbg_ctx );
-}
+void * __create_pthread( pthread_t *, void * (*)(void *), void * );
+
+
 
 struct event_kernel_t {
@@ -85 +59 @@
 extern volatile thread_local __cfa_kernel_preemption_state_t preemption_state __attribute__ ((tls_model ( "initial-exec" )));
 
+extern cluster * mainCluster;
+
 //-----------------------------------------------------------------------------
 // Threads
 extern "C" {
-      void CtxInvokeThread(void (*main)(void *), void * this);
-}
-
-extern void ThreadCtxSwitch(coroutine_desc * src, coroutine_desc * dst);
+      void __cfactx_invoke_thread(void (*main)(void *), void * this);
+}
 
 __cfaabi_dbg_debug_do(
-        extern void __cfaabi_dbg_thread_register  ( thread_desc * thrd );
-        extern void __cfaabi_dbg_thread_unregister( thread_desc * thrd );
+        extern void __cfaabi_dbg_thread_register  ( $thread * thrd );
+        extern void __cfaabi_dbg_thread_unregister( $thread * thrd );
 )
+
+// KERNEL ONLY unpark with out disabling interrupts
+void __unpark( $thread * thrd __cfaabi_dbg_ctx_param2 );
+
+//-----------------------------------------------------------------------------
+// I/O
+void __kernel_io_startup     ( cluster &, int, bool );
+void __kernel_io_finish_start( cluster & );
+void __kernel_io_prepare_stop( cluster & );
+void __kernel_io_shutdown    ( cluster &, bool );
 
 //-----------------------------------------------------------------------------
@@ -102 +86 @@
 #define KERNEL_STORAGE(T,X) __attribute((aligned(__alignof__(T)))) static char storage_##X[sizeof(T)]
 
-static inline uint32_t tls_rand() {
+static inline uint32_t __tls_rand() {
         kernelTLS.rand_seed ^= kernelTLS.rand_seed << 6;
         kernelTLS.rand_seed ^= kernelTLS.rand_seed >> 21;
@@ -113 +97 @@
 void unregister( struct cluster & cltr );
 
-void doregister( struct cluster * cltr, struct thread_desc & thrd );
-void unregister( struct cluster * cltr, struct thread_desc & thrd );
+void doregister( struct cluster * cltr, struct $thread & thrd );
+void unregister( struct cluster * cltr, struct $thread & thrd );
 
 //=======================================================================

libcfa/src/concurrency/monitor.cfa

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// monitor_desc.c --
+// $monitor.c --
 //
 // Author           : Thierry Delisle
@@ -27 +27 @@
 //-----------------------------------------------------------------------------
 // Forward declarations
-static inline void set_owner ( monitor_desc * this, thread_desc * owner );
-static inline void set_owner ( monitor_desc * storage [], __lock_size_t count, thread_desc * owner );
-static inline void set_mask  ( monitor_desc * storage [], __lock_size_t count, const __waitfor_mask_t & mask );
-static inline void reset_mask( monitor_desc * this );
-
-static inline thread_desc * next_thread( monitor_desc * this );
-static inline bool is_accepted( monitor_desc * this, const __monitor_group_t & monitors );
+static inline void __set_owner ( $monitor * this, $thread * owner );
+static inline void __set_owner ( $monitor * storage [], __lock_size_t count, $thread * owner );
+static inline void set_mask  ( $monitor * storage [], __lock_size_t count, const __waitfor_mask_t & mask );
+static inline void reset_mask( $monitor * this );
+
+static inline $thread * next_thread( $monitor * this );
+static inline bool is_accepted( $monitor * this, const __monitor_group_t & monitors );
 
 static inline void lock_all  ( __spinlock_t * locks [], __lock_size_t count );
-static inline void lock_all  ( monitor_desc * source [], __spinlock_t * /*out*/ locks [], __lock_size_t count );
+static inline void lock_all  ( $monitor * source [], __spinlock_t * /*out*/ locks [], __lock_size_t count );
 static inline void unlock_all( __spinlock_t * locks [], __lock_size_t count );
-static inline void unlock_all( monitor_desc * locks [], __lock_size_t count );
-
-static inline void save   ( monitor_desc * ctx [], __lock_size_t count, __spinlock_t * locks [], unsigned int /*out*/ recursions [], __waitfor_mask_t /*out*/ masks [] );
-static inline void restore( monitor_desc * ctx [], __lock_size_t count, __spinlock_t * locks [], unsigned int /*in */ recursions [], __waitfor_mask_t /*in */ masks [] );
-
-static inline void init     ( __lock_size_t count, monitor_desc * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] );
-static inline void init_push( __lock_size_t count, monitor_desc * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] );
-
-static inline thread_desc *        check_condition   ( __condition_criterion_t * );
+static inline void unlock_all( $monitor * locks [], __lock_size_t count );
+
+static inline void save   ( $monitor * ctx [], __lock_size_t count, __spinlock_t * locks [], unsigned int /*out*/ recursions [], __waitfor_mask_t /*out*/ masks [] );
+static inline void restore( $monitor * ctx [], __lock_size_t count, __spinlock_t * locks [], unsigned int /*in */ recursions [], __waitfor_mask_t /*in */ masks [] );
+
+static inline void init     ( __lock_size_t count, $monitor * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] );
+static inline void init_push( __lock_size_t count, $monitor * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] );
+
+static inline $thread *        check_condition   ( __condition_criterion_t * );
 static inline void                 brand_condition   ( condition & );
-static inline [thread_desc *, int] search_entry_queue( const __waitfor_mask_t &, monitor_desc * monitors [], __lock_size_t count );
+static inline [$thread *, int] search_entry_queue( const __waitfor_mask_t &, $monitor * monitors [], __lock_size_t count );
 
 forall(dtype T | sized( T ))
 static inline __lock_size_t insert_unique( T * array [], __lock_size_t & size, T * val );
 static inline __lock_size_t count_max    ( const __waitfor_mask_t & mask );
-static inline __lock_size_t aggregate    ( monitor_desc * storage [], const __waitfor_mask_t & mask );
+static inline __lock_size_t aggregate    ( $monitor * storage [], const __waitfor_mask_t & mask );
 
 //-----------------------------------------------------------------------------
@@ -68 +68 @@
 
 #define monitor_ctx( mons, cnt )                                /* Define that create the necessary struct for internal/external scheduling operations */ \
-        monitor_desc ** monitors = mons;                          /* Save the targeted monitors                                                          */ \
+        $monitor ** monitors = mons;                          /* Save the targeted monitors                                                          */ \
         __lock_size_t count = cnt;                                /* Save the count to a local variable                                                  */ \
         unsigned int recursions[ count ];                         /* Save the current recursion levels to restore them later                             */ \
@@ -80 +80 @@
 //-----------------------------------------------------------------------------
 // Enter/Leave routines
-
-
-extern "C" {
-        // Enter single monitor
-        static void __enter_monitor_desc( monitor_desc * this, const __monitor_group_t & group ) {
-                // Lock the monitor spinlock
-                lock( this->lock __cfaabi_dbg_ctx2 );
-                // Interrupts disable inside critical section
-                thread_desc * thrd = kernelTLS.this_thread;
-
-                __cfaabi_dbg_print_safe( "Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner);
-
-                if( !this->owner ) {
-                        // No one has the monitor, just take it
-                        set_owner( this, thrd );
-
-                        __cfaabi_dbg_print_safe( "Kernel :  mon is free \n" );
-                }
-                else if( this->owner == thrd) {
-                        // We already have the monitor, just note how many times we took it
-                        this->recursion += 1;
-
-                        __cfaabi_dbg_print_safe( "Kernel :  mon already owned \n" );
-                }
-                else if( is_accepted( this, group) ) {
-                        // Some one was waiting for us, enter
-                        set_owner( this, thrd );
-
-                        // Reset mask
-                        reset_mask( this );
-
-                        __cfaabi_dbg_print_safe( "Kernel :  mon accepts \n" );
-                }
-                else {
-                        __cfaabi_dbg_print_safe( "Kernel :  blocking \n" );
-
-                        // Some one else has the monitor, wait in line for it
-                        append( this->entry_queue, thrd );
-
-                        BlockInternal( &this->lock );
-
-                        __cfaabi_dbg_print_safe( "Kernel : %10p Entered  mon %p\n", thrd, this);
-
-                        // BlockInternal will unlock spinlock, no need to unlock ourselves
-                        return;
-                }
+// Enter single monitor
+static void __enter( $monitor * this, const __monitor_group_t & group ) {
+        // Lock the monitor spinlock
+        lock( this->lock __cfaabi_dbg_ctx2 );
+        // Interrupts disable inside critical section
+        $thread * thrd = kernelTLS.this_thread;
+
+        __cfaabi_dbg_print_safe( "Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner);
+
+        if( !this->owner ) {
+                // No one has the monitor, just take it
+                __set_owner( this, thrd );
+
+                __cfaabi_dbg_print_safe( "Kernel :  mon is free \n" );
+        }
+        else if( this->owner == thrd) {
+                // We already have the monitor, just note how many times we took it
+                this->recursion += 1;
+
+                __cfaabi_dbg_print_safe( "Kernel :  mon already owned \n" );
+        }
+        else if( is_accepted( this, group) ) {
+                // Some one was waiting for us, enter
+                __set_owner( this, thrd );
+
+                // Reset mask
+                reset_mask( this );
+
+                __cfaabi_dbg_print_safe( "Kernel :  mon accepts \n" );
+        }
+        else {
+                __cfaabi_dbg_print_safe( "Kernel :  blocking \n" );
+
+                // Some one else has the monitor, wait in line for it
+                /* paranoid */ verify( thrd->next == 0p );
+                append( this->entry_queue, thrd );
+                /* paranoid */ verify( thrd->next == 1p );
+
+                unlock( this->lock );
+                park( __cfaabi_dbg_ctx );
 
                 __cfaabi_dbg_print_safe( "Kernel : %10p Entered  mon %p\n", thrd, this);
 
-                // Release the lock and leave
+                /* paranoid */ verifyf( kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
+                return;
+        }
+
+        __cfaabi_dbg_print_safe( "Kernel : %10p Entered  mon %p\n", thrd, this);
+
+        /* paranoid */ verifyf( kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
+        /* paranoid */ verify( this->lock.lock );
+
+        // Release the lock and leave
+        unlock( this->lock );
+        return;
+}
+
+static void __dtor_enter( $monitor * this, fptr_t func ) {
+        // Lock the monitor spinlock
+        lock( this->lock __cfaabi_dbg_ctx2 );
+        // Interrupts disable inside critical section
+        $thread * thrd = kernelTLS.this_thread;
+
+        __cfaabi_dbg_print_safe( "Kernel : %10p Entering dtor for mon %p (%p)\n", thrd, this, this->owner);
+
+
+        if( !this->owner ) {
+                __cfaabi_dbg_print_safe( "Kernel : Destroying free mon %p\n", this);
+
+                // No one has the monitor, just take it
+                __set_owner( this, thrd );
+
+                verifyf( kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
+
                 unlock( this->lock );
                 return;
         }
-
-        static void __enter_monitor_dtor( monitor_desc * this, fptr_t func ) {
-                // Lock the monitor spinlock
-                lock( this->lock __cfaabi_dbg_ctx2 );
-                // Interrupts disable inside critical section
-                thread_desc * thrd = kernelTLS.this_thread;
-
-                __cfaabi_dbg_print_safe( "Kernel : %10p Entering dtor for mon %p (%p)\n", thrd, this, this->owner);
-
-
-                if( !this->owner ) {
-                        __cfaabi_dbg_print_safe( "Kernel : Destroying free mon %p\n", this);
-
-                        // No one has the monitor, just take it
-                        set_owner( this, thrd );
-
-                        unlock( this->lock );
-                        return;
+        else if( this->owner == thrd) {
+                // We already have the monitor... but where about to destroy it so the nesting will fail
+                // Abort!
+                abort( "Attempt to destroy monitor %p by thread \"%.256s\" (%p) in nested mutex.", this, thrd->self_cor.name, thrd );
+        }
+
+        __lock_size_t count = 1;
+        $monitor ** monitors = &this;
+        __monitor_group_t group = { &this, 1, func };
+        if( is_accepted( this, group) ) {
+                __cfaabi_dbg_print_safe( "Kernel :  mon accepts dtor, block and signal it \n" );
+
+                // Wake the thread that is waiting for this
+                __condition_criterion_t * urgent = pop( this->signal_stack );
+                /* paranoid */ verify( urgent );
+
+                // Reset mask
+                reset_mask( this );
+
+                // Create the node specific to this wait operation
+                wait_ctx_primed( thrd, 0 )
+
+                // Some one else has the monitor, wait for him to finish and then run
+                unlock( this->lock );
+
+                // Release the next thread
+                /* paranoid */ verifyf( urgent->owner->waiting_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
+                unpark( urgent->owner->waiting_thread __cfaabi_dbg_ctx2 );
+
+                // Park current thread waiting
+                park( __cfaabi_dbg_ctx );
+
+                // Some one was waiting for us, enter
+                /* paranoid */ verifyf( kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
+        }
+        else {
+                __cfaabi_dbg_print_safe( "Kernel :  blocking \n" );
+
+                wait_ctx( thrd, 0 )
+                this->dtor_node = &waiter;
+
+                // Some one else has the monitor, wait in line for it
+                /* paranoid */ verify( thrd->next == 0p );
+                append( this->entry_queue, thrd );
+                /* paranoid */ verify( thrd->next == 1p );
+                unlock( this->lock );
+
+                // Park current thread waiting
+                park( __cfaabi_dbg_ctx );
+
+                /* paranoid */ verifyf( kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
+                return;
+        }
+
+        __cfaabi_dbg_print_safe( "Kernel : Destroying %p\n", this);
+
+}
+
+// Leave single monitor
+void __leave( $monitor * this ) {
+        // Lock the monitor spinlock
+        lock( this->lock __cfaabi_dbg_ctx2 );
+
+        __cfaabi_dbg_print_safe( "Kernel : %10p Leaving mon %p (%p)\n", kernelTLS.this_thread, this, this->owner);
+
+        /* paranoid */ verifyf( kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
+
+        // Leaving a recursion level, decrement the counter
+        this->recursion -= 1;
+
+        // If we haven't left the last level of recursion
+        // it means we don't need to do anything
+        if( this->recursion != 0) {
+                __cfaabi_dbg_print_safe( "Kernel :  recursion still %d\n", this->recursion);
+                unlock( this->lock );
+                return;
+        }
+
+        // Get the next thread, will be null on low contention monitor
+        $thread * new_owner = next_thread( this );
+
+        // Check the new owner is consistent with who we wake-up
+        // new_owner might be null even if someone owns the monitor when the owner is still waiting for another monitor
+        /* paranoid */ verifyf( !new_owner || new_owner == this->owner, "Expected owner to be %p, got %p (m: %p)", new_owner, this->owner, this );
+
+        // We can now let other threads in safely
+        unlock( this->lock );
+
+        //We need to wake-up the thread
+        /* paranoid */ verifyf( !new_owner || new_owner == this->owner, "Expected owner to be %p, got %p (m: %p)", new_owner, this->owner, this );
+        unpark( new_owner __cfaabi_dbg_ctx2 );
+}
+
+// Leave single monitor for the last time
+void __dtor_leave( $monitor * this ) {
+        __cfaabi_dbg_debug_do(
+                if( TL_GET( this_thread ) != this->owner ) {
+                        abort( "Destroyed monitor %p has inconsistent owner, expected %p got %p.\n", this, TL_GET( this_thread ), this->owner);
                 }
-                else if( this->owner == thrd) {
-                        // We already have the monitor... but where about to destroy it so the nesting will fail
-                        // Abort!
-                        abort( "Attempt to destroy monitor %p by thread \"%.256s\" (%p) in nested mutex.", this, thrd->self_cor.name, thrd );
+                if( this->recursion != 1 ) {
+                        abort( "Destroyed monitor %p has %d outstanding nested calls.\n", this, this->recursion - 1);
                 }
-
-                __lock_size_t count = 1;
-                monitor_desc ** monitors = &this;
-                __monitor_group_t group = { &this, 1, func };
-                if( is_accepted( this, group) ) {
-                        __cfaabi_dbg_print_safe( "Kernel :  mon accepts dtor, block and signal it \n" );
-
-                        // Wake the thread that is waiting for this
-                        __condition_criterion_t * urgent = pop( this->signal_stack );
-                        verify( urgent );
-
-                        // Reset mask
-                        reset_mask( this );
-
-                        // Create the node specific to this wait operation
-                        wait_ctx_primed( thrd, 0 )
-
-                        // Some one else has the monitor, wait for him to finish and then run
-                        BlockInternal( &this->lock, urgent->owner->waiting_thread );
-
-                        // Some one was waiting for us, enter
-                        set_owner( this, thrd );
-                }
-                else {
-                        __cfaabi_dbg_print_safe( "Kernel :  blocking \n" );
-
-                        wait_ctx( thrd, 0 )
-                        this->dtor_node = &waiter;
-
-                        // Some one else has the monitor, wait in line for it
-                        append( this->entry_queue, thrd );
-                        BlockInternal( &this->lock );
-
-                        // BlockInternal will unlock spinlock, no need to unlock ourselves
-                        return;
-                }
-
-                __cfaabi_dbg_print_safe( "Kernel : Destroying %p\n", this);
-
-        }
-
-        // Leave single monitor
-        void __leave_monitor_desc( monitor_desc * this ) {
-                // Lock the monitor spinlock
-                lock( this->lock __cfaabi_dbg_ctx2 );
-
-                __cfaabi_dbg_print_safe( "Kernel : %10p Leaving mon %p (%p)\n", kernelTLS.this_thread, this, this->owner);
-
-                verifyf( kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
-
-                // Leaving a recursion level, decrement the counter
-                this->recursion -= 1;
-
-                // If we haven't left the last level of recursion
-                // it means we don't need to do anything
-                if( this->recursion != 0) {
-                        __cfaabi_dbg_print_safe( "Kernel :  recursion still %d\n", this->recursion);
-                        unlock( this->lock );
-                        return;
-                }
-
-                // Get the next thread, will be null on low contention monitor
-                thread_desc * new_owner = next_thread( this );
-
-                // We can now let other threads in safely
-                unlock( this->lock );
-
-                //We need to wake-up the thread
-                WakeThread( new_owner );
-        }
-
-        // Leave single monitor for the last time
-        void __leave_dtor_monitor_desc( monitor_desc * this ) {
-                __cfaabi_dbg_debug_do(
-                        if( TL_GET( this_thread ) != this->owner ) {
-                                abort( "Destroyed monitor %p has inconsistent owner, expected %p got %p.\n", this, TL_GET( this_thread ), this->owner);
-                        }
-                        if( this->recursion != 1 ) {
-                                abort( "Destroyed monitor %p has %d outstanding nested calls.\n", this, this->recursion - 1);
-                        }
-                )
-        }
-
+        )
+}
+
+extern "C" {
         // Leave the thread monitor
         // last routine called by a thread.
         // Should never return
-        void __leave_thread_monitor() {
-                thread_desc * thrd = TL_GET( this_thread );
-                monitor_desc * this = &thrd->self_mon;
+        void __cfactx_thrd_leave() {
+                $thread * thrd = TL_GET( this_thread );
+                $monitor * this = &thrd->self_mon;
 
                 // Lock the monitor now
@@ -252 +275 @@
                 disable_interrupts();
 
-                thrd->self_cor.state = Halted;
-
-                verifyf( thrd == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", thrd, this->owner, this->recursion, this );
+                thrd->state = Halted;
+
+                /* paranoid */ verifyf( thrd == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", thrd, this->owner, this->recursion, this );
 
                 // Leaving a recursion level, decrement the counter
@@ -264 +287 @@
 
                 // Fetch the next thread, can be null
-                thread_desc * new_owner = next_thread( this );
-
-                // Leave the thread, this will unlock the spinlock
-                // Use leave thread instead of BlockInternal which is
-                // specialized for this case and supports null new_owner
-                LeaveThread( &this->lock, new_owner );
+                $thread * new_owner = next_thread( this );
+
+                // Release the monitor lock
+                unlock( this->lock );
+
+                // Unpark the next owner if needed
+                /* paranoid */ verifyf( !new_owner || new_owner == this->owner, "Expected owner to be %p, got %p (m: %p)", new_owner, this->owner, this );
+                /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+                /* paranoid */ verify( ! kernelTLS.this_processor->destroyer );
+                /* paranoid */ verify( thrd->state == Halted );
+
+                kernelTLS.this_processor->destroyer = new_owner;
+
+                // Leave the thread
+                __leave_thread();
 
                 // Control flow should never reach here!
@@ -279 +311 @@
 static inline void enter( __monitor_group_t monitors ) {
         for( __lock_size_t i = 0; i < monitors.size; i++) {
-                __enter_monitor_desc( monitors[i], monitors );
+                __enter( monitors[i], monitors );
         }
 }
@@ -285 +317 @@
 // Leave multiple monitor
 // relies on the monitor array being sorted
-static inline void leave(monitor_desc * monitors [], __lock_size_t count) {
+static inline void leave($monitor * monitors [], __lock_size_t count) {
         for( __lock_size_t i = count - 1; i >= 0; i--) {
-                __leave_monitor_desc( monitors[i] );
+                __leave( monitors[i] );
         }
 }
@@ -293 +325 @@
 // Ctor for monitor guard
 // Sorts monitors before entering
-void ?{}( monitor_guard_t & this, monitor_desc * m [], __lock_size_t count, fptr_t func ) {
-        thread_desc * thrd = TL_GET( this_thread );
+void ?{}( monitor_guard_t & this, $monitor * m [], __lock_size_t count, fptr_t func ) {
+        $thread * thrd = TL_GET( this_thread );
 
         // Store current array
@@ -334 +366 @@
 // Ctor for monitor guard
 // Sorts monitors before entering
-void ?{}( monitor_dtor_guard_t & this, monitor_desc * m [], fptr_t func ) {
+void ?{}( monitor_dtor_guard_t & this, $monitor * m [], fptr_t func ) {
         // optimization
-        thread_desc * thrd = TL_GET( this_thread );
+        $thread * thrd = TL_GET( this_thread );
 
         // Store current array
@@ -347 +379 @@
         (thrd->monitors){m, 1, func};
 
-        __enter_monitor_dtor( this.m, func );
+        __dtor_enter( this.m, func );
 }
 
@@ -353 +385 @@
 void ^?{}( monitor_dtor_guard_t & this ) {
         // Leave the monitors in order
-        __leave_dtor_monitor_desc( this.m );
+        __dtor_leave( this.m );
 
         // Restore thread context
@@ -361 +393 @@
 //-----------------------------------------------------------------------------
 // Internal scheduling types
-void ?{}(__condition_node_t & this, thread_desc * waiting_thread, __lock_size_t count, uintptr_t user_info ) {
+void ?{}(__condition_node_t & this, $thread * waiting_thread, __lock_size_t count, uintptr_t user_info ) {
         this.waiting_thread = waiting_thread;
         this.count = count;
@@ -375 +407 @@
 }
 
-void ?{}(__condition_criterion_t & this, monitor_desc * target, __condition_node_t & owner ) {
+void ?{}(__condition_criterion_t & this, $monitor * target, __condition_node_t & owner ) {
         this.ready  = false;
         this.target = target;
@@ -400 +432 @@
         // Append the current wait operation to the ones already queued on the condition
         // We don't need locks for that since conditions must always be waited on inside monitor mutual exclusion
+        /* paranoid */ verify( waiter.next == 0p );
         append( this.blocked, &waiter );
+        /* paranoid */ verify( waiter.next == 1p );
 
         // Lock all monitors (aggregates the locks as well)
@@ -407 +441 @@
         // Find the next thread(s) to run
         __lock_size_t thread_count = 0;
-        thread_desc * threads[ count ];
+        $thread * threads[ count ];
         __builtin_memset( threads, 0, sizeof( threads ) );
 
@@ -415 +449 @@
         // Remove any duplicate threads
         for( __lock_size_t i = 0; i < count; i++) {
-                thread_desc * new_owner = next_thread( monitors[i] );
+                $thread * new_owner = next_thread( monitors[i] );
                 insert_unique( threads, thread_count, new_owner );
         }
 
+        // Unlock the locks, we don't need them anymore
+        for(int i = 0; i < count; i++) {
+                unlock( *locks[i] );
+        }
+
+        // Wake the threads
+        for(int i = 0; i < thread_count; i++) {
+                unpark( threads[i] __cfaabi_dbg_ctx2 );
+        }
+
         // Everything is ready to go to sleep
-        BlockInternal( locks, count, threads, thread_count );
+        park( __cfaabi_dbg_ctx );
 
         // We are back, restore the owners and recursions
@@ -435 +479 @@
         //Some more checking in debug
         __cfaabi_dbg_debug_do(
-                thread_desc * this_thrd = TL_GET( this_thread );
+                $thread * this_thrd = TL_GET( this_thread );
                 if ( this.monitor_count != this_thrd->monitors.size ) {
                         abort( "Signal on condition %p made with different number of monitor(s), expected %zi got %zi", &this, this.monitor_count, this_thrd->monitors.size );
@@ -489 +533 @@
 
         //Find the thread to run
-        thread_desc * signallee = pop_head( this.blocked )->waiting_thread;
-        set_owner( monitors, count, signallee );
+        $thread * signallee = pop_head( this.blocked )->waiting_thread;
+        __set_owner( monitors, count, signallee );
 
         __cfaabi_dbg_print_buffer_decl( "Kernel : signal_block condition %p (s: %p)\n", &this, signallee );
 
+        // unlock all the monitors
+        unlock_all( locks, count );
+
+        // unpark the thread we signalled
+        unpark( signallee __cfaabi_dbg_ctx2 );
+
         //Everything is ready to go to sleep
-        BlockInternal( locks, count, &signallee, 1 );
+        park( __cfaabi_dbg_ctx );
 
 
@@ -536 +586 @@
         // Create one!
         __lock_size_t max = count_max( mask );
-        monitor_desc * mon_storage[max];
+        $monitor * mon_storage[max];
         __builtin_memset( mon_storage, 0, sizeof( mon_storage ) );
         __lock_size_t actual_count = aggregate( mon_storage, mask );
@@ -554 +604 @@
         {
                 // Check if the entry queue
-                thread_desc * next; int index;
+                $thread * next; int index;
                 [next, index] = search_entry_queue( mask, monitors, count );
 
@@ -564 +614 @@
                                 verifyf( accepted.size == 1,  "ERROR: Accepted dtor has more than 1 mutex parameter." );
 
-                                monitor_desc * mon2dtor = accepted[0];
+                                $monitor * mon2dtor = accepted[0];
                                 verifyf( mon2dtor->dtor_node, "ERROR: Accepted monitor has no dtor_node." );
 
@@ -590 +640 @@
 
                                 // Set the owners to be the next thread
-                                set_owner( monitors, count, next );
-
-                                // Everything is ready to go to sleep
-                                BlockInternal( locks, count, &next, 1 );
+                                __set_owner( monitors, count, next );
+
+                                // unlock all the monitors
+                                unlock_all( locks, count );
+
+                                // unpark the thread we signalled
+                                unpark( next __cfaabi_dbg_ctx2 );
+
+                                //Everything is ready to go to sleep
+                                park( __cfaabi_dbg_ctx );
 
                                 // We are back, restore the owners and recursions
@@ -631 +687 @@
         }
 
+        // unlock all the monitors
+        unlock_all( locks, count );
+
         //Everything is ready to go to sleep
-        BlockInternal( locks, count );
+        park( __cfaabi_dbg_ctx );
 
 
@@ -649 +708 @@
 // Utilities
 
-static inline void set_owner( monitor_desc * this, thread_desc * owner ) {
-        // __cfaabi_dbg_print_safe( "Kernal :   Setting owner of %p to %p ( was %p)\n", this, owner, this->owner );
+static inline void __set_owner( $monitor * this, $thread * owner ) {
+        /* paranoid */ verify( this->lock.lock );
 
         //Pass the monitor appropriately
@@ -659 +718 @@
 }
 
-static inline void set_owner( monitor_desc * monitors [], __lock_size_t count, thread_desc * owner ) {
-        monitors[0]->owner     = owner;
-        monitors[0]->recursion = 1;
+static inline void __set_owner( $monitor * monitors [], __lock_size_t count, $thread * owner ) {
+        /* paranoid */ verify ( monitors[0]->lock.lock );
+        /* paranoid */ verifyf( monitors[0]->owner == kernelTLS.this_thread, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, monitors[0]->owner, monitors[0]->recursion, monitors[0] );
+        monitors[0]->owner        = owner;
+        monitors[0]->recursion    = 1;
         for( __lock_size_t i = 1; i < count; i++ ) {
-                monitors[i]->owner     = owner;
-                monitors[i]->recursion = 0;
-        }
-}
-
-static inline void set_mask( monitor_desc * storage [], __lock_size_t count, const __waitfor_mask_t & mask ) {
+                /* paranoid */ verify ( monitors[i]->lock.lock );
+                /* paranoid */ verifyf( monitors[i]->owner == kernelTLS.this_thread, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, monitors[i]->owner, monitors[i]->recursion, monitors[i] );
+                monitors[i]->owner        = owner;
+                monitors[i]->recursion    = 0;
+        }
+}
+
+static inline void set_mask( $monitor * storage [], __lock_size_t count, const __waitfor_mask_t & mask ) {
         for( __lock_size_t i = 0; i < count; i++) {
                 storage[i]->mask = mask;
@@ -674 +737 @@
 }
 
-static inline void reset_mask( monitor_desc * this ) {
+static inline void reset_mask( $monitor * this ) {
         this->mask.accepted = 0p;
         this->mask.data = 0p;
@@ -680 +743 @@
 }
 
-static inline thread_desc * next_thread( monitor_desc * this ) {
+static inline $thread * next_thread( $monitor * this ) {
         //Check the signaller stack
         __cfaabi_dbg_print_safe( "Kernel :  mon %p AS-stack top %p\n", this, this->signal_stack.top);
@@ -688 +751 @@
                 //regardless of if we are ready to baton pass,
                 //we need to set the monitor as in use
-                set_owner( this,  urgent->owner->waiting_thread );
+                /* paranoid */ verifyf( !this->owner || kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
+                __set_owner( this,  urgent->owner->waiting_thread );
 
                 return check_condition( urgent );
@@ -695 +759 @@
         // No signaller thread
         // Get the next thread in the entry_queue
-        thread_desc * new_owner = pop_head( this->entry_queue );
-        set_owner( this, new_owner );
+        $thread * new_owner = pop_head( this->entry_queue );
+        /* paranoid */ verifyf( !this->owner || kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
+        /* paranoid */ verify( !new_owner || new_owner->next == 0p );
+        __set_owner( this, new_owner );
 
         return new_owner;
 }
 
-static inline bool is_accepted( monitor_desc * this, const __monitor_group_t & group ) {
+static inline bool is_accepted( $monitor * this, const __monitor_group_t & group ) {
         __acceptable_t * it = this->mask.data; // Optim
         __lock_size_t count = this->mask.size;
@@ -723 +789 @@
 }
 
-static inline void init( __lock_size_t count, monitor_desc * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] ) {
+static inline void init( __lock_size_t count, $monitor * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] ) {
         for( __lock_size_t i = 0; i < count; i++) {
                 (criteria[i]){ monitors[i], waiter };
@@ -731 +797 @@
 }
 
-static inline void init_push( __lock_size_t count, monitor_desc * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] ) {
+static inline void init_push( __lock_size_t count, $monitor * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] ) {
         for( __lock_size_t i = 0; i < count; i++) {
                 (criteria[i]){ monitors[i], waiter };
@@ -747 +813 @@
 }
 
-static inline void lock_all( monitor_desc * source [], __spinlock_t * /*out*/ locks [], __lock_size_t count ) {
+static inline void lock_all( $monitor * source [], __spinlock_t * /*out*/ locks [], __lock_size_t count ) {
         for( __lock_size_t i = 0; i < count; i++ ) {
                 __spinlock_t * l = &source[i]->lock;
@@ -761 +827 @@
 }
 
-static inline void unlock_all( monitor_desc * locks [], __lock_size_t count ) {
+static inline void unlock_all( $monitor * locks [], __lock_size_t count ) {
         for( __lock_size_t i = 0; i < count; i++ ) {
                 unlock( locks[i]->lock );
@@ -768 +834 @@
 
 static inline void save(
-        monitor_desc * ctx [],
+        $monitor * ctx [],
         __lock_size_t count,
         __attribute((unused)) __spinlock_t * locks [],
@@ -781 +847 @@
 
 static inline void restore(
-        monitor_desc * ctx [],
+        $monitor * ctx [],
         __lock_size_t count,
         __spinlock_t * locks [],
@@ -799 +865 @@
 // 2 - Checks if all the monitors are ready to run
 //     if so return the thread to run
-static inline thread_desc * check_condition( __condition_criterion_t * target ) {
+static inline $thread * check_condition( __condition_criterion_t * target ) {
         __condition_node_t * node = target->owner;
         unsigned short count = node->count;
@@ -822 +888 @@
 
 static inline void brand_condition( condition & this ) {
-        thread_desc * thrd = TL_GET( this_thread );
+        $thread * thrd = TL_GET( this_thread );
         if( !this.monitors ) {
                 // __cfaabi_dbg_print_safe( "Branding\n" );
@@ -828 +894 @@
                 this.monitor_count = thrd->monitors.size;
 
-                this.monitors = (monitor_desc **)malloc( this.monitor_count * sizeof( *this.monitors ) );
+                this.monitors = ($monitor **)malloc( this.monitor_count * sizeof( *this.monitors ) );
                 for( int i = 0; i < this.monitor_count; i++ ) {
                         this.monitors[i] = thrd->monitors[i];
@@ -835 +901 @@
 }
 
-static inline [thread_desc *, int] search_entry_queue( const __waitfor_mask_t & mask, monitor_desc * monitors [], __lock_size_t count ) {
-
-        __queue_t(thread_desc) & entry_queue = monitors[0]->entry_queue;
+static inline [$thread *, int] search_entry_queue( const __waitfor_mask_t & mask, $monitor * monitors [], __lock_size_t count ) {
+
+        __queue_t($thread) & entry_queue = monitors[0]->entry_queue;
 
         // For each thread in the entry-queue
-        for(    thread_desc ** thrd_it = &entry_queue.head;
+        for(    $thread ** thrd_it = &entry_queue.head;
                 *thrd_it;
                 thrd_it = &(*thrd_it)->link.next
@@ -884 +950 @@
 }
 
-static inline __lock_size_t aggregate( monitor_desc * storage [], const __waitfor_mask_t & mask ) {
+static inline __lock_size_t aggregate( $monitor * storage [], const __waitfor_mask_t & mask ) {
         __lock_size_t size = 0;
         for( __lock_size_t i = 0; i < mask.size; i++ ) {

libcfa/src/concurrency/monitor.hfa

@@ -23 +23 @@
 
 trait is_monitor(dtype T) {
-        monitor_desc * get_monitor( T & );
+        $monitor * get_monitor( T & );
         void ^?{}( T & mutex );
 };
 
-static inline void ?{}(monitor_desc & this) with( this ) {
+static inline void ?{}($monitor & this) with( this ) {
         lock{};
         entry_queue{};
@@ -39 +39 @@
 }
 
-static inline void ^?{}(monitor_desc & ) {}
+static inline void ^?{}($monitor & ) {}
 
 struct monitor_guard_t {
-        monitor_desc **         m;
+        $monitor **     m;
         __lock_size_t           count;
         __monitor_group_t prev;
 };
 
-void ?{}( monitor_guard_t & this, monitor_desc ** m, __lock_size_t count, void (*func)() );
+void ?{}( monitor_guard_t & this, $monitor ** m, __lock_size_t count, void (*func)() );
 void ^?{}( monitor_guard_t & this );
 
 struct monitor_dtor_guard_t {
-        monitor_desc *    m;
+        $monitor *    m;
         __monitor_group_t prev;
 };
 
-void ?{}( monitor_dtor_guard_t & this, monitor_desc ** m, void (*func)() );
+void ?{}( monitor_dtor_guard_t & this, $monitor ** m, void (*func)() );
 void ^?{}( monitor_dtor_guard_t & this );
 
@@ -72 +72 @@
 
         // The monitor this criterion concerns
-        monitor_desc * target;
+        $monitor * target;
 
         // The parent node to which this criterion belongs
@@ -87 +87 @@
 struct __condition_node_t {
         // Thread that needs to be woken when all criteria are met
-        thread_desc * waiting_thread;
+        $thread * waiting_thread;
 
         // Array of criteria (Criterions are contiguous in memory)
@@ -106 +106 @@
 }
 
-void ?{}(__condition_node_t & this, thread_desc * waiting_thread, __lock_size_t count, uintptr_t user_info );
+void ?{}(__condition_node_t & this, $thread * waiting_thread, __lock_size_t count, uintptr_t user_info );
 void ?{}(__condition_criterion_t & this );
-void ?{}(__condition_criterion_t & this, monitor_desc * target, __condition_node_t * owner );
+void ?{}(__condition_criterion_t & this, $monitor * target, __condition_node_t * owner );
 
 struct condition {
@@ -115 +115 @@
 
         // Array of monitor pointers (Monitors are NOT contiguous in memory)
-        monitor_desc ** monitors;
+        $monitor ** monitors;
 
         // Number of monitors in the array
@@ -133 +133 @@
               bool signal      ( condition & this );
               bool signal_block( condition & this );
-static inline bool is_empty    ( condition & this ) { return !this.blocked.head; }
+static inline bool is_empty    ( condition & this ) { return this.blocked.head == 1p; }
          uintptr_t front       ( condition & this );
 

libcfa/src/concurrency/mutex.cfa

@@ -40 +40 @@
         if( is_locked ) {
                 append( blocked_threads, kernelTLS.this_thread );
-                BlockInternal( &lock );
+                unlock( lock );
+                park( __cfaabi_dbg_ctx );
         }
         else {
@@ -62 +63 @@
         lock( this.lock __cfaabi_dbg_ctx2 );
         this.is_locked = (this.blocked_threads != 0);
-        WakeThread(
-                pop_head( this.blocked_threads )
+        unpark(
+                pop_head( this.blocked_threads ) __cfaabi_dbg_ctx2
         );
         unlock( this.lock );
@@ -94 +95 @@
         else {
                 append( blocked_threads, kernelTLS.this_thread );
-                BlockInternal( &lock );
+                unlock( lock );
+                park( __cfaabi_dbg_ctx );
         }
 }
@@ -118 +120 @@
         recursion_count--;
         if( recursion_count == 0 ) {
-                thread_desc * thrd = pop_head( blocked_threads );
+                $thread * thrd = pop_head( blocked_threads );
                 owner = thrd;
                 recursion_count = (thrd ? 1 : 0);
-                WakeThread( thrd );
+                unpark( thrd __cfaabi_dbg_ctx2 );
         }
         unlock( lock );
@@ -138 +140 @@
 void notify_one(condition_variable & this) with(this) {
         lock( lock __cfaabi_dbg_ctx2 );
-        WakeThread(
-                pop_head( this.blocked_threads )
+        unpark(
+                pop_head( this.blocked_threads ) __cfaabi_dbg_ctx2
         );
         unlock( lock );
@@ -147 +149 @@
         lock( lock __cfaabi_dbg_ctx2 );
         while(this.blocked_threads) {
-                WakeThread(
-                        pop_head( this.blocked_threads )
+                unpark(
+                        pop_head( this.blocked_threads ) __cfaabi_dbg_ctx2
                 );
         }
@@ -157 +159 @@
         lock( this.lock __cfaabi_dbg_ctx2 );
         append( this.blocked_threads, kernelTLS.this_thread );
-        BlockInternal( &this.lock );
+        unlock( this.lock );
+        park( __cfaabi_dbg_ctx );
 }
 
@@ -164 +167 @@
         lock( this.lock __cfaabi_dbg_ctx2 );
         append( this.blocked_threads, kernelTLS.this_thread );
-        void __unlock(void) {
-                unlock(l);
-                unlock(this.lock);
-        }
-        BlockInternal( __unlock );
+        unlock(l);
+        unlock(this.lock);
+        park( __cfaabi_dbg_ctx );
         lock(l);
 }

libcfa/src/concurrency/mutex.hfa

@@ -36 +36 @@
 
         // List of blocked threads
-        __queue_t(struct thread_desc) blocked_threads;
+        __queue_t(struct $thread) blocked_threads;
 
         // Locked flag
@@ -55 +55 @@
 
         // List of blocked threads
-        __queue_t(struct thread_desc) blocked_threads;
+        __queue_t(struct $thread) blocked_threads;
 
         // Current thread owning the lock
-        struct thread_desc * owner;
+        struct $thread * owner;
 
         // Number of recursion level
@@ -83 +83 @@
 
         // List of blocked threads
-        __queue_t(struct thread_desc) blocked_threads;
+        __queue_t(struct $thread) blocked_threads;
 };
 

libcfa/src/concurrency/preemption.cfa

@@ -39 +39 @@
 // FwdDeclarations : timeout handlers
 static void preempt( processor   * this );
-static void timeout( thread_desc * this );
+static void timeout( $thread * this );
 
 // FwdDeclarations : Signal handlers
 static void sigHandler_ctxSwitch( __CFA_SIGPARMS__ );
+static void sigHandler_alarm    ( __CFA_SIGPARMS__ );
 static void sigHandler_segv     ( __CFA_SIGPARMS__ );
 static void sigHandler_ill      ( __CFA_SIGPARMS__ );
@@ -83 +84 @@
 // Get next expired node
 static inline alarm_node_t * get_expired( alarm_list_t * alarms, Time currtime ) {
-        if( !alarms->head ) return 0p;                                          // If no alarms return null
-        if( alarms->head->alarm >= currtime ) return 0p;        // If alarms head not expired return null
+        if( ! & (*alarms)`first ) return 0p;                                            // If no alarms return null
+        if( (*alarms)`first.alarm >= currtime ) return 0p;      // If alarms head not expired return null
         return pop(alarms);                                                                     // Otherwise just pop head
 }
@@ -97 +98 @@
         while( node = get_expired( alarms, currtime ) ) {
                 // __cfaabi_dbg_print_buffer_decl( " KERNEL: preemption tick.\n" );
+                Duration period = node->period;
+                if( period == 0) {
+                        node->set = false;                  // Node is one-shot, just mark it as not pending
+                }
 
                 // Check if this is a kernel
@@ -107 +112 @@
 
                 // Check if this is a periodic alarm
-                Duration period = node->period;
                 if( period > 0 ) {
                         // __cfaabi_dbg_print_buffer_local( " KERNEL: alarm period is %lu.\n", period.tv );
@@ -113 +117 @@
                         insert( alarms, node );             // Reinsert the node for the next time it triggers
                 }
-                else {
-                        node->set = false;                  // Node is one-shot, just mark it as not pending
-                }
         }
 
         // If there are still alarms pending, reset the timer
-        if( alarms->head ) {
-                // __cfaabi_dbg_print_buffer_decl( " KERNEL: @%ju(%ju) resetting alarm to %ju.\n", currtime.tv, __kernel_get_time().tv, (alarms->head->alarm - currtime).tv);
-                Duration delta = alarms->head->alarm - currtime;
-                Duration caped = max(delta, 50`us);
+        if( & (*alarms)`first ) {
+                __cfadbg_print_buffer_decl(preemption, " KERNEL: @%ju(%ju) resetting alarm to %ju.\n", currtime.tv, __kernel_get_time().tv, (alarms->head->alarm - currtime).tv);
+                Duration delta = (*alarms)`first.alarm - currtime;
+                Duration capped = max(delta, 50`us);
                 // itimerval tim  = { caped };
                 // __cfaabi_dbg_print_buffer_local( "    Values are %lu, %lu, %lu %lu.\n", delta.tv, caped.tv, tim.it_value.tv_sec, tim.it_value.tv_usec);
 
-                __kernel_set_timer( caped );
+                __kernel_set_timer( capped );
         }
 }
@@ -184 +185 @@
 
         // Enable interrupts by decrementing the counter
-        // If counter reaches 0, execute any pending CtxSwitch
+        // If counter reaches 0, execute any pending __cfactx_switch
         void enable_interrupts( __cfaabi_dbg_ctx_param ) {
                 processor   * proc = kernelTLS.this_processor; // Cache the processor now since interrupts can start happening after the atomic store
-                thread_desc * thrd = kernelTLS.this_thread;       // Cache the thread now since interrupts can start happening after the atomic store
 
                 with( kernelTLS.preemption_state ){
@@ -209 +209 @@
                                 if( proc->pending_preemption ) {
                                         proc->pending_preemption = false;
-                                        BlockInternal( thrd );
+                                        force_yield( __POLL_PREEMPTION );
                                 }
                         }
@@ -219 +219 @@
 
         // Disable interrupts by incrementint the counter
-        // Don't execute any pending CtxSwitch even if counter reaches 0
+        // Don't execute any pending __cfactx_switch even if counter reaches 0
         void enable_interrupts_noPoll() {
                 unsigned short prev = kernelTLS.preemption_state.disable_count;
@@ -257 +257 @@
 
         if ( pthread_sigmask( SIG_BLOCK, &mask, 0p ) == -1 ) {
-            abort( "internal error, pthread_sigmask" );
+                abort( "internal error, pthread_sigmask" );
         }
 }
@@ -268 +268 @@
 
 // reserved for future use
-static void timeout( thread_desc * this ) {
-        //TODO : implement waking threads
+static void timeout( $thread * this ) {
+        __unpark( this __cfaabi_dbg_ctx2 );
 }
 
 // KERNEL ONLY
-// Check if a CtxSwitch signal handler shoud defer
+// Check if a __cfactx_switch signal handler shoud defer
 // If true  : preemption is safe
 // If false : preemption is unsafe and marked as pending
@@ -303 +303 @@
 
         // Setup proper signal handlers
-        __cfaabi_sigaction( SIGUSR1, sigHandler_ctxSwitch, SA_SIGINFO | SA_RESTART ); // CtxSwitch handler
+        __cfaabi_sigaction( SIGUSR1, sigHandler_ctxSwitch, SA_SIGINFO | SA_RESTART ); // __cfactx_switch handler
+        __cfaabi_sigaction( SIGALRM, sigHandler_alarm    , SA_SIGINFO | SA_RESTART ); // debug handler
 
         signal_block( SIGALRM );
 
-        alarm_stack = create_pthread( &alarm_thread, alarm_loop, 0p );
+        alarm_stack = __create_pthread( &alarm_thread, alarm_loop, 0p );
 }
 
@@ -394 +395 @@
         // Preemption can occur here
 
-        BlockInternal( kernelTLS.this_thread ); // Do the actual CtxSwitch
+        force_yield( __ALARM_PREEMPTION ); // Do the actual __cfactx_switch
+}
+
+static void sigHandler_alarm( __CFA_SIGPARMS__ ) {
+        abort("SIGALRM should never reach the signal handler");
 }
 

libcfa/src/concurrency/thread.cfa

@@ -23 +23 @@
 #include "invoke.h"
 
-extern "C" {
-        #include <fenv.h>
-        #include <stddef.h>
-}
-
-//extern volatile thread_local processor * this_processor;
-
 //-----------------------------------------------------------------------------
 // Thread ctors and dtors
-void ?{}(thread_desc & this, const char * const name, cluster & cl, void * storage, size_t storageSize ) with( this ) {
+void ?{}($thread & this, const char * const name, cluster & cl, void * storage, size_t storageSize ) with( this ) {
         context{ 0p, 0p };
         self_cor{ name, storage, storageSize };
         state = Start;
+        preempted = __NO_PREEMPTION;
         curr_cor = &self_cor;
         self_mon.owner = &this;
@@ -51 +45 @@
 }
 
-void ^?{}(thread_desc& this) with( this ) {
+void ^?{}($thread& this) with( this ) {
         unregister(curr_cluster, this);
         ^self_cor{};
 }
 
+//-----------------------------------------------------------------------------
+// Starting and stopping threads
+forall( dtype T | is_thread(T) )
+void __thrd_start( T & this, void (*main_p)(T &) ) {
+        $thread * this_thrd = get_thread(this);
+
+        disable_interrupts();
+        __cfactx_start(main_p, get_coroutine(this), this, __cfactx_invoke_thread);
+
+        this_thrd->context.[SP, FP] = this_thrd->self_cor.context.[SP, FP];
+        verify( this_thrd->context.SP );
+
+        __schedule_thread(this_thrd);
+        enable_interrupts( __cfaabi_dbg_ctx );
+}
+
+//-----------------------------------------------------------------------------
+// Support for threads that don't ues the thread keyword
 forall( dtype T | sized(T) | is_thread(T) | { void ?{}(T&); } )
 void ?{}( scoped(T)& this ) with( this ) {
@@ -73 +85 @@
 }
 
-//-----------------------------------------------------------------------------
-// Starting and stopping threads
-forall( dtype T | is_thread(T) )
-void __thrd_start( T & this, void (*main_p)(T &) ) {
-        thread_desc * this_thrd = get_thread(this);
-
-        disable_interrupts();
-        CtxStart(main_p, get_coroutine(this), this, CtxInvokeThread);
-
-        this_thrd->context.[SP, FP] = this_thrd->self_cor.context.[SP, FP];
-        verify( this_thrd->context.SP );
-
-        ScheduleThread(this_thrd);
-        enable_interrupts( __cfaabi_dbg_ctx );
-}
-
-void yield( void ) {
-        // Safety note : This could cause some false positives due to preemption
-      verify( TL_GET( preemption_state.enabled ) );
-        BlockInternal( TL_GET( this_thread ) );
-        // Safety note : This could cause some false positives due to preemption
-      verify( TL_GET( preemption_state.enabled ) );
-}
-
-void yield( unsigned times ) {
-        for( unsigned i = 0; i < times; i++ ) {
-                yield();
-        }
-}
-
 // Local Variables: //
 // mode: c //

libcfa/src/concurrency/thread.hfa

@@ -28 +28 @@
       void ^?{}(T& mutex this);
       void main(T& this);
-      thread_desc* get_thread(T& this);
+      $thread* get_thread(T& this);
 };
 
-#define DECL_THREAD(X) thread_desc* get_thread(X& this) { return &this.__thrd; } void main(X& this)
+// define that satisfies the trait without using the thread keyword
+#define DECL_THREAD(X) $thread* get_thread(X& this) __attribute__((const)) { return &this.__thrd; } void main(X& this)
+
+// Inline getters for threads/coroutines/monitors
+forall( dtype T | is_thread(T) )
+static inline $coroutine* get_coroutine(T & this) __attribute__((const)) { return &get_thread(this)->self_cor; }
 
 forall( dtype T | is_thread(T) )
-static inline coroutine_desc* get_coroutine(T & this) {
-        return &get_thread(this)->self_cor;
-}
+static inline $monitor  * get_monitor  (T & this) __attribute__((const)) { return &get_thread(this)->self_mon; }
 
-forall( dtype T | is_thread(T) )
-static inline monitor_desc* get_monitor(T & this) {
-        return &get_thread(this)->self_mon;
-}
+static inline $coroutine* get_coroutine($thread * this) __attribute__((const)) { return &this->self_cor; }
+static inline $monitor  * get_monitor  ($thread * this) __attribute__((const)) { return &this->self_mon; }
 
-static inline coroutine_desc* get_coroutine(thread_desc * this) {
-        return &this->self_cor;
-}
-
-static inline monitor_desc* get_monitor(thread_desc * this) {
-        return &this->self_mon;
-}
-
+//-----------------------------------------------------------------------------
+// forward declarations needed for threads
 extern struct cluster * mainCluster;
 
@@ -58 +53 @@
 //-----------------------------------------------------------------------------
 // Ctors and dtors
-void ?{}(thread_desc & this, const char * const name, struct cluster & cl, void * storage, size_t storageSize );
-void ^?{}(thread_desc & this);
+void ?{}($thread & this, const char * const name, struct cluster & cl, void * storage, size_t storageSize );
+void ^?{}($thread & this);
 
-static inline void ?{}(thread_desc & this)                                                                  { this{ "Anonymous Thread", *mainCluster, 0p, 65000 }; }
-static inline void ?{}(thread_desc & this, size_t stackSize )                                               { this{ "Anonymous Thread", *mainCluster, 0p, stackSize }; }
-static inline void ?{}(thread_desc & this, void * storage, size_t storageSize )                             { this{ "Anonymous Thread", *mainCluster, storage, storageSize }; }
-static inline void ?{}(thread_desc & this, struct cluster & cl )                                            { this{ "Anonymous Thread", cl, 0p, 65000 }; }
-static inline void ?{}(thread_desc & this, struct cluster & cl, size_t stackSize )                          { this{ "Anonymous Thread", cl, 0p, stackSize }; }
-static inline void ?{}(thread_desc & this, struct cluster & cl, void * storage, size_t storageSize )        { this{ "Anonymous Thread", cl, storage, storageSize }; }
-static inline void ?{}(thread_desc & this, const char * const name)                                         { this{ name, *mainCluster, 0p, 65000 }; }
-static inline void ?{}(thread_desc & this, const char * const name, struct cluster & cl )                   { this{ name, cl, 0p, 65000 }; }
-static inline void ?{}(thread_desc & this, const char * const name, struct cluster & cl, size_t stackSize ) { this{ name, cl, 0p, stackSize }; }
+static inline void ?{}($thread & this)                                                                  { this{ "Anonymous Thread", *mainCluster, 0p, 65000 }; }
+static inline void ?{}($thread & this, size_t stackSize )                                               { this{ "Anonymous Thread", *mainCluster, 0p, stackSize }; }
+static inline void ?{}($thread & this, void * storage, size_t storageSize )                             { this{ "Anonymous Thread", *mainCluster, storage, storageSize }; }
+static inline void ?{}($thread & this, struct cluster & cl )                                            { this{ "Anonymous Thread", cl, 0p, 65000 }; }
+static inline void ?{}($thread & this, struct cluster & cl, size_t stackSize )                          { this{ "Anonymous Thread", cl, 0p, stackSize }; }
+static inline void ?{}($thread & this, struct cluster & cl, void * storage, size_t storageSize )        { this{ "Anonymous Thread", cl, storage, storageSize }; }
+static inline void ?{}($thread & this, const char * const name)                                         { this{ name, *mainCluster, 0p, 65000 }; }
+static inline void ?{}($thread & this, const char * const name, struct cluster & cl )                   { this{ name, cl, 0p, 65000 }; }
+static inline void ?{}($thread & this, const char * const name, struct cluster & cl, size_t stackSize ) { this{ name, cl, 0p, stackSize }; }
 
 //-----------------------------------------------------------------------------
@@ -88 +83 @@
 void ^?{}( scoped(T)& this );
 
-void yield();
-void yield( unsigned times );
+//-----------------------------------------------------------------------------
+// Thread getters
+static inline struct $thread * active_thread () { return TL_GET( this_thread ); }
 
-static inline struct thread_desc * active_thread () { return TL_GET( this_thread ); }
+//-----------------------------------------------------------------------------
+// Scheduler API
+
+//----------
+// Park thread: block until corresponding call to unpark, won't block if unpark is already called
+void park( __cfaabi_dbg_ctx_param );
+
+//----------
+// Unpark a thread, if the thread is already blocked, schedule it
+//                  if the thread is not yet block, signal that it should rerun immediately
+void unpark( $thread * this __cfaabi_dbg_ctx_param2 );
+
+forall( dtype T | is_thread(T) )
+static inline void unpark( T & this __cfaabi_dbg_ctx_param2 ) { if(!&this) return; unpark( get_thread( this ) __cfaabi_dbg_ctx_fwd2 );}
+
+//----------
+// Yield: force thread to block and be rescheduled
+bool force_yield( enum __Preemption_Reason );
+
+static inline void yield() {
+        force_yield(__MANUAL_PREEMPTION);
+}
+
+// Yield: yield N times
+static inline void yield( unsigned times ) {
+        for( times ) {
+                yield();
+        }
+}
+
+//----------
+// sleep: force thread to block and be rescheduled after Duration duration
+void sleep( Duration duration );
 
 // Local Variables: //

libcfa/src/exception.c

@@ -9 +9 @@
 // Author           : Andrew Beach
 // Created On       : Mon Jun 26 15:13:00 2017
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Feb 22 18:17:34 2018
-// Update Count     : 11
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue Apr 14 12:01:00 2020
+// Update Count     : 18
 //
 
+// Normally we would get this from the CFA prelude.
 #include <stddef.h> // for size_t
 
 #include "exception.h"
 
-// Implementation of the secret header.
+// Implementation of the secret header is hardware dependent.
+#if !( defined( __x86_64 ) || defined( __i386 ) )
+#error Exception Handling: No known architecture detected.
+#endif
 
 #include <stdlib.h>
@@ -24 +28 @@
 #include <unwind.h>
 #include <bits/debug.hfa>
+#include "stdhdr/assert.h"
 
 // FIX ME: temporary hack to keep ARM build working
 #ifndef _URC_FATAL_PHASE1_ERROR
-#define _URC_FATAL_PHASE1_ERROR 2
+#define _URC_FATAL_PHASE1_ERROR 3
 #endif // ! _URC_FATAL_PHASE1_ERROR
 #ifndef _URC_FATAL_PHASE2_ERROR
@@ -35 +40 @@
 #include "lsda.h"
 
+/* The exception class for our exceptions. Because of the vendor component
+ * its value would not be standard.
+ * Vendor: UWPL
+ * Language: CFA\0
+ */
+const _Unwind_Exception_Class __cfaehm_exception_class = 0x4c50575500414643;
 
 // Base exception vtable is abstract, you should not have base exceptions.
-struct __cfaabi_ehm__base_exception_t_vtable
-                ___cfaabi_ehm__base_exception_t_vtable_instance = {
+struct __cfaehm_base_exception_t_vtable
+                ___cfaehm_base_exception_t_vtable_instance = {
         .parent = NULL,
         .size = 0,
@@ -49 +60 @@
 // Temperary global exception context. Does not work with concurency.
 struct exception_context_t {
-    struct __cfaabi_ehm__try_resume_node * top_resume;
-    struct __cfaabi_ehm__try_resume_node * current_resume;
-
-    exception_t * current_exception;
-    int current_handler_index;
-} shared_stack = {NULL, NULL, 0, 0};
+        struct __cfaehm_try_resume_node * top_resume;
+
+        exception_t * current_exception;
+        int current_handler_index;
+} static shared_stack = {NULL, NULL, 0};
 
 // Get the current exception context.
@@ -62 +72 @@
         return &shared_stack;
 }
-//#define SAVE_EXCEPTION_CONTEXT(to_name)
-//struct exception_context_t * to_name = this_exception_context();
-//exception * this_exception() {
-//    return this_exception_context()->current_exception;
-//}
-
-
-// This macro should be the only thing that needs to change across machines.
-// Used in the personality function, way down in termination.
-// struct _Unwind_Context * -> _Unwind_Reason_Code(*)(exception_t *)
-#define MATCHER_FROM_CONTEXT(ptr_to_context) \
-        (*(_Unwind_Reason_Code(**)(exception_t *))(_Unwind_GetCFA(ptr_to_context) + 8))
 
 
 // RESUMPTION ================================================================
 
-void __cfaabi_ehm__throw_resume(exception_t * except) {
-
-        __cfaabi_dbg_print_safe("Throwing resumption exception\n");
-
-        struct __cfaabi_ehm__try_resume_node * original_head = shared_stack.current_resume;
-        struct __cfaabi_ehm__try_resume_node * current =
-                (original_head) ? original_head->next : shared_stack.top_resume;
+static void reset_top_resume(struct __cfaehm_try_resume_node ** store) {
+        this_exception_context()->top_resume = *store;
+}
+
+void __cfaehm_throw_resume(exception_t * except) {
+        struct exception_context_t * context = this_exception_context();
+
+        __cfadbg_print_safe(exception, "Throwing resumption exception\n");
+
+        __attribute__((cleanup(reset_top_resume)))
+        struct __cfaehm_try_resume_node * original_head = context->top_resume;
+        struct __cfaehm_try_resume_node * current = context->top_resume;
 
         for ( ; current ; current = current->next) {
-                shared_stack.current_resume = current;
+                context->top_resume = current->next;
                 if (current->handler(except)) {
-                        shared_stack.current_resume = original_head;
                         return;
                 }
         }
 
-        __cfaabi_dbg_print_safe("Unhandled exception\n");
-        shared_stack.current_resume = original_head;
+        __cfadbg_print_safe(exception, "Unhandled exception\n");
 
         // Fall back to termination:
-        __cfaabi_ehm__throw_terminate(except);
+        __cfaehm_throw_terminate(except);
         // TODO: Default handler for resumption.
 }
@@ -106 +107 @@
 // be added after the node is built but before it is made the top node.
 
-void __cfaabi_ehm__try_resume_setup(struct __cfaabi_ehm__try_resume_node * node,
+void __cfaehm_try_resume_setup(struct __cfaehm_try_resume_node * node,
                         _Bool (*handler)(exception_t * except)) {
-        node->next = shared_stack.top_resume;
+        struct exception_context_t * context = this_exception_context();
+        node->next = context->top_resume;
         node->handler = handler;
-        shared_stack.top_resume = node;
-}
-
-void __cfaabi_ehm__try_resume_cleanup(struct __cfaabi_ehm__try_resume_node * node) {
-        shared_stack.top_resume = node->next;
+        context->top_resume = node;
+}
+
+void __cfaehm_try_resume_cleanup(struct __cfaehm_try_resume_node * node) {
+        struct exception_context_t * context = this_exception_context();
+        context->top_resume = node->next;
 }
 
@@ -123 +126 @@
 // May have to move to cfa for constructors and destructors (references).
 
-struct __cfaabi_ehm__node {
-        struct __cfaabi_ehm__node * next;
+// How to clean up an exception in various situations.
+static void __cfaehm_exception_cleanup(
+                _Unwind_Reason_Code reason,
+                struct _Unwind_Exception * exception) {
+        switch (reason) {
+        case _URC_FOREIGN_EXCEPTION_CAUGHT:
+                // This one we could clean-up to allow cross-language exceptions.
+        case _URC_FATAL_PHASE1_ERROR:
+        case _URC_FATAL_PHASE2_ERROR:
+        default:
+                abort();
+        }
+}
+
+// We need a piece of storage to raise the exception, for now its a single
+// piece.
+static struct _Unwind_Exception this_exception_storage;
+
+struct __cfaehm_node {
+        struct __cfaehm_node * next;
 };
 
 #define NODE_TO_EXCEPT(node) ((exception_t *)(1 + (node)))
-#define EXCEPT_TO_NODE(except) ((struct __cfaabi_ehm__node *)(except) - 1)
+#define EXCEPT_TO_NODE(except) ((struct __cfaehm_node *)(except) - 1)
 
 // Creates a copy of the indicated exception and sets current_exception to it.
-static void __cfaabi_ehm__allocate_exception( exception_t * except ) {
+static void __cfaehm_allocate_exception( exception_t * except ) {
         struct exception_context_t * context = this_exception_context();
 
         // Allocate memory for the exception.
-        struct __cfaabi_ehm__node * store = malloc(
-                sizeof( struct __cfaabi_ehm__node ) + except->virtual_table->size );
+        struct __cfaehm_node * store = malloc(
+                sizeof( struct __cfaehm_node ) + except->virtual_table->size );
 
         if ( ! store ) {
@@ -149 +170 @@
         // Copy the exception to storage.
         except->virtual_table->copy( context->current_exception, except );
+
+        // Set up the exception storage.
+        this_exception_storage.exception_class = __cfaehm_exception_class;
+        this_exception_storage.exception_cleanup = __cfaehm_exception_cleanup;
 }
 
 // Delete the provided exception, unsetting current_exception if relivant.
-static void __cfaabi_ehm__delete_exception( exception_t * except ) {
+static void __cfaehm_delete_exception( exception_t * except ) {
         struct exception_context_t * context = this_exception_context();
 
-        __cfaabi_dbg_print_safe("Deleting Exception\n");
+        __cfadbg_print_safe(exception, "Deleting Exception\n");
 
         // Remove the exception from the list.
-        struct __cfaabi_ehm__node * to_free = EXCEPT_TO_NODE(except);
-        struct __cfaabi_ehm__node * node;
+        struct __cfaehm_node * to_free = EXCEPT_TO_NODE(except);
+        struct __cfaehm_node * node;
 
         if ( context->current_exception == except ) {
@@ -167 +192 @@
                 node = EXCEPT_TO_NODE(context->current_exception);
                 // It may always be in the first or second position.
-                while( to_free != node->next ) {
+                while ( to_free != node->next ) {
                         node = node->next;
                 }
@@ -179 +204 @@
 
 // If this isn't a rethrow (*except==0), delete the provided exception.
-void __cfaabi_ehm__cleanup_terminate( void * except ) {
-        if ( *(void**)except ) __cfaabi_ehm__delete_exception( *(exception_t **)except );
-}
-
-
-// We need a piece of storage to raise the exception
-struct _Unwind_Exception this_exception_storage;
+void __cfaehm_cleanup_terminate( void * except ) {
+        if ( *(void**)except ) __cfaehm_delete_exception( *(exception_t **)except );
+}
 
 // Function needed by force unwind
@@ -192 +213 @@
                 int version,
                 _Unwind_Action actions,
-                _Unwind_Exception_Class exceptionClass,
+                _Unwind_Exception_Class exception_class,
                 struct _Unwind_Exception * unwind_exception,
-                struct _Unwind_Context * context,
-                void * some_param) {
-        if( actions & _UA_END_OF_STACK  ) exit(1);
-        if( actions & _UA_CLEANUP_PHASE ) return _URC_NO_REASON;
-
-        return _URC_FATAL_PHASE2_ERROR;
+                struct _Unwind_Context * unwind_context,
+                void * stop_param) {
+        // Verify actions follow the rules we expect.
+        verify((actions & _UA_CLEANUP_PHASE) && (actions & _UA_FORCE_UNWIND));
+        verify(!(actions & (_UA_SEARCH_PHASE | _UA_HANDER_FRAME)));
+
+        if ( actions & _UA_END_OF_STACK ) {
+                exit(1);
+        } else {
+                return _URC_NO_REASON;
+        }
 }
 
 // The exception that is being thrown must already be stored.
-__attribute__((noreturn)) void __cfaabi_ehm__begin_unwind(void) {
+static __attribute__((noreturn)) void __cfaehm_begin_unwind(void) {
         if ( ! this_exception_context()->current_exception ) {
                 printf("UNWIND ERROR missing exception in begin unwind\n");
                 abort();
         }
-
 
         // Call stdlibc to raise the exception
@@ -220 +245 @@
         // the whole stack.
 
-        if( ret == _URC_END_OF_STACK ) {
+        if ( ret == _URC_END_OF_STACK ) {
                 // No proper handler was found. This can be handled in many ways, C++ calls std::terminate.
                 // Here we force unwind the stack, basically raising a cancellation.
@@ -235 +260 @@
 }
 
-void __cfaabi_ehm__throw_terminate( exception_t * val ) {
-        __cfaabi_dbg_print_safe("Throwing termination exception\n");
-
-        __cfaabi_ehm__allocate_exception( val );
-        __cfaabi_ehm__begin_unwind();
-}
-
-void __cfaabi_ehm__rethrow_terminate(void) {
-        __cfaabi_dbg_print_safe("Rethrowing termination exception\n");
-
-        __cfaabi_ehm__begin_unwind();
-}
-
-#pragma GCC push_options
-#pragma GCC optimize("O0")
+void __cfaehm_throw_terminate( exception_t * val ) {
+        __cfadbg_print_safe(exception, "Throwing termination exception\n");
+
+        __cfaehm_allocate_exception( val );
+        __cfaehm_begin_unwind();
+}
+
+void __cfaehm_rethrow_terminate(void) {
+        __cfadbg_print_safe(exception, "Rethrowing termination exception\n");
+
+        __cfaehm_begin_unwind();
+}
 
 // This is our personality routine. For every stack frame annotated with
 // ".cfi_personality 0x3,__gcfa_personality_v0" this function will be called twice when unwinding.
 //  Once in the search phase and once in the cleanup phase.
-_Unwind_Reason_Code __gcfa_personality_v0 (
-                int version, _Unwind_Action actions, unsigned long long exceptionClass,
-                struct _Unwind_Exception* unwind_exception,
-                struct _Unwind_Context* context)
+_Unwind_Reason_Code __gcfa_personality_v0(
+                int version,
+                _Unwind_Action actions,
+                unsigned long long exception_class,
+                struct _Unwind_Exception * unwind_exception,
+                struct _Unwind_Context * unwind_context)
 {
 
-        //__cfaabi_dbg_print_safe("CFA: 0x%lx\n", _Unwind_GetCFA(context));
-        __cfaabi_dbg_print_safe("Personality function (%d, %x, %llu, %p, %p):",
-                        version, actions, exceptionClass, unwind_exception, context);
-
-        // If we've reached the end of the stack then there is nothing much we can do...
-        if( actions & _UA_END_OF_STACK ) return _URC_END_OF_STACK;
-
+        //__cfadbg_print_safe(exception, "CFA: 0x%lx\n", _Unwind_GetCFA(context));
+        __cfadbg_print_safe(exception, "Personality function (%d, %x, %llu, %p, %p):",
+                        version, actions, exception_class, unwind_exception, unwind_context);
+
+        // Verify that actions follow the rules we expect.
+        // This function should never be called at the end of the stack.
+        verify(!(actions & _UA_END_OF_STACK));
+        // Either only the search phase flag is set or...
         if (actions & _UA_SEARCH_PHASE) {
-                __cfaabi_dbg_print_safe(" lookup phase");
-        }
-        else if (actions & _UA_CLEANUP_PHASE) {
-                __cfaabi_dbg_print_safe(" cleanup phase");
-        }
-        // Just in case, probably can't actually happen
-        else {
-                printf(" error\n");
-                return _URC_FATAL_PHASE1_ERROR;
+                verify(actions == _UA_SEARCH_PHASE);
+                __cfadbg_print_safe(exception, " lookup phase");
+        // ... we are in clean-up phase.
+        } else {
+                verify(actions & _UA_CLEANUP_PHASE);
+                __cfadbg_print_safe(exception, " cleanup phase");
+                // We shouldn't be the handler frame during forced unwind.
+                if (actions & _UA_HANDLER_FRAME) {
+                        verify(!(actions & _UA_FORCE_UNWIND));
+                        __cfadbg_print_safe(exception, " (handler frame)");
+                } else if (actions & _UA_FORCE_UNWIND) {
+                        __cfadbg_print_safe(exception, " (force unwind)");
+                }
         }
 
         // Get a pointer to the language specific data from which we will read what we need
-        const unsigned char * lsd = (const unsigned char*) _Unwind_GetLanguageSpecificData( context );
-
-        if( !lsd ) {    //Nothing to do, keep unwinding
+        const unsigned char * lsd = _Unwind_GetLanguageSpecificData( unwind_context );
+
+        if ( !lsd ) {   //Nothing to do, keep unwinding
                 printf(" no LSD");
                 goto UNWIND;
@@ -289 +318 @@
         // Get the instuction pointer and a reading pointer into the exception table
         lsda_header_info lsd_info;
-        const unsigned char * cur_ptr = parse_lsda_header(context, lsd, &lsd_info);
-        _Unwind_Ptr instruction_ptr = _Unwind_GetIP( context );
+        const unsigned char * cur_ptr = parse_lsda_header(unwind_context, lsd, &lsd_info);
+        _Unwind_Ptr instruction_ptr = _Unwind_GetIP(unwind_context);
+
+        struct exception_context_t * context = this_exception_context();
 
         // Linearly search the table for stuff to do
-        while( cur_ptr < lsd_info.action_table ) {
+        while ( cur_ptr < lsd_info.action_table ) {
                 _Unwind_Ptr callsite_start;
                 _Unwind_Ptr callsite_len;
@@ -306 +337 @@
 
                 // Have we reach the correct frame info yet?
-                if( lsd_info.Start + callsite_start + callsite_len < instruction_ptr ) {
+                if ( lsd_info.Start + callsite_start + callsite_len < instruction_ptr ) {
 #ifdef __CFA_DEBUG_PRINT__
                         void * ls = (void*)lsd_info.Start;
@@ -314 +345 @@
                         void * ep = (void*)lsd_info.Start + callsite_start + callsite_len;
                         void * ip = (void*)instruction_ptr;
-                        __cfaabi_dbg_print_safe("\nfound %p - %p (%p, %p, %p), looking for %p\n",
+                        __cfadbg_print_safe(exception, "\nfound %p - %p (%p, %p, %p), looking for %p\n",
                                         bp, ep, ls, cs, cl, ip);
 #endif // __CFA_DEBUG_PRINT__
@@ -321 +352 @@
 
                 // Have we gone too far?
-                if( lsd_info.Start + callsite_start > instruction_ptr ) {
+                if ( lsd_info.Start + callsite_start > instruction_ptr ) {
                         printf(" gone too far");
                         break;
                 }
 
-                // Something to do?
-                if( callsite_landing_pad ) {
-                        // Which phase are we in
-                        if (actions & _UA_SEARCH_PHASE) {
-                                // In search phase, these means we found a potential handler we must check.
-
-                                // We have arbitrarily decided that 0 means nothing to do and 1 means there is
-                                // a potential handler. This doesn't seem to conflict the gcc default behavior.
-                                if (callsite_action != 0) {
-                                        // Now we want to run some code to see if the handler matches
-                                        // This is the tricky part where we want to the power to run arbitrary code
-                                        // However, generating a new exception table entry and try routine every time
-                                        // is way more expansive than we might like
-                                        // The information we have is :
-                                        //  - The GR (Series of registers)
-                                        //    GR1=GP Global Pointer of frame ref by context
-                                        //  - The instruction pointer
-                                        //  - The instruction pointer info (???)
-                                        //  - The CFA (Canonical Frame Address)
-                                        //  - The BSP (Probably the base stack pointer)
-
-
-                                        // The current apprach uses one exception table entry per try block
-                                        _uleb128_t imatcher;
-                                        // Get the relative offset to the {...}?
-                                        cur_ptr = read_uleb128(cur_ptr, &imatcher);
-
-                                        _Unwind_Reason_Code (*matcher)(exception_t *) =
-                                                MATCHER_FROM_CONTEXT(context);
-                                        int index = matcher(shared_stack.current_exception);
-                                        _Unwind_Reason_Code ret = (0 == index)
-                                                ? _URC_CONTINUE_UNWIND : _URC_HANDLER_FOUND;
-                                        shared_stack.current_handler_index = index;
-
-                                        // Based on the return value, check if we matched the exception
-                                        if( ret == _URC_HANDLER_FOUND) {
-                                                __cfaabi_dbg_print_safe(" handler found\n");
-                                        } else {
-                                                __cfaabi_dbg_print_safe(" no handler\n");
-                                        }
-                                        return ret;
+                // Check for what we must do:
+                if ( 0 == callsite_landing_pad ) {
+                        // Nothing to do, move along
+                        __cfadbg_print_safe(exception, " no landing pad");
+                } else if (actions & _UA_SEARCH_PHASE) {
+                        // In search phase, these means we found a potential handler we must check.
+
+                        // We have arbitrarily decided that 0 means nothing to do and 1 means there is
+                        // a potential handler. This doesn't seem to conflict the gcc default behavior.
+                        if (callsite_action != 0) {
+                                // Now we want to run some code to see if the handler matches
+                                // This is the tricky part where we want to the power to run arbitrary code
+                                // However, generating a new exception table entry and try routine every time
+                                // is way more expansive than we might like
+                                // The information we have is :
+                                //  - The GR (Series of registers)
+                                //    GR1=GP Global Pointer of frame ref by context
+                                //  - The instruction pointer
+                                //  - The instruction pointer info (???)
+                                //  - The CFA (Canonical Frame Address)
+                                //  - The BSP (Probably the base stack pointer)
+
+                                // The current apprach uses one exception table entry per try block
+                                _uleb128_t imatcher;
+                                // Get the relative offset to the {...}?
+                                cur_ptr = read_uleb128(cur_ptr, &imatcher);
+
+#                               if defined( __x86_64 )
+                                _Unwind_Word match_pos = _Unwind_GetCFA(unwind_context) + 8;
+#                               elif defined( __i386 )
+                                _Unwind_Word match_pos = _Unwind_GetCFA(unwind_context) + 24;
+#                               endif
+                                int (*matcher)(exception_t *) = *(int(**)(exception_t *))match_pos;
+
+                                int index = matcher(context->current_exception);
+                                _Unwind_Reason_Code ret = (0 == index)
+                                        ? _URC_CONTINUE_UNWIND : _URC_HANDLER_FOUND;
+                                context->current_handler_index = index;
+
+                                // Based on the return value, check if we matched the exception
+                                if (ret == _URC_HANDLER_FOUND) {
+                                        __cfadbg_print_safe(exception, " handler found\n");
+                                } else {
+                                        __cfadbg_print_safe(exception, " no handler\n");
                                 }
-
-                                // This is only a cleanup handler, ignore it
-                                __cfaabi_dbg_print_safe(" no action");
+                                return ret;
                         }
-                        else if (actions & _UA_CLEANUP_PHASE) {
-
-                                if( (callsite_action != 0) && !(actions & _UA_HANDLER_FRAME) ){
-                                        // If this is a potential exception handler
-                                        // but not the one that matched the exception in the seach phase,
-                                        // just ignore it
-                                        goto UNWIND;
-                                }
-
-                                // We need to run some clean-up or a handler
-                                // These statment do the right thing but I don't know any specifics at all
-                                _Unwind_SetGR( context, __builtin_eh_return_data_regno(0), (_Unwind_Ptr) unwind_exception );
-                                _Unwind_SetGR( context, __builtin_eh_return_data_regno(1), 0 );
-
-                                // I assume this sets the instruction pointer to the adress of the landing pad
-                                // It doesn't actually set it, it only state the value that needs to be set once we return _URC_INSTALL_CONTEXT
-                                _Unwind_SetIP( context, ((lsd_info.LPStart) + (callsite_landing_pad)) );
-
-                                __cfaabi_dbg_print_safe(" action\n");
-
-                                // Return have some action to run
-                                return _URC_INSTALL_CONTEXT;
+
+                        // This is only a cleanup handler, ignore it
+                        __cfadbg_print_safe(exception, " no action");
+                } else {
+                        // In clean-up phase, no destructors here but this could be the handler.
+
+                        if ( (callsite_action != 0) && !(actions & _UA_HANDLER_FRAME) ){
+                                // If this is a potential exception handler
+                                // but not the one that matched the exception in the seach phase,
+                                // just ignore it
+                                goto UNWIND;
                         }
+
+                        // We need to run some clean-up or a handler
+                        // These statment do the right thing but I don't know any specifics at all
+                        _Unwind_SetGR( unwind_context, __builtin_eh_return_data_regno(0),
+                                (_Unwind_Ptr)unwind_exception );
+                        _Unwind_SetGR( unwind_context, __builtin_eh_return_data_regno(1), 0 );
+
+                        // I assume this sets the instruction pointer to the adress of the landing pad
+                        // It doesn't actually set it, it only state the value that needs to be set once we
+                        // return _URC_INSTALL_CONTEXT
+                        _Unwind_SetIP( unwind_context, ((lsd_info.LPStart) + (callsite_landing_pad)) );
+
+                        __cfadbg_print_safe(exception, " action\n");
+
+                        // Return have some action to run
+                        return _URC_INSTALL_CONTEXT;
                 }
-
-                // Nothing to do, move along
-                __cfaabi_dbg_print_safe(" no landing pad");
         }
         // No handling found
-        __cfaabi_dbg_print_safe(" table end reached\n");
+        __cfadbg_print_safe(exception, " table end reached");
 
         UNWIND:
-        __cfaabi_dbg_print_safe(" unwind\n");
+        __cfadbg_print_safe(exception, " unwind\n");
 
         // Keep unwinding the stack
         return _URC_CONTINUE_UNWIND;
 }
+
+#pragma GCC push_options
+#pragma GCC optimize(0)
 
 // Try statements are hoisted out see comments for details. While this could probably be unique
 // and simply linked from libcfa but there is one problem left, see the exception table for details
 __attribute__((noinline))
-void __cfaabi_ehm__try_terminate(void (*try_block)(),
+void __cfaehm_try_terminate(void (*try_block)(),
                 void (*catch_block)(int index, exception_t * except),
                 __attribute__((unused)) int (*match_block)(exception_t * except)) {
@@ -419 +456 @@
         //! printf("%p %p %p %p\n", &try_block, &catch_block, &match_block, &xy);
 
-        // Setup statments: These 2 statments won't actually result in any code, they only setup global tables.
-        // However, they clobber gcc cancellation support from gcc.  We can replace the personality routine but
-        // replacing the exception table gcc generates is not really doable, it generates labels based on how the
-        // assembly works.
-
         // Setup the personality routine and exception table.
+        // Unforturnately these clobber gcc cancellation support which means we can't get access to
+        // the attribute cleanup tables at the same time. We would have to inspect the assembly to
+        // create a new set ourselves.
 #ifdef __PIC__
         asm volatile (".cfi_personality 0x9b,CFA.ref.__gcfa_personality_v0");
@@ -449 +484 @@
         // Label which defines the end of the area for which the handler is setup.
         asm volatile (".TRYEND:");
-        // Label which defines the start of the exception landing pad.  Basically what is called when the exception is
-        // caught.  Note, if multiple handlers are given, the multiplexing should be done by the generated code, not the
-        // exception runtime.
+        // Label which defines the start of the exception landing pad. Basically what is called when
+        // the exception is caught. Note, if multiple handlers are given, the multiplexing should be
+        // done by the generated code, not the exception runtime.
         asm volatile (".CATCH:");
 
         // Exception handler
-        catch_block( shared_stack.current_handler_index,
-                     shared_stack.current_exception );
+        // Note: Saving the exception context on the stack breaks termination exceptions.
+        catch_block( this_exception_context()->current_handler_index,
+                     this_exception_context()->current_exception );
 }
 
@@ -464 +500 @@
 
 #ifdef __PIC__
-#if defined( __i386 ) || defined( __x86_64 )
 asm (
         // HEADER
@@ -481 +516 @@
         // handler landing pad offset and 1 (action code, gcc seems to use 0).
         ".LLSDACSBCFA2:\n"
-        "       .uleb128 .TRYSTART-__cfaabi_ehm__try_terminate\n"
+        "       .uleb128 .TRYSTART-__cfaehm_try_terminate\n"
         "       .uleb128 .TRYEND-.TRYSTART\n"
-        "       .uleb128 .CATCH-__cfaabi_ehm__try_terminate\n"
+        "       .uleb128 .CATCH-__cfaehm_try_terminate\n"
         "       .uleb128 1\n"
         ".LLSDACSECFA2:\n"
         // TABLE FOOTER
         "       .text\n"
-        "       .size   __cfaabi_ehm__try_terminate, .-__cfaabi_ehm__try_terminate\n"
+        "       .size   __cfaehm_try_terminate, .-__cfaehm_try_terminate\n"
 );
 
@@ -507 +542 @@
         "       .quad __gcfa_personality_v0\n"
 #else // then __i386
-        "   .long __gcfa_personality_v0\n"
+        "       .long __gcfa_personality_v0\n"
 #endif
 );
-#else
-#error Exception Handling: unknown architecture for position independent code.
-#endif // __i386 || __x86_64
 #else // __PIC__
-#if defined( __i386 ) || defined( __x86_64 )
 asm (
         // HEADER
@@ -529 +560 @@
         ".LLSDACSBCFA2:\n"
         //      Handled area start (relative to start of function)
-        "       .uleb128 .TRYSTART-__cfaabi_ehm__try_terminate\n"
+        "       .uleb128 .TRYSTART-__cfaehm_try_terminate\n"
         //      Handled area length
         "       .uleb128 .TRYEND-.TRYSTART\n"
         //      Handler landing pad address (relative to start of function)
-        "       .uleb128 .CATCH-__cfaabi_ehm__try_terminate\n"
+        "       .uleb128 .CATCH-__cfaehm_try_terminate\n"
         //      Action code, gcc seems to always use 0.
         "       .uleb128 1\n"
@@ -539 +570 @@
         ".LLSDACSECFA2:\n"
         "       .text\n"
-        "       .size   __cfaabi_ehm__try_terminate, .-__cfaabi_ehm__try_terminate\n"
+        "       .size   __cfaehm_try_terminate, .-__cfaehm_try_terminate\n"
         "       .ident  \"GCC: (Ubuntu 6.2.0-3ubuntu11~16.04) 6.2.0 20160901\"\n"
         "       .section        .note.GNU-stack,\"x\",@progbits\n"
 );
-#else
-#error Exception Handling: unknown architecture for position dependent code.
-#endif // __i386 || __x86_64
 #endif // __PIC__
 

libcfa/src/exception.h

@@ -9 +9 @@
 // Author           : Andrew Beach
 // Created On       : Mon Jun 26 15:11:00 2017
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Feb 22 18:11:15 2018
-// Update Count     : 8
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Mar 27 10:16:00 2020
+// Update Count     : 9
 //
 
@@ -21 +21 @@
 #endif
 
-struct __cfaabi_ehm__base_exception_t;
-typedef struct __cfaabi_ehm__base_exception_t exception_t;
-struct __cfaabi_ehm__base_exception_t_vtable {
-        const struct __cfaabi_ehm__base_exception_t_vtable * parent;
+struct __cfaehm_base_exception_t;
+typedef struct __cfaehm_base_exception_t exception_t;
+struct __cfaehm_base_exception_t_vtable {
+        const struct __cfaehm_base_exception_t_vtable * parent;
         size_t size;
-        void (*copy)(struct __cfaabi_ehm__base_exception_t *this,
-                     struct __cfaabi_ehm__base_exception_t * other);
-        void (*free)(struct __cfaabi_ehm__base_exception_t *this);
-        const char * (*msg)(struct __cfaabi_ehm__base_exception_t *this);
+        void (*copy)(struct __cfaehm_base_exception_t *this,
+                     struct __cfaehm_base_exception_t * other);
+        void (*free)(struct __cfaehm_base_exception_t *this);
+        const char * (*msg)(struct __cfaehm_base_exception_t *this);
 };
-struct __cfaabi_ehm__base_exception_t {
-        struct __cfaabi_ehm__base_exception_t_vtable const * virtual_table;
+struct __cfaehm_base_exception_t {
+        struct __cfaehm_base_exception_t_vtable const * virtual_table;
 };
-extern struct __cfaabi_ehm__base_exception_t_vtable
-        ___cfaabi_ehm__base_exception_t_vtable_instance;
+extern struct __cfaehm_base_exception_t_vtable
+        ___cfaehm_base_exception_t_vtable_instance;
 
 
 // Used in throw statement translation.
-void __cfaabi_ehm__throw_terminate(exception_t * except) __attribute__((noreturn));
-void __cfaabi_ehm__rethrow_terminate() __attribute__((noreturn));
-void __cfaabi_ehm__throw_resume(exception_t * except);
+void __cfaehm_throw_terminate(exception_t * except) __attribute__((noreturn));
+void __cfaehm_rethrow_terminate() __attribute__((noreturn));
+void __cfaehm_throw_resume(exception_t * except);
 
 // Function catches termination exceptions.
-void __cfaabi_ehm__try_terminate(
+void __cfaehm_try_terminate(
     void (*try_block)(),
     void (*catch_block)(int index, exception_t * except),
@@ -50 +50 @@
 
 // Clean-up the exception in catch blocks.
-void __cfaabi_ehm__cleanup_terminate(void * except);
+void __cfaehm_cleanup_terminate(void * except);
 
 // Data structure creates a list of resume handlers.
-struct __cfaabi_ehm__try_resume_node {
-    struct __cfaabi_ehm__try_resume_node * next;
+struct __cfaehm_try_resume_node {
+    struct __cfaehm_try_resume_node * next;
     _Bool (*handler)(exception_t * except);
 };
 
 // These act as constructor and destructor for the resume node.
-void __cfaabi_ehm__try_resume_setup(
-    struct __cfaabi_ehm__try_resume_node * node,
+void __cfaehm_try_resume_setup(
+    struct __cfaehm_try_resume_node * node,
     _Bool (*handler)(exception_t * except));
-void __cfaabi_ehm__try_resume_cleanup(
-    struct __cfaabi_ehm__try_resume_node * node);
+void __cfaehm_try_resume_cleanup(
+    struct __cfaehm_try_resume_node * node);
 
 // Check for a standard way to call fake deconstructors.
-struct __cfaabi_ehm__cleanup_hook {};
+struct __cfaehm_cleanup_hook {};
 
 #ifdef __cforall

libcfa/src/heap.cfa

@@ -10 +10 @@
 // Created On       : Tue Dec 19 21:58:35 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Feb  4 10:04:51 2020
-// Update Count     : 648
+// Last Modified On : Wed May  6 17:29:26 2020
+// Update Count     : 727
 //
 
@@ -19 +19 @@
 #include <errno.h>                                                                              // errno
 #include <string.h>                                                                             // memset, memcpy
+#include <limits.h>                                                                             // ULONG_MAX
 extern "C" {
 #include <sys/mman.h>                                                                   // mmap, munmap
 } // extern "C"
 
-// #comment TD : Many of these should be merged into math I believe
 #include "bits/align.hfa"                                                               // libPow2
 #include "bits/defs.hfa"                                                                // likely, unlikely
@@ -30 +30 @@
 //#include "stdlib.hfa"                                                                 // bsearchl
 #include "malloc.h"
+#include "bitmanip.hfa"                                                                 // ceiling
 
 #define MIN(x, y) (y > x ? x : y)
@@ -81 +82 @@
 };
 
+size_t default_heap_expansion() __attribute__(( weak )) {
+        return __CFA_DEFAULT_HEAP_EXPANSION__;
+} // default_heap_expansion
+
 size_t default_mmap_start() __attribute__(( weak )) {
         return __CFA_DEFAULT_MMAP_START__;
 } // default_mmap_start
-
-size_t default_heap_expansion() __attribute__(( weak )) {
-        return __CFA_DEFAULT_HEAP_EXPANSION__;
-} // default_heap_expansion
 
 
@@ -150 +151 @@
                                                         union {
 //                                                              FreeHeader * home;              // allocated block points back to home locations (must overlay alignment)
+                                                                // 2nd low-order bit => zero filled
                                                                 void * home;                    // allocated block points back to home locations (must overlay alignment)
                                                                 size_t blockSize;               // size for munmap (must overlay alignment)
@@ -169 +171 @@
                                 struct FakeHeader {
                                         #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-                                        uint32_t alignment;                                     // low-order bits of home/blockSize used for tricks
+                                        // 1st low-order bit => fake header & alignment
+                                        uint32_t alignment;
                                         #endif // __ORDER_LITTLE_ENDIAN__
 
@@ -179 +182 @@
                                 } fake; // FakeHeader
                         } kind; // Kind
+                        size_t size;                                                            // allocation size in bytes
                 } header; // Header
                 char pad[libAlign() - sizeof( Header )];
@@ -262 +266 @@
 static unsigned long long int free_storage;
 static unsigned int free_calls;
+static unsigned long long int aalloc_storage;
+static unsigned int aalloc_calls;
 static unsigned long long int calloc_storage;
 static unsigned int calloc_calls;
 static unsigned long long int memalign_storage;
 static unsigned int memalign_calls;
+static unsigned long long int amemalign_storage;
+static unsigned int amemalign_calls;
 static unsigned long long int cmemalign_storage;
 static unsigned int cmemalign_calls;
+static unsigned long long int resize_storage;
+static unsigned int resize_calls;
 static unsigned long long int realloc_storage;
 static unsigned int realloc_calls;
@@ -275 +285 @@
 // Use "write" because streams may be shutdown when calls are made.
 static void printStats() {
-        char helpText[512];
+        char helpText[1024];
         __cfaabi_bits_print_buffer( STDERR_FILENO, helpText, sizeof(helpText),
                                                                         "\nHeap statistics:\n"
                                                                         "  malloc: calls %u / storage %llu\n"
+                                                                        "  aalloc: calls %u / storage %llu\n"
                                                                         "  calloc: calls %u / storage %llu\n"
                                                                         "  memalign: calls %u / storage %llu\n"
+                                                                        "  amemalign: calls %u / storage %llu\n"
                                                                         "  cmemalign: calls %u / storage %llu\n"
+                                                                        "  resize: calls %u / storage %llu\n"
                                                                         "  realloc: calls %u / storage %llu\n"
                                                                         "  free: calls %u / storage %llu\n"
@@ -288 +301 @@
                                                                         "  sbrk: calls %u / storage %llu\n",
                                                                         malloc_calls, malloc_storage,
+                                                                        aalloc_calls, calloc_storage,
                                                                         calloc_calls, calloc_storage,
                                                                         memalign_calls, memalign_storage,
+                                                                        amemalign_calls, amemalign_storage,
                                                                         cmemalign_calls, cmemalign_storage,
+                                                                        resize_calls, resize_storage,
                                                                         realloc_calls, realloc_storage,
                                                                         free_calls, free_storage,
@@ -300 +316 @@
 
 static int printStatsXML( FILE * stream ) {                             // see malloc_info
-        char helpText[512];
+        char helpText[1024];
         int len = snprintf( helpText, sizeof(helpText),
                                                 "<malloc version=\"1\">\n"
@@ -307 +323 @@
                                                 "</sizes>\n"
                                                 "<total type=\"malloc\" count=\"%u\" size=\"%llu\"/>\n"
+                                                "<total type=\"aalloc\" count=\"%u\" size=\"%llu\"/>\n"
                                                 "<total type=\"calloc\" count=\"%u\" size=\"%llu\"/>\n"
                                                 "<total type=\"memalign\" count=\"%u\" size=\"%llu\"/>\n"
+                                                "<total type=\"amemalign\" count=\"%u\" size=\"%llu\"/>\n"
                                                 "<total type=\"cmemalign\" count=\"%u\" size=\"%llu\"/>\n"
+                                                "<total type=\"resize\" count=\"%u\" size=\"%llu\"/>\n"
                                                 "<total type=\"realloc\" count=\"%u\" size=\"%llu\"/>\n"
                                                 "<total type=\"free\" count=\"%u\" size=\"%llu\"/>\n"
@@ -317 +336 @@
                                                 "</malloc>",
                                                 malloc_calls, malloc_storage,
+                                                aalloc_calls, aalloc_storage,
                                                 calloc_calls, calloc_storage,
                                                 memalign_calls, memalign_storage,
+                                                amemalign_calls, amemalign_storage,
                                                 cmemalign_calls, cmemalign_storage,
+                                                resize_calls, resize_storage,
                                                 realloc_calls, realloc_storage,
                                                 free_calls, free_storage,
@@ -339 +361 @@
 
 
-static inline void checkAlign( size_t alignment ) {
-        if ( alignment < libAlign() || ! libPow2( alignment ) ) {
-                abort( "Alignment %zu for memory allocation is less than %d and/or not a power of 2.", alignment, libAlign() );
-        } // if
-} // checkAlign
-
-
-static inline bool setHeapExpand( size_t value ) {
-  if ( heapExpand < pageSize ) return true;
-        heapExpand = value;
-        return false;
-} // setHeapExpand
-
-
 // thunk problem
 size_t Bsearchl( unsigned int key, const unsigned int * vals, size_t dim ) {
@@ -369 +377 @@
 
 static inline bool setMmapStart( size_t value ) {               // true => mmapped, false => sbrk
-  if ( value < pageSize || bucketSizes[NoBucketSizes - 1] < value ) return true;
+  if ( value < pageSize || bucketSizes[NoBucketSizes - 1] < value ) return false;
         mmapStart = value;                                                                      // set global
 
@@ -376 +384 @@
         assert( maxBucketsUsed < NoBucketSizes );                       // subscript failure ?
         assert( mmapStart <= bucketSizes[maxBucketsUsed] ); // search failure ?
-        return false;
+        return true;
 } // setMmapStart
+
+
+// <-------+----------------------------------------------------> bsize (bucket size)
+// |header |addr
+//==================================================================================
+//                   align/offset |
+// <-----------------<------------+-----------------------------> bsize (bucket size)
+//                   |fake-header | addr
+#define headerAddr( addr ) ((HeapManager.Storage.Header *)( (char *)addr - sizeof(HeapManager.Storage) ))
+#define realHeader( header ) ((HeapManager.Storage.Header *)((char *)header - header->kind.fake.offset))
+
+// <-------<<--------------------- dsize ---------------------->> bsize (bucket size)
+// |header |addr
+//==================================================================================
+//                   align/offset |
+// <------------------------------<<---------- dsize --------->>> bsize (bucket size)
+//                   |fake-header |addr
+#define dataStorage( bsize, addr, header ) (bsize - ( (char *)addr - (char *)header ))
+
+
+static inline void checkAlign( size_t alignment ) {
+        if ( alignment < libAlign() || ! libPow2( alignment ) ) {
+                abort( "Alignment %zu for memory allocation is less than %d and/or not a power of 2.", alignment, libAlign() );
+        } // if
+} // checkAlign
 
 
@@ -391 +424 @@
 static inline void fakeHeader( HeapManager.Storage.Header *& header, size_t & alignment ) {
         if ( unlikely( (header->kind.fake.alignment & 1) == 1 ) ) { // fake header ?
-                size_t offset = header->kind.fake.offset;
                 alignment = header->kind.fake.alignment & -2;   // remove flag from value
                 #ifdef __CFA_DEBUG__
                 checkAlign( alignment );                                                // check alignment
                 #endif // __CFA_DEBUG__
-                header = (HeapManager.Storage.Header *)((char *)header - offset);
+                header = realHeader( header );                                  // backup from fake to real header
         } // if
 } // fakeHeader
-
-
-// <-------+----------------------------------------------------> bsize (bucket size)
-// |header |addr
-//==================================================================================
-//                                | alignment
-// <-----------------<------------+-----------------------------> bsize (bucket size)
-//                   |fake-header | addr
-#define headerAddr( addr ) ((HeapManager.Storage.Header *)( (char *)addr - sizeof(HeapManager.Storage) ))
-
-// <-------<<--------------------- dsize ---------------------->> bsize (bucket size)
-// |header |addr
-//==================================================================================
-//                                | alignment
-// <------------------------------<<---------- dsize --------->>> bsize (bucket size)
-//                   |fake-header |addr
-#define dataStorage( bsize, addr, header ) (bsize - ( (char *)addr - (char *)header ))
 
 
@@ -428 +443 @@
 
         #ifdef __CFA_DEBUG__
-        checkHeader( addr < heapBegin || header < (HeapManager.Storage.Header *)heapBegin, name, addr ); // bad low address ?
+        checkHeader( addr < heapBegin, name, addr );            // bad low address ?
         #endif // __CFA_DEBUG__
 
@@ -487 +502 @@
         // along with the block and is a multiple of the alignment size.
 
-  if ( unlikely( size > ~0ul - sizeof(HeapManager.Storage) ) ) return 0p;
+  if ( unlikely( size > ULONG_MAX - sizeof(HeapManager.Storage) ) ) return 0p;
         size_t tsize = size + sizeof(HeapManager.Storage);
         if ( likely( tsize < mmapStart ) ) {                            // small size => sbrk
@@ -539 +554 @@
                 block->header.kind.real.home = freeElem;                // pointer back to free list of apropriate size
         } else {                                                                                        // large size => mmap
-  if ( unlikely( size > ~0ul - pageSize ) ) return 0p;
+  if ( unlikely( size > ULONG_MAX - pageSize ) ) return 0p;
                 tsize = libCeiling( tsize, pageSize );                  // must be multiple of page size
                 #ifdef __STATISTICS__
@@ -557 +572 @@
         } // if
 
+        block->header.size = size;                                                      // store allocation size
         void * addr = &(block->data);                                           // adjust off header to user bytes
 
@@ -680 +696 @@
         #endif // FASTLOOKUP
 
-        if ( setMmapStart( default_mmap_start() ) ) {
+        if ( ! setMmapStart( default_mmap_start() ) ) {
                 abort( "HeapManager : internal error, mmap start initialization failure." );
         } // if
@@ -686 +702 @@
 
         char * end = (char *)sbrk( 0 );
-        sbrk( (char *)libCeiling( (long unsigned int)end, libAlign() ) - end ); // move start of heap to multiple of alignment
-        heapBegin = heapEnd = sbrk( 0 );                                        // get new start point
+        heapBegin = heapEnd = sbrk( (char *)libCeiling( (long unsigned int)end, libAlign() ) - end ); // move start of heap to multiple of alignment
 } // HeapManager
 
@@ -713 +728 @@
         //assert( heapManager.heapBegin != 0 );
         //heapManager{};
-        if ( heapManager.heapBegin == 0p ) heapManager{};
+        if ( heapManager.heapBegin == 0p ) heapManager{};       // sanity check
 } // memory_startup
 
@@ -725 +740 @@
         //assert( heapManager.heapBegin != 0 );
         if ( unlikely( heapManager.heapBegin == 0p ) ) heapManager{}; // called before memory_startup ?
+#if __SIZEOF_POINTER__ == 8
+        verify( size < ((typeof(size_t))1 << 48) );
+#endif // __SIZEOF_POINTER__ == 8
         void * addr = doMalloc( size );
         if ( unlikely( addr == 0p ) ) errno = ENOMEM;           // POSIX
@@ -731 +749 @@
 
 
-static inline void * callocNoStats( size_t noOfElems, size_t elemSize ) {
-        size_t size = noOfElems * elemSize;
+static inline void * callocNoStats( size_t dim, size_t elemSize ) {
+        size_t size = dim * elemSize;
         char * addr = (char *)mallocNoStats( size );
   if ( unlikely( addr == 0p ) ) return 0p;
@@ -790 +808 @@
 
 
-static inline void * cmemalignNoStats( size_t alignment, size_t noOfElems, size_t elemSize ) {
-        size_t size = noOfElems * elemSize;
+static inline void * cmemalignNoStats( size_t alignment, size_t dim, size_t elemSize ) {
+        size_t size = dim * elemSize;
         char * addr = (char *)memalignNoStats( alignment, size );
   if ( unlikely( addr == 0p ) ) return 0p;
@@ -803 +821 @@
         #endif // __CFA_DEBUG__
                 memset( addr, '\0', dataStorage( bsize, addr, header ) ); // set to zeros
-        header->kind.real.blockSize |= 2;                               // mark as zero filled
-
+
+        header->kind.real.blockSize |= 2;                                       // mark as zero filled
         return addr;
 } // cmemalignNoStats
@@ -819 +837 @@
 
 extern "C" {
-        // The malloc() function allocates size bytes and returns a pointer to the allocated memory. The memory is not
-        // initialized. If size is 0, then malloc() returns either 0p, or a unique pointer value that can later be
-        // successfully passed to free().
+        // Allocates size bytes and returns a pointer to the allocated memory.  The contents are undefined. If size is 0,
+        // then malloc() returns a unique pointer value that can later be successfully passed to free().
         void * malloc( size_t size ) {
                 #ifdef __STATISTICS__
@@ -831 +848 @@
         } // malloc
 
-        // The calloc() function allocates memory for an array of nmemb elements of size bytes each and returns a pointer to
-        // the allocated memory. The memory is set to zero. If nmemb or size is 0, then calloc() returns either 0p, or a
-        // unique pointer value that can later be successfully passed to free().
-        void * calloc( size_t noOfElems, size_t elemSize ) {
+
+        // Same as malloc() except size bytes is an array of dim elements each of elemSize bytes.
+        void * aalloc( size_t dim, size_t elemSize ) {
+                #ifdef __STATISTICS__
+                __atomic_add_fetch( &aalloc_calls, 1, __ATOMIC_SEQ_CST );
+                __atomic_add_fetch( &aalloc_storage, dim * elemSize, __ATOMIC_SEQ_CST );
+                #endif // __STATISTICS__
+
+                return mallocNoStats( dim * elemSize );
+        } // aalloc
+
+
+        // Same as aalloc() with memory set to zero.
+        void * calloc( size_t dim, size_t elemSize ) {
                 #ifdef __STATISTICS__
                 __atomic_add_fetch( &calloc_calls, 1, __ATOMIC_SEQ_CST );
-                __atomic_add_fetch( &calloc_storage, noOfElems * elemSize, __ATOMIC_SEQ_CST );
-                #endif // __STATISTICS__
-
-                return callocNoStats( noOfElems, elemSize );
+                __atomic_add_fetch( &calloc_storage, dim * elemSize, __ATOMIC_SEQ_CST );
+                #endif // __STATISTICS__
+
+                return callocNoStats( dim, elemSize );
         } // calloc
 
-        // The realloc() function changes the size of the memory block pointed to by ptr to size bytes. The contents will be
-        // unchanged in the range from the start of the region up to the minimum of the old and new sizes. If the new size
-        // is larger than the old size, the added memory will not be initialized.  If ptr is 0p, then the call is
-        // equivalent to malloc(size), for all values of size; if size is equal to zero, and ptr is not 0p, then the call
-        // is equivalent to free(ptr). Unless ptr is 0p, it must have been returned by an earlier call to malloc(),
-        // calloc() or realloc(). If the area pointed to was moved, a free(ptr) is done.
+        // Change the size of the memory block pointed to by oaddr to size bytes. The contents are undefined.  If oaddr is
+        // 0p, then the call is equivalent to malloc(size), for all values of size; if size is equal to zero, and oaddr is
+        // not 0p, then the call is equivalent to free(oaddr). Unless oaddr is 0p, it must have been returned by an earlier
+        // call to malloc(), alloc(), calloc() or realloc(). If the area pointed to was moved, a free(oaddr) is done.
+        void * resize( void * oaddr, size_t size ) {
+                #ifdef __STATISTICS__
+                __atomic_add_fetch( &resize_calls, 1, __ATOMIC_SEQ_CST );
+                __atomic_add_fetch( &resize_storage, size, __ATOMIC_SEQ_CST );
+                #endif // __STATISTICS__
+
+                // If size is equal to 0, either NULL or a pointer suitable to be passed to free() is returned.
+          if ( unlikely( size == 0 ) ) { free( oaddr ); return mallocNoStats( size ); } // special cases
+          if ( unlikely( oaddr == 0p ) ) return mallocNoStats( size );
+
+                HeapManager.Storage.Header * header;
+                HeapManager.FreeHeader * freeElem;
+                size_t bsize, oalign = 0;
+                headers( "resize", oaddr, header, freeElem, bsize, oalign );
+
+                size_t odsize = dataStorage( bsize, oaddr, header ); // data storage available in bucket
+                // same size, DO NOT preserve STICKY PROPERTIES.
+          if ( oalign == 0 && size <= odsize && odsize <= size * 2 ) { // allow 50% wasted storage for smaller size
+                        header->kind.real.blockSize &= -2;                      // no alignment and turn off 0 fill
+                        return oaddr;
+                } // if
+        
+                // change size, DO NOT preserve STICKY PROPERTIES.
+                free( oaddr );
+                void * naddr = mallocNoStats( size );                   // create new area
+                return naddr;
+        } // resize
+
+
+        // Same as resize() but the contents are unchanged in the range from the start of the region up to the minimum of
+        // the old and new sizes.
         void * realloc( void * oaddr, size_t size ) {
                 #ifdef __STATISTICS__
                 __atomic_add_fetch( &realloc_calls, 1, __ATOMIC_SEQ_CST );
+                __atomic_add_fetch( &realloc_storage, size, __ATOMIC_SEQ_CST );
                 #endif // __STATISTICS__
 
@@ -867 +924 @@
                         // Do not know size of original allocation => cannot do 0 fill for any additional space because do not know
                         // where to start filling, i.e., do not overwrite existing values in space.
-                        //
-                        // This case does not result in a new profiler entry because the previous one still exists and it must match with
-                        // the free for this memory.  Hence, this realloc does not appear in the profiler output.
                         return oaddr;
                 } // if
-
-                #ifdef __STATISTICS__
-                __atomic_add_fetch( &realloc_storage, size, __ATOMIC_SEQ_CST );
-                #endif // __STATISTICS__
 
                 // change size and copy old content to new storage
@@ -903 +953 @@
         } // realloc
 
-        // The obsolete function memalign() allocates size bytes and returns a pointer to the allocated memory. The memory
-        // address will be a multiple of alignment, which must be a power of two.
+        // Same as malloc() except the memory address is a multiple of alignment, which must be a power of two. (obsolete)
         void * memalign( size_t alignment, size_t size ) {
                 #ifdef __STATISTICS__
@@ -915 +964 @@
 
 
-        // The cmemalign() function is the same as calloc() with memory alignment.
-        void * cmemalign( size_t alignment, size_t noOfElems, size_t elemSize ) {
+        // Same as aalloc() with memory alignment.
+        void * amemalign( size_t alignment, size_t dim, size_t elemSize ) {
                 #ifdef __STATISTICS__
                 __atomic_add_fetch( &cmemalign_calls, 1, __ATOMIC_SEQ_CST );
-                __atomic_add_fetch( &cmemalign_storage, noOfElems * elemSize, __ATOMIC_SEQ_CST );
-                #endif // __STATISTICS__
-
-                return cmemalignNoStats( alignment, noOfElems, elemSize );
+                __atomic_add_fetch( &cmemalign_storage, dim * elemSize, __ATOMIC_SEQ_CST );
+                #endif // __STATISTICS__
+
+                return memalignNoStats( alignment, dim * elemSize );
+        } // amemalign
+
+
+        // Same as calloc() with memory alignment.
+        void * cmemalign( size_t alignment, size_t dim, size_t elemSize ) {
+                #ifdef __STATISTICS__
+                __atomic_add_fetch( &cmemalign_calls, 1, __ATOMIC_SEQ_CST );
+                __atomic_add_fetch( &cmemalign_storage, dim * elemSize, __ATOMIC_SEQ_CST );
+                #endif // __STATISTICS__
+
+                return cmemalignNoStats( alignment, dim, elemSize );
         } // cmemalign
 
-        // The function aligned_alloc() is the same as memalign(), except for the added restriction that size should be a
-        // multiple of alignment.
+        // Same as memalign(), but ISO/IEC 2011 C11 Section 7.22.2 states: the value of size shall be an integral multiple
+    // of alignment. This requirement is universally ignored.
         void * aligned_alloc( size_t alignment, size_t size ) {
                 return memalign( alignment, size );
@@ -932 +992 @@
 
 
-        // The function posix_memalign() allocates size bytes and places the address of the allocated memory in *memptr. The
-        // address of the allocated memory will be a multiple of alignment, which must be a power of two and a multiple of
-        // sizeof(void *). If size is 0, then posix_memalign() returns either 0p, or a unique pointer value that can later
-        // be successfully passed to free(3).
+        // Allocates size bytes and places the address of the allocated memory in *memptr. The address of the allocated
+        // memory shall be a multiple of alignment, which must be a power of two and a multiple of sizeof(void *). If size
+        // is 0, then posix_memalign() returns either 0p, or a unique pointer value that can later be successfully passed to
+        // free(3).
         int posix_memalign( void ** memptr, size_t alignment, size_t size ) {
           if ( alignment < sizeof(void *) || ! libPow2( alignment ) ) return EINVAL; // check alignment
@@ -943 +1003 @@
         } // posix_memalign
 
-        // The obsolete function valloc() allocates size bytes and returns a pointer to the allocated memory. The memory
-        // address will be a multiple of the page size.  It is equivalent to memalign(sysconf(_SC_PAGESIZE),size).
+        // Allocates size bytes and returns a pointer to the allocated memory. The memory address shall be a multiple of the
+        // page size.  It is equivalent to memalign(sysconf(_SC_PAGESIZE),size).
         void * valloc( size_t size ) {
                 return memalign( pageSize, size );
@@ -950 +1010 @@
 
 
-        // The free() function frees the memory space pointed to by ptr, which must have been returned by a previous call to
-        // malloc(), calloc() or realloc().  Otherwise, or if free(ptr) has already been called before, undefined behavior
-        // occurs. If ptr is 0p, no operation is performed.
+        // Same as valloc but rounds size to multiple of page size.
+        void * pvalloc( size_t size ) {
+                return memalign( pageSize, libCeiling( size, pageSize ) );
+        } // pvalloc
+
+
+        // Frees the memory space pointed to by ptr, which must have been returned by a previous call to malloc(), calloc()
+        // or realloc().  Otherwise, or if free(ptr) has already been called before, undefined behaviour occurs. If ptr is
+        // 0p, no operation is performed.
         void free( void * addr ) {
                 #ifdef __STATISTICS__
@@ -973 +1039 @@
 
 
-        // The malloc_alignment() function returns the alignment of the allocation.
+        // Returns the alignment of an allocation.
         size_t malloc_alignment( void * addr ) {
           if ( unlikely( addr == 0p ) ) return libAlign();      // minimum alignment
@@ -980 +1046 @@
                         return header->kind.fake.alignment & -2;        // remove flag from value
                 } else {
-                        return libAlign ();                                                     // minimum alignment
+                        return libAlign();                                                      // minimum alignment
                 } // if
         } // malloc_alignment
 
-
-        // The malloc_zero_fill() function returns true if the allocation is zero filled, i.e., initially allocated by calloc().
+        // Set the alignment for an the allocation and return previous alignment or 0 if no alignment.
+        size_t $malloc_alignment_set( void * addr, size_t alignment ) {
+          if ( unlikely( addr == 0p ) ) return libAlign();      // minimum alignment
+                size_t ret;
+                HeapManager.Storage.Header * header = headerAddr( addr );
+                if ( (header->kind.fake.alignment & 1) == 1 ) { // fake header ?
+                        ret = header->kind.fake.alignment & -2;         // remove flag from old value
+                        header->kind.fake.alignment = alignment | 1; // add flag to new value
+                } else {
+                        ret = 0;                                                                        // => no alignment to change
+                } // if
+                return ret;
+        } // $malloc_alignment_set
+
+
+        // Returns true if the allocation is zero filled, e.g., allocated by calloc().
         bool malloc_zero_fill( void * addr ) {
           if ( unlikely( addr == 0p ) ) return false;           // null allocation is not zero fill
                 HeapManager.Storage.Header * header = headerAddr( addr );
                 if ( (header->kind.fake.alignment & 1) == 1 ) { // fake header ?
-                        header = (HeapManager.Storage.Header *)((char *)header - header->kind.fake.offset);
-                } // if
-                return (header->kind.real.blockSize & 2) != 0;  // zero filled (calloc/cmemalign) ?
+                        header = realHeader( header );                          // backup from fake to real header
+                } // if
+                return (header->kind.real.blockSize & 2) != 0;  // zero filled ?
         } // malloc_zero_fill
 
-
-        // The malloc_usable_size() function returns the number of usable bytes in the block pointed to by ptr, a pointer to
-        // a block of memory allocated by malloc(3) or a related function.
+        // Set allocation is zero filled and return previous zero filled.
+        bool $malloc_zero_fill_set( void * addr ) {
+          if ( unlikely( addr == 0p ) ) return false;           // null allocation is not zero fill
+                HeapManager.Storage.Header * header = headerAddr( addr );
+                if ( (header->kind.fake.alignment & 1) == 1 ) { // fake header ?
+                        header = realHeader( header );                          // backup from fake to real header
+                } // if
+                bool ret = (header->kind.real.blockSize & 2) != 0; // zero filled ?
+                header->kind.real.blockSize |= 2;                               // mark as zero filled
+                return ret;
+        } // $malloc_zero_fill_set
+
+
+        // Returns original total allocation size (not bucket size) => array size is dimension * sizeif(T).
+        size_t malloc_size( void * addr ) {
+          if ( unlikely( addr == 0p ) ) return false;           // null allocation is not zero fill
+                HeapManager.Storage.Header * header = headerAddr( addr );
+                if ( (header->kind.fake.alignment & 1) == 1 ) { // fake header ?
+                        header = realHeader( header );                          // backup from fake to real header
+                } // if
+                return header->size;
+        } // malloc_size
+
+        // Set allocation size and return previous size.
+        size_t $malloc_size_set( void * addr, size_t size ) {
+          if ( unlikely( addr == 0p ) ) return false;           // null allocation is not zero fill
+                HeapManager.Storage.Header * header = headerAddr( addr );
+                if ( (header->kind.fake.alignment & 1) == 1 ) { // fake header ?
+                        header = realHeader( header );                          // backup from fake to real header
+                } // if
+                size_t ret = header->size;
+                header->size = size;
+                return ret;
+        } // $malloc_size_set
+
+
+        // Returns the number of usable bytes in the block pointed to by ptr, a pointer to a block of memory allocated by
+        // malloc or a related function.
         size_t malloc_usable_size( void * addr ) {
           if ( unlikely( addr == 0p ) ) return 0;                       // null allocation has 0 size
@@ -1009 +1124 @@
 
 
-        // The malloc_stats() function prints (on default standard error) statistics about memory allocated by malloc(3) and
-        // related functions.
+        // Prints (on default standard error) statistics about memory allocated by malloc and related functions.
         void malloc_stats( void ) {
                 #ifdef __STATISTICS__
@@ -1018 +1132 @@
         } // malloc_stats
 
-        // The malloc_stats_fd() function changes the file descripter where malloc_stats() writes the statistics.
+        // Changes the file descripter where malloc_stats() writes statistics.
         int malloc_stats_fd( int fd __attribute__(( unused )) ) {
                 #ifdef __STATISTICS__
@@ -1030 +1144 @@
 
 
-        // The mallopt() function adjusts parameters that control the behavior of the memory-allocation functions (see
-        // malloc(3)). The param argument specifies the parameter to be modified, and value specifies the new value for that
-        // parameter.
+        // Adjusts parameters that control the behaviour of the memory-allocation functions (see malloc). The param argument
+        // specifies the parameter to be modified, and value specifies the new value for that parameter.
         int mallopt( int option, int value ) {
                 choose( option ) {
                   case M_TOP_PAD:
-                        if ( setHeapExpand( value ) ) return 1;
+                        heapExpand = ceiling( value, pageSize ); return 1;
                   case M_MMAP_THRESHOLD:
                         if ( setMmapStart( value ) ) return 1;
+                        break;
                 } // switch
                 return 0;                                                                               // error, unsupported
         } // mallopt
 
-        // The malloc_trim() function attempts to release free memory at the top of the heap (by calling sbrk(2) with a
-        // suitable argument).
+        // Attempt to release free memory at the top of the heap (by calling sbrk with a suitable argument).
         int malloc_trim( size_t ) {
                 return 0;                                                                               // => impossible to release memory
@@ -1050 +1163 @@
 
 
-        // The malloc_info() function exports an XML string that describes the current state of the memory-allocation
-        // implementation in the caller.  The string is printed on the file stream stream.  The exported string includes
-        // information about all arenas (see malloc(3)).
+        // Exports an XML string that describes the current state of the memory-allocation implementation in the caller.
+        // The string is printed on the file stream stream.  The exported string includes information about all arenas (see
+        // malloc).
         int malloc_info( int options, FILE * stream ) {
                 if ( options != 0 ) { errno = EINVAL; return -1; }
@@ -1059 +1172 @@
 
 
-        // The malloc_get_state() function records the current state of all malloc(3) internal bookkeeping variables (but
-        // not the actual contents of the heap or the state of malloc_hook(3) functions pointers).  The state is recorded in
-        // a system-dependent opaque data structure dynamically allocated via malloc(3), and a pointer to that data
-        // structure is returned as the function result.  (It is the caller's responsibility to free(3) this memory.)
+        // Records the current state of all malloc internal bookkeeping variables (but not the actual contents of the heap
+        // or the state of malloc_hook functions pointers).  The state is recorded in a system-dependent opaque data
+        // structure dynamically allocated via malloc, and a pointer to that data structure is returned as the function
+        // result.  (The caller must free this memory.)
         void * malloc_get_state( void ) {
                 return 0p;                                                                              // unsupported
@@ -1068 +1181 @@
 
 
-        // The malloc_set_state() function restores the state of all malloc(3) internal bookkeeping variables to the values
-        // recorded in the opaque data structure pointed to by state.
+        // Restores the state of all malloc internal bookkeeping variables to the values recorded in the opaque data
+        // structure pointed to by state.
         int malloc_set_state( void * ptr ) {
                 return 0;                                                                               // unsupported
@@ -1077 +1190 @@
 
 // Must have CFA linkage to overload with C linkage realloc.
-void * realloc( void * oaddr, size_t nalign, size_t size ) {
+void * resize( void * oaddr, size_t nalign, size_t size ) {
         #ifdef __STATISTICS__
-        __atomic_add_fetch( &realloc_calls, 1, __ATOMIC_SEQ_CST );
+        __atomic_add_fetch( &resize_calls, 1, __ATOMIC_SEQ_CST );
+        __atomic_add_fetch( &resize_storage, size, __ATOMIC_SEQ_CST );
         #endif // __STATISTICS__
 
         // If size is equal to 0, either NULL or a pointer suitable to be passed to free() is returned.
-  if ( unlikely( size == 0 ) ) { free( oaddr ); return mallocNoStats( size ); } // special cases
-  if ( unlikely( oaddr == 0p ) ) return mallocNoStats( size );
+  if ( unlikely( size == 0 ) ) { free( oaddr ); return memalignNoStats( nalign, size ); } // special cases
+  if ( unlikely( oaddr == 0p ) ) return memalignNoStats( nalign, size );
+
 
         if ( unlikely( nalign == 0 ) ) nalign = libAlign();     // reset alignment to minimum
@@ -1095 +1210 @@
         HeapManager.FreeHeader * freeElem;
         size_t bsize, oalign = 0;
-        headers( "realloc", oaddr, header, freeElem, bsize, oalign );
+        headers( "resize", oaddr, header, freeElem, bsize, oalign );
         size_t odsize = dataStorage( bsize, oaddr, header ); // data storage available in bucket
 
-  if ( oalign != 0 && (uintptr_t)oaddr % nalign == 0 ) { // has alignment and just happens to work out
-                headerAddr( oaddr )->kind.fake.alignment = nalign | 1; // update alignment (could be the same)
-                return realloc( oaddr, size );
-        } // if
-
-        #ifdef __STATISTICS__
-        __atomic_add_fetch( &realloc_storage, size, __ATOMIC_SEQ_CST );
-        #endif // __STATISTICS__
-
-        // change size and copy old content to new storage
+        if ( oalign <= nalign && (uintptr_t)oaddr % nalign == 0 ) { // <= alignment and new alignment happens to match
+                if ( oalign >= libAlign() ) {                                   // fake header ?
+                        headerAddr( oaddr )->kind.fake.alignment = nalign | 1; // update alignment (could be the same)
+                } // if
+                if ( size <= odsize && odsize <= size * 2 ) {   // allow 50% wasted storage for smaller size
+                        header->kind.real.blockSize &= -2;                      // turn off 0 fill
+                        return oaddr;
+                } // if
+        } // if
+
+        // change size
 
         void * naddr;
@@ -1116 +1232 @@
         } // if
 
+        free( oaddr );
+        return naddr;
+} // resize
+
+
+void * realloc( void * oaddr, size_t nalign, size_t size ) {
+        if ( unlikely( nalign == 0 ) ) nalign = libAlign();     // reset alignment to minimum
+        #ifdef __CFA_DEBUG__
+        else
+                checkAlign( nalign );                                                   // check alignment
+        #endif // __CFA_DEBUG__
+
+        HeapManager.Storage.Header * header;
+        HeapManager.FreeHeader * freeElem;
+        size_t bsize, oalign = 0;
+        headers( "realloc", oaddr, header, freeElem, bsize, oalign );
+        size_t odsize = dataStorage( bsize, oaddr, header ); // data storage available in bucket
+
+        if ( oalign <= nalign && (uintptr_t)oaddr % nalign == 0 ) { // <= alignment and new alignment happens to match
+                if ( oalign >= libAlign() ) {                                   // fake header ?
+                        headerAddr( oaddr )->kind.fake.alignment = nalign | 1; // update alignment (could be the same)
+                } // if
+                return realloc( oaddr, size );
+        } // if
+
+        // change size and copy old content to new storage
+
+        #ifdef __STATISTICS__
+        __atomic_add_fetch( &realloc_calls, 1, __ATOMIC_SEQ_CST );
+        __atomic_add_fetch( &realloc_storage, size, __ATOMIC_SEQ_CST );
+        #endif // __STATISTICS__
+
+        // If size is equal to 0, either NULL or a pointer suitable to be passed to free() is returned.
+  if ( unlikely( size == 0 ) ) { free( oaddr ); return memalignNoStats( nalign, size ); } // special cases
+  if ( unlikely( oaddr == 0p ) ) return memalignNoStats( nalign, size );
+
+        void * naddr;
+        if ( unlikely( header->kind.real.blockSize & 2 ) ) { // previous request zero fill
+                naddr = cmemalignNoStats( nalign, 1, size );    // create new aligned area
+        } else {
+                naddr = memalignNoStats( nalign, size );                // create new aligned area
+        } // if
+
         headers( "realloc", naddr, header, freeElem, bsize, oalign );
-        size_t ndsize = dataStorage( bsize, naddr, header ); // data storage avilable in bucket
+        size_t ndsize = dataStorage( bsize, naddr, header ); // data storage available in bucket
         // To preserve prior fill, the entire bucket must be copied versus the size.
         memcpy( naddr, oaddr, MIN( odsize, ndsize ) );          // copy bytes

libcfa/src/interpose.cfa

@@ -10 +10 @@
 // Created On       : Wed Mar 29 16:10:31 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Feb 17 10:18:53 2020
-// Update Count     : 166
+// Last Modified On : Fri Mar 13 17:35:37 2020
+// Update Count     : 178
 //
 
 #include <stdarg.h>                                                                             // va_start, va_end
+#include <stdio.h>
 #include <string.h>                                                                             // strlen
 #include <unistd.h>                                                                             // _exit, getpid
@@ -143 +144 @@
 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( bool signalAbort, const char fmt[], va_list args ) __attribute__(( __nothrow__, __leaf__, __noreturn__ ));
 
 extern "C" {
@@ -152 +154 @@
                 va_list argp;
                 va_start( argp, fmt );
-                abort( false, fmt, argp );
+                __abort( false, fmt, argp );
                 va_end( argp );
         }
@@ -218 +220 @@
 }
 
-void abort( bool signalAbort, const char fmt[], ... ) {
+// Cannot forward va_list.
+void __abort( bool signalAbort, const char fmt[], va_list args ) {
         void * kernel_data = kernel_abort();                            // must be done here to lock down kernel
         int len;
@@ -228 +231 @@
 
         assert( fmt );
-        va_list args;
-        va_start( args, fmt );
-
         len = vsnprintf( abort_text, abort_text_size, fmt, args );
-        va_end( args );
         __cfaabi_bits_write( STDERR_FILENO, abort_text, len );
 
         if ( fmt[strlen( fmt ) - 1] != '\n' ) {                         // add optional newline if missing at the end of the format text
-                __cfaabi_dbg_write( "\n", 1 );
+                __cfaabi_bits_write( STDERR_FILENO, "\n", 1 );
         } // if
         kernel_abort_msg( kernel_data, abort_text, abort_text_size );
@@ -248 +247 @@
         va_list args;
         va_start( args, fmt );
-        abort( false, fmt, args );
+        __abort( false, fmt, args );
+    // CONTROL NEVER REACHES HERE!
         va_end( args );
+}
+
+void abort( bool signalAbort, const char fmt[], ... ) {
+    va_list args;
+    va_start( args, fmt );
+    __abort( signalAbort, fmt, args );
+    // CONTROL NEVER REACHES HERE!
+    va_end( args );
 }
 

libcfa/src/iostream.cfa

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Feb 20 15:53:23 2020
-// Update Count     : 829
+// Last Modified On : Sat May  2 18:30:25 2020
+// Update Count     : 1017
 //
 
@@ -29 +29 @@
 #include <complex.h>                                                                    // creal, cimag
 } // extern "C"
+
+#include <bitmanip.hfa>                                                                 // fms
 
 
@@ -459 +461 @@
 \
                 if ( f.base == 'b' || f.base == 'B' ) {                 /* bespoke binary format */ \
-                        int bits;                                                                                                       \
-                        if ( f.val == (T){0} ) bits = 1;                        /* force at least one bit to print */ \
-                        else bits = sizeof(long long int) * 8 - __builtin_clzll( f.val ); /* position of most significant bit */ \
-                        bits = bits > sizeof(f.val) * 8 ? sizeof(f.val) * 8 : bits; \
-                        int spaces = f.wd - bits;                                       /* can be negative */ \
-                        if ( ! f.flags.nobsdp ) { spaces -= 2; }        /* base prefix takes space */ \
-                        /* printf( "%d %d\n", bits, spaces ); */ \
+                        int bits = high1( f.val );                                      /* position of most significant bit */ \
+                        if ( bits == 0 ) bits = 1;                                      /* 0 value => force one bit to print */ \
+                        int spaces; \
                         if ( ! f.flags.left ) {                                         /* right justified ? */ \
                                 /* Note, base prefix then zero padding or spacing then prefix. */ \
-                                if ( f.flags.pad0 || f.flags.pc ) { \
+                                if ( f.flags.pc ) { \
+                                        spaces = f.wd - f.pc; \
+                                        if ( ! f.flags.nobsdp ) { spaces -= 2; } /* base prefix takes space */ \
+                                        if ( spaces > 0 ) fmt( os, "%*s", spaces, " " ); /* space pad */ \
                                         if ( ! f.flags.nobsdp ) { fmt( os, "0%c", f.base ); } \
-                                        if ( f.flags.pc ) spaces = f.pc - bits; \
+                                        spaces = f.pc - bits; \
                                         if ( spaces > 0 ) fmt( os, "%0*d", spaces, 0 ); /* zero pad */ \
                                 } else { \
-                                        if ( spaces > 0 ) fmt( os, "%*s", spaces, " " ); /* space pad */ \
-                                        if ( ! f.flags.nobsdp ) { fmt( os, "0%c", f.base ); } \
+                                        spaces = f.wd - bits; \
+                                        if ( ! f.flags.nobsdp ) { spaces -= 2; } /* base prefix takes space */ \
+                                        if ( f.flags.pad0 ) { \
+                                                if ( ! f.flags.nobsdp ) { fmt( os, "0%c", f.base ); } \
+                                                if ( spaces > 0 ) fmt( os, "%0*d", spaces, 0 ); /* zero pad */ \
+                                        } else { \
+                                                if ( spaces > 0 ) fmt( os, "%*s", spaces, " " ); /* space pad */ \
+                                                if ( ! f.flags.nobsdp ) { fmt( os, "0%c", f.base ); } \
+                                        } /* if */ \
                                 } /* if */ \
-                        } else if ( ! f.flags.nobsdp ) { \
-                                fmt( os, "0%c", f.base ); \
+                        } else { \
+                                if ( ! f.flags.nobsdp ) fmt( os, "0%c", f.base ); \
+                                if ( f.flags.pc ) { \
+                                        spaces = f.pc - bits; \
+                                        if ( spaces > 0 ) fmt( os, "%0*d", spaces, 0 ); /* zero pad */ \
+                                        spaces = f.wd - f.pc; \
+                                } else { /* pad0 flag ignored with left flag */ \
+                                        spaces = f.wd - bits; \
+                                } /* if */ \
+                                if ( ! f.flags.nobsdp ) { spaces -= 2; } /* base prefix takes space */ \
                         } /* if */ \
-                        int shift = (bits - 1) / 4 * 4; /* floor( bits - 1, 4 ) */ \
+                        int shift = floor( bits - 1, 4 ); \
                         typeof( f.val ) temp = f.val; \
                         fmt( os, "%s", shortbin[(temp >> shift) & 0xf] ); \
@@ -534 +550 @@
 #define IntegralFMTImpl128( T, SIGNED, CODE, IFMTNP, IFMTP ) \
 forall( dtype ostype | ostream( ostype ) ) \
-static void base10_128( ostype & os, _Ostream_Manip(T) fmt ) { \
-        if ( fmt.val > UINT64_MAX ) { \
-                fmt.val /= P10_UINT64; \
-                base10_128( os, fmt ); /* recursive */ \
-                _Ostream_Manip(unsigned long long int) fmt2 @= { (uint64_t)(fmt.val % P10_UINT64), 0, 19, 'u', { .all : 0 } }; \
-                fmt2.flags.nobsdp = true; \
-                printf( "fmt2 %c %lld %d\n", fmt2.base, fmt2.val, fmt2.all );   \
+static void base10_128( ostype & os, _Ostream_Manip(T) f ) { \
+        if ( f.val > UINT64_MAX ) { \
+                unsigned long long int lsig = f.val % P10_UINT64; \
+                f.val /= P10_UINT64; /* msig */ \
+                base10_128( os, f ); /* recursion */ \
+                _Ostream_Manip(unsigned long long int) fmt @= { lsig, 0, 19, 'u', { .all : 0 } }; \
+                fmt.flags.nobsdp = true; \
+                /* printf( "fmt1 %c %lld %d\n", fmt.base, fmt.val, fmt.all ); */ \
                 sepOff( os ); \
-                (ostype &)(os | fmt2); \
+                (ostype &)(os | fmt); \
         } else { \
-                printf( "fmt %c %lld %d\n", fmt.base, fmt.val, fmt.all ); \
+                /* printf( "fmt2 %c %lld %d\n", f.base, (unsigned long long int)f.val, f.all ); */ \
+                _Ostream_Manip(SIGNED long long int) fmt @= { (SIGNED long long int)f.val, f.wd, f.pc, f.base, { .all : f.all } }; \
                 (ostype &)(os | fmt); \
         } /* if */ \
-} /* base10_128 */                                                 \
+} /* base10_128 */ \
 forall( dtype ostype | ostream( ostype ) ) { \
         ostype & ?|?( ostype & os, _Ostream_Manip(T) f ) { \
                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); \
 \
-                if ( f.base == 'b' | f.base == 'o' | f.base == 'x' | f.base == 'X' ) { \
+                if ( f.base == 'b' | f.base == 'B' | f.base == 'o' | f.base == 'x' | f.base == 'X' ) { \
                         unsigned long long int msig = (unsigned long long int)(f.val >> 64); \
                         unsigned long long int lsig = (unsigned long long int)(f.val); \
@@ -562 +580 @@
                         } else { \
                                 fmt2.flags.pad0 = fmt2.flags.nobsdp = true;     \
-                                if ( f.base == 'b' ) { \
-                                        if ( f.wd > 64 ) fmt.wd = f.wd - 64; \
-                                        fmt2.wd = 64; \
+                                if ( f.base == 'b' | f.base == 'B' ) { \
+                                        if ( fmt.flags.pc && fmt.pc > 64 ) fmt.pc -= 64; else { fmt.flags.pc = false; fmt.pc = 0; } \
+                                        if ( fmt.flags.left ) { \
+                                                fmt.flags.left = false; \
+                                                fmt.wd = 0; \
+                                                /* printf( "L %llo %llo %llo %d %d '%c' %x\n", msig, lsig, fmt.val, fmt.wd, fmt.pc, fmt.base, fmt.all ); */ \
+                                                fmt2.flags.left = true; \
+                                                int msigd = high1( msig ); \
+                                                fmt2.wd = f.wd - (fmt.pc > msigd ? fmt.pc : msigd); \
+                                                if ( ! fmt.flags.nobsdp ) fmt2.wd -= 2; /* compensate for 0b base specifier */ \
+                                                if ( (int)fmt2.wd < 64 ) fmt2.wd = 64; /* cast deals with negative value */ \
+                                                fmt2.flags.pc = true; fmt2.pc = 64; \
+                                        } else { \
+                                                if ( fmt.wd > 64 ) fmt.wd -= 64; \
+                                                else fmt.wd = 1; \
+                                                /* printf( "R %llo %llo %llo %d %d '%c' %x\n", msig, lsig, fmt.val, fmt.wd, fmt.pc, fmt.base, fmt.all ); */ \
+                                                fmt2.wd = 64; \
+                                        } /* if */ \
+                                        /* printf( "C %llo %d %d '%c' %x\n", fmt2.val, fmt2.wd, fmt2.pc, fmt2.base, fmt2.all ); */ \
                                         (ostype &)(os | fmt | "" | fmt2); \
                                 } else if ( f.base == 'o' ) { \
+                                        if ( fmt.flags.pc && fmt.pc > 22 ) fmt.pc -= 22; else { fmt.flags.pc = false; fmt.pc = 0; } \
                                         fmt.val = (unsigned long long int)fmt.val >> 2; \
-                                        if ( f.wd > 21 ) fmt.wd = f.wd - 21; \
-                                        fmt2.wd = 1; \
-                                        fmt2.val = ((msig & 0x3) << 1) + 1; \
-                                        (ostype &)(os | fmt | "" | fmt2); \
-                                        sepOff( os ); \
-                                        fmt2.wd = 21; \
-                                        fmt2.val = lsig & 0x7fffffffffffffff; \
+                                        fmt2.val = ((msig & 0x3) << 1) + ((lsig & 0x8000000000000000U) != 0); \
+                                        if ( fmt.flags.left ) { \
+                                                fmt.flags.left = false; \
+                                                fmt.wd = 0; \
+                                                /* printf( "L %llo %llo %llo %d %d '%c' %x %llo %d %d '%c' %x\n", msig, lsig, fmt.val, fmt.wd, fmt.pc, fmt.base, fmt.all, fmt2.val, fmt2.wd, fmt2.pc, fmt2.base, fmt2.all ); */ \
+                                                (ostype &)(os | fmt | "" | fmt2); \
+                                                sepOff( os ); \
+                                                fmt2.flags.left = true; \
+                                                int msigd = ceiling( high1( fmt.val ), 3 ); \
+                                                fmt2.wd = f.wd - (fmt.pc > msigd ? fmt.pc : msigd); \
+                                                if ( ! fmt.flags.nobsdp ) fmt2.wd -= 1; /* compensate for 0 base specifier */ \
+                                                if ( (int)fmt2.wd < 21 ) fmt2.wd = 21; /* cast deals with negative value */ \
+                                                fmt2.flags.pc = true; fmt2.pc = 21; \
+                                        } else { \
+                                                if ( fmt.wd > 22 ) fmt.wd -= 22; \
+                                                else fmt.wd = 1; \
+                                                /* printf( "R %llo %llo %llo %d %d '%c' %x %llo %d %d '%c' %x\n", msig, lsig, fmt.val, fmt.wd, fmt.pc, fmt.base, fmt.all, fmt2.val, fmt2.wd, fmt2.pc, fmt2.base, fmt2.all ); */ \
+                                                (ostype &)(os | fmt | "" | fmt2); \
+                                                sepOff( os ); \
+                                                fmt2.wd = 21; \
+                                        } /* if */ \
+                                        fmt2.val = lsig & 0x7fffffffffffffffU; \
+                                        /* printf( "\nC %llo %d %d '%c' %x\n", fmt2.val, fmt2.wd, fmt2.pc, fmt2.base, fmt2.all ); */ \
                                         (ostype &)(os | fmt2); \
-                                } else { \
-                                        if ( f.flags.left ) { \
-                                                if ( f.wd > 16 ) fmt2.wd = f.wd - 16;   \
-                                                fmt.wd = 16;                                                    \
+                                } else { /* f.base == 'x'  | f.base == 'X' */ \
+                                        if ( fmt.flags.pc && fmt.pc > 16 ) fmt.pc -= 16; else { fmt.flags.pc = false; fmt.pc = 0; } \
+                                        if ( fmt.flags.left ) { \
+                                                fmt.flags.left = false; \
+                                                fmt.wd = 0; \
+                                                /* printf( "L %llo %llo %llo %d %d '%c' %x\n", msig, lsig, fmt.val, fmt.wd, fmt.pc, fmt.base, fmt.all ); */ \
+                                                fmt2.flags.left = true; \
+                                                int msigd = high1( msig ); \
+                                                fmt2.wd = f.wd - (fmt.pc > msigd ? fmt.pc : msigd); \
+                                                if ( ! fmt.flags.nobsdp ) fmt2.wd -= 2; /* compensate for 0x base specifier */ \
+                                                if ( (int)fmt2.wd < 16 ) fmt2.wd = 16; /* cast deals with negative value */ \
+                                                fmt2.flags.pc = true; fmt2.pc = 16; \
                                         } else { \
-                                                if ( f.wd > 16 ) fmt.wd = f.wd - 16;    \
-                                                fmt2.wd = 16;                                                   \
+                                                if ( fmt.wd > 16 ) fmt.wd -= 16; \
+                                                else fmt.wd = 1; \
+                                                /* printf( "R %llo %llo %llo %d %d '%c' %x\n", msig, lsig, fmt.val, fmt.wd, fmt.pc, fmt.base, fmt.all ); */ \
+                                                fmt2.wd = 16; \
                                         } /* if */ \
+                                        /* printf( "C %llo %d %d '%c' %x\n", fmt2.val, fmt2.wd, fmt2.pc, fmt2.base, fmt2.all ); */ \
                                         (ostype &)(os | fmt | "" | fmt2); \
                                 } /* if */ \
                         } /* if */ \
                 } else { \
+                        if ( CODE == 'd' ) { \
+                                if ( f.val < 0 )  { fmt( os, "-" ); sepOff( os ); f.val = -f.val; f.flags.sign = false; } \
+                        } /* if */ \
                         base10_128( os, f ); \
                 } /* if */ \

libcfa/src/startup.cfa

@@ -14 +14 @@
 //
 
-#include <time.h>                                                                               // tzset
+#include <time.h>                // tzset
+#include <locale.h>        // setlocale
 #include "startup.hfa"
 
@@ -21 +22 @@
     void __cfaabi_appready_startup( void ) {
                 tzset();                                                                                // initialize time global variables
+                setlocale(LC_NUMERIC, "");
                 #ifdef __CFA_DEBUG__
                 extern void heapAppStart();
@@ -41 +43 @@
 struct __spinlock_t;
 extern "C" {
-        void __cfaabi_dbg_record(struct __spinlock_t & this, const char prev_name[]) __attribute__(( weak )) {}
+        void __cfaabi_dbg_record_lock(struct __spinlock_t & this, const char prev_name[]) __attribute__(( weak )) {}
 }
 

libcfa/src/stdhdr/malloc.h

@@ -10 +10 @@
 // Created On       : Thu Jul 20 15:58:16 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Aug 11 09:06:31 2018
-// Update Count     : 10
+// Last Modified On : Thu Apr 16 22:44:06 2020
+// Update Count     : 13
 // 
 
@@ -31 +31 @@
 
 extern "C" {
+void * aalloc( size_t noOfElems, size_t elemSize );
+void * amemalign( size_t alignment, size_t noOfElems, size_t elemSize );
+void * cmemalign( size_t alignment, size_t noOfElems, size_t elemSize );
 size_t malloc_alignment( void * );
 bool malloc_zero_fill( void * );
+size_t malloc_size( void * );
 int malloc_stats_fd( int fd );
-void * cmemalign( size_t alignment, size_t noOfElems, size_t elemSize );
 } // extern "C"
 

libcfa/src/stdlib.cfa

@@ -10 +10 @@
 // Created On       : Thu Jan 28 17:10:29 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Feb  4 08:27:08 2020
-// Update Count     : 486
+// Last Modified On : Thu Apr 16 22:43:33 2020
+// Update Count     : 498
 //
 
@@ -20 +20 @@
 #define _XOPEN_SOURCE 600                                                               // posix_memalign, *rand48
 #include <string.h>                                                                             // memcpy, memset
-#include <malloc.h>                                                                             // malloc_usable_size
 //#include <math.h>                                                                             // fabsf, fabs, fabsl
 #include <complex.h>                                                                    // _Complex_I
@@ -38 +37 @@
         } // alloc_set
 
+        T * alloc_set( T ptr[], size_t dim, T fill ) {          // realloc array with fill
+                size_t olen = malloc_usable_size( ptr );                // current allocation
+                void * nptr = (void *)realloc( (void *)ptr, dim * sizeof(T) ); // C realloc
+                size_t nlen = malloc_usable_size( nptr );               // new allocation
+                if ( nlen > olen ) {                                                    // larger ?
+                        for ( i; malloc_size( ptr ) / sizeof(T) ~ dim ) {
+                                memcpy( &ptr[i], &fill, sizeof(T) );    // initialize with fill value
+                        } // for
+                } // if
+                return (T *)nptr;
+        } // alloc_align_set
+
         T * alloc_align_set( T ptr[], size_t align, char fill ) { // aligned realloc with fill
                 size_t olen = malloc_usable_size( ptr );                // current allocation
@@ -45 +56 @@
                 if ( nlen > olen ) {                                                    // larger ?
                         memset( (char *)nptr + olen, (int)fill, nlen - olen ); // initialize added storage
+                } // if
+                return (T *)nptr;
+        } // alloc_align_set
+
+        T * alloc_align_set( T ptr[], size_t align, size_t dim, T fill ) { // aligned realloc with fill
+                size_t olen = malloc_usable_size( ptr );                // current allocation
+                void * nptr = (void *)realloc( (void *)ptr, align, sizeof(T) ); // CFA realloc
+                // char * nptr = alloc_align( ptr, align );
+                size_t nlen = malloc_usable_size( nptr );               // new allocation
+                if ( nlen > olen ) {                                                    // larger ?
+                        for ( i; dim ) { memcpy( &ptr[i], &fill, sizeof(T) ); } // initialize with fill value
                 } // if
                 return (T *)nptr;

libcfa/src/stdlib.hfa

@@ -10 +10 @@
 // Created On       : Thu Jan 28 17:12:35 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Feb  4 08:27:01 2020
-// Update Count     : 401
+// Last Modified On : Thu Apr 16 22:44:05 2020
+// Update Count     : 432
 //
 
@@ -21 +21 @@
 #include <stdlib.h>                                                                             // *alloc, strto*, ato*
 
+// Reduce includes by explicitly defining these routines.
 extern "C" {
         void * memalign( size_t align, size_t size );           // malloc.h
+        size_t malloc_usable_size( void * ptr );                        // malloc.h
+        size_t malloc_size( void * addr );                                      // CFA heap
+        void * cmemalign( size_t alignment, size_t noOfElems, size_t elemSize ); // CFA heap
         void * memset( void * dest, int fill, size_t size ); // string.h
         void * memcpy( void * dest, const void * src, size_t size ); // string.h
-    void * cmemalign( size_t alignment, size_t noOfElems, size_t elemSize ); // CFA heap
+        void * resize( void * oaddr, size_t size );                     // CFA heap
 } // extern "C"
 
+void * resize( void * oaddr, size_t nalign, size_t size ); // CFA heap
 void * realloc( void * oaddr, size_t nalign, size_t size ); // CFA heap
 
@@ -40 +45 @@
 
 static inline forall( dtype T | sized(T) ) {
-        // C dynamic allocation
+        // Cforall safe equivalents, i.e., implicit size specification
 
         T * malloc( void ) {
@@ -71 +76 @@
                 return posix_memalign( (void **)ptr, align, sizeof(T) ); // C posix_memalign
         } // posix_memalign
-
-        // Cforall dynamic allocation
+} // distribution
+
+static inline forall( dtype T | sized(T) ) {
+        // Cforall safe general allocation, fill, resize, array
 
         T * alloc( void ) {
@@ -83 +90 @@
         } // alloc
 
-        T * alloc( T ptr[], size_t dim ) {                                      // realloc
-                return (T *)(void *)realloc( (void *)ptr, dim * sizeof(T) ); // C realloc
+        forall( dtype S | sized(S) )
+        T * alloc( S ptr[], size_t dim = 1 ) {                          // singleton/array resize
+                size_t len = malloc_usable_size( ptr );                 // current bucket size
+                if ( sizeof(T) * dim > len ) {                                  // not enough space ?
+                        T * temp = alloc( dim );                                        // new storage
+                        free( ptr );                                                            // free old storage
+                        return temp;
+                } else {
+                        return (T *)ptr;
+                } // if
+        } // alloc
+
+        T * alloc( T ptr[], size_t dim, bool copy = true ) {
+                if ( copy ) {                                                                   // realloc
+                        return (T *)(void *)realloc( (void *)ptr, dim * sizeof(T) ); // C realloc
+                } else {
+                        struct __Unknown {};
+                        return alloc( (__Unknown *)ptr, dim );          // reuse, cheat making T/S different types
+                } // if
         } // alloc
 
@@ -112 +136 @@
 forall( dtype T | sized(T) ) {
         T * alloc_set( T ptr[], size_t dim, char fill );        // realloc array with fill
+        T * alloc_set( T ptr[], size_t dim, T fill );           // realloc array with fill
 } // distribution
 
@@ -125 +150 @@
         T * alloc_align( T ptr[], size_t align ) {                      // aligned realloc array
                 return (T *)(void *)realloc( (void *)ptr, align, sizeof(T) ); // CFA realloc
+        } // alloc_align
+
+        forall( dtype S | sized(S) )
+        T * alloc_align( S ptr[], size_t align ) {                      // aligned reuse array
+                return (T *)(void *)resize( (void *)ptr, align, sizeof(T) ); // CFA realloc
         } // alloc_align
 
@@ -155 +185 @@
 
 forall( dtype T | sized(T) ) {
+        T * alloc_align_set( T ptr[], size_t align, char fill ); // aligned realloc with fill
+        T * alloc_align_set( T ptr[], size_t align, T fill ); // aligned realloc with fill
         T * alloc_align_set( T ptr[], size_t align, size_t dim, char fill ); // aligned realloc array with fill
-} // distribution
-
-static inline forall( dtype T | sized(T) ) {
-        // data, non-array types
+        T * alloc_align_set( T ptr[], size_t align, size_t dim, T fill ); // aligned realloc array with fill
+} // distribution
+
+static inline forall( dtype T | sized(T) ) {
+        // Cforall safe initialization/copy, i.e., implicit size specification, non-array types
         T * memset( T * dest, char fill ) {
                 return (T *)memset( dest, fill, sizeof(T) );
@@ -170 +203 @@
 
 static inline forall( dtype T | sized(T) ) {
-        // data, array types
+        // Cforall safe initialization/copy, i.e., implicit size specification, array types
         T * amemset( T dest[], char fill, size_t dim ) {
                 return (T *)(void *)memset( dest, fill, dim * sizeof(T) ); // C memset
@@ -180 +213 @@
 } // distribution
 
-// allocation/deallocation and constructor/destructor, non-array types
+// Cforall allocation/deallocation and constructor/destructor, non-array types
 forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } ) T * new( Params p );
 forall( dtype T | sized(T) | { void ^?{}( T & ); } ) void delete( T * ptr );
 forall( dtype T, ttype Params | sized(T) | { void ^?{}( T & ); void delete( Params ); } ) void delete( T * ptr, Params rest );
 
-// allocation/deallocation and constructor/destructor, array types
+// Cforall allocation/deallocation and constructor/destructor, array types
 forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } ) T * anew( size_t dim, Params p );
 forall( dtype T | sized(T) | { void ^?{}( T & ); } ) void adelete( size_t dim, T arr[] );