Diff [949339bcf1a4b73094f56400ac11f28f3946ade1:4e28d2e987926b6958f35e9bd29cb40aa0e5348d] for / – Cforall

benchmark/Cargo.toml.in

-              r949339b
+              r4e28d2e9
 [[bin]]
 name = "rdq-cycle-tokio"
+name = "cycle-tokio"
 path = "@abs_srcdir@/readyQ/cycle.rs"
 [[bin]]
 name = "rdq-locality-tokio"
+name = "locality-tokio"
 path = "@abs_srcdir@/readyQ/locality.rs"
-[[bin]]
-name = "rdq-transfer-tokio"
-path = "@abs_srcdir@/readyQ/transfer.rs"
-[[bin]]
-name = "rdq-yield-tokio"
-path = "@abs_srcdir@/readyQ/yield.rs"
 [features]

benchmark/Makefile.am

-              r949339b
+              r4e28d2e9
 include $(top_srcdir)/tools/build/cfa.make
 AM_CFLAGS = -O3 -Wall -Wextra -I$(srcdir) -lrt -pthread # -Werror
+AM_CFLAGS = -O2 -Wall -Wextra -I$(srcdir) -lrt -pthread # -Werror
 AM_CFAFLAGS = -quiet -nodebug
 AM_UPPFLAGS = -quiet -nodebug -multi -std=c++14
 …
         $(srcdir)/fixcsv.sh $@
-# use --no-print-directory to generate csv appropriately
-mutexStmt.csv:
-        echo "building $@"
-        echo "1-lock,2-lock,4-lock,8-lock,1-no-stmt-lock,2-no-stmt-lock,4-no-stmt-lock,8-no-stmt-lock,1-monitor,2-monitor,4-monitor" > $@
-        +make mutexStmt-lock1.runquiet >> $@ && echo -n ',' >> $@
-        +make mutexStmt-lock2.runquiet >> $@ && echo -n ',' >> $@
-        +make mutexStmt-lock4.runquiet >> $@ && echo -n ',' >> $@
-        +make mutexStmt-lock8.runquiet >> $@ && echo -n ',' >> $@
-        +make mutexStmt-no-stmt-lock1.runquiet >> $@ && echo -n ',' >> $@
-        +make mutexStmt-no-stmt-lock2.runquiet >> $@ && echo -n ',' >> $@
-        +make mutexStmt-no-stmt-lock4.runquiet >> $@ && echo -n ',' >> $@
-        +make mutexStmt-no-stmt-lock8.runquiet >> $@ && echo -n ',' >> $@
-        +make mutexStmt-monitor1.runquiet >> $@ && echo -n ',' >> $@
-        +make mutexStmt-monitor2.runquiet >> $@ && echo -n ',' >> $@
-        +make mutexStmt-monitor4.runquiet >> $@
-        $(srcdir)/fixcsv.sh $@
 schedint.csv:
         echo "building $@"
 …
 ## =========================================================================================================
-mutexStmt$(EXEEXT) :                \
-        mutexStmt-cpp1.run                      \
-        mutexStmt-cpp2.run                      \
-        mutexStmt-cpp4.run                      \
-        mutexStmt-cpp8.run                      \
-        mutexStmt-java.run                      \
-        mutexStmt-lock1.run                 \
-        mutexStmt-lock2.run                 \
-        mutexStmt-lock4.run                 \
-        mutexStmt-lock8.run                 \
-        mutexStmt-no-stmt-lock1.run \
-        mutexStmt-no-stmt-lock2.run \
-        mutexStmt-no-stmt-lock4.run \
-        mutexStmt-no-stmt-lock8.run \
-        mutexStmt-monitor1.run      \
-        mutexStmt-monitor2.run      \
-        mutexStmt-monitor4.run
-mutexStmt-lock1$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/mutexStmt/lock1.cfa
-mutexStmt-lock2$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/mutexStmt/lock2.cfa
-mutexStmt-lock4$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/mutexStmt/lock4.cfa
-mutexStmt-lock8$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/mutexStmt/lock8.cfa
-mutexStmt-cpp1$(EXEEXT):
-        $(BENCH_V_CXX)$(CXXCOMPILE) -std=c++17 $(srcdir)/mutexStmt/cpp1.cc
-mutexStmt-cpp2$(EXEEXT):
-        $(BENCH_V_CXX)$(CXXCOMPILE) -std=c++17 $(srcdir)/mutexStmt/cpp2.cc
-mutexStmt-cpp4$(EXEEXT):
-        $(BENCH_V_CXX)$(CXXCOMPILE) -std=c++17 $(srcdir)/mutexStmt/cpp4.cc
-mutexStmt-cpp8$(EXEEXT):
-        $(BENCH_V_CXX)$(CXXCOMPILE) -std=c++17 $(srcdir)/mutexStmt/cpp8.cc
-mutexStmt-monitor1$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/mutexStmt/monitor1.cfa
-mutexStmt-monitor2$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/mutexStmt/monitor2.cfa
-mutexStmt-monitor4$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/mutexStmt/monitor4.cfa
-mutexStmt-no-stmt-lock1$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/mutexStmt/no_stmt_lock1.cfa
-mutexStmt-no-stmt-lock2$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/mutexStmt/no_stmt_lock2.cfa
-mutexStmt-no-stmt-lock4$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/mutexStmt/no_stmt_lock4.cfa
-mutexStmt-no-stmt-lock8$(EXEEXT):
-        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/mutexStmt/no_stmt_lock8.cfa
-mutexStmt-java$(EXEEXT):
-        $(BENCH_V_JAVAC)javac -d $(builddir) $(srcdir)/mutexStmt/JavaThread.java
-        echo "#!/bin/sh" > a.out
-        echo "java JavaThread \"$$""@\"" >> a.out
-        chmod a+x a.out
-## =========================================================================================================
 schedint$(EXEEXT) :             \
         schedint-cfa1.run       \
 …
 ## =========================================================================================================
+RDQBENCHES = \
+        rdq-cycle-cfa \
+        rdq-cycle-tokio \
+        rdq-cycle-go \
+        rdq-cycle-fibre \
+        rdq-yield-cfa \
+        rdq-yield-tokio \
+        rdq-yield-go \
+        rdq-yield-fibre \
+        rdq-locality-cfa \
+        rdq-locality-tokio \
+        rdq-locality-go \
+        rdq-locality-fibre \
+        rdq-transfer-cfa \
+        rdq-transfer-tokio \
+        rdq-transfer-go \
+        rdq-transfer-fibre
+rdq-benches:
+        +make $(RDQBENCHES)
+clean-rdq-benches:
+        rm -rf $(RDQBENCHES) $(builddir)/target go.mod
+rdq-%-tokio$(EXEEXT): $(builddir)/target/release/rdq-%-tokio$(EXEEXT)
+        $(BENCH_V_RUSTC)cp $(builddir)/target/release/$(basename $@) $@
+$(builddir)/target/release/rdq-%-tokio$(EXEEXT): $(srcdir)/readyQ/%.rs $(srcdir)/bench.rs
+        $(BENCH_V_RUSTC)cd $(builddir) && cargo build --release
+rdq-%-cfa$(EXEEXT): $(srcdir)/readyQ/%.cfa $(srcdir)/readyQ/rq_bench.hfa
+        $(BENCH_V_CFA)$(CFACOMPILE) $< -o $@
+go.mod:
+        touch $@
+        go mod edit -module=rdq.bench
+        go get golang.org/x/sync/semaphore
+        go get golang.org/x/text/language
+        go get golang.org/x/text/message
+rdq-%-go$(EXEEXT): $(srcdir)/readyQ/%.go $(srcdir)/readyQ/bench.go go.mod
+        $(BENCH_V_GOC)go build -o $@ $< $(srcdir)/readyQ/bench.go
+rdq-%-fibre$(EXEEXT): $(srcdir)/readyQ/%.cpp
+        $(BENCH_V_CXX)$(CXXCOMPILE) $< -o $@ -lfibre -std=c++17 $(AM_CFLAGS)
+# ## =========================================================================================================
+CLEANFILES = $(RDQBENCHES) go.mod go.sum
+clean-local:
+        -rm -rf target
+%-tokio$(EXEEXT): $(srcdir)/readyQ/%.rs $(srcdir)/bench.rs
+        cd $(builddir) && cargo build --release
+        cp $(builddir)/target/release/$(basename $@) $@

benchmark/bench.h

-              r949339b
+              r4e28d2e9
         return 1000000000LL * ts.tv_sec + ts.tv_nsec;
 } // bench_time
-#if defined(__cforall)
-struct test_spinlock {
-        volatile bool lock;
-};
-static inline void lock( test_spinlock & this ) {
-        for ( ;; ) {
-                if ( (this.lock == 0) && (__atomic_test_and_set( &this.lock, __ATOMIC_ACQUIRE ) == 0) ) break;
+        }
+}
-static inline void unlock( test_spinlock & this ) {
-        __atomic_clear( &this.lock, __ATOMIC_RELEASE );
+}
-#endif
 #ifndef BENCH_N

benchmark/bench.rs

-              r949339b
+              r4e28d2e9
 use std::io::{self, Write};
-use std::option;
 use std::sync::atomic::{AtomicU64, AtomicBool, Ordering};
 use std::time::{Instant,Duration};
-use std::u128;
 use clap::{Arg, ArgMatches};
 …
 impl BenchData {
         pub fn new(options: ArgMatches, nthreads: usize, default_it: option::Option<u64>) -> BenchData {
+        pub fn new(options: ArgMatches, nthreads: usize) -> BenchData {
                 let (clock_mode, stop_count, duration) = if options.is_present("iterations") {
                         (false,
                         options.value_of("iterations").unwrap().parse::<u64>().unwrap(),
-                        -1.0)
-                } else if !default_it.is_none() {
-                        (false,
-                        default_it.unwrap(),
                         -1.0)
                 } else {
 …
+        }
-        #[allow(dead_code)]
         pub async fn wait(&self, start: &Instant) -> Duration{
                 loop {
 …
+}
-// ==================================================
-pub fn _lehmer64( state: &mut u128 ) -> u64 {
-        *state = state.wrapping_mul(0xda942042e4dd58b5);
-        return (*state >> 64) as u64;
+}

benchmark/readyQ/cycle.cpp

-              r949339b
+              r4e28d2e9
                         Fibre * threads[tthreads];
                         Partner thddata[tthreads];
                         for(unsigned i = 0; i < tthreads; i++) {
+                        for(int i = 0; i < tthreads; i++) {
                                 unsigned pi = (i + nthreads) % tthreads;
                                 thddata[i].next = &thddata[pi].self;
+                        }
                         for(unsigned i = 0; i < tthreads; i++) {
+                        for(int i = 0; i < tthreads; i++) {
                                 threads[i] = new Fibre( reinterpret_cast<void (*)(void *)>(partner_main), &thddata[i] );
+                        }
 …
                         start = timeHiRes();
                         for(unsigned i = 0; i < nthreads; i++) {
+                        for(int i = 0; i < nthreads; i++) {
                                 thddata[i].self.post();
+                        }
 …
                         printf("\nDone\n");
                         for(unsigned i = 0; i < tthreads; i++) {
+                        for(int i = 0; i < tthreads; i++) {
                                 thddata[i].self.post();
                                 fibre_join( threads[i], nullptr );

benchmark/readyQ/cycle.go

-              r949339b
+              r4e28d2e9
         atomic.StoreInt32(&stop, 1)
         end := time.Now()
         duration := end.Sub(start)
+        delta := end.Sub(start)
         fmt.Printf("\nDone\n")
 …
         p := message.NewPrinter(language.English)
         p.Printf("Duration (ms)        : %d\n", duration.Milliseconds())
+        p.Printf("Duration (ms)        : %f\n", delta.Seconds());
         p.Printf("Number of processors : %d\n", nprocs);
         p.Printf("Number of threads    : %d\n", tthreads);
         p.Printf("Cycle size (# thrds) : %d\n", ring_size);
         p.Printf("Total Operations(ops): %15d\n", global_counter)
         p.Printf("Ops per second       : %18.2f\n", float64(global_counter) / duration.Seconds())
         p.Printf("ns per ops           : %18.2f\n", float64(duration.Nanoseconds()) / float64(global_counter))
+        p.Printf("Ops per second       : %18.2f\n", float64(global_counter) / delta.Seconds())
+        p.Printf("ns per ops           : %18.2f\n", float64(delta.Nanoseconds()) / float64(global_counter))
         p.Printf("Ops per threads      : %15d\n", global_counter / uint64(tthreads))
         p.Printf("Ops per procs        : %15d\n", global_counter / uint64(nprocs))
         p.Printf("Ops/sec/procs        : %18.2f\n", (float64(global_counter) / float64(nprocs)) / duration.Seconds())
         p.Printf("ns per ops/procs     : %18.2f\n", float64(duration.Nanoseconds()) / (float64(global_counter) / float64(nprocs)))
+        p.Printf("Ops/sec/procs        : %18.2f\n", (float64(global_counter) / float64(nprocs)) / delta.Seconds())
+        p.Printf("ns per ops/procs     : %18.2f\n", float64(delta.Nanoseconds()) / (float64(global_counter) / float64(nprocs)))
+}

benchmark/readyQ/cycle.rs

r949339b	r4e28d2e9
46	46
47	47	let tthreads = nthreads * ring_size;
48		let exp = Arc::new(bench::BenchData::new(options, tthreads~~, None~~));
	48	let exp = Arc::new(bench::BenchData::new(options, tthreads));
49	49
50	50	let s = (1000000 as u64).to_formatted_string(&Locale::en);

benchmark/readyQ/locality.go

r949339b	r4e28d2e9
286	286	// Print with nice 's, i.e. 1'000'000 instead of 1000000
287	287	p := message.NewPrinter(language.English)
288		p.Printf("Duration (~~ms) : %f\n", delta.Millis~~econds());
	288	p.Printf("Duration (s) : %f\n", delta.Seconds());
289	289	p.Printf("Number of processors : %d\n", nprocs);
290	290	p.Printf("Number of threads : %d\n", nthreads);

benchmark/readyQ/locality.rs

-              r949339b
+              r4e28d2e9
                                                 return (r as *mut MyData, true);
+                                        }
                                         let got = self.ptr.compare_exchange_weak(expected, ctx as *mut MyCtx as u64, Ordering::SeqCst, Ordering::SeqCst);
                                         if got == Ok(expected) {
+                                        let got = self.ptr.compare_and_swap(expected, ctx as *mut MyCtx as u64, Ordering::SeqCst);
+                                        if got == expected {
                                                 break expected;// We got the seat
+                                        }
 …
         assert_eq!(&s, "1,000,000");
         let exp = Arc::new(bench::BenchData::new(options, nprocs, None));
+        let exp = Arc::new(bench::BenchData::new(options, nprocs));
         let mut results = Result::new();

benchmark/readyQ/transfer.cfa

-              r949339b
+              r4e28d2e9
                         Pause();
                         if( (timeHiRes() - start) > 5`s ) {
-                                print_stats_now( bench_cluster, CFA_STATS_READY_Q | CFA_STATS_IO );
                                 serr | "Programs has been blocked for more than 5 secs";
                                 exit(1);
 …
         cfa_option opt[] = {
                 BENCH_OPT,
                 { 'e', "exhaust", "Whether or not threads that have seen the new epoch should park instead of yielding.", exhaust, parse_yesno}
+                { 'e', "exhaust", "Whether or not threads that have seen the new epoch should yield or park.", exhaust, parse_yesno}
         };
         BENCH_OPT_PARSE("cforall transition benchmark");
 …
+        }
         sout | "Duration (ms)           : " | ws(3, 3, unit(eng((end - start)`dms)));
+        sout | "Duration                : " | ws(3, 3, unit(eng((end - start)`ds))) | 's';
         sout | "Number of processors    : " | nprocs;
         sout | "Number of threads       : " | nthreads;

benchmark/readyQ/transfer.cpp

r949339b	r4e28d2e9
173	173	}
174	174
175		std::cout << "Duration ~~(ms) : " << to_miliseconds(end - start)~~ << std::endl;
	175	std::cout << "Duration : " << to_miliseconds(end - start) << "ms" << std::endl;
176	176	std::cout << "Number of processors : " << nprocs << std::endl;
177	177	std::cout << "Number of threads : " << nthreads << std::endl;

benchmark/readyQ/yield.cfa

-              r949339b
+              r4e28d2e9
+                }
+                printf("Duration (ms)       : %'ld\n", (end - start)`dms);
+                printf("Number of processors: %'d\n", nprocs);
+                printf("Number of threads   : %'d\n", nthreads);
+                printf("Total yields        : %'15llu\n", global_counter);
+                printf("Took %'ld ms\n", (end - start)`ms);
                 printf("Yields per second   : %'18.2lf\n", ((double)global_counter) / (end - start)`s);
                 printf("ns per yields       : %'18.2lf\n", ((double)(end - start)`ns) / global_counter);
+                printf("Total yields        : %'15llu\n", global_counter);
                 printf("Yields per procs    : %'15llu\n", global_counter / nprocs);
                 printf("Yields/sec/procs    : %'18.2lf\n", (((double)global_counter) / nprocs) / (end - start)`s);

benchmark/readyQ/yield.cpp

-              r949339b
+              r4e28d2e9
                 auto dur_nano = duration_cast<std::nano>(duration);
-                auto dur_dms  = duration_cast<std::milli>(duration);
                 printf("Duration (ms)       : %'.2lf\n", dur_dms );
+                std::cout << "Took " << duration << " s\n";
                 printf("Total yields        : %'15llu\n", global_counter );
                 printf("Yields per procs    : %'15llu\n", global_counter / nprocs );

benchmark/rmit.py

-              r949339b
+              r4e28d2e9
 import random
 import re
-import socket
 import subprocess
 import sys
 …
         return nopts
-# returns the first option with key 'opt'
-def search_option(action, opt):
-        i = 0
-        while i < len(action):
-                if action[i] == opt:
-                        i += 1
-                        if i != len(action):
-                                return action[i]
-                i += 1
-        return None
 def actions_eta(actions):
         time = 0
         for a in actions:
+                o = search_option(a, '-d')
+                if o :
+                        time += int(o)
+                i = 0
+                while i < len(a):
+                        if a[i] == '-d':
+                                i += 1
+                                if i != len(a):
+                                        time += int(a[i])
+                        i += 1
         return time
-taskset_maps = None
-def init_taskset_maps():
-        global taskset_maps
-        known_hosts = {
-                "jax": {
-                        range(  1,  24) : "48-71",
-                        range( 25,  48) : "48-71,144-167",
-                        range( 49,  96) : "48-95,144-191",
-                        range( 97, 144) : "24-95,120-191",
-                        range(145, 192) : "0-95,96-191",
-                },
+        }
-        if (host := socket.gethostname()) in known_hosts:
-                taskset_maps = known_hosts[host]
-                return True
-        print("Warning unknown host '{}', disable taskset usage".format(host), file=sys.stderr)
-        return False
-def settaskset_one(action):
-        o = search_option(action, '-p')
-        if not o:
-                return action
-        try:
-                oi = int(o)
-        except ValueError:
-                return action
-        m = "Not found"
-        for key in taskset_maps:
-                if oi in key:
-                        return ['taskset', '-c', taskset_maps[key], *action]
-        print("Warning no mapping for {} cores".format(oi), file=sys.stderr)
-        return action
-def settaskset(actions):
-        return [settaskset_one(a) for a in actions]
 if __name__ == "__main__":
 …
         parser.add_argument('--file', nargs='?', type=argparse.FileType('w'), default=sys.stdout)
         parser.add_argument('--trials', help='Number of trials to run per combinaison', type=int, default=3)
-        parser.add_argument('--notaskset', help='If specified, the trial will not use taskset to match the -p option', action='store_true')
         parser.add_argument('command', metavar='command', type=str, nargs=1, help='the command prefix to run')
         parser.add_argument('candidates', metavar='candidates', type=str, nargs='*', help='the candidate suffix to run')
 …
         # ================================================================================
+        # Fixup the different commands
+        # Add tasksets
+        withtaskset = False
+        if not options.notaskset and init_taskset_maps():
+                withtaskset = True
+                actions = settaskset(actions)
+        # ================================================================================
+        # Now that we know what to run, print it.
+        # find expected time
+        time = actions_eta(actions)
+        print("Running {} trials{}".format(len(actions), "" if time == 0 else " (expecting to take {})".format(str(datetime.timedelta(seconds=int(time)))) ))
+        # dry run if options ask for it
+        # Figure out all the combinations to run
         if options.list:
                 for a in actions:
 …
         # Prepare to run
+        # find expected time
+        time = actions_eta(actions)
+        print("Running {} trials{}".format(len(actions), "" if time == 0 else " (expecting to take {})".format(str(datetime.timedelta(seconds=int(time)))) ))
         random.shuffle(actions)
 …
         first = True
         for i, a in enumerate(actions):
                 sa = " ".join(a[3:] if withtaskset else a)
+                sa = " ".join(a)
                 if first:
                         first = False
 …
                                 match = re.search("^(.*):(.*)$", s)
                                 if match:
+                                        try:
+                                                fields[match.group(1).strip()] = float(match.group(2).strip().replace(',',''))
+                                        except:
+                                                pass
+                options.file.write(json.dumps([a[3 if withtaskset else 0][2:], sa, fields]))
+                                        fields[match.group(1).strip()] = float(match.group(2).strip().replace(',',''))
+                options.file.write(json.dumps([a[0][2:], sa, fields]))
                 options.file.flush()

doc/theses/andrew_beach_MMath/Makefile

-              r949339b
+              r4e28d2e9
 # The main rule, it does all the tex/latex processing.
 ${BUILD}/${BASE}.dvi: ${RAWSRC} ${FIGTEX} termhandle.pstex resumhandle.pstex Makefile | ${BUILD}
+${BUILD}/${BASE}.dvi: ${RAWSRC} ${FIGTEX} Makefile | ${BUILD}
         ${LATEX} ${BASE}
         ${BIBTEX} ${BUILD}/${BASE}
 …
 ${FIGTEX}: ${BUILD}/%.tex: %.fig | ${BUILD}
         fig2dev -L eepic $< > $@
-%.pstex : %.fig | ${Build}
-        fig2dev -L pstex $< > ${BUILD}/$@
-        fig2dev -L pstex_t -p ${BUILD}/$@ $< > ${BUILD}/$@_t
 # Step through dvi & postscript to handle xfig specials.

doc/theses/andrew_beach_MMath/code/cond-catch.py

r949339b	r4e28d2e9
32	32
33	33	end_time = thread_time_ns()
34		print('Run-Time (s)~~: {:.1f}~~'.format((end_time - start_time) / 1_000_000_000.))
	34	print('Run-Time (s) {:.1f}:'.format((end_time - start_time) / 1_000_000_000.))
35	35
36	36

doc/theses/andrew_beach_MMath/code/resume-empty.cfa

r949339b	r4e28d2e9
11	11	if (frames) {
12	12	nounwind_empty(frames - 1);
13		~~if ( frames == -1 ) printf( "42" ); // prevent recursion optimizations~~
14	13	} else {
15	14	throwResume (empty_exception){&empty_vt};

doc/theses/andrew_beach_MMath/code/run.sh

-              r949339b
+              r4e28d2e9
 #!/usr/bin/env bash
 readonly ALL_TESTS=(raise-{empty,detor,finally,other} try-{catch,finally} \
                         cond-match-{all,none} fixup-{empty,other})
+readonly ALL_TESTS=(raise-{empty,detor,finally,other} try-{catch,finally} cond-match-{all,none} \
+                    raise-{fixup-empty,fixup-other})
 gen-file-name() (
 …
+)
+#readonly N=${1:-5}
 readonly N=${1:-1}
 readonly OUT_FILE=$(gen-file-name ${2:-run-%-$N})

doc/theses/andrew_beach_MMath/code/test.sh

-              r949339b
+              r4e28d2e9
 #   View the result from TEST in LANGUAGE stored in FILE.
+readonly DIR=$(dirname "$(readlink -f "$0")")
+cd $DIR
+readonly MIL=000000
+# Various preset values used as arguments.
+readonly ITERS_1M=1$MIL
+readonly ITERS_10M=10$MIL
+readonly ITERS_100M=100$MIL
+readonly ITERS_1000M=1000$MIL
+readonly ITERS_1M=1000000 # 1 000 000, one million
+readonly ITERS_10M=10000000 # 10 000 000, ten million
+readonly ITERS_100M=100000000 # 100 000 000, hundred million
+readonly ITERS_1000M=1000000000 # 1 000 000 000, billion
 readonly STACK_HEIGHT=100
 …
         case "$1" in
         *.cfa)
+                # A symbolic link/local copy can be used as an override.
+                cmd=./cfa
+                if [ ! -x $cmd ]; then
+                        cmd=cfa
+                fi
+                mmake "${1%.cfa}" "$1" $cmd -DNDEBUG -nodebug -O3 "$1" -o "${1%.cfa}"
+                # Requires a symbolic link.
+                mmake "${1%.cfa}" "$1" cfa -DNDEBUG -nodebug -O3 "$1" -o "${1%.cfa}"
                 ;;
         *.cpp)
 …
+)
 if [ "-a" = "$1" ]; then
+if [ "-a" = "$1" ]; then                        # build all
         for file in *.cfa *.cpp *.java; do
                 build $file
         done
         exit 0
 elif [ "-b" = "$1" ]; then
+elif [ "-b" = "$1" ]; then                      # build given
         for file in "${@:2}"; do
                 build $file
         done
         exit 0
 elif [ "-c" = "$1" ]; then
+elif [ "-c" = "$1" ]; then                      # clean all
         rm $(basename -s ".cfa" -a *.cfa)
         rm $(basename -s ".cpp" -a *.cpp)
 …
 raise-empty)
         CFAT="./throw-empty $ITERS_1M $STACK_HEIGHT"
         CFAR="./resume-empty $ITERS_10M $STACK_HEIGHT"
+# see resume-fixup-empty-r      CFAR="./resume-empty $ITERS_1M $STACK_HEIGHT"
         CPP="./throw-empty-cpp $ITERS_1M $STACK_HEIGHT"
         JAVA="java ThrowEmpty $ITERS_1M $STACK_HEIGHT"
 …
 raise-detor)
         CFAT="./throw-detor $ITERS_1M $STACK_HEIGHT"
         CFAR="./resume-detor $ITERS_10M $STACK_HEIGHT"
+# N/A   CFAR="./resume-detor $ITERS_1M $STACK_HEIGHT"
         CPP="./throw-detor-cpp $ITERS_1M $STACK_HEIGHT"
         JAVA=unsupported
 …
 raise-finally)
         CFAT="./throw-finally $ITERS_1M $STACK_HEIGHT"
         CFAR="./resume-finally $ITERS_10M $STACK_HEIGHT"
+# N/A   CFAR="./resume-finally $ITERS_1M $STACK_HEIGHT"
         CPP=unsupported
         JAVA="java ThrowFinally $ITERS_1M $STACK_HEIGHT"
 …
 raise-other)
         CFAT="./throw-other $ITERS_1M $STACK_HEIGHT"
         CFAR="./resume-other $ITERS_10M $STACK_HEIGHT"
+# N/A   CFAR="./resume-other $ITERS_1M $STACK_HEIGHT"
         CPP="./throw-other-cpp $ITERS_1M $STACK_HEIGHT"
         JAVA="java ThrowOther $ITERS_1M $STACK_HEIGHT"
 …
 cond-match-all)
         CFAT="./cond-catch $ITERS_10M 1"
         CFAR="./cond-fixup $ITERS_100M 1"
+        CFAR="./cond-fixup $ITERS_10M 1"
         CPP="./cond-catch-cpp $ITERS_10M 1"
         JAVA="java CondCatch $ITERS_10M 1"
 …
 cond-match-none)
         CFAT="./cond-catch $ITERS_10M 0"
         CFAR="./cond-fixup $ITERS_100M 0"
+        CFAR="./cond-fixup $ITERS_10M 0"
         CPP="./cond-catch-cpp $ITERS_10M 0"
         JAVA="java CondCatch $ITERS_10M 0"
         PYTHON="./cond-catch.py $ITERS_10M 0"
         ;;
 fixup-empty)
         CFAT="./fixup-empty-f $ITERS_10M $STACK_HEIGHT"
         CFAR="./fixup-empty-r $ITERS_10M $STACK_HEIGHT"
         CPP="./fixup-empty-cpp $ITERS_10M $STACK_HEIGHT"
         JAVA="java FixupEmpty $ITERS_10M $STACK_HEIGHT"
         PYTHON="./fixup-empty.py $ITERS_10M $STACK_HEIGHT"
+raise-fixup-empty)
+        CFAT="./resume-fixup-empty-f $ITERS_10M $STACK_HEIGHT"
+        CFAR="./resume-fixup-empty-r $ITERS_10M $STACK_HEIGHT"
+        CPP="./resume-fixup-empty-cpp $ITERS_10M $STACK_HEIGHT"
+        JAVA="java ResumeFixupEmpty $ITERS_10M $STACK_HEIGHT"
+        PYTHON="./resume-fixup-empty.py $ITERS_10M $STACK_HEIGHT"
         ;;
 fixup-other)
         CFAT="./fixup-other-f $ITERS_10M $STACK_HEIGHT"
         CFAR="./fixup-other-r $ITERS_10M $STACK_HEIGHT"
         CPP="./fixup-other-cpp $ITERS_10M $STACK_HEIGHT"
         JAVA="java FixupOther $ITERS_10M $STACK_HEIGHT"
         PYTHON="./fixup-other.py $ITERS_10M $STACK_HEIGHT"
+raise-fixup-other)
+        CFAT="./resume-fixup-other-f $ITERS_10M $STACK_HEIGHT"
+        CFAR="./resume-fixup-other-r $ITERS_10M $STACK_HEIGHT"
+        CPP="./resume-fixup-other-cpp $ITERS_10M $STACK_HEIGHT"
+        JAVA="java ResumeFixupOther $ITERS_10M $STACK_HEIGHT"
+        PYTHON="./resume-fixup-other.py $ITERS_10M $STACK_HEIGHT"
         ;;
 *)
 …
 case "$TEST_LANG" in
 cfa-t) CALL="$CFAT";;
 cfa-r) CALL="$CFAR";;
 cpp) CALL="$CPP";;
 java) CALL="$JAVA";;
 python) CALL="$PYTHON";;
 *)
         echo "No such language: $TEST_LANG" >&2
         exit 2
+        cfa-t) CALL="$CFAT";;
+        cfa-r) CALL="$CFAR";;
+        cpp) CALL="$CPP";;
+        java) CALL="$JAVA";;
+        python) CALL="$PYTHON";;
+        *)
+                echo "No such language: $TEST_LANG" >&2
+                exit 2
         ;;
 esac
 …
 if [ -n "$VIEW_FILE" ]; then
         grep -A 1 -B 0 "$CALL" "$VIEW_FILE" | sed -n -e 's!Run-Time.*: !!;T;p'
+        grep -A 1 -B 0 "$CALL" "$VIEW_FILE" | sed -n -e 's!Run-Time (ns): !!;T;p'
         exit
 fi

doc/theses/andrew_beach_MMath/code/throw-empty.cfa

r949339b	r4e28d2e9
11	11	if (frames) {
12	12	unwind_empty(frames - 1);
13		~~if ( frames == -1 ) printf( "42" ); // prevent recursion optimizations~~
14	13	} else {
15	14	throw (empty_exception){&empty_vt};

doc/theses/andrew_beach_MMath/code/throw-empty.cpp

-              r949339b
+              r4e28d2e9
 // Throw Across Empty Function
 #include <chrono>
-#include <cstdio>
 #include <cstdlib>
 #include <exception>
 …
         if (frames) {
                 unwind_empty(frames - 1);
-                if (-1 == frames) printf("~");
         } else {
                 throw (EmptyException){};

doc/theses/andrew_beach_MMath/code/throw-empty.py

r949339b	r4e28d2e9
33	33
34	34	end_time = thread_time_ns()
35		print('Run-Time (s)~~: {:.1f}~~'.format((end_time - start_time) / 1_000_000_000.))
	35	print('Run-Time (s) {:.1f}:'.format((end_time - start_time) / 1_000_000_000.))
36	36
37	37

doc/theses/andrew_beach_MMath/code/throw-finally.py

r949339b	r4e28d2e9
36	36
37	37	end_time = thread_time_ns()
38		print('Run-Time (s)~~: {:.1f}~~'.format((end_time - start_time) / 1_000_000_000.))
	38	print('Run-Time (s) {:.1f}:'.format((end_time - start_time) / 1_000_000_000.))
39	39
40	40

doc/theses/andrew_beach_MMath/code/throw-other.py

r949339b	r4e28d2e9
40	40
41	41	end_time = thread_time_ns()
42		print('Run-Time (s)~~: {:.1f}~~'.format((end_time - start_time) / 1_000_000_000.))
	42	print('Run-Time (s) {:.1f}:'.format((end_time - start_time) / 1_000_000_000.))
43	43
44	44

doc/theses/andrew_beach_MMath/code/throw-with.py

r949339b	r4e28d2e9
43	43
44	44	end_time = thread_time_ns()
45		print('Run-Time (s)~~: {:.1f}~~'.format((end_time - start_time) / 1_000_000_000.))
	45	print('Run-Time (s) {:.1f}:'.format((end_time - start_time) / 1_000_000_000.))
46	46
47	47

doc/theses/andrew_beach_MMath/code/try-catch.py

r949339b	r4e28d2e9
23	23
24	24	end_time = thread_time_ns()
25		print('Run-Time (s)~~: {:.1f}~~'.format((end_time - start_time) / 1_000_000_000.))
	25	print('Run-Time (s) {:.1f}:'.format((end_time - start_time) / 1_000_000_000.))
26	26
27	27

doc/theses/andrew_beach_MMath/code/try-finally.py

r949339b	r4e28d2e9
22	22
23	23	end_time = thread_time_ns()
24		print('Run-Time (s)~~: {:.1f}~~'.format((end_time - start_time) / 1_000_000_000.))
	24	print('Run-Time (s) {:.1f}:'.format((end_time - start_time) / 1_000_000_000.))
25	25
26	26

doc/theses/andrew_beach_MMath/conclusion.tex

-              r949339b
+              r4e28d2e9
 % Just a little knot to tie the paper together.
 In the previous chapters, this thesis presents the design and implementation
+In the previous chapters this thesis presents the design and implementation
 of \CFA's exception handling mechanism (EHM).
 Both the design and implementation are based off of tools and
 techniques developed for other programming languages but they were adapted to
 better fit \CFA's feature set and add a few features that do not exist in
 other EHMs,
+other EHMs;
 including conditional matching, default handlers for unhandled exceptions
 and cancellation though coroutines and threads back to the program main stack.

doc/theses/andrew_beach_MMath/existing.tex

-              r949339b
+              r4e28d2e9
 compatibility with C and its programmers.  \CFA is designed to have an
 orthogonal feature-set based closely on the C programming paradigm
+(non-object-oriented), and these features can be added incrementally to an
+existing C code-base,
+allowing programmers to learn \CFA on an as-needed basis.
+(non-object-oriented) and these features can be added incrementally to an
+existing C code-base allowing programmers to learn \CFA on an as-needed basis.
 Only those \CFA features pertaining to this thesis are discussed.
 …
 \CFA adds a reference type to C as an auto-dereferencing pointer.
 They work very similarly to pointers.
 Reference-types are written the same way as pointer-types, but each
+Reference-types are written the same way as a pointer-type but each
 asterisk (@*@) is replaced with a ampersand (@&@);
+this includes cv-qualifiers (\snake{const} and \snake{volatile})
+and multiple levels of reference.
+Generally, references act like pointers with an implicit dereferencing
+this includes cv-qualifiers and multiple levels of reference.
+Generally, references act like pointers with an implicate dereferencing
 operation added to each use of the variable.
 These automatic dereferences may be disabled with the address-of operator
 …
 Mutable references may be assigned to by converting them to a pointer
 with a @&@ and then assigning a pointer to them, as in @&ri = &j;@ above.
+% ???
 \section{Operators}
 …
 For example,
 infixed multiplication is @?*?@, while prefix dereference is @*?@.
 This syntax makes it easy to tell the difference between prefix operations
 (such as @++?@) and postfix operations (@?++@).
+This syntax make it easy to tell the difference between prefix operations
+(such as @++?@) and post-fix operations (@?++@).
 As an example, here are the addition and equality operators for a point type.
 …
+}
 \end{cfa}
 Note that this syntax works effectively as a textual transformation;
+Note that this syntax works effectively but a textual transformation,
 the compiler converts all operators into functions and then resolves them
 normally. This means any combination of types may be used,
 …
 %\subsection{Constructors and Destructors}
 In \CFA, constructors and destructors are operators, which means they are
 functions with special operator names, rather than type names as in \Cpp.
+functions with special operator names rather than type names in \Cpp.
 Both constructors and destructors can be implicity called by the compiler,
 however the operator names allow explicit calls.
 …
 @b@ because of the explicit call and @a@ implicitly.
 @c@ will be initalized with the second constructor.
 Currently, there is no general way to skip initialization.
+Currently, there is no general way to skip initialation.
 % I don't use @= anywhere in the thesis.
 …
 do_twice(i);
 \end{cfa}
 Any value with a type fulfilling the assertion may be passed as an argument to
+Any object with a type fulfilling the assertion may be passed as an argument to
 a @do_twice@ call.
 …
 function. The matched assertion function is then passed as a function pointer
 to @do_twice@ and called within it.
 The global definition of @do_once@ is ignored, however if @quadruple@ took a
+The global definition of @do_once@ is ignored, however if quadruple took a
 @double@ argument, then the global definition would be used instead as it
 would then be a better match.\cite{Moss19}
 To avoid typing long lists of assertions, constraints can be collected into
 a convenient package called a @trait@, which can then be used in an assertion
+convenient a package called a @trait@, which can then be used in an assertion
 instead of the individual constraints.
 \begin{cfa}
 …
 functions and variables, and are usually used to create a shorthand for, and
 give descriptive names to, common groupings of assertions describing a certain
 functionality, like @summable@, @listable@, \etc.
+functionality, like @sumable@, @listable@, \etc.
 Polymorphic structures and unions are defined by qualifying an aggregate type
 with @forall@. The type variables work the same except they are used in field
 declarations instead of parameters, returns and local variable declarations.
+declarations instead of parameters, returns, and local variable declarations.
 \begin{cfa}
 forall(dtype T)
 …
 \section{Control Flow}
+\CFA has a number of advanced control-flow features: @generator@, @coroutine@,
+@monitor@, @mutex@ parameters, and @thread@.
+\CFA has a number of advanced control-flow features: @generator@, @coroutine@, @monitor@, @mutex@ parameters, and @thread@.
 The two features that interact with
 the exception system are @coroutine@ and @thread@; they and their supporting
 …
 \subsection{Coroutine}
 A coroutine is a type with associated functions, where the functions are not
+required to finish execution when control is handed back to the caller.
+Instead,
+required to finish execution when control is handed back to the caller. Instead
 they may suspend execution at any time and be resumed later at the point of
+last suspension.
+Coroutine
+last suspension. (Generators are stackless and coroutines are stackful.) These
 types are not concurrent but share some similarities along with common
+underpinnings, so they are combined with the \CFA threading library.
+% I had mention of generators, but they don't actually matter here.
+underpinnings, so they are combined with the \CFA threading library. Further
+discussion in this section only refers to the coroutine because generators are
+similar.
 In \CFA, a coroutine is created using the @coroutine@ keyword, which is an
 …
 \end{cfa}
 When the main function returns, the coroutine halts and can no longer be
+When the main function returns the coroutine halts and can no longer be
 resumed.
 \subsection{Monitor and Mutex Parameter}
 Concurrency does not guarantee ordering; without ordering, results are
+Concurrency does not guarantee ordering; without ordering results are
 non-deterministic. To claw back ordering, \CFA uses monitors and @mutex@
 (mutual exclusion) parameters. A monitor is another kind of aggregate, where
 …
 @mutex@ parameters.
 A function that requires deterministic (ordered) execution acquires mutual
+A function that requires deterministic (ordered) execution, acquires mutual
 exclusion on a monitor object by qualifying an object reference parameter with
 the @mutex@ qualifier.
+@mutex@.
 \begin{cfa}
 void example(MonitorA & mutex argA, MonitorB & mutex argB);
 …
 \subsection{Thread}
 Functions, generators and coroutines are sequential, so there is only a single
+Functions, generators, and coroutines are sequential so there is only a single
 (but potentially sophisticated) execution path in a program. Threads introduce
 multiple execution paths that continue independently.
 For threads to work safely with objects requires mutual exclusion using
 monitors and mutex parameters. For threads to work safely with other threads
+monitors and mutex parameters. For threads to work safely with other threads,
 also requires mutual exclusion in the form of a communication rendezvous, which
 also supports internal synchronization as for mutex objects. For exceptions,

doc/theses/andrew_beach_MMath/features.tex

-              r949339b
+              r4e28d2e9
 and begins with a general overview of EHMs. It is not a strict
 definition of all EHMs nor an exhaustive list of all possible features.
 However, it does cover the most common structure and features found in them.
+However it does cover the most common structure and features found in them.
 \section{Overview of EHMs}
 …
 The @try@ statements of \Cpp, Java and Python are common examples. All three
 also show another common feature of handlers: they are grouped by the guarded
+also show another common feature of handlers, they are grouped by the guarded
 region.
 …
 \paragraph{Hierarchy}
 A common way to organize exceptions is in a hierarchical structure.
 This pattern comes from object-oriented languages where the
+This pattern comes from object-orientated languages where the
 exception hierarchy is a natural extension of the object hierarchy.
 …
 between different sub-hierarchies.
 This design is used in \CFA even though it is not a object-orientated
 language, so different tools are used to create the hierarchy.
+language; so different tools are used to create the hierarchy.
 % Could I cite the rational for the Python IO exception rework?
 …
 For effective exception handling, additional information is often passed
 from the raise to the handler and back again.
 So far, only communication of the exception's identity is covered.
+So far, only communication of the exceptions' identity is covered.
 A common communication method for adding information to an exception
 is putting fields into the exception instance
 …
 \section{Virtuals}
 \label{s:virtuals}
-A common feature in many programming languages is a tool to pair code
-(behaviour) with data.
-In \CFA, this is done with the virtual system,
-which allow type information to be abstracted away, recovered and allow
-operations to be performed on the abstract objects.
 Virtual types and casts are not part of \CFA's EHM nor are they required for
 an EHM.
 …
 % A type's descendants are its children and its children's descendants.
 For the purposes of illustration, a proposed, but unimplemented, syntax
+For the purposes of illustration, a proposed -- but unimplemented syntax --
 will be used. Each virtual type is represented by a trait with an annotation
 that makes it a virtual type. This annotation is empty for a root type, which
 …
 \end{minipage}
 Every virtual type also has a list of virtual members and a unique id.
 Both are stored in a virtual table.
+Every virtual type also has a list of virtual members and a unique id,
+both are stored in a virtual table.
 Every instance of a virtual type also has a pointer to a virtual table stored
 in it, although there is no per-type virtual table as in many other languages.
+The list of virtual members is accumulated from the root type down the tree.
+Every virtual type
+The list of virtual members is built up down the tree. Every virtual type
 inherits the list of virtual members from its parent and may add more
 virtual members to the end of the list which are passed on to its children.
 …
 % Consider adding a diagram, but we might be good with the explanation.
 As @child_type@ is a child of @root_type@, it has the virtual members of
+As @child_type@ is a child of @root_type@ it has the virtual members of
 @root_type@ (@to_string@ and @size@) as well as the one it declared
 (@irrelevant_function@).
 …
 The names ``size" and ``align" are reserved for the size and alignment of the
 virtual type, and are always automatically initialized as such.
 The other special case is uses of the trait's polymorphic argument
+The other special case are uses of the trait's polymorphic argument
 (@T@ in the example), which are always updated to refer to the current
 virtual type. This allows functions that refer to the polymorphic argument
+virtual type. This allows functions that refer to to polymorphic argument
 to act as traditional virtual methods (@to_string@ in the example), as the
 object can always be passed to a virtual method in its virtual table.
 Up until this point, the virtual system is similar to ones found in
 object-oriented languages, but this is where \CFA diverges.
+Up until this point the virtual system is similar to ones found in
+object-oriented languages but this is where \CFA diverges.
 Objects encapsulate a single set of methods in each type,
 universally across the entire program,
 …
 In \CFA, types do not encapsulate any code.
 Whether or not a type satisfies any given assertion, and hence any trait, is
+Whether or not satisfies any given assertion, and hence any trait, is
 context sensitive. Types can begin to satisfy a trait, stop satisfying it or
 satisfy the same trait at any lexical location in the program.
 In this sense, a type's implementation in the set of functions and variables
+In this sense, an type's implementation in the set of functions and variables
 that allow it to satisfy a trait is ``open" and can change
 throughout the program.
 …
 \end{cfa}
 Like any variable, they may be forward declared with the @extern@ keyword.
+Like any variable they may be forward declared with the @extern@ keyword.
 Forward declaring virtual tables is relatively common.
 Many virtual types have an ``obvious" implementation that works in most
 …
 Initialization is automatic.
 The type id and special virtual members ``size" and ``align" only depend on
 the virtual type, which is fixed given the type of the virtual table, and
+the virtual type, which is fixed given the type of the virtual table and
 so the compiler fills in a fixed value.
 The other virtual members are resolved using the best match to the member's
+The other virtual members are resolved, using the best match to the member's
 name and type, in the same context as the virtual table is declared using
 \CFA's normal resolution rules.
+While much of the virtual infrastructure has been created,
+it is currently only used
+While much of the virtual infrastructure is created, it is currently only used
 internally for exception handling. The only user-level feature is the virtual
 cast, which is the same as the \Cpp \code{C++}{dynamic_cast}.
 …
 Note, the syntax and semantics matches a C-cast, rather than the function-like
 \Cpp syntax for special casts. Both the type of @EXPRESSION@ and @TYPE@ must be
 pointers to virtual types.
+a pointer to a virtual type.
 The cast dynamically checks if the @EXPRESSION@ type is the same or a sub-type
 of @TYPE@, and if true, returns a pointer to the
 @EXPRESSION@ object, otherwise it returns @0p@ (null pointer).
-This allows the expression to be used as both a cast and a type check.
 \section{Exceptions}
 The syntax for declaring an exception is the same as declaring a structure
 except the keyword:
+except the keyword that is swapped out:
 \begin{cfa}
 exception TYPE_NAME {
 …
 \end{cfa}
 Fields are filled in the same way as a structure as well. However, an extra
+Fields are filled in the same way as a structure as well. However an extra
 field is added that contains the pointer to the virtual table.
 It must be explicitly initialized by the user when the exception is
 …
 \begin{minipage}[t]{0.4\textwidth}
 Header (.hfa):
+Header:
 \begin{cfa}
 exception Example {
 …
 \end{minipage}
 \begin{minipage}[t]{0.6\textwidth}
 Implementation (.cfa):
+Source:
 \begin{cfa}
 vtable(Example) example_base_vtable
 …
 %\subsection{Exception Details}
 This is the only interface needed when raising and handling exceptions.
 However, it is actually a shorthand for a more complex
 trait-based interface.
+However it is actually a short hand for a more complex
+trait based interface.
 The language views exceptions through a series of traits.
 …
 completing the virtual system). The imaginary assertions would probably come
 from a trait defined by the virtual system, and state that the exception type
+is a virtual type,
+that that the type is a descendant of @exception_t@ (the base exception type)
+is a virtual type, is a descendant of @exception_t@ (the base exception type)
 and allow the user to find the virtual table type.
 …
 };
 \end{cfa}
 Both traits ensure a pair of types is an exception type and
+its virtual table type,
+Both traits ensure a pair of types is an exception type, its virtual table
+type
 and defines one of the two default handlers. The default handlers are used
 as fallbacks and are discussed in detail in \autoref{s:ExceptionHandling}.
+as fallbacks and are discussed in detail in \vref{s:ExceptionHandling}.
 However, all three of these traits can be tricky to use directly.
 While there is a bit of repetition required,
 the largest issue is that the virtual table type is mangled and not in a user
 facing way. So, these three macros are provided to wrap these traits to
+facing way. So these three macros are provided to wrap these traits to
 simplify referring to the names:
 @IS_EXCEPTION@, @IS_TERMINATION_EXCEPTION@ and @IS_RESUMPTION_EXCEPTION@.
 …
 The second (optional) argument is a parenthesized list of polymorphic
 arguments. This argument is only used with polymorphic exceptions and the
 list is passed to both types.
+list is be passed to both types.
 In the current set-up, the two types always have the same polymorphic
 arguments, so these macros can be used without losing flexibility.
 For example, consider a function that is polymorphic over types that have a
+arguments so these macros can be used without losing flexibility.
+For example consider a function that is polymorphic over types that have a
 defined arithmetic exception:
 \begin{cfa}
 …
 These twin operations are the core of \CFA's exception handling mechanism.
 This section covers the general patterns shared by the two operations and
 then goes on to cover the details of each individual operation.
+then goes on to cover the details each individual operation.
 Both operations follow the same set of steps.
 …
 \label{s:Termination}
 Termination handling is the familiar kind of handling
 used in most programming
+and used in most programming
 languages with exception handling.
 It is a dynamic, non-local goto. If the raised exception is matched and
 …
 Since it is so general, a more specific handler can be defined,
 overriding the default behaviour for the specific exception types.
-For example, consider an error reading a configuration file.
-This is most likely a problem with the configuration file (@config_error@),
-but the function could have been passed the wrong file name (@arg_error@).
-In this case the function could raise one exception and then, if it is
-unhandled, raise the other.
-This is not usual behaviour for either exception so changing the
-default handler will be done locally:
-\begin{cfa}
+{
-        void defaultTerminationHandler(config_error &) {
-                throw (arg_error){arg_vt};
+        }
-        throw (config_error){config_vt};
+}
-\end{cfa}
 \subsection{Resumption}
 …
 @EXCEPTION_TYPE@$_i$ is matched and @NAME@$_i$ is bound to the exception,
 @HANDLER_BLOCK@$_i$ is executed right away without first unwinding the stack.
 After the block has finished running, control jumps to the raise site, where
+After the block has finished running control jumps to the raise site, where
 the just handled exception came from, and continues executing after it,
 not after the try statement.
-For instance, a resumption used to send messages to the logger may not
-need to be handled at all. Putting the following default handler
-at the global scope can make handling that exception optional by default.
-\begin{cfa}
-void defaultResumptionHandler(log_message &) {
-    // Nothing, it is fine not to handle logging.
+}
-// ... No change at raise sites. ...
-throwResume (log_message){strlit_log, "Begin event processing."}
-\end{cfa}
 \subsubsection{Resumption Marking}
 …
 not unwind the stack. A side effect is that, when a handler is matched
 and run, its try block (the guarded statements) and every try statement
 searched before it are still on the stack. Their presence can lead to
+searched before it are still on the stack. There presence can lead to
 the recursive resumption problem.\cite{Buhr00a}
 % Other possible citation is MacLaren77, but the form is different.
 …
 \end{center}
 There are other sets of marking rules that could be used.
+For instance, marking just the handlers that caught the exception
+There are other sets of marking rules that could be used,
+for instance, marking just the handlers that caught the exception,
 would also prevent recursive resumption.
 However, the rules selected mirror what happens with termination,
+However, the rules selected mirrors what happens with termination,
 so this reduces the amount of rules and patterns a programmer has to know.
 …
 // Handle a failure relating to f2 further down the stack.
 \end{cfa}
 In this example, the file that experienced the IO error is used to decide
+In this example the file that experienced the IO error is used to decide
 which handler should be run, if any at all.
 …
 \subsection{Comparison with Reraising}
 In languages without conditional catch -- that is, no ability to match an
 exception based on something other than its type -- it can be mimicked
+In languages without conditional catch, that is no ability to match an
+exception based on something other than its type, it can be mimicked
 by matching all exceptions of the right type, checking any additional
 conditions inside the handler and re-raising the exception if it does not
 …
 Here is a minimal example comparing both patterns, using @throw;@
 (no operand) to start a re-raise.
+(no argument) to start a re-raise.
 \begin{center}
 \begin{tabular}{l r}
 …
 \end{tabular}
 \end{center}
 At first glance, catch-and-reraise may appear to just be a quality-of-life
+At first glance catch-and-reraise may appear to just be a quality of life
 feature, but there are some significant differences between the two
 strategies.
+stratagies.
 A simple difference that is more important for \CFA than many other languages
 is that the raise site changes with a re-raise, but does not with a
+is that the raise site changes, with a re-raise but does not with a
 conditional catch.
 This is important in \CFA because control returns to the raise site to run
 the per-site default handler. Because of this, only a conditional catch can
+the per-site default handler. Because of this only a conditional catch can
 allow the original raise to continue.
 …
 %   } else throw;
 % }
 In similar simple examples, translating from re-raise to conditional catch
 takes less code but it does not have a general, trivial solution either.
+In similar simple examples translating from re-raise to conditional catch
+takes less code but it does not have a general trivial solution either.
 So, given that the two patterns do not trivially translate into each other,
 it becomes a matter of which on should be encouraged and made the default.
 From the premise that if a handler could handle an exception then it
+From the premise that if a handler that could handle an exception then it
 should, it follows that checking as many handlers as possible is preferred.
 So, conditional catch and checking later handlers is a good default.
+So conditional catch and checking later handlers is a good default.
 \section{Finally Clauses}
 \label{s:FinallyClauses}
 Finally clauses are used to perform unconditional cleanup when leaving a
+Finally clauses are used to preform unconditional clean-up when leaving a
 scope and are placed at the end of a try statement after any handler clauses:
 \begin{cfa}
 …
 Execution of the finally block should always finish, meaning control runs off
 the end of the block. This requirement ensures control always continues as if
 the finally clause is not present, \ie finally is for cleanup, not changing
+the finally clause is not present, \ie finally is for cleanup not changing
 control flow.
 Because of this requirement, local control flow out of the finally block
 is forbidden. The compiler precludes any @break@, @continue@, @fallthru@ or
 @return@ that causes control to leave the finally block. Other ways to leave
 the finally block, such as a @longjmp@ or termination are much harder to check,
 and at best require additional run-time overhead, and so are only
+the finally block, such as a long jump or termination are much harder to check,
+and at best requiring additional run-time overhead, and so are only
 discouraged.
 Not all languages with unwinding have finally clauses. Notably, \Cpp does
+Not all languages with unwinding have finally clauses. Notably \Cpp does
 without it as destructors, and the RAII design pattern, serve a similar role.
 Although destructors and finally clauses can be used for the same cases,
 …
 Destructors take more work to create, but if there is clean-up code
 that needs to be run every time a type is used, they are much easier
 to set up for each use. % It's automatic.
 On the other hand, finally clauses capture the local context, so are easy to
 use when the cleanup is not dependent on the type of a variable or requires
+to set-up for each use. % It's automatic.
+On the other hand finally clauses capture the local context, so is easy to
+use when the clean-up is not dependent on the type of a variable or requires
 information from multiple variables.
 …
 Cancellation is a stack-level abort, which can be thought of as as an
 uncatchable termination. It unwinds the entire current stack, and if
 possible, forwards the cancellation exception to a different stack.
+possible forwards the cancellation exception to a different stack.
 Cancellation is not an exception operation like termination or resumption.
 There is no special statement for starting a cancellation; instead the standard
 library function @cancel_stack@ is called, passing an exception. Unlike a
 raise, this exception is not used in matching, only to pass information about
+library function @cancel_stack@ is called passing an exception. Unlike a
+raise, this exception is not used in matching only to pass information about
 the cause of the cancellation.
 Finally, as no handler is provided, there is no default handler.
 After @cancel_stack@ is called, the exception is copied into the EHM's memory
+After @cancel_stack@ is called the exception is copied into the EHM's memory
 and the current stack is unwound.
 The behaviour after that depends on the kind of stack being cancelled.
 \paragraph{Main Stack}
+The main stack is the one used by
+the program's main function at the start of execution,
+The main stack is the one used by the program main at the start of execution,
 and is the only stack in a sequential program.
 After the main stack is unwound, there is a program-level abort.
+After the main stack is unwound there is a program-level abort.
 The first reason for this behaviour is for sequential programs where there
 is only one stack, and hence no stack to pass information to.
+is only one stack, and hence to stack to pass information to.
 Second, even in concurrent programs, the main stack has no dependency
 on another stack and no reliable way to find another living stack.
 …
 and an implicit join (from a destructor call). The explicit join takes the
 default handler (@defaultResumptionHandler@) from its calling context while
 the implicit join provides its own, which does a program abort if the
+the implicit join provides its own; which does a program abort if the
 @ThreadCancelled@ exception cannot be handled.
 …
 After a coroutine stack is unwound, control returns to the @resume@ function
 that most recently resumed it. @resume@ reports a
 @CoroutineCancelled@ exception, which contains a reference to the cancelled
+@CoroutineCancelled@ exception, which contains a references to the cancelled
 coroutine and the exception used to cancel it.
 The @resume@ function also takes the \defaultResumptionHandler{} from the

doc/theses/andrew_beach_MMath/future.tex

-              r949339b
+              r4e28d2e9
 The following discussion covers both possible interesting research
 that could follow from this work as well as simple implementation
+that could follow from this work as long as simple implementation
 improvements.
 …
 \CFA is a developing programming language. As such, there are partially or
 unimplemented features (including several broken components)
 that I had to work around while building the EHM largely in
+that I had to workaround while building the EHM largely in
 the \CFA language (some C components). Below are a few of these issues
 and how implementing/fixing them would affect the EHM.
 In addition, there are some simple improvements that had no interesting
+In addition there are some simple improvements that had no interesting
 research attached to them but would make using the language easier.
 \begin{itemize}
 …
 Termination handlers cannot use local control-flow transfers, \eg by @break@,
 @return@, \etc. The reason is that current code generation hoists a handler
 into a nested function for convenience (versus assembly-code generation at the
+into a nested function for convenience (versus assemble-code generation at the
 try statement). Hence, when the handler runs, it can still access local
 variables in the lexical scope of the try statement. Still, it does mean
 that seemingly local control flow is not in fact local and crosses a function
 boundary.
 Making the termination handler's code within the surrounding
+Making the termination handlers code within the surrounding
 function would remove this limitation.
 % Try blocks are much more difficult to do practically (requires our own
 % assembly) and resumption handlers have some theoretical complexity.
 \item
 There is no detection of colliding unwinds. It is possible for cleanup code
 run during an unwind to trigger another unwind that escapes the cleanup code
 itself, such as a termination exception caught further down the stack or a
+There is no detection of colliding unwinds. It is possible for clean-up code
+run during an unwind to trigger another unwind that escapes the clean-up code
+itself; such as a termination exception caught further down the stack or a
 cancellation. There do exist ways to handle this case, but currently there is
 no detection and the first unwind will simply be forgotten, often leaving
 …
 Other features of the virtual system could also remove some of the
 special cases around exception virtual tables, such as the generation
 of the @msg@ function.
+of the @msg@ function, could be removed.
 The full virtual system might also include other improvement like associated
 …
 \section{Additional Raises}
 Several other kinds of exception raises were considered beyond termination
 (@throw@), resumption (@throwResume@), and re-raise.
+(@throw@), resumption (@throwResume@), and reraise.
 The first is a non-local/concurrent raise providing asynchronous exceptions,
 …
 passed on.
 Checked exceptions were never seriously considered for this project
+However checked exceptions were never seriously considered for this project
 because they have significant trade-offs in usability and code reuse in
 exchange for the increased safety.
 …
 higher-order functions from the functions the user passed into the
 higher-order function. There are no well known solutions to this problem
 that were satisfactory for \CFA (which carries some of C's
 flexibility-over-safety design) so additional research is needed.
+that were satisfactory for \CFA (which carries some of C's flexibility
+over safety design) so additional research is needed.
 Follow-up work might add some form of checked exceptions to \CFA,
 …
 Zero-cost resumptions is still an open problem. First, because libunwind does
 not support a successful-exiting stack-search without doing an unwind.
 Workarounds are possible but awkward. Ideally, an extension to libunwind could
+Workarounds are possible but awkward. Ideally an extension to libunwind could
 be made, but that would either require separate maintenance or gaining enough
 support to have it folded into the official library itself.
 Also, new techniques to skip previously searched parts of the stack need to be
+Also new techniques to skip previously searched parts of the stack need to be
 developed to handle the recursive resume problem and support advanced algebraic
 effects.

doc/theses/andrew_beach_MMath/implement.tex

-              r949339b
+              r4e28d2e9
 \label{s:VirtualSystem}
 % Virtual table rules. Virtual tables, the pointer to them and the cast.
 While the \CFA virtual system currently has only two public features, virtual
+While the \CFA virtual system currently has only one public features, virtual
 cast and virtual tables,
+% ??? refs (see the virtual cast feature \vpageref{p:VirtualCast}),
 substantial structure is required to support them,
 and provide features for exception handling and the standard library.
 …
 as part of field-by-field construction.
 \subsection{Type ID}
 Every virtual type has a unique ID.
+\subsection{Type Id}
+Every virtual type has a unique id.
 These are used in type equality, to check if the representation of two values
 are the same, and to access the type's type information.
 …
 Our approach for program uniqueness is using a static declaration for each
 type ID, where the run-time storage address of that variable is guaranteed to
+type id, where the run-time storage address of that variable is guaranteed to
 be unique during program execution.
 The type ID storage can also be used for other purposes,
+The type id storage can also be used for other purposes,
 and is used for type information.
 The problem is that a type ID may appear in multiple TUs that compose a
 program (see \autoref{ss:VirtualTable}), so the initial solution would seem
 to be make it external in each translation unit. However, the type ID must
+The problem is that a type id may appear in multiple TUs that compose a
+program (see \autoref{ss:VirtualTable}); so the initial solution would seem
+to be make it external in each translation unit. Hovever, the type id must
 have a declaration in (exactly) one of the TUs to create the storage.
 No other declaration related to the virtual type has this property, so doing
 this through standard C declarations would require the user to do it manually.
 Instead, the linker is used to handle this problem.
+Instead the linker is used to handle this problem.
 % I did not base anything off of C++17; they are solving the same problem.
 A new feature has been added to \CFA for this purpose, the special attribute
 \snake{cfa_linkonce}, which uses the special section @.gnu.linkonce@.
 When used as a prefix (\eg @.gnu.linkonce.example@), the linker does
+When used as a prefix (\eg @.gnu.linkonce.example@) the linker does
 not combine these sections, but instead discards all but one with the same
 full name.
 So, each type ID must be given a unique section name with the \snake{linkonce}
 prefix. Luckily, \CFA already has a way to get unique names, the name mangler.
+So each type id must be given a unique section name with the linkonce
+prefix. Luckily \CFA already has a way to get unique names, the name mangler.
 For example, this could be written directly in \CFA:
 \begin{cfa}
 …
 __attribute__((section(".gnu.linkonce._X1fFv___1"))) void _X1fFv___1() {}
 \end{cfa}
 This is done internally to access the name mangler.
+This is done internally to access the name manglers.
 This attribute is useful for other purposes, any other place a unique
 instance required, and should eventually be made part of a public and
 …
 \subsection{Type Information}
 There is data stored at the type ID's declaration, the type information.
 The type information currently is only the parent's type ID or, if the
+There is data stored at the type id's declaration, the type information.
+The type information currently is only the parent's type id or, if the
 type has no parent, the null pointer.
 The ancestors of a virtual type are found by traversing type IDs through
+The ancestors of a virtual type are found by traversing type ids through
 the type information.
 An example using helper macros looks like:
 …
 \item
 Generate a new structure definition to store the type
 information. The layout is the same in each case, just the parent's type ID,
+information. The layout is the same in each case, just the parent's type id,
 but the types used change from instance to instance.
 The generated name is used for both this structure and, if relevant, the
 …
 \item
 The definition is generated and initialized.
 The parent ID is set to the null pointer or to the address of the parent's
+The parent id is set to the null pointer or to the address of the parent's
 type information instance. Name resolution handles the rest.
 \item
 …
 file as if it was a forward declaration, except no definition is required.
 This technique is used for type ID instances. A link-once definition is
+This technique is used for type-id instances. A link-once definition is
 generated each time the structure is seen. This will result in multiple
 copies but the link-once attribute ensures all but one are removed for a
 …
 \subsection{Virtual Table}
 \label{ss:VirtualTable}
 Each virtual type has a virtual table type that stores its type ID and
+Each virtual type has a virtual table type that stores its type id and
 virtual members.
+An instance of a virtual type is bound to a virtual table instance,
+which have the values of the virtual members.
+Both the layout of the fields (in the virtual table type)
+and their value (in the virtual table instance) are decided by the rules given
+Each virtual type instance is bound to a table instance that is filled with
+the values of virtual members.
+Both the layout of the fields and their value are decided by the rules given
 below.
 The layout always comes in three parts (see \autoref{f:VirtualTableLayout}).
 The first section is just the type ID at the head of the table. It is always
+The first section is just the type id at the head of the table. It is always
 there to ensure that it can be found even when the accessing code does not
 know which virtual type it has.
 The second section is all the virtual members of the parent, in the same
+The second section are all the virtual members of the parent, in the same
 order as they appear in the parent's virtual table. Note that the type may
 change slightly as references to the ``this" change. This is limited to
 …
 This, combined with the fixed offset to the virtual table pointer, means that
 for any virtual type, it is always safe to access its virtual table and,
 from there, it is safe to check the type ID to identify the exact type of the
+from there, it is safe to check the type id to identify the exact type of the
 underlying object, access any of the virtual members and pass the object to
 any of the method-like virtual members.
 …
 the context of the declaration.
 The type ID is always fixed, with each virtual table type having
 exactly one possible type ID.
+The type id is always fixed; with each virtual table type having
+exactly one possible type id.
 The virtual members are usually filled in by type resolution.
 The best match for a given name and type at the declaration site is used.
 There are two exceptions to that rule: the @size@ field, the type's size,
 is set using a @sizeof@ expression, and the @align@ field, the
+is set using a @sizeof@ expression and the @align@ field, the
 type's alignment, is set using an @alignof@ expression.
 Most of these tools are already inside the compiler. Using simple
 code transformations early on in compilation allows most of that work to be
+code transformations early on in compilation, allows most of that work to be
 handed off to the existing tools. \autoref{f:VirtualTableTransformation}
 shows an example transformation; this example shows an exception virtual table.
+shows an example transformation, this example shows an exception virtual table.
 It also shows the transformation on the full declaration.
 For a forward declaration, the @extern@ keyword is preserved and the
 …
         struct __cfavir_type_id * const * child );
 \end{cfa}
 The type ID for the target type of the virtual cast is passed in as
+The type id for the target type of the virtual cast is passed in as
 @parent@ and
 the cast target is passed in as @child@.
 …
 The virtual cast either returns the original pointer or the null pointer
 as the new type.
 The function does the parent check and returns the appropriate value.
 The parent check is a simple linear search of the child's ancestors using the
+So the function does the parent check and returns the appropriate value.
+The parent check is a simple linear search of child's ancestors using the
 type information.
 …
 % The implementation of exception types.
 Creating exceptions can be roughly divided into two parts:
+Creating exceptions can roughly divided into two parts,
 the exceptions themselves and the virtual system interactions.
 …
 All types associated with a virtual type,
 the types of the virtual table and the type ID,
+the types of the virtual table and the type id,
 are generated when the virtual type (the exception) is first found.
 The type ID (the instance) is generated with the exception, if it is
+The type id (the instance) is generated with the exception, if it is
 a monomorphic type.
 However, if the exception is polymorphic, then a different type ID has to
+However, if the exception is polymorphic, then a different type id has to
 be generated for every instance. In this case, generation is delayed
 until a virtual table is created.
 …
 When a virtual table is created and initialized, two functions are created
 to fill in the list of virtual members.
 The first is the @copy@ function that adapts the exception's copy constructor
+The first is a copy function that adapts the exception's copy constructor
 to work with pointers, avoiding some issues with the current copy constructor
 interface.
 Second is the @msg@ function that returns a C-string with the type's name,
+Second is the msg function that returns a C-string with the type's name,
 including any polymorphic parameters.
 …
 % Discussing multiple frame stack unwinding:
 Unwinding across multiple stack frames is more complex, because that
+Unwinding across multiple stack frames is more complex because that
 information is no longer contained within the current function.
 With separate compilation,
 a function does not know its callers nor their frame layout.
 Even using the return address, that information is encoded in terms of
 actions in code, intermixed with the actions required to finish the function.
+actions in code, intermixed with the actions required finish the function.
 Without changing the main code path it is impossible to select one of those
 two groups of actions at the return site.
 The traditional unwinding mechanism for C is implemented by saving a snapshot
 of a function's state with @setjmp@ and restoring that snapshot with
+The traditional unwinding mechanism for C is implemented by saving a snap-shot
+of a function's state with @setjmp@ and restoring that snap-shot with
 @longjmp@. This approach bypasses the need to know stack details by simply
+resetting to a snapshot of an arbitrary but existing function frame on the
+stack. It is up to the programmer to ensure the snapshot is valid when it is
+reset and that all required cleanup from the unwound stacks is performed.
+Because it does not automate or check any of this cleanup,
+it can be easy to make mistakes and always must be handled manually.
+reseting to a snap-shot of an arbitrary but existing function frame on the
+stack. It is up to the programmer to ensure the snap-shot is valid when it is
+reset and that all required clean-up from the unwound stacks is performed.
+This approach is fragile and requires extra work in the surrounding code.
 With respect to the extra work in the surrounding code,
 many languages define cleanup actions that must be taken when certain
 sections of the stack are removed, such as when the storage for a variable
+many languages define clean-up actions that must be taken when certain
+sections of the stack are removed. Such as when the storage for a variable
 is removed from the stack, possibly requiring a destructor call,
 or when a try statement with a finally clause is
 (conceptually) popped from the stack.
 None of these cases should be handled by the user -- that would contradict the
 intention of these features -- so they need to be handled automatically.
+None of these cases should be handled by the user --- that would contradict the
+intention of these features --- so they need to be handled automatically.
 To safely remove sections of the stack, the language must be able to find and
 run these cleanup actions even when removing multiple functions unknown at
+run these clean-up actions even when removing multiple functions unknown at
 the beginning of the unwinding.
 …
 library that provides tools for stack walking, handler execution, and
 unwinding. What follows is an overview of all the relevant features of
+libunwind needed for this work.
+Following that is the description of the \CFA code that uses libunwind
+to implement termination.
+libunwind needed for this work, and how \CFA uses them to implement exception
+handling.
 \subsection{libunwind Usage}
 …
 provided storage object. It has two public fields: the @exception_class@,
 which is described above, and the @exception_cleanup@ function.
 The cleanup function is used by the EHM to clean up the exception. If it
+The clean-up function is used by the EHM to clean-up the exception, if it
 should need to be freed at an unusual time, it takes an argument that says
 why it had to be cleaned up.
 …
 of the most recent stack frame. It continues to call personality functions
 traversing the stack from newest to oldest until a function finds a handler or
 the end of the stack is reached. In the latter case,
 @_Unwind_RaiseException@ returns @_URC_END_OF_STACK@.
 Second, when a handler is matched, @_Unwind_RaiseException@
 moves to the cleanup phase and walks the stack a second time.
+the end of the stack is reached. In the latter case, raise exception returns
+@_URC_END_OF_STACK@.
+Second, when a handler is matched, raise exception moves to the clean-up
+phase and walks the stack a second time.
 Once again, it calls the personality functions of each stack frame from newest
 to oldest. This pass stops at the stack frame containing the matching handler.
 If that personality function has not installed a handler, it is an error.
 If an error is encountered, @_Unwind_RaiseException@ returns either
+If that personality function has not install a handler, it is an error.
+If an error is encountered, raise exception returns either
 @_URC_FATAL_PHASE1_ERROR@ or @_URC_FATAL_PHASE2_ERROR@ depending on when the
 error occurred.
 …
         _Unwind_Stop_Fn, void *);
 \end{cfa}
+It also unwinds the stack but it does not use the search phase. Instead,
+another
+It also unwinds the stack but it does not use the search phase. Instead another
 function, the stop function, is used to stop searching. The exception is the
+same as the one passed to @_Unwind_RaiseException@.
+The extra arguments are the stop
+same as the one passed to raise exception. The extra arguments are the stop
 function and the stop parameter. The stop function has a similar interface as a
 personality function, except it is also passed the stop parameter.
 …
 one list per stack, with the
 list head stored in the exception context. Within each linked list, the most
 recently thrown exception is at the head, followed by older thrown
+recently thrown exception is at the head followed by older thrown
 exceptions. This format allows exceptions to be thrown, while a different
 exception is being handled. The exception at the head of the list is currently
 …
 exception into managed memory. After the exception is handled, the free
 function is used to clean up the exception and then the entire node is
 passed to @free@, returning the memory back to the heap.
+passed to free, returning the memory back to the heap.
 \subsection{Try Statements and Catch Clauses}
 …
 The three functions passed to try terminate are:
 \begin{description}
 \item[try function:] This function is the try block. It is where all the code
+\item[try function:] This function is the try block, it is where all the code
 from inside the try block is placed. It takes no parameters and has no
 return value. This function is called during regular execution to run the try
 …
 from the conditional part of each handler and runs each check, top to bottom,
 in turn, to see if the exception matches this handler.
 The match is performed in two steps: first, a virtual cast is used to check
+The match is performed in two steps, first a virtual cast is used to check
 if the raised exception is an instance of the declared exception type or
 one of its descendant types, and then the condition is evaluated, if
 present.
 The match function takes a pointer to the exception and returns 0 if the
 exception is not handled here. Otherwise, the return value is the ID of the
+exception is not handled here. Otherwise the return value is the id of the
 handler that matches the exception.
 …
 \end{description}
 All three functions are created with GCC nested functions. GCC nested functions
 can be used to create closures;
+can be used to create closures,
 in other words,
 functions that can refer to variables in their lexical scope even though
+functions that can refer to variables in their lexical scope even
 those variables are part of a different function.
 This approach allows the functions to refer to all the
 …
 At each node, the EHM checks to see if the try statement the node represents
 can handle the exception. If it can, then the exception is handled and
 the operation finishes; otherwise, the search continues to the next node.
+the operation finishes, otherwise the search continues to the next node.
 If the search reaches the end of the list without finding a try statement
 with a handler clause
 …
 if the exception is handled and false otherwise.
 The handler function checks each of its internal handlers in order,
 top-to-bottom, until it finds a match. If a match is found that handler is
+top-to-bottom, until it funds a match. If a match is found that handler is
 run, after which the function returns true, ignoring all remaining handlers.
 If no match is found the function returns false.
 The match is performed in two steps. First a virtual cast is used to see
+The match is performed in two steps, first a virtual cast is used to see
 if the raised exception is an instance of the declared exception type or one
+of its descendant types, if so, then the second step is to see if the
+exception passes the custom predicate
+of its descendant types, if so then it is passed to the custom predicate
 if one is defined.
 % You need to make sure the type is correct before running the predicate
 …
 % Recursive Resumption Stuff:
 \autoref{f:ResumptionMarking} shows search skipping
 (see \autoref{s:ResumptionMarking}), which ignores parts of
+(see \vpageref{s:ResumptionMarking}), which ignores parts of
 the stack
 already examined, and is accomplished by updating the front of the list as
 …
 This structure also supports new handlers added while the resumption is being
 handled. These are added to the front of the list, pointing back along the
 stack -- the first one points over all the checked handlers --
+stack --- the first one points over all the checked handlers ---
 and the ordering is maintained.
 …
 %\autoref{code:cleanup}
 A finally clause is handled by converting it into a once-off destructor.
 The code inside the clause is placed into a GCC nested-function
+The code inside the clause is placed into GCC nested-function
 with a unique name, and no arguments or return values.
 This nested function is
 then set as the cleanup function of an empty object that is declared at the
 beginning of a block placed around the context of the associated try
 statement, as shown in \autoref{f:FinallyTransformation}.
+statement (see \autoref{f:FinallyTransformation}).
 \begin{figure}
 …
 % Stack selections, the three internal unwind functions.
 Cancellation also uses libunwind to do its stack traversal and unwinding.
 However, it uses a different primary function: @_Unwind_ForcedUnwind@. Details
 of its interface can be found in Section~\vref{s:ForcedUnwind}.
+Cancellation also uses libunwind to do its stack traversal and unwinding,
+however it uses a different primary function: @_Unwind_ForcedUnwind@. Details
+of its interface can be found in the Section~\vref{s:ForcedUnwind}.
 The first step of cancellation is to find the cancelled stack and its type:

doc/theses/andrew_beach_MMath/intro.tex

-              r949339b
+              r4e28d2e9
 All types of exception handling link a raise with a handler.
 Both operations are usually language primitives, although raises can be
 treated as a function that takes an exception argument.
 Handlers are more complex, as they are added to and removed from the stack
 during execution, must specify what they can handle and must give the code to
+treated as a primitive function that takes an exception argument.
+Handlers are more complex as they are added to and removed from the stack
+during execution, must specify what they can handle and give the code to
 handle the exception.
 …
 it returns control to that function.
 \begin{center}
+%\input{termination}
+%
+%\medskip
+\input{termhandle.pstex_t}
+% I hate these diagrams, but I can't access xfig to fix them and they are
+% better than the alternative.
+\input{termination}
 \end{center}
 …
 The handler is run on top of the existing stack, often as a new function or
 closure capturing the context in which the handler was defined.
 After the handler has finished running, it returns control to the function
+After the handler has finished running it returns control to the function
 that preformed the raise, usually starting after the raise.
 \begin{center}
+%\input{resumption}
+%
+%\medskip
+\input{resumhandle.pstex_t}
+% The other one.
+\input{resumption}
 \end{center}
 Although a powerful feature, exception handling tends to be complex to set up
 and expensive to use,
+and expensive to use
 so it is often limited to unusual or ``exceptional" cases.
 The classic example is error handling; exceptions can be used to
+The classic example is error handling, exceptions can be used to
 remove error handling logic from the main execution path, and pay
 most of the cost only when the error actually occurs.
 …
 The \CFA EHM implements all of the common exception features (or an
 equivalent) found in most other EHMs and adds some features of its own.
 The design of all the features had to be adapted to \CFA's feature set, as
+The design of all the features had to be adapted to \CFA's feature set as
 some of the underlying tools used to implement and express exception handling
 in other languages are absent in \CFA.
 Still, the resulting syntax resembles that of other languages:
+Still the resulting syntax resembles that of other languages:
 \begin{cfa}
 try {
 …
 covering both changes to the compiler and the run-time.
 In addition, a suite of test cases and performance benchmarks were created
 alongside the implementation.
+along side the implementation.
 The implementation techniques are generally applicable in other programming
 languages and much of the design is as well.
 …
 \item Implementing stack unwinding and the \CFA EHM, including updating
 the \CFA compiler and the run-time environment.
 \item Designing and implementing a prototype virtual system.
+\item Designed and implemented a prototype virtual system.
 % I think the virtual system and per-call site default handlers are the only
 % "new" features, everything else is a matter of implementation.
 \item Creating tests to check the behaviour of the EHM.
 \item Creating benchmarks to check the performance of the EHM,
+\item Creating benchmarks to check the performances of the EHM,
 as compared to other languages.
 \end{enumerate}
 …
 The rest of this thesis is organized as follows.
 The current state of exceptions is covered in \autoref{s:background}.
 The existing state of \CFA is covered in \autoref{c:existing}.
+The existing state of \CFA is also covered in \autoref{c:existing}.
 New EHM features are introduced in \autoref{c:features},
 covering their usage and design.
 …
 message as a payload\cite{Ada12}.
 The modern flagship for termination exceptions -- if one exists -- is \Cpp,
+The modern flag-ship for termination exceptions is \Cpp,
 which added them in its first major wave of non-object-orientated features
 in 1990.\cite{CppHistory}
 …
 inheriting from
 \code{C++}{std::exception}.
 Although there is a special catch-all syntax (@catch(...)@), there are no
+Although there is a special catch-all syntax (@catch(...)@) there are no
 operations that can be performed on the caught value, not even type inspection.
 Instead, the base exception-type \code{C++}{std::exception} defines common
+Instead the base exception-type \code{C++}{std::exception} defines common
 functionality (such as
 the ability to describe the reason the exception was raised) and all
 …
 Java was the next popular language to use exceptions.\cite{Java8}
 Its exception system largely reflects that of \Cpp, except that it requires
+Its exception system largely reflects that of \Cpp, except that requires
 you throw a child type of \code{Java}{java.lang.Throwable}
 and it uses checked exceptions.
 Checked exceptions are part of a function's interface,
 the exception signature of the function.
 Every exception that could be raised from a function, either directly or
+Every function that could be raised from a function, either directly or
 because it is not handled from a called function, is given.
 Using this information, it is possible to statically verify if any given
 exception is handled, and guarantee that no exception will go unhandled.
+exception is handled and guarantee that no exception will go unhandled.
 Making exception information explicit improves clarity and safety,
 but can slow down or restrict programming.
 …
 recovery or repair. In theory that could be good enough to properly handle
 the exception, but more often is used to ignore an exception that the
 programmer does not feel is worth the effort of handling, for instance if
+programmer does not feel is worth the effort of handling it, for instance if
 they do not believe it will ever be raised.
 If they are incorrect, the exception will be silenced, while in a similar
+If they are incorrect the exception will be silenced, while in a similar
 situation with unchecked exceptions the exception would at least activate
 the language's unhandled exception code (usually, a program abort with an
+the language's unhandled exception code (usually program abort with an
 error message).
 %\subsection
 Resumption exceptions are less popular,
 although resumption is as old as termination; that is, few
+although resumption is as old as termination; hence, few
 programming languages have implemented them.
 % http://bitsavers.informatik.uni-stuttgart.de/pdf/xerox/parc/techReports/
 …
 included in the \Cpp standard.
 % https://en.wikipedia.org/wiki/Exception_handling
 Since then, resumptions have been ignored in mainstream programming languages.
+Since then resumptions have been ignored in main-stream programming languages.
 However, resumption is being revisited in the context of decades of other
 developments in programming languages.
 While rejecting resumption may have been the right decision in the past,
 the situation has changed since then.
 Some developments, such as the functional programming equivalent to resumptions,
+Some developments, such as the function programming equivalent to resumptions,
 algebraic effects\cite{Zhang19}, are enjoying success.
 A complete reexamination of resumption is beyond this thesis,
 but their reemergence is enough reason to try them in \CFA.
+A complete reexamination of resumptions is beyond this thesis,
+but there reemergence is enough to try them in \CFA.
 % Especially considering how much easier they are to implement than
 % termination exceptions and how much Peter likes them.
 …
 %\subsection
 More recently, exceptions seem to be vanishing from newer programming
+More recently exceptions seem to be vanishing from newer programming
 languages, replaced by ``panic".
 In Rust, a panic is just a program level abort that may be implemented by
 unwinding the stack like in termination exception
 handling.\cite{RustPanicMacro}\cite{RustPanicModule}
 Go's panic though is very similar to a termination, except it only supports
+Go's panic through is very similar to a termination, except it only supports
 a catch-all by calling \code{Go}{recover()}, simplifying the interface at
 the cost of flexibility.\cite{Go:2021}
 %\subsection
 As exception handling's most common use cases are in error handling,
+While exception handling's most common use cases are in error handling,
 here are some other ways to handle errors with comparisons with exceptions.
 \begin{itemize}
 …
 is discarded to avoid this problem.
 Checking error codes also bloats the main execution path,
 especially if the error is not handled immediately and has to be passed
+especially if the error is not handled immediately hand has to be passed
 through multiple functions before it is addressed.
-Here is an example of the pattern in Bash, where commands can only  ``return"
-numbers and most output is done through streams of text.
-\begin{lstlisting}[language=bash,escapechar={}]
-# Immediately after running a command:
-case $? in
-)
-        # Success
-        ;;
-)
-        # Error Code 1
-        ;;
-|3)
-        # Error Code 2 or Error Code 3
-        ;;
-# Add more cases as needed.
-asac
-\end{lstlisting}
 \item\emph{Special Return with Global Store}:
 Similar to the error codes pattern but the function itself only returns
 that there was an error,
 and stores the reason for the error in a fixed global location.
 For example, many routines in the C standard library will only return some
+that there was an error
+and store the reason for the error in a fixed global location.
+For example many routines in the C standard library will only return some
 error value (such as -1 or a null pointer) and the error code is written into
 the standard variable @errno@.
 This approach avoids the multiple results issue encountered with straight
+error codes as only a single error value has to be returned,
+but otherwise has the same disadvantages and more.
+error codes but otherwise has the same disadvantages and more.
 Every function that reads or writes to the global store must agree on all
 possible errors and managing it becomes more complex with concurrency.
-This example shows some of what has to be done to robustly handle a C
-standard library function that reports errors this way.
-\begin{lstlisting}[language=C]
-// Now a library function can set the error.
-int handle = open(path_name, flags);
-if (-1 == handle) {
-        switch (errno) {
-    case ENAMETOOLONG:
-                // path_name is a bad argument.
-                break;
-        case ENFILE:
-                // A system resource has been exausted.
-                break;
-        // And many more...
+    }
+}
-\end{lstlisting}
-% cite open man page?
 \item\emph{Return Union}:
 …
 Success is one tag and the errors are another.
 It is also possible to make each possible error its own tag and carry its own
 additional information, but the two-branch format is easy to make generic
+additional information, but the two branch format is easy to make generic
 so that one type can be used everywhere in error handling code.
 This pattern is very popular in any functional or semi-functional language
 with primitive support for tagged unions (or algebraic data types).
-Return unions can also be expressed as monads (evaluation in a context)
-and often are in languages with special syntax for monadic evaluation,
-such as Haskell's \code{haskell}{do} blocks.
-The main advantage is that an arbitrary object can be used to represent an
-error, so it can include a lot more information than a simple error code.
-The disadvantages include that the it does have to be checked along the main
-execution, and if there aren't primitive tagged unions proper, usage can be
-hard to enforce.
 % We need listing Rust/rust to format code snippets from it.
 % Rust's \code{rust}{Result<T, E>}
+This is a simple example of examining the result of a failing function in
+Haskell, using its \code{haskell}{Either} type.
+Examining \code{haskell}{error} further would likely involve more matching,
+but the type of \code{haskell}{error} is user defined so there are no
+general cases.
+\begin{lstlisting}[language=haskell]
+case failingFunction argA argB of
+    Right value -> -- Use the successful computed value.
+    Left error -> -- Handle the produced error.
+\end{lstlisting}
+Return unions as monads will result in the same code, but can hide most
+of the work to propagate errors in simple cases. The code to actually handle
+the errors, or to interact with other monads (a common case in these
+languages) still has to be written by hand.
+If \code{haskell}{failingFunction} is implemented with two helpers that
+use the same error type, then it can be implemented with a \code{haskell}{do}
+block.
+\begin{lstlisting}[language=haskell,literate={}]
+failingFunction x y = do
+        z <- helperOne x
+        helperTwo y z
+\end{lstlisting}
+The main advantage is that an arbitrary object can be used to represent an
+error so it can include a lot more information than a simple error code.
+The disadvantages include that the it does have to be checked along the main
+execution and if there aren't primitive tagged unions proper usage can be
+hard to enforce.
 \item\emph{Handler Functions}:
 …
 variable).
 C++ uses this approach as its fallback system if exception handling fails,
+such as \snake{std::terminate} and, for a time,
+\snake{std::unexpected}.\footnote{\snake{std::unexpected} was part of the
+Dynamic Exception Specification, which has been removed from the standard
+as of C++20.\cite{CppExceptSpec}}
+such as \snake{std::terminate_handler} and, for a time,
+\snake{std::unexpected_handler}.
 Handler functions work a lot like resumption exceptions,
 …
 function calls, but cheaper (constant time) to call,
 they are more suited to more frequent (less exceptional) situations.
-Although, in \Cpp and other languages that do not have checked exceptions,
-they can actually be enforced by the type system be more reliable.
-This is a more local example in \Cpp, using a function to provide
-a default value for a mapping.
-\begin{lstlisting}[language=C++]
-ValueT Map::key_or_default(KeyT key, ValueT(*make_default)(KeyT)) {
-        ValueT * value = find_value(key);
-        if (nullptr != value) {
-                return *value;
-        } else {
-                return make_default(key);
+        }
+}
-\end{lstlisting}
 \end{itemize}
 …
 Because of their cost, exceptions are rarely used for hot paths of execution.
 Hence, there is an element of self-fulfilling prophecy as implementation
 techniques have been focused on making them cheap to set up,
+techniques have been focused on making them cheap to set-up,
 happily making them expensive to use in exchange.
 This difference is less important in higher-level scripting languages,
 where using exceptions for other tasks is more common.
+where using exception for other tasks is more common.
 An iconic example is Python's
 \code{Python}{StopIteration}\cite{PythonExceptions} exception, that
+\code{Python}{StopIteration}\cite{PythonExceptions} exception that
 is thrown by an iterator to indicate that it is exhausted.
 When paired with Python's iterator-based for-loop, this will be thrown every
+When paired with Python's iterator-based for-loop this will be thrown every
 time the end of the loop is reached.\cite{PythonForLoop}

doc/theses/andrew_beach_MMath/performance.tex

-              r949339b
+              r4e28d2e9
 Instead, the focus was to get the features working. The only performance
 requirement is to ensure the tests for correctness run in a reasonable
 amount of time. Hence, only a few basic performance tests were performed to
+amount of time. Hence, a few basic performance tests were performed to
 check this requirement.
 …
 one with termination and one with resumption.
 GCC C++ is the most comparable language because both it and \CFA use the same
+C++ is the most comparable language because both it and \CFA use the same
 framework, libunwind.
 In fact, the comparison is almost entirely in quality of implementation.
 …
 resumption exceptions. Even the older programming languages with resumption
 seem to be notable only for having resumption.
-On the other hand, the functional equivalents to resumption are too new.
-There does not seem to be any standard implementations in well-known
-languages; so far, they seem confined to extensions and research languages.
-% There was some maybe interesting comparison to an OCaml extension
-% but I'm not sure how to get that working if it is interesting.
 Instead, resumption is compared to its simulation in other programming
 languages: fixup functions that are explicitly passed into a function.
 …
 the number used in the timing runs is given with the results per test.
 The Java tests run the main loop 1000 times before
 beginning the actual test to ``warm up" the JVM.
+beginning the actual test to ``warm-up" the JVM.
 % All other languages are precompiled or interpreted.
 …
 unhandled exceptions in \Cpp and Java as that would cause the process to
 terminate.
 Luckily, performance on the ``give up and kill the process" path is not
+Luckily, performance on the ``give-up and kill the process" path is not
 critical.
 …
 using gcc-10 10.3.0 as a backend.
 g++-10 10.3.0 is used for \Cpp.
 Java tests are complied and run with Oracle OpenJDK version 11.0.11.
 Python used CPython version 3.8.10.
+Java tests are complied and run with version 11.0.11.
+Python used version 3.8.10.
 The machines used to run the tests are:
 \begin{itemize}[nosep]
 …
       \lstinline{@} 2.5 GHz running Linux v5.11.0-25
 \end{itemize}
 These represent the two major families of hardware architecture.
+Representing the two major families of hardware architecture.
 \section{Tests}
 …
 \paragraph{Stack Traversal}
 This group of tests measures the cost of traversing the stack
+This group measures the cost of traversing the stack,
 (and in termination, unwinding it).
 Inside the main loop is a call to a recursive function.
 …
 This group of tests measures the cost for setting up exception handling,
 if it is
 not used because the exceptional case did not occur.
+not used (because the exceptional case did not occur).
 Tests repeatedly cross (enter, execute and leave) a try statement but never
 perform a raise.
 …
 for that language and the result is marked N/A.
 There are also cases where the feature is supported but measuring its
 cost is impossible. This happened with Java, which uses a JIT that optimizes
 away the tests and cannot be stopped.\cite{Dice21}
+cost is impossible. This happened with Java, which uses a JIT that optimize
+away the tests and it cannot be stopped.\cite{Dice21}
 These tests are marked N/C.
 To get results in a consistent range (1 second to 1 minute is ideal,
 …
 results and has a value in the millions.
 An anomaly in some results came from \CFA's use of GCC nested functions.
+An anomaly in some results came from \CFA's use of gcc nested functions.
 These nested functions are used to create closures that can access stack
 variables in their lexical scope.
 However, if they do so, then they can cause the benchmark's run time to
+However, if they do so, then they can cause the benchmark's run-time to
 increase by an order of magnitude.
 The simplest solution is to make those values global variables instead
 of function-local variables.
+of function local variables.
 % Do we know if editing a global inside nested function is a problem?
 Tests that had to be modified to avoid this problem have been marked
 …
                          \multicolumn{1}{c}{\CFA} & \multicolumn{1}{c}{\Cpp} & \multicolumn{1}{c}{Java} & \multicolumn{1}{c|}{Python} \\
 \hline
 Empty Traversal (1M)   & 23.0  & 9.6   & 17.6  & 23.4      & 30.6  & 13.6  & 15.5  & 14.7  \\
 D'tor Traversal (1M)   & 48.1  & 23.5  & N/A   & N/A       & 64.2  & 29.2  & N/A   & N/A   \\
 Finally Traversal (1M) & 3.2*  & N/A   & 17.6  & 29.2      & 3.9*  & N/A   & 15.5  & 19.0  \\
 Other Traversal (1M)   & 3.3*  & 23.9  & 17.7  & 32.8      & 3.9*  & 24.5  & 15.5  & 21.6  \\
 Cross Handler (1B)     & 6.5   & 0.9   & N/C   & 38.0      & 9.6   & 0.8   & N/C   & 32.1  \\
 Cross Finally (1B)     & 0.8   & N/A   & N/C   & 44.6      & 0.6   & N/A   & N/C   & 37.3  \\
 Match All (10M)        & 30.5  & 20.6  & 11.2  & 3.9       & 36.9  & 24.6  & 10.7  & 3.1   \\
 Match None (10M)       & 30.6  & 50.9  & 11.2  & 5.0       & 36.9  & 71.9  & 10.7  & 4.1   \\
+Empty Traversal (1M)   & 3.4   & 2.8   & 18.3  & 23.4      & 3.7   & 3.2   & 15.5  & 14.8  \\
+D'tor Traversal (1M)   & 48.4  & 23.6  & N/A   & N/A       & 64.2  & 29.0  & N/A   & N/A   \\
+Finally Traversal (1M) & 3.4*  & N/A   & 17.9  & 29.0      & 4.1*  & N/A   & 15.6  & 19.0  \\
+Other Traversal (1M)   & 3.6*  & 23.2  & 18.2  & 32.7      & 4.0*  & 24.5  & 15.5  & 21.4  \\
+Cross Handler (100M)   & 6.0   & 0.9   & N/C   & 37.4      & 10.0  & 0.8   & N/C   & 32.2  \\
+Cross Finally (100M)   & 0.9   & N/A   & N/C   & 44.1      & 0.8   & N/A   & N/C   & 37.3  \\
+Match All (10M)        & 32.9  & 20.7  & 13.4  & 4.9       & 36.2  & 24.5  & 12.0  & 3.1   \\
+Match None (10M)       & 32.7  & 50.3  & 11.0  & 5.1       & 36.3  & 71.9  & 12.3  & 4.2   \\
 \hline
 \end{tabular}
 …
                         & AMD     & ARM  \\
 \hline
 Empty Traversal (10M)   & 1.4     & 1.2  \\
+Empty Traversal (10M)   & 0.2     & 0.3  \\
 D'tor Traversal (10M)   & 1.8     & 1.0  \\
 Finally Traversal (10M) & 1.8     & 1.0  \\
 Other Traversal (10M)   & 22.6    & 25.8 \\
 Cross Handler (1B)      & 9.0     & 11.9 \\
+Finally Traversal (10M) & 1.7     & 1.0  \\
+Other Traversal (10M)   & 22.6    & 25.9 \\
+Cross Handler (100M)    & 8.4     & 11.9 \\
 Match All (100M)        & 2.3     & 3.2  \\
 Match None (100M)       & 3.0     & 3.8  \\
+Match None (100M)       & 2.9     & 3.9  \\
 \hline
 \end{tabular}
 …
               \multicolumn{1}{c}{Raise} & \multicolumn{1}{c}{\CFA} & \multicolumn{1}{c}{\Cpp} & \multicolumn{1}{c}{Java} & \multicolumn{1}{c|}{Python} \\
 \hline
 Resume Empty (10M)  & 1.4 & 1.4 & 15.4 & 2.3 & 178.0  & 1.2 & 1.2 & 8.9 & 1.2 & 118.4 \\
+Resume Empty (10M)  & 1.5 & 1.5 & 14.7 & 2.3 & 176.1  & 1.0 & 1.4 & 8.9 & 1.2 & 119.9 \\
 \hline
 \end{tabular}
 …
 \CFA, \Cpp and Java.
 % To be exact, the Match All and Match None cases.
+The most likely explanation is that
+the generally faster languages have made ``common cases fast" at the expense
+of the rarer cases. Since exceptions are considered rare, they are made
+expensive to help speed up common actions, such as entering and leaving try
+statements.
+Python, on the other hand, while generally slower than the other languages,
+uses exceptions more and has not sacrificed their performance.
+The most likely explanation is that, since exceptions
+are rarely considered to be the common case, the more optimized languages
+make that case expensive to improve other cases.
 In addition, languages with high-level representations have a much
 easier time scanning the stack as there is less to decode.
 …
 Performance is similar to Empty Traversal in all languages that support finally
 clauses. Only Python seems to have a larger than random noise change in
 its run time and it is still not large.
+its run-time and it is still not large.
 Despite the similarity between finally clauses and destructors,
 finally clauses seem to avoid the spike that run time destructors have.
+finally clauses seem to avoid the spike that run-time destructors have.
 Possibly some optimization removes the cost of changing contexts.
 …
 This results in a significant jump.
 Other languages experience a small increase in run time.
+Other languages experience a small increase in run-time.
 The small increase likely comes from running the checks,
 but they could avoid the spike by not having the same kind of overhead for
 …
 \item[Cross Handler]
 Here, \CFA falls behind \Cpp by a much more significant margin.
 This is likely due to the fact that \CFA has to insert two extra function
 calls, while \Cpp does not have to execute any other instructions.
+Here \CFA falls behind \Cpp by a much more significant margin.
+This is likely due to the fact \CFA has to insert two extra function
+calls, while \Cpp does not have to do execute any other instructions.
 Python is much further behind.
 …
 \item[Conditional Match]
 Both of the conditional matching tests can be considered on their own.
 However, for evaluating the value of conditional matching itself, the
+However for evaluating the value of conditional matching itself, the
 comparison of the two sets of results is useful.
 Consider the massive jump in run time for \Cpp going from match all to match
+Consider the massive jump in run-time for \Cpp going from match all to match
 none, which none of the other languages have.
 Some strange interaction is causing run time to more than double for doing
+Some strange interaction is causing run-time to more than double for doing
 twice as many raises.
 Java and Python avoid this problem and have similar run time for both tests,
+Java and Python avoid this problem and have similar run-time for both tests,
 possibly through resource reuse or their program representation.
+However, \CFA is built like \Cpp, and avoids the problem as well.
+This matches
+However \CFA is built like \Cpp and avoids the problem as well, this matches
 the pattern of the conditional match, which makes the two execution paths
 very similar.
 …
 \subsection{Resumption \texorpdfstring{(\autoref{t:PerformanceResumption})}{}}
 Moving on to resumption, there is one general note:
+Moving on to resumption, there is one general note,
 resumption is \textit{fast}. The only test where it fell
 behind termination is Cross Handler.
 In every other case, the number of iterations had to be increased by a
 factor of 10 to get the run time in an appropriate range
+factor of 10 to get the run-time in an appropriate range
 and in some cases resumption still took less time.
 …
 \item[D'tor Traversal]
 Resumption does have the same spike in run time that termination has.
 The run time is actually very similar to Finally Traversal.
+Resumption does have the same spike in run-time that termination has.
+The run-time is actually very similar to Finally Traversal.
 As resumption does not unwind the stack, both destructors and finally
 clauses are run while walking down the stack during the recursive returns.
 …
 \item[Finally Traversal]
 Same as D'tor Traversal,
 except termination did not have a spike in run time on this test case.
+except termination did not have a spike in run-time on this test case.
 \item[Other Traversal]
 …
 The only test case where resumption could not keep up with termination,
 although the difference is not as significant as many other cases.
 It is simply a matter of where the costs come from:
 both termination and resumption have some work to set up or tear down a
+It is simply a matter of where the costs come from,
+both termination and resumption have some work to set-up or tear-down a
 handler. It just so happens that resumption's work is slightly slower.
 …
 Resumption shows a slight slowdown if the exception is not matched
 by the first handler, which follows from the fact the second handler now has
 to be checked. However, the difference is not large.
+to be checked. However the difference is not large.
 \end{description}
 …
 More experiments could try to tease out the exact trade-offs,
 but the prototype's only performance goal is to be reasonable.
 It is already in that range, and \CFA's fixup routine simulation is
+It has already in that range, and \CFA's fixup routine simulation is
 one of the faster simulations as well.
 Plus, exceptions add features and remove syntactic overhead,
 so even at similar performance, resumptions have advantages
+Plus exceptions add features and remove syntactic overhead,
+so even at similar performance resumptions have advantages
 over fixup routines.

doc/theses/andrew_beach_MMath/uw-ethesis-frontpgs.tex

-              r949339b
+              r4e28d2e9
 \begin{center}\textbf{Abstract}\end{center}
+The \CFA (Cforall) programming language is an evolutionary refinement of
+the C programming language, adding modern programming features without
+changing the programming paradigms of C.
+One of these modern programming features is more powerful error handling
+through the addition of an exception handling mechanism (EHM).
+This thesis covers the design and implementation of the \CFA EHM,
+along with a review of the other required \CFA features.
+The EHM includes common features of termination exception handling,
+which abandons and recovers from an operation,
+and similar support for resumption exception handling,
+which repairs and continues with an operation.
+The design of both has been adapted to utilize other tools \CFA provides,
+as well as fit with the assertion based interfaces of the language.
+The EHM has been implemented into the \CFA compiler and run-time environment.
+Although it has not yet been optimized, performance testing has shown it has
+comparable performance to other EHMs,
+which is sufficient for use in current \CFA programs.
+This is the abstract.
 \cleardoublepage
 …
 \begin{center}\textbf{Acknowledgements}\end{center}
+As is tradition and his due, I would like to begin by thanking my
+supervisor Peter Buhr. From accepting me in a first place,
+to helping me run performance tests, I would not be here without him.
+Also if there was an ``artist" field here he would be listed there as well,
+he helped me a lot with the diagrams.
+I would like to thank the readers
+Gregor Richards and Yizhou Zhang
+for their feedback and approval.
+The presentation of the thesis has definitely been improved with their
+feedback.
+I also thank the entire Cforall Team who built the rest of the
+\CFA compiler. From the existing features I used in my work, to the
+internal tooling that makes further development easier and the optimizations
+that make running tests pass by quickly.
+This includes: Aaron Moss, Rob Schluntz, Thierry Delisle, Michael Brooks,
+Mubeen Zulfieqar \& Fangren Yu.
+And thank-you Henry Xue, the co-op student who
+converted my macro implementation of exception declarations into
+the compiler features presented in this thesis.
+Finally I thank my family, who are still relieved I learned how to read.
+I would like to thank all the little people who made this thesis possible.
 \cleardoublepage

doc/theses/andrew_beach_MMath/uw-ethesis.bib

-              r949339b
+              r4e28d2e9
+}
-@misc{CppExceptSpec,
-    author={C++ Community},
-    key={Cpp Reference Exception Specification},
-    howpublished={\href{https://en.cppreference.com/w/cpp/language/except_spec}{https://\-en.cppreference.com/\-w/\-cpp/\-language/\-except\_spec}},
-    addendum={Accessed 2021-09-08},
+}
 @misc{RustPanicMacro,
     author={The Rust Team},
     key={Rust Panic Macro},
     howpublished={\href{https://doc.rust-lang.org/std/macro.panic.html}{https://\-doc.rust-lang.org/\-std/\-macro.panic.html}},
+    howpublished={\href{https://doc.rust-lang.org/std/panic/index.html}{https://\-doc.rust-lang.org/\-std/\-panic/\-index.html}},
     addendum={Accessed 2021-08-31},
+}

libcfa/src/Makefile.am

-              r949339b
+              r4e28d2e9
         math.hfa \
         time_t.hfa \
-        bits/algorithm.hfa \
         bits/align.hfa \
         bits/containers.hfa \
 …
         containers/array.hfa \
         concurrency/iofwd.hfa \
+        concurrency/mutex_stmt.hfa \
         containers/list.hfa \
         containers/queueLockFree.hfa \
 …
         memory.hfa \
         parseargs.hfa \
-        parseconfig.hfa \
         rational.hfa \
         stdlib.hfa \
 …
         containers/pair.hfa \
         containers/result.hfa \
-        containers/string.hfa \
-        containers/string_res.hfa \
         containers/vector.hfa \
         device/cpu.hfa
 …
 libsrc = ${inst_headers_src} ${inst_headers_src:.hfa=.cfa} \
         assert.cfa \
+        bits/algorithm.hfa \
         bits/debug.cfa \
         exception.c \
 …
         concurrency/invoke.h \
         concurrency/future.hfa \
+        concurrency/kernel/fwd.hfa \
+        concurrency/mutex_stmt.hfa
+        concurrency/kernel/fwd.hfa
 inst_thread_headers_src = \
 …
         $(CFACOMPILE) -quiet -XCFA,-l ${<} -c -o ${@}
-concurrency/io/call.cfa: $(srcdir)/concurrency/io/call.cfa.in
-        ${AM_V_GEN}python3 $< > $@
 #----------------------------------------------------------------------------------------------------------------
 libcfa_la_SOURCES = ${libsrc}

libcfa/src/concurrency/clib/cfathread.cfa

-              r949339b
+              r4e28d2e9
 // Update Count     :
 //
-// #define EPOLL_FOR_SOCKETS
 #include "fstream.hfa"
 …
 #include "cfathread.h"
-extern "C" {
-                #include <string.h>
-                #include <errno.h>
+}
 extern void ?{}(processor &, const char[], cluster &, thread$ *);
 extern "C" {
       extern void __cfactx_invoke_thread(void (*main)(void *), void * this);
-        extern int accept4(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags);
+}
 extern Time __kernel_get_time();
-extern unsigned register_proc_id( void );
 //================================================================================
+// Epoll support for sockets
+#if defined(EPOLL_FOR_SOCKETS)
+        extern "C" {
+                #include <sys/epoll.h>
+                #include <sys/resource.h>
+        }
+        static pthread_t master_poller;
+        static int master_epollfd = 0;
+        static size_t poller_cnt = 0;
+        static int * poller_fds = 0p;
+        static struct leaf_poller * pollers = 0p;
+        struct __attribute__((aligned)) fd_info_t {
+                int pollid;
+                size_t rearms;
+        };
+        rlim_t fd_limit = 0;
+        static fd_info_t * volatile * fd_map = 0p;
+        void * master_epoll( __attribute__((unused)) void * args ) {
+                unsigned id = register_proc_id();
+                enum { MAX_EVENTS = 5 };
+                struct epoll_event events[MAX_EVENTS];
+                for() {
+                        int ret = epoll_wait(master_epollfd, events, MAX_EVENTS, -1);
+                        if ( ret < 0 ) {
+                                abort | "Master epoll error: " | strerror(errno);
+                        }
+                        for(i; ret) {
+                                thread$ * thrd = (thread$ *)events[i].data.u64;
+                                unpark( thrd );
+                        }
+                }
+                return 0p;
+        }
+        static inline int epoll_rearm(int epollfd, int fd, uint32_t event) {
+                struct epoll_event eevent;
+                eevent.events = event | EPOLLET | EPOLLONESHOT;
+                eevent.data.u64 = (uint64_t)active_thread();
+                if(0 != epoll_ctl(epollfd, EPOLL_CTL_MOD, fd, &eevent))
+                {
+                        if(errno == ENOENT) return -1;
+                        abort | acquire | "epoll" | epollfd | "ctl rearm" | fd | "error: " | errno | strerror(errno);
+                }
+                park();
+                return 0;
+        }
+        thread leaf_poller {
+                int epollfd;
+        };
+        void ?{}(leaf_poller & this, int fd) { this.epollfd = fd; }
+        void main(leaf_poller & this) {
+                enum { MAX_EVENTS = 1024 };
+                struct epoll_event events[MAX_EVENTS];
+                const int max_retries = 5;
+                int retries = max_retries;
+                struct epoll_event event;
+                event.events = EPOLLIN | EPOLLET | EPOLLONESHOT;
+                event.data.u64 = (uint64_t)&(thread&)this;
+                if(0 != epoll_ctl(master_epollfd, EPOLL_CTL_ADD, this.epollfd, &event))
+                {
+                        abort | "master epoll ctl add leaf: " | errno | strerror(errno);
+                }
+                park();
+                for() {
+                        yield();
+                        int ret = epoll_wait(this.epollfd, events, MAX_EVENTS, 0);
+                        if ( ret < 0 ) {
+                                abort | "Leaf epoll error: " | errno | strerror(errno);
+                        }
+                        if(ret) {
+                                for(i; ret) {
+                                        thread$ * thrd = (thread$ *)events[i].data.u64;
+                                        unpark( thrd, UNPARK_REMOTE );
+                                }
+                        }
+                        else if(0 >= --retries) {
+                                epoll_rearm(master_epollfd, this.epollfd, EPOLLIN);
+                        }
+                }
+        }
+        void setup_epoll( void ) __attribute__(( constructor ));
+        void setup_epoll( void ) {
+                if(master_epollfd) abort | "Master epoll already setup";
+                master_epollfd = epoll_create1(0);
+                if(master_epollfd == -1) {
+                        abort | "failed to create master epoll: " | errno | strerror(errno);
+                }
+                struct rlimit rlim;
+                if(int ret = getrlimit(RLIMIT_NOFILE, &rlim); 0 != ret) {
+                        abort | "failed to get nofile limit: " | errno | strerror(errno);
+                }
+                fd_limit = rlim.rlim_cur;
+                fd_map = alloc(fd_limit);
+                for(i;fd_limit) {
+                        fd_map[i] = 0p;
+                }
+                poller_cnt = 2;
+                poller_fds = alloc(poller_cnt);
+                pollers    = alloc(poller_cnt);
+                for(i; poller_cnt) {
+                        poller_fds[i] = epoll_create1(0);
+                        if(poller_fds[i] == -1) {
+                                abort | "failed to create leaf epoll [" | i | "]: " | errno | strerror(errno);
+                        }
+                        (pollers[i]){ poller_fds[i] };
+                }
+                pthread_attr_t attr;
+                if (int ret = pthread_attr_init(&attr); 0 != ret) {
+                        abort | "failed to create master epoll thread attr: " | ret | strerror(ret);
+                }
+                if (int ret = pthread_create(&master_poller, &attr, master_epoll, 0p); 0 != ret) {
+                        abort | "failed to create master epoll thread: " | ret | strerror(ret);
+                }
+        }
+        static inline int epoll_wait(int fd, uint32_t event) {
+                if(fd_map[fd] >= 1p) {
+                        fd_map[fd]->rearms++;
+                        epoll_rearm(poller_fds[fd_map[fd]->pollid], fd, event);
+                        return 0;
+                }
+                for() {
+                        fd_info_t * expected = 0p;
+                        fd_info_t * sentinel = 1p;
+                        if(__atomic_compare_exchange_n( &(fd_map[fd]), &expected, sentinel, true, __ATOMIC_SEQ_CST, __ATOMIC_RELAXED)) {
+                                struct epoll_event eevent;
+                                eevent.events = event | EPOLLET | EPOLLONESHOT;
+                                eevent.data.u64 = (uint64_t)active_thread();
+                                int id = thread_rand() % poller_cnt;
+                                if(0 != epoll_ctl(poller_fds[id], EPOLL_CTL_ADD, fd, &eevent))
+                                {
+                                        abort | "epoll ctl add" | poller_fds[id] | fd | fd_map[fd] | expected | "error: " | errno | strerror(errno);
+                                }
+                                fd_info_t * ninfo = alloc();
+                                ninfo->pollid = id;
+                                ninfo->rearms = 0;
+                                __atomic_store_n( &fd_map[fd], ninfo, __ATOMIC_SEQ_CST);
+                                park();
+                                return 0;
+                        }
+                        if(expected >= 0) {
+                                fd_map[fd]->rearms++;
+                                epoll_rearm(poller_fds[fd_map[fd]->pollid], fd, event);
+                                return 0;
+                        }
+                        Pause();
+                }
+        }
+#endif
+//================================================================================
+// Thread run by the C Interface
+// Thread run y the C Interface
 struct cfathread_object {
 …
         // Mutex
         struct cfathread_mutex {
                 linear_backoff_then_block_lock impl;
+                fast_lock impl;
         };
         int cfathread_mutex_init(cfathread_mutex_t *restrict mut, const cfathread_mutexattr_t *restrict) __attribute__((nonnull (1))) { *mut = new(); return 0; }
 …
         // Condition
         struct cfathread_condition {
                 condition_variable(linear_backoff_then_block_lock) impl;
+                condition_variable(fast_lock) impl;
         };
         int cfathread_cond_init(cfathread_cond_t *restrict cond, const cfathread_condattr_t *restrict) __attribute__((nonnull (1))) { *cond = new(); return 0; }
 …
         // IO operations
         int cfathread_socket(int domain, int type, int protocol) {
+                return socket(domain, type
+                #if defined(EPOLL_FOR_SOCKETS)
+                        | SOCK_NONBLOCK
+                #endif
+                , protocol);
+                return socket(domain, type, protocol);
+        }
         int cfathread_bind(int socket, const struct sockaddr *address, socklen_t address_len) {
 …
         int cfathread_accept(int socket, struct sockaddr *restrict address, socklen_t *restrict address_len) {
+                #if defined(EPOLL_FOR_SOCKETS)
+                        int ret;
+                        for() {
+                                yield();
+                                ret = accept4(socket, address, address_len, SOCK_NONBLOCK);
+                                if(ret >= 0) break;
+                                if(errno != EAGAIN && errno != EWOULDBLOCK) break;
+                                epoll_wait(socket, EPOLLIN);
+                        }
+                        return ret;
+                #else
+                        return cfa_accept4(socket, address, address_len, 0, CFA_IO_LAZY);
+                #endif
+                return cfa_accept4(socket, address, address_len, 0, CFA_IO_LAZY);
+        }
         int cfathread_connect(int socket, const struct sockaddr *address, socklen_t address_len) {
+                #if defined(EPOLL_FOR_SOCKETS)
+                        int ret;
+                        for() {
+                                ret = connect(socket, address, address_len);
+                                if(ret >= 0) break;
+                                if(errno != EAGAIN && errno != EWOULDBLOCK) break;
+                                epoll_wait(socket, EPOLLIN);
+                        }
+                        return ret;
+                #else
+                        return cfa_connect(socket, address, address_len, CFA_IO_LAZY);
+                #endif
+                return cfa_connect(socket, address, address_len, CFA_IO_LAZY);
+        }
 …
         ssize_t cfathread_sendmsg(int socket, const struct msghdr *message, int flags) {
+                #if defined(EPOLL_FOR_SOCKETS)
+                        ssize_t ret;
+                        __STATS__( false, io.ops.sockwrite++; )
+                        for() {
+                                ret = sendmsg(socket, message, flags);
+                                if(ret >= 0) break;
+                                if(errno != EAGAIN && errno != EWOULDBLOCK) break;
+                                __STATS__( false, io.ops.epllwrite++; )
+                                epoll_wait(socket, EPOLLOUT);
+                        }
+                #else
+                        ssize_t ret = cfa_sendmsg(socket, message, flags, CFA_IO_LAZY);
+                #endif
+                return ret;
+                return cfa_sendmsg(socket, message, flags, CFA_IO_LAZY);
+        }
         ssize_t cfathread_write(int fildes, const void *buf, size_t nbyte) {
                 // Use send rather then write for socket since it's faster
+                #if defined(EPOLL_FOR_SOCKETS)
+                        ssize_t ret;
+                        // __STATS__( false, io.ops.sockwrite++; )
+                        for() {
+                                ret = send(fildes, buf, nbyte, 0);
+                                if(ret >= 0) break;
+                                if(errno != EAGAIN && errno != EWOULDBLOCK) break;
+                                // __STATS__( false, io.ops.epllwrite++; )
+                                epoll_wait(fildes, EPOLLOUT);
+                        }
+                #else
+                        ssize_t ret = cfa_send(fildes, buf, nbyte, 0, CFA_IO_LAZY);
+                #endif
+                return ret;
+                return cfa_send(fildes, buf, nbyte, 0, CFA_IO_LAZY);
+        }
 …
                 msg.msg_controllen = 0;
+                #if defined(EPOLL_FOR_SOCKETS)
+                        ssize_t ret;
+                        yield();
+                        for() {
+                                ret = recvmsg(socket, &msg, flags);
+                                if(ret >= 0) break;
+                                if(errno != EAGAIN && errno != EWOULDBLOCK) break;
+                                epoll_wait(socket, EPOLLIN);
+                        }
+                #else
+                        ssize_t ret = cfa_recvmsg(socket, &msg, flags, CFA_IO_LAZY);
+                #endif
+                ssize_t ret = cfa_recvmsg(socket, &msg, flags, CFA_IO_LAZY);
                 if(address_len) *address_len = msg.msg_namelen;
 …
         ssize_t cfathread_read(int fildes, void *buf, size_t nbyte) {
                 // Use recv rather then read for socket since it's faster
+                #if defined(EPOLL_FOR_SOCKETS)
+                        ssize_t ret;
+                        __STATS__( false, io.ops.sockread++; )
+                        yield();
+                        for() {
+                                ret = recv(fildes, buf, nbyte, 0);
+                                if(ret >= 0) break;
+                                if(errno != EAGAIN && errno != EWOULDBLOCK) break;
+                                __STATS__( false, io.ops.epllread++; )
+                                epoll_wait(fildes, EPOLLIN);
+                        }
+                #else
+                        ssize_t ret = cfa_recv(fildes, buf, nbyte, 0, CFA_IO_LAZY);
+                #endif
+                return ret;
+        }
+}
+                return cfa_recv(fildes, buf, nbyte, 0, CFA_IO_LAZY);
+        }
+}

libcfa/src/concurrency/invoke.h

-              r949339b
+              r4e28d2e9
                 bool corctx_flag;
+                int last_cpu;
                 //SKULLDUGGERY errno is not save in the thread data structure because returnToKernel appears to be the only function to require saving and restoring it
 …
                 struct cluster * curr_cluster;
                 // preferred ready-queue or CPU
+                // preferred ready-queue
                 unsigned preferred;

libcfa/src/concurrency/io.cfa

-              r949339b
+              r4e28d2e9
         static inline unsigned __flush( struct $io_context & );
         static inline __u32 __release_sqes( struct $io_context & );
         extern void __kernel_unpark( thread$ * thrd, unpark_hint );
+        extern void __kernel_unpark( thread$ * thrd );
         bool __cfa_io_drain( processor * proc ) {
 …
                         __cfadbg_print_safe( io, "Kernel I/O : Syscall completed : cqe %p, result %d for %p\n", &cqe, cqe.res, future );
                         __kernel_unpark( fulfil( *future, cqe.res, false ), UNPARK_LOCAL );
+                        __kernel_unpark( fulfil( *future, cqe.res, false ) );
+                }

libcfa/src/concurrency/kernel.cfa

-              r949339b
+              r4e28d2e9
 #include <errno.h>
 #include <stdio.h>
-#include <string.h>
 #include <signal.h>
 #include <unistd.h>
 …
 #include "kernel_private.hfa"
 #include "preemption.hfa"
-#include "strstream.hfa"
-#include "device/cpu.hfa"
 //Private includes
 …
                                 __cfadbg_print_safe(runtime_core, "Kernel : core %p waiting on eventfd %d\n", this, this->idle);
+                                {
+                                        eventfd_t val;
+                                        ssize_t ret = read( this->idle, &val, sizeof(val) );
+                                        if(ret < 0) {
+                                                switch((int)errno) {
+                                                case EAGAIN:
+                                                #if EAGAIN != EWOULDBLOCK
+                                                        case EWOULDBLOCK:
+                                                #endif
+                                                case EINTR:
+                                                        // No need to do anything special here, just assume it's a legitimate wake-up
+                                                        break;
+                                                default:
+                                                        abort( "KERNEL : internal error, read failure on idle eventfd, error(%d) %s.", (int)errno, strerror( (int)errno ) );
+                                                }
+                                        }
+                                }
+                                __disable_interrupts_hard();
+                                eventfd_t val;
+                                eventfd_read( this->idle, &val );
+                                __enable_interrupts_hard();
                                 #if !defined(__CFA_NO_STATISTICS__)
 …
+                                }
                                 __STATS( if(this->print_halts) __cfaabi_bits_print_safe( STDOUT_FILENO, "PH:%d - %lld 0\n", this->unique_id, rdtscl()); )
+                                        __STATS( if(this->print_halts) __cfaabi_bits_print_safe( STDOUT_FILENO, "PH:%d - %lld 0\n", this->unique_id, rdtscl()); )
                                 __cfadbg_print_safe(runtime_core, "Kernel : core %p waiting on eventfd %d\n", this, this->idle);
+                                {
+                                        eventfd_t val;
+                                        ssize_t ret = read( this->idle, &val, sizeof(val) );
+                                        if(ret < 0) {
+                                                switch((int)errno) {
+                                                case EAGAIN:
+                                                #if EAGAIN != EWOULDBLOCK
+                                                        case EWOULDBLOCK:
+                                                #endif
+                                                case EINTR:
+                                                        // No need to do anything special here, just assume it's a legitimate wake-up
+                                                        break;
+                                                default:
+                                                        abort( "KERNEL : internal error, read failure on idle eventfd, error(%d) %s.", (int)errno, strerror( (int)errno ) );
+                                                }
+                                        }
+                                }
+                                // __disable_interrupts_hard();
+                                eventfd_t val;
+                                eventfd_read( this->idle, &val );
+                                // __enable_interrupts_hard();
                                         __STATS( if(this->print_halts) __cfaabi_bits_print_safe( STDOUT_FILENO, "PH:%d - %lld 1\n", this->unique_id, rdtscl()); )
 …
         /* paranoid */ verifyf( thrd_dst->link.next == 0p, "Expected null got %p", thrd_dst->link.next );
         __builtin_prefetch( thrd_dst->context.SP );
+        int curr = __kernel_getcpu();
+        if(thrd_dst->last_cpu != curr) {
+                int64_t l = thrd_dst->last_cpu;
+                int64_t c = curr;
+                int64_t v = (l << 32) | c;
+                __push_stat( __tls_stats(), v, false, "Processor", this );
+        }
+        thrd_dst->last_cpu = curr;
         __cfadbg_print_safe(runtime_core, "Kernel : core %p running thread %p (%s)\n", this, thrd_dst, thrd_dst->self_cor.name);
 …
                 if(unlikely(thrd_dst->preempted != __NO_PREEMPTION)) {
                         // The thread was preempted, reschedule it and reset the flag
                         schedule_thread$( thrd_dst, UNPARK_LOCAL );
+                        schedule_thread$( thrd_dst );
                         break RUNNING;
+                }
 …
 // Scheduler routines
 // KERNEL ONLY
 static void __schedule_thread( thread$ * thrd, unpark_hint hint ) {
+static void __schedule_thread( thread$ * thrd ) {
         /* paranoid */ verify( ! __preemption_enabled() );
         /* paranoid */ verify( ready_schedule_islocked());
 …
         // Dereference the thread now because once we push it, there is not guaranteed it's still valid.
         struct cluster * cl = thrd->curr_cluster;
         __STATS(bool outside = hint == UNPARK_LOCAL && thrd->last_proc && thrd->last_proc != kernelTLS().this_processor; )
+        __STATS(bool outside = thrd->last_proc && thrd->last_proc != kernelTLS().this_processor; )
         // push the thread to the cluster ready-queue
         push( cl, thrd, hint );
+        push( cl, thrd, local );
         // variable thrd is no longer safe to use
 …
+}
 void schedule_thread$( thread$ * thrd, unpark_hint hint ) {
+void schedule_thread$( thread$ * thrd ) {
         ready_schedule_lock();
                 __schedule_thread( thrd, hint );
+                __schedule_thread( thrd );
         ready_schedule_unlock();
+}
 …
+}
 void __kernel_unpark( thread$ * thrd, unpark_hint hint ) {
+void __kernel_unpark( thread$ * thrd ) {
         /* paranoid */ verify( ! __preemption_enabled() );
         /* paranoid */ verify( ready_schedule_islocked());
 …
         if(__must_unpark(thrd)) {
                 // Wake lost the race,
                 __schedule_thread( thrd, hint );
+                __schedule_thread( thrd );
+        }
 …
+}
 void unpark( thread$ * thrd, unpark_hint hint ) {
+void unpark( thread$ * thrd ) {
         if( !thrd ) return;
 …
                 disable_interrupts();
                         // Wake lost the race,
                         schedule_thread$( thrd, hint );
+                        schedule_thread$( thrd );
                 enable_interrupts(false);
+        }

libcfa/src/concurrency/kernel.hfa

-              r949339b
+              r4e28d2e9
 struct __attribute__((aligned(128))) __timestamp_t {
         volatile unsigned long long tv;
+        volatile unsigned long long ma;
+};
+// Aligned timestamps which are used by the relaxed ready queue
+struct __attribute__((aligned(128))) __help_cnts_t {
+        volatile unsigned long long src;
+        volatile unsigned long long dst;
+        volatile unsigned long long tri;
+};
+static inline void  ?{}(__timestamp_t & this) { this.tv = 0; this.ma = 0; }
+};
+static inline void  ?{}(__timestamp_t & this) { this.tv = 0; }
 static inline void ^?{}(__timestamp_t & this) {}
 …
                 // Array of times
                 __timestamp_t * volatile tscs;
-                // Array of stats
-                __help_cnts_t * volatile help;
                 // Number of lanes (empty or not)

libcfa/src/concurrency/kernel/fwd.hfa

-              r949339b
+              r4e28d2e9
         extern "Cforall" {
-                enum unpark_hint { UNPARK_LOCAL, UNPARK_REMOTE };
                 extern void park( void );
+                extern void unpark( struct thread$ *, unpark_hint );
+                static inline void unpark( struct thread$ * thrd ) { unpark(thrd, UNPARK_LOCAL); }
+                extern void unpark( struct thread$ * this );
                 static inline struct thread$ * active_thread () {
                         struct thread$ * t = publicTLS_get( this_thread );

libcfa/src/concurrency/kernel/startup.cfa

-              r949339b
+              r4e28d2e9
         __cfadbg_print_safe(runtime_core, "Kernel : Main cluster ready\n");
-        // Construct the processor context of the main processor
-        void ?{}(processorCtx_t & this, processor * proc) {
-                (this.__cor){ "Processor" };
-                this.__cor.starter = 0p;
-                this.proc = proc;
+        }
-        void ?{}(processor & this) with( this ) {
-                ( this.terminated ){};
-                ( this.runner ){};
-                init( this, "Main Processor", *mainCluster, 0p );
-                kernel_thread = pthread_self();
-                runner{ &this };
-                __cfadbg_print_safe(runtime_core, "Kernel : constructed main processor context %p\n", &runner);
+        }
-        // Initialize the main processor and the main processor ctx
-        // (the coroutine that contains the processing control flow)
-        mainProcessor = (processor *)&storage_mainProcessor;
-        (*mainProcessor){};
-        register_tls( mainProcessor );
         // Start by initializing the main thread
         // SKULLDUGGERY: the mainThread steals the process main thread
 …
         __cfadbg_print_safe(runtime_core, "Kernel : Main thread ready\n");
+        // Construct the processor context of the main processor
+        void ?{}(processorCtx_t & this, processor * proc) {
+                (this.__cor){ "Processor" };
+                this.__cor.starter = 0p;
+                this.proc = proc;
+        }
+        void ?{}(processor & this) with( this ) {
+                ( this.terminated ){};
+                ( this.runner ){};
+                init( this, "Main Processor", *mainCluster, 0p );
+                kernel_thread = pthread_self();
+                runner{ &this };
+                __cfadbg_print_safe(runtime_core, "Kernel : constructed main processor context %p\n", &runner);
+        }
+        // Initialize the main processor and the main processor ctx
+        // (the coroutine that contains the processing control flow)
+        mainProcessor = (processor *)&storage_mainProcessor;
+        (*mainProcessor){};
+        register_tls( mainProcessor );
+        mainThread->last_cpu = __kernel_getcpu();
         //initialize the global state variables
         __cfaabi_tls.this_processor = mainProcessor;
 …
         // 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
         schedule_thread$(mainThread, UNPARK_LOCAL);
+        schedule_thread$(mainThread);
         // SKULLDUGGERY: Force a context switch to the main processor to set the main thread's context to the current UNIX
 …
         link.next = 0p;
         link.ts   = -1llu;
         preferred = ready_queue_new_preferred();
+        preferred = -1u;
         last_proc = 0p;
         #if defined( __CFA_WITH_VERIFY__ )

libcfa/src/concurrency/kernel_private.hfa

-              r949339b
+              r4e28d2e9
+}
 void schedule_thread$( thread$ *, unpark_hint hint ) __attribute__((nonnull (1)));
+void schedule_thread$( thread$ * ) __attribute__((nonnull (1)));
 extern bool __preemption_enabled();
 …
 // push thread onto a ready queue for a cluster
 // returns true if the list was previously empty, false otherwise
 __attribute__((hot)) void push(struct cluster * cltr, struct thread$ * thrd, unpark_hint hint);
+__attribute__((hot)) void push(struct cluster * cltr, struct thread$ * thrd, bool local);
 //-----------------------------------------------------------------------
 …
 //-----------------------------------------------------------------------
-// get preferred ready for new thread
-unsigned ready_queue_new_preferred();
-//-----------------------------------------------------------------------
 // Increase the width of the ready queue (number of lanes) by 4
 void ready_queue_grow  (struct cluster * cltr);

libcfa/src/concurrency/locks.hfa

-              r949339b
+              r4e28d2e9
+        }
+        // linear backoff bounded by spin_count
+        spin = spin_start;
+        int spin_counter = 0;
+        int yield_counter = 0;
+        for ( ;; ) {
+                if(try_lock_contention(this)) return true;
+                if(spin_counter < spin_count) {
+                        for (int i = 0; i < spin; i++) Pause();
+                        if (spin < spin_end) spin += spin;
+                        else spin_counter++;
+                } else if (yield_counter < yield_count) {
+                        // after linear backoff yield yield_count times
+                        yield_counter++;
+                        yield();
+                } else { break; }
+        }
+        // block until signalled
+        while (block(this)) if(try_lock_contention(this)) return true;
+        // this should never be reached as block(this) always returns true
+        return false;
+}
+static inline bool lock_improved(linear_backoff_then_block_lock & this) with(this) {
+        // if owner just return
+        if (active_thread() == owner) return true;
+        size_t compare_val = 0;
+        int spin = spin_start;
+        // linear backoff
+        for( ;; ) {
+                compare_val = 0;
+                if (internal_try_lock(this, compare_val)) return true;
+                if (2 == compare_val) break;
+                for (int i = 0; i < spin; i++) Pause();
+                if (spin >= spin_end) break;
+                spin += spin;
+        }
+        // linear backoff bounded by spin_count
+        spin = spin_start;
+        int spin_counter = 0;
+        int yield_counter = 0;
+        for ( ;; ) {
+                compare_val = 0;
+                if(internal_try_lock(this, compare_val)) return true;
+                if (2 == compare_val) break;
+                if(spin_counter < spin_count) {
+                        for (int i = 0; i < spin; i++) Pause();
+                        if (spin < spin_end) spin += spin;
+                        else spin_counter++;
+                } else if (yield_counter < yield_count) {
+                        // after linear backoff yield yield_count times
+                        yield_counter++;
+                        yield();
+                } else { break; }
+        }
         if(2 != compare_val && try_lock_contention(this)) return true;
         // block until signalled
 …
 static inline void on_notify(linear_backoff_then_block_lock & this, struct thread$ * t ) { unpark(t); }
 static inline size_t on_wait(linear_backoff_then_block_lock & this) { unlock(this); return 0; }
 static inline void on_wakeup(linear_backoff_then_block_lock & this, size_t recursion ) { lock(this); }
+static inline void on_wakeup(linear_backoff_then_block_lock & this, size_t recursion ) { lock_improved(this); }
 //-----------------------------------------------------------------------------

libcfa/src/concurrency/mutex_stmt.hfa

r949339b	r4e28d2e9
41	41	}
42	42
43		static inline L * __get_p~~tr( L & this~~ ) {
44		return &~~this~~;
	43	static inline L * __get_pointer( L & lock ) {
	44	return &lock;
45	45	}
46
47		~~static inline L __get_type( L & this );~~
48
49		~~static inline L __get_type( L * this );~~
50	46	}

libcfa/src/concurrency/ready_queue.cfa

-              r949339b
+              r4e28d2e9
         #define __kernel_rseq_unregister rseq_unregister_current_thread
 #elif defined(CFA_HAVE_LINUX_RSEQ_H)
         static void __kernel_raw_rseq_register  (void);
         static void __kernel_raw_rseq_unregister(void);
+        void __kernel_raw_rseq_register  (void);
+        void __kernel_raw_rseq_unregister(void);
         #define __kernel_rseq_register __kernel_raw_rseq_register
 …
 // Cforall Ready Queue used for scheduling
 //=======================================================================
-unsigned long long moving_average(unsigned long long nval, unsigned long long oval) {
-        const unsigned long long tw = 16;
-        const unsigned long long nw = 4;
-        const unsigned long long ow = tw - nw;
-        return ((nw * nval) + (ow * oval)) / tw;
+}
 void ?{}(__ready_queue_t & this) with (this) {
         #if defined(USE_CPU_WORK_STEALING)
 …
                 lanes.data = alloc( lanes.count );
                 lanes.tscs = alloc( lanes.count );
-                lanes.help = alloc( cpu_info.hthrd_count );
                 for( idx; (size_t)lanes.count ) {
                         (lanes.data[idx]){};
                         lanes.tscs[idx].tv = rdtscl();
-                        lanes.tscs[idx].ma = rdtscl();
+                }
-                for( idx; (size_t)cpu_info.hthrd_count ) {
-                        lanes.help[idx].src = 0;
-                        lanes.help[idx].dst = 0;
-                        lanes.help[idx].tri = 0;
+                }
         #else
                 lanes.data  = 0p;
                 lanes.tscs  = 0p;
-                lanes.help  = 0p;
                 lanes.count = 0;
         #endif
 …
         free(lanes.data);
         free(lanes.tscs);
-        free(lanes.help);
+}
 //-----------------------------------------------------------------------
 #if defined(USE_CPU_WORK_STEALING)
         __attribute__((hot)) void push(struct cluster * cltr, struct thread$ * thrd, unpark_hint hint) with (cltr->ready_queue) {
+        __attribute__((hot)) void push(struct cluster * cltr, struct thread$ * thrd, bool push_local) with (cltr->ready_queue) {
                 __cfadbg_print_safe(ready_queue, "Kernel : Pushing %p on cluster %p\n", thrd, cltr);
                 processor * const proc = kernelTLS().this_processor;
+                const bool external = (!proc) || (cltr != proc->cltr);
+                // Figure out the current cpu and make sure it is valid
+                const bool external = !push_local || (!proc) || (cltr != proc->cltr);
                 const int cpu = __kernel_getcpu();
                 /* paranoid */ verify(cpu >= 0);
 …
                 /* paranoid */ verify(cpu * READYQ_SHARD_FACTOR < lanes.count);
+                // Figure out where thread was last time and make sure it's
+                /* paranoid */ verify(thrd->preferred >= 0);
+                /* paranoid */ verify(thrd->preferred < cpu_info.hthrd_count);
+                /* paranoid */ verify(thrd->preferred * READYQ_SHARD_FACTOR < lanes.count);
+                const int prf = thrd->preferred * READYQ_SHARD_FACTOR;
+                const cpu_map_entry_t & map;
+                choose(hint) {
+                        case UNPARK_LOCAL : &map = &cpu_info.llc_map[cpu];
+                        case UNPARK_REMOTE: &map = &cpu_info.llc_map[prf];
+                }
+                const cpu_map_entry_t & map = cpu_info.llc_map[cpu];
                 /* paranoid */ verify(map.start * READYQ_SHARD_FACTOR < lanes.count);
                 /* paranoid */ verify(map.self * READYQ_SHARD_FACTOR < lanes.count);
 …
                         if(unlikely(external)) { r = __tls_rand(); }
                         else { r = proc->rdq.its++; }
+                        choose(hint) {
+                                case UNPARK_LOCAL : i = start + (r % READYQ_SHARD_FACTOR);
+                                case UNPARK_REMOTE: i = prf   + (r % READYQ_SHARD_FACTOR);
+                        }
+                        i = start + (r % READYQ_SHARD_FACTOR);
                         // If we can't lock it retry
                 } while( !__atomic_try_acquire( &lanes.data[i].lock ) );
 …
                 processor * const proc = kernelTLS().this_processor;
                 const int start = map.self * READYQ_SHARD_FACTOR;
-                const unsigned long long ctsc = rdtscl();
                 // Did we already have a help target
                 if(proc->rdq.target == -1u) {
+                        unsigned long long max = 0;
+                        // if We don't have a
+                        unsigned long long min = ts(lanes.data[start]);
                         for(i; READYQ_SHARD_FACTOR) {
+                                unsigned long long tsc = moving_average(ctsc - ts(lanes.data[start + i]), lanes.tscs[start + i].ma);
+                                if(tsc > max) max = tsc;
+                        }
+                         proc->rdq.cutoff = (max + 2 * max) / 2;
+                                unsigned long long tsc = ts(lanes.data[start + i]);
+                                if(tsc < min) min = tsc;
+                        }
+                        proc->rdq.cutoff = min;
                         /* paranoid */ verify(lanes.count < 65536); // The following code assumes max 65536 cores.
                         /* paranoid */ verify(map.count < 65536); // The following code assumes max 65536 cores.
                         if(0 == (__tls_rand() % 100)) {
+                        if(0 == (__tls_rand() % 10_000)) {
                                 proc->rdq.target = __tls_rand() % lanes.count;
                         } else {
 …
+                }
                 else {
+                        unsigned long long max = 0;
+                        for(i; READYQ_SHARD_FACTOR) {
+                                unsigned long long tsc = moving_average(ctsc - ts(lanes.data[start + i]), lanes.tscs[start + i].ma);
+                                if(tsc > max) max = tsc;
+                        }
+                        const unsigned long long cutoff = (max + 2 * max) / 2;
+                        const unsigned long long bias = 0; //2_500_000_000;
+                        const unsigned long long cutoff = proc->rdq.cutoff > bias ? proc->rdq.cutoff - bias : proc->rdq.cutoff;
+                        {
                                 unsigned target = proc->rdq.target;
                                 proc->rdq.target = -1u;
+                                lanes.help[target / READYQ_SHARD_FACTOR].tri++;
+                                if(moving_average(ctsc - lanes.tscs[target].tv, lanes.tscs[target].ma) > cutoff) {
+                                if(lanes.tscs[target].tv < cutoff && ts(lanes.data[target]) < cutoff) {
                                         thread$ * t = try_pop(cltr, target __STATS(, __tls_stats()->ready.pop.help));
                                         proc->rdq.last = target;
                                         if(t) return t;
-                                        else proc->rdq.target = -1u;
+                                }
-                                else proc->rdq.target = -1u;
+                        }
 …
+        }
         __attribute__((hot)) void push(struct cluster * cltr, struct thread$ * thrd, unpark_hint hint) with (cltr->ready_queue) {
+        __attribute__((hot)) void push(struct cluster * cltr, struct thread$ * thrd, bool push_local) with (cltr->ready_queue) {
                 __cfadbg_print_safe(ready_queue, "Kernel : Pushing %p on cluster %p\n", thrd, cltr);
                 const bool external = (hint != UNPARK_LOCAL) || (!kernelTLS().this_processor) || (cltr != kernelTLS().this_processor->cltr);
+                const bool external = !push_local || (!kernelTLS().this_processor) || (cltr != kernelTLS().this_processor->cltr);
                 /* paranoid */ verify(external || kernelTLS().this_processor->rdq.id < lanes.count );
 …
 #endif
 #if defined(USE_WORK_STEALING)
         __attribute__((hot)) void push(struct cluster * cltr, struct thread$ * thrd, unpark_hint hint) with (cltr->ready_queue) {
+        __attribute__((hot)) void push(struct cluster * cltr, struct thread$ * thrd, bool push_local) with (cltr->ready_queue) {
                 __cfadbg_print_safe(ready_queue, "Kernel : Pushing %p on cluster %p\n", thrd, cltr);
                 // #define USE_PREFERRED
                 #if !defined(USE_PREFERRED)
                 const bool external = (hint != UNPARK_LOCAL) || (!kernelTLS().this_processor) || (cltr != kernelTLS().this_processor->cltr);
+                const bool external = !push_local || (!kernelTLS().this_processor) || (cltr != kernelTLS().this_processor->cltr);
                 /* paranoid */ verify(external || kernelTLS().this_processor->rdq.id < lanes.count );
                 #else
                         unsigned preferred = thrd->preferred;
                         const bool external = (hint != UNPARK_LOCAL) || (!kernelTLS().this_processor) || preferred == -1u || thrd->curr_cluster != cltr;
+                        const bool external = push_local || (!kernelTLS().this_processor) || preferred == -1u || thrd->curr_cluster != cltr;
                         /* paranoid */ verifyf(external || preferred < lanes.count, "Invalid preferred queue %u for %u lanes", preferred, lanes.count );
 …
         // Actually pop the list
         struct thread$ * thrd;
-        unsigned long long tsc_before = ts(lane);
         unsigned long long tsv;
         [thrd, tsv] = pop(lane);
 …
         __STATS( stats.success++; )
+        #if defined(USE_WORK_STEALING) || defined(USE_CPU_WORK_STEALING)
+                unsigned long long now = rdtscl();
+        #if defined(USE_WORK_STEALING)
                 lanes.tscs[w].tv = tsv;
-                lanes.tscs[w].ma = moving_average(now > tsc_before ? now - tsc_before : 0, lanes.tscs[w].ma);
         #endif
+        #if defined(USE_CPU_WORK_STEALING)
+                thrd->preferred = w / READYQ_SHARD_FACTOR;
+        #else
+                thrd->preferred = w;
+        #endif
+        thrd->preferred = w;
         // return the popped thread
 …
 //-----------------------------------------------------------------------
-// get preferred ready for new thread
-unsigned ready_queue_new_preferred() {
-        unsigned pref = 0;
-        if(struct thread$ * thrd = publicTLS_get( this_thread )) {
-                pref = thrd->preferred;
+        }
-        else {
-                #if defined(USE_CPU_WORK_STEALING)
-                        pref = __kernel_getcpu();
-                #endif
+        }
-        #if defined(USE_CPU_WORK_STEALING)
-                /* paranoid */ verify(pref >= 0);
-                /* paranoid */ verify(pref < cpu_info.hthrd_count);
-        #endif
-        return pref;
+}
-//-----------------------------------------------------------------------
 // Check that all the intrusive queues in the data structure are still consistent
 static void check( __ready_queue_t & q ) with (q) {
 …
         extern void __enable_interrupts_hard();
         static void __kernel_raw_rseq_register  (void) {
+        void __kernel_raw_rseq_register  (void) {
                 /* paranoid */ verify( __cfaabi_rseq.cpu_id == RSEQ_CPU_ID_UNINITIALIZED );
 …
+        }
         static void __kernel_raw_rseq_unregister(void) {
+        void __kernel_raw_rseq_unregister(void) {
                 /* paranoid */ verify( __cfaabi_rseq.cpu_id >= 0 );

libcfa/src/concurrency/ready_subqueue.hfa

-              r949339b
+              r4e28d2e9
         // Get the relevant nodes locally
+        unsigned long long ts = this.anchor.ts;
         thread$ * node = this.anchor.next;
         this.anchor.next = node->link.next;
 …
         /* paranoid */ verify( node->link.ts   != 0  );
         /* paranoid */ verify( this.anchor.ts  != 0  );
         return [node, this.anchor.ts];
+        return [node, ts];
+}

libcfa/src/concurrency/stats.cfa

-              r949339b
+              r4e28d2e9
                         stats->io.calls.completed   = 0;
                         stats->io.calls.errors.busy = 0;
-                        stats->io.ops.sockread      = 0;
-                        stats->io.ops.epllread      = 0;
-                        stats->io.ops.sockwrite     = 0;
-                        stats->io.ops.epllwrite     = 0;
                 #endif
 …
                         tally_one( &cltr->io.calls.completed  , &proc->io.calls.completed   );
                         tally_one( &cltr->io.calls.errors.busy, &proc->io.calls.errors.busy );
-                        tally_one( &cltr->io.ops.sockread     , &proc->io.ops.sockread      );
-                        tally_one( &cltr->io.ops.epllread     , &proc->io.ops.epllread      );
-                        tally_one( &cltr->io.ops.sockwrite    , &proc->io.ops.sockwrite     );
-                        tally_one( &cltr->io.ops.epllwrite    , &proc->io.ops.epllwrite     );
                 #endif
+        }
 …
                                      | " - cmp " | eng3(io.calls.drain) | "/" | eng3(io.calls.completed) | "(" | ws(3, 3, avgcomp) | "/drain)"
                                      | " - " | eng3(io.calls.errors.busy) | " EBUSY";
-                                sstr | "- ops blk: "
-                                     |   " sk rd: " | eng3(io.ops.sockread)  | "epll: " | eng3(io.ops.epllread)
-                                     |   " sk wr: " | eng3(io.ops.sockwrite) | "epll: " | eng3(io.ops.epllwrite);
                                 sstr | nl;
+                        }

libcfa/src/concurrency/stats.hfa

-              r949339b
+              r4e28d2e9
                                 volatile uint64_t sleeps;
                         } poller;
-                        struct {
-                                volatile uint64_t sockread;
-                                volatile uint64_t epllread;
-                                volatile uint64_t sockwrite;
-                                volatile uint64_t epllwrite;
-                        } ops;
                 };
         #endif

libcfa/src/concurrency/thread.cfa

-              r949339b
+              r4e28d2e9
 #include "invoke.h"
-uint64_t thread_rand();
 //-----------------------------------------------------------------------------
 // Thread ctors and dtors
 …
         preempted = __NO_PREEMPTION;
         corctx_flag = false;
+        disable_interrupts();
+        last_cpu = __kernel_getcpu();
+        enable_interrupts();
         curr_cor = &self_cor;
         self_mon.owner = &this;
 …
         link.next = 0p;
         link.ts   = -1llu;
         preferred = ready_queue_new_preferred();
+        preferred = -1u;
         last_proc = 0p;
         #if defined( __CFA_WITH_VERIFY__ )
 …
         /* paranoid */ verify( this_thrd->context.SP );
         schedule_thread$( this_thrd, UNPARK_LOCAL );
+        schedule_thread$( this_thrd );
         enable_interrupts();
+}

libcfa/src/device/cpu.cfa

r949339b	r4e28d2e9
422	422	}
423	423	}
424
425		~~cpu_info_t cpu_info;~~

libcfa/src/device/cpu.hfa

r949339b	r4e28d2e9
30	30	};
31	31
32		~~extern~~ cpu_info_t cpu_info;
	32	cpu_info_t cpu_info;

libcfa/src/fstream.cfa

-              r949339b
+              r4e28d2e9
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Sep 21 21:51:38 2021
 // Update Count     : 460
+// Last Modified On : Thu Jul 29 22:34:10 2021
+// Update Count     : 454
 //
 …
 #define IO_MSG "I/O error: "
 void ?{}( ofstream & os, void * file ) with(os) {
         file$ = file;
         sepDefault$ = true;
         sepOnOff$ = false;
         nlOnOff$ = true;
         prt$ = false;
         sawNL$ = false;
         acquired$ = false;
+void ?{}( ofstream & os, void * file ) {
+        os.file$ = file;
+        os.sepDefault$ = true;
+        os.sepOnOff$ = false;
+        os.nlOnOff$ = true;
+        os.prt$ = false;
+        os.sawNL$ = false;
+        os.acquired$ = false;
         sepSetCur$( os, sepGet( os ) );
         sepSet( os, " " );
 …
 void open( ofstream & os, const char name[], const char mode[] ) {
         FILE * file = fopen( name, mode );
+        #ifdef __CFA_DEBUG__
         if ( file == 0p ) {
                 throw (Open_Failure){ os };
                 // abort | IO_MSG "open output file \"" | name | "\"" | nl | strerror( errno );
         } // if
+        (os){ file };                                                                           // initialize
+        #endif // __CFA_DEBUG__
+        (os){ file };
 } // open
 …
 } // open
 void close( ofstream & os ) with(os) {
   if ( (FILE *)(file$) == 0p ) return;
   if ( (FILE *)(file$) == (FILE *)stdout || (FILE *)(file$) == (FILE *)stderr ) return;
         if ( fclose( (FILE *)(file$) ) == EOF ) {
+void close( ofstream & os ) {
+  if ( (FILE *)(os.file$) == 0p ) return;
+  if ( (FILE *)(os.file$) == (FILE *)stdout || (FILE *)(os.file$) == (FILE *)stderr ) return;
+        if ( fclose( (FILE *)(os.file$) ) == EOF ) {
                 throw (Close_Failure){ os };
                 // abort | IO_MSG "close output" | nl | strerror( errno );
         } // if
         file$ = 0p;
+        os.file$ = 0p;
 } // close
 …
 } // fmt
 inline void acquire( ofstream & os ) with(os) {
         lock( lock$ );                                                                          // may increase recursive lock
         if ( ! acquired$ ) acquired$ = true;                            // not locked ?
         else unlock( lock$ );                                                           // unwind recursive lock at start
+inline void acquire( ofstream & os ) {
+        lock( os.lock$ );
+        if ( ! os.acquired$ ) os.acquired$ = true;
+        else unlock( os.lock$ );
 } // acquire
 …
 } // release
 void ?{}( osacquire & acq, ofstream & os ) { lock( os.lock$ ); &acq.os = &os; }
+void ?{}( osacquire & acq, ofstream & os ) { &acq.os = &os; lock( os.lock$ ); }
 void ^?{}( osacquire & acq ) { release( acq.os ); }
 …
 // private
 void ?{}( ifstream & is, void * file ) with(is) {
         file$ = file;
         nlOnOff$ = false;
         acquired$ = false;
+void ?{}( ifstream & is, void * file ) {
+        is.file$ = file;
+        is.nlOnOff$ = false;
+        is.acquired$ = false;
 } // ?{}
 …
 void open( ifstream & is, const char name[], const char mode[] ) {
         FILE * file = fopen( name, mode );
+        #ifdef __CFA_DEBUG__
         if ( file == 0p ) {
                 throw (Open_Failure){ is };
                 // abort | IO_MSG "open input file \"" | name | "\"" | nl | strerror( errno );
         } // if
+        (is){ file };                                                                           // initialize
+        #endif // __CFA_DEBUG__
+        is.file$ = file;
 } // open
 …
 } // open
 void close( ifstream & is ) with(is) {
   if ( (FILE *)(file$) == 0p ) return;
   if ( (FILE *)(file$) == (FILE *)stdin ) return;
         if ( fclose( (FILE *)(file$) ) == EOF ) {
+void close( ifstream & is ) {
+  if ( (FILE *)(is.file$) == 0p ) return;
+  if ( (FILE *)(is.file$) == (FILE *)stdin ) return;
+        if ( fclose( (FILE *)(is.file$) ) == EOF ) {
                 throw (Close_Failure){ is };
                 // abort | IO_MSG "close input" | nl | strerror( errno );
         } // if
         file$ = 0p;
+        is.file$ = 0p;
 } // close
 …
 } // fmt
 inline void acquire( ifstream & is ) with(is) {
         lock( lock$ );                                                                          // may increase recursive lock
         if ( ! acquired$ ) acquired$ = true;                            // not locked ?
         else unlock( lock$ );                                                           // unwind recursive lock at start
+inline void acquire( ifstream & is ) {
+        lock( is.lock$ );
+        if ( ! is.acquired$ ) is.acquired$ = true;
+        else unlock( is.lock$ );
 } // acquire
 …
 } // release
 void ?{}( isacquire & acq, ifstream & is ) { lock( is.lock$ ); &acq.is = &is; }
+void ?{}( isacquire & acq, ifstream & is ) { &acq.is = &is; lock( is.lock$ ); }
 void ^?{}( isacquire & acq ) { release( acq.is ); }
 …
 // exception I/O constructors
 void ?{}( Open_Failure & ex, ofstream & ostream ) with(ex) {
         virtual_table = &Open_Failure_vt;
         ostream = &ostream;
         tag = 1;
 } // ?{}
 void ?{}( Open_Failure & ex, ifstream & istream ) with(ex) {
         virtual_table = &Open_Failure_vt;
         istream = &istream;
         tag = 0;
+void ?{}( Open_Failure & this, ofstream & ostream ) {
+        this.virtual_table = &Open_Failure_vt;
+        this.ostream = &ostream;
+        this.tag = 1;
+} // ?{}
+void ?{}( Open_Failure & this, ifstream & istream ) {
+        this.virtual_table = &Open_Failure_vt;
+        this.istream = &istream;
+        this.tag = 0;
 } // ?{}
 …
 // exception I/O constructors
 void ?{}( Close_Failure & ex, ofstream & ostream ) with(ex) {
         virtual_table = &Close_Failure_vt;
         ostream = &ostream;
         tag = 1;
 } // ?{}
 void ?{}( Close_Failure & ex, ifstream & istream ) with(ex) {
         virtual_table = &Close_Failure_vt;
         istream = &istream;
         tag = 0;
+void ?{}( Close_Failure & this, ofstream & ostream ) {
+        this.virtual_table = &Close_Failure_vt;
+        this.ostream = &ostream;
+        this.tag = 1;
+} // ?{}
+void ?{}( Close_Failure & this, ifstream & istream ) {
+        this.virtual_table = &Close_Failure_vt;
+        this.istream = &istream;
+        this.tag = 0;
 } // ?{}
 …
 // exception I/O constructors
 void ?{}( Write_Failure & ex, ofstream & ostream ) with(ex) {
         virtual_table = &Write_Failure_vt;
         ostream = &ostream;
         tag = 1;
 } // ?{}
 void ?{}( Write_Failure & ex, ifstream & istream ) with(ex) {
         virtual_table = &Write_Failure_vt;
         istream = &istream;
         tag = 0;
+void ?{}( Write_Failure & this, ofstream & ostream ) {
+        this.virtual_table = &Write_Failure_vt;
+        this.ostream = &ostream;
+        this.tag = 1;
+} // ?{}
+void ?{}( Write_Failure & this, ifstream & istream ) {
+        this.virtual_table = &Write_Failure_vt;
+        this.istream = &istream;
+        this.tag = 0;
 } // ?{}
 …
 // exception I/O constructors
 void ?{}( Read_Failure & ex, ofstream & ostream ) with(ex) {
         virtual_table = &Read_Failure_vt;
         ostream = &ostream;
         tag = 1;
 } // ?{}
 void ?{}( Read_Failure & ex, ifstream & istream ) with(ex) {
         virtual_table = &Read_Failure_vt;
         istream = &istream;
         tag = 0;
+void ?{}( Read_Failure & this, ofstream & ostream ) {
+        this.virtual_table = &Read_Failure_vt;
+        this.ostream = &ostream;
+        this.tag = 1;
+} // ?{}
+void ?{}( Read_Failure & this, ifstream & istream ) {
+        this.virtual_table = &Read_Failure_vt;
+        this.istream = &istream;
+        this.tag = 0;
 } // ?{}

libcfa/src/fstream.hfa

-              r949339b
+              r4e28d2e9
 void release( ofstream & );
-void lock( ofstream & );
-void unlock( ofstream & );
 struct osacquire {
         ofstream & os;

libcfa/src/memory.cfa

-              r949339b
+              r4e28d2e9
 forall(T &)
-T * release(unique_ptr(T) & this) {
-        T * data = this.data;
-        this.data = 0p;
-        return data;
+}
-forall(T &)
 int ?==?(unique_ptr(T) const & this, unique_ptr(T) const & that) {
         return this.data == that.data;

libcfa/src/memory.hfa

-              r949339b
+              r4e28d2e9
 forall(T &)
-T * release(unique_ptr(T) & this);
-forall(T &)
 int ?==?(unique_ptr(T) const & this, unique_ptr(T) const & that);
 forall(T &)

src/Concurrency/Keywords.cc

-              r949339b
+              r4e28d2e9
                                 new PointerType(
                                         noQualifiers,
+                                        //new TypeofType( noQualifiers, args.front()->clone() )
+                                        new TypeofType( noQualifiers, new UntypedExpr(
+                                                        new NameExpr( "__get_type" ),
+                                                        { args.front()->clone() }
+                                                )
+                                        )
+                                        new TypeofType( noQualifiers, args.front()->clone() )
                                 ),
                                 new ConstantExpr( Constant::from_ulong( args.size() ) ),
 …
                                 map_range < std::list<Initializer*> > ( args, [](Expression * var ){
                                         return new SingleInit( new UntypedExpr(
                                                         new NameExpr( "__get_ptr" ),
                                                         { var }
+                                                new NameExpr( "__get_pointer" ),
+                                                { var }
                                         ) );
-                                        //return new SingleInit( new AddressExpr( var ) );
                                 })
+                        )
 …
                 StructInstType * lock_guard_struct = new StructInstType( noQualifiers, lock_guard_decl );
+                TypeExpr * lock_type_expr = new TypeExpr(
+                        new TypeofType( noQualifiers, new UntypedExpr(
+                                new NameExpr( "__get_type" ),
+                                { args.front()->clone() }
+                                )
+                        )
+                );
+                TypeExpr * lock_type_expr = new TypeExpr( new TypeofType( noQualifiers, args.front()->clone() ) );
                 lock_guard_struct->parameters.push_back( lock_type_expr ) ;

src/Parser/parser.yy

-              r949339b
+              r4e28d2e9
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Sep 11 08:20:44 2021
 // Update Count     : 5040
+// Last Modified On : Sun Aug  8 09:14:44 2021
+// Update Count     : 5038
 //
 …
         | simple_assignment_operator initializer        { $$ = $1 == OperKinds::Assign ? $2 : $2->set_maybeConstructed( false ); }
         | '=' VOID                                                                      { $$ = new InitializerNode( true ); }
-        | '{' initializer_list_opt comma_opt '}'        { $$ = new InitializerNode( $2, true ); }
+        ;
 …
         | designation initializer                                       { $$ = $2->set_designators( $1 ); }
         | initializer_list_opt ',' initializer          { $$ = (InitializerNode *)( $1->set_last( $3 ) ); }
+        | initializer_list_opt ',' designation initializer { $$ = (InitializerNode *)($1->set_last( $4->set_designators( $3 ) )); }
+        | initializer_list_opt ',' designation initializer
+                { $$ = (InitializerNode *)($1->set_last( $4->set_designators( $3 ) )); }
+        ;

tests/Makefile.am

-              r949339b
+              r4e28d2e9
         pybin/tools.py \
         long_tests.hfa \
-        .in/parseconfig-all.txt \
-        .in/parseconfig-errors.txt \
-        .in/parseconfig-missing.txt \
         io/.in/io.data \
         io/.in/many_read.data \
 …
         concurrent/clib_tls.c \
         exceptions/with-threads.hfa \
+        exceptions/except-io.hfa \
+        unified_locking/mutex_test.hfa
+        exceptions/except-io.hfa
 dist-hook:

tests/concurrent/mutexstmt/locks.cfa

-              r949339b
+              r4e28d2e9
 const unsigned int num_times = 10000;
 single_acquisition_lock m1, m2, m3, m4, m5;
+owner_lock m1, m2, m3, m4, m5;
 thread T_Mutex {};
 …
         printf("Start Test: single lock mutual exclusion\n");
+        {
                 T_Mutex t[10];
+                T_Mutex t[1];
+        }
         printf("End Test: single lock mutual exclusion\n");

tools/perf/process_stat_array.py

-              r949339b
+              r4e28d2e9
 #!/usr/bin/python3
+import argparse, json, math, os, sys, re
+from PIL import Image
+import numpy as np
+import argparse, os, sys, re
 def dir_path(string):
 …
 parser = argparse.ArgumentParser()
 parser.add_argument('--path', type=dir_path, default=".cfadata", help= 'paste path to biog.txt file')
-parser.add_argument('--out', type=argparse.FileType('w'), default=sys.stdout)
 try :
 …
 counters = {}
-max_cpu = 0
-min_cpu = 1000000
-max_tsc = 0
-min_tsc = 18446744073709551615
 #open the files
 for filename in filenames:
 …
                 with open(os.path.join(root, filename), 'r') as file:
                         for line in file:
+                                raw = [int(x.strip()) for x in line.split(',')]
+                                ## from/to
+                                high = (raw[1] >> 32)
+                                low  = (raw[1] & 0xffffffff)
+                                data = [me, raw[0], high, low]
+                                max_cpu = max(max_cpu, high, low)
+                                min_cpu = min(min_cpu, high, low)
+                                ## number
+                                # high = (raw[1] >> 8)
+                                # low  = (raw[1] & 0xff)
+                                # data = [me, raw[0], high, low]
+                                # max_cpu = max(max_cpu, low)
+                                # min_cpu = min(min_cpu, low)
+                                max_tsc = max(max_tsc, raw[0])
+                                min_tsc = min(min_tsc, raw[0])
+                                # data = [int(x.strip()) for x in line.split(',')]
+                                data = [int(line.strip())]
+                                data = [me, *data]
                                 merged.append(data)
+        except Exception as e:
+                print(e)
+        except:
                 pass
-print({"max-cpu": max_cpu, "min-cpu": min_cpu, "max-tsc": max_tsc, "min-tsc": min_tsc})
 # Sort by timestamp (the second element)
 …
 merged.sort(key=takeSecond)
+json.dump({"values":merged, "max-cpu": max_cpu, "min-cpu": min_cpu, "max-tsc": max_tsc, "min-tsc": min_tsc}, args.out)
+# for m in merged:
+#       print(m)
+# vmin = merged[ 0][1]
+# vmax = float(merged[-1][1] - vmin) / 2500000000.0
+# # print(vmax)
+single = []
+curr = 0
+# bins = []
+# for _ in range(0, int(math.ceil(vmax * 10))):
+#       bins.append([0] * (32 * 32))
+# merge the data
+# for (me, time, value) in merged:
+for (me, value) in merged:
+        # check now much this changes
+        old = counters[me]
+        change = value - old
+        counters[me] = value
+# # print(len(bins))
+# bins = np.array(bins)
+        # add change to the current
+        curr = curr + change
+        single.append( value )
+# rejected = 0
+# highest  = 0
+        pass
+# for x in merged:
+#       b = int(float(x[1] - vmin) / 250000000.0)
+#       from_ = x[2]
+#       if from_ < 0 or from_ > 32:
+#               rejected += 1
+#               continue;
+#       to_   = x[3]
+#       if to_ < 0 or to_ > 32:
+#               rejected += 1
+#               continue;
+#       idx = (to_ * 32) + from_
+#       bins[b][idx] = bins[b][idx] + 1
+#       highest = max(highest, bins[b][idx])
+# bins = np.array(map(lambda x: np.int8(x * 255.0 / float(highest)), bins))
+# print([highest, rejected])
+# print(bins.shape)
+# im = Image.fromarray(bins)
+# im.save('test.png')
+# vmax = merged[-1][1]
+# diff = float(vmax - vmin) / 2500000000.0
+# print([vmin, vmax])
+# print([vmax - vmin, diff])
+# print(len(merged))
+# for b in bins:
+#       print(b)
+# single = []
+# curr = 0
+# # merge the data
+# # for (me, time, value) in merged:
+# for (me, value) in merged:
+#       # check now much this changes
+#       old = counters[me]
+#       change = value - old
+#       counters[me] = value
+#       # add change to the current
+#       curr = curr + change
+#       single.append( value )
+#       pass
+# print(single)
+print(single)
 # single = sorted(single)[:len(single)-100]

Context Navigation

Changes in / [949339b:4e28d2e9]

Legend:

Download in other formats: