Diff [2b4daf23cdfb724c24a5ed13d7d20d9fe2c80590:42f6e07e6f562d26e2a4c552e12cfcd2f2660dce] for / – Cforall

Jenkins/FullBuild

-                      r2b4daf2
+                      r42f6e07
                         stage('Package') {
                                 trigger_dist( commitId, currentBuild.number.toString() )
+                                build job: 'Cforall_Distribute_Ref', parameters: [string(name: 'GitRef', value: commitId), string(name: 'Build', value: currentBuild.number.toString())]
+                        }
+                }
 …
+}
-def trigger_dist(String commitId, String buildNum) {
-        def result = build job: 'Cforall_Distribute_Ref',       \
-                parameters: [                                           \
-                        string(name: 'GitRef', value: commitId),        \
-                        string(name: 'Build' , value: buildNum) \
-                ],                                                              \
-                propagate: false
-        echo(result.result)
-        if(result.result != 'SUCCESS') {
-                sh("wget -q -O - https://cforall.uwaterloo.ca/jenkins/job/Cforall_Distribute_Ref/${result.number}/consoleText")
-                error(result.result)
+        }
+}
 //===========================================================================================================
 //Routine responsible of sending the email notification once the build is completed

Jenkins/tools.groovy

-                      r2b4daf2
+                      r42f6e07
 import org.jenkinsci.plugins.pipeline.modeldefinition.Utils
+// Global for the stage name
+StageName = ''
 // wrapper around stage declaretion to be more verbose
 // and allow showing as skipped in the UI
 def BuildStage(String name, boolean run, Closure block ) {
+        echo " -------- ${name} -------- "
+        StageName = name
+        echo " -------- ${StageName} -------- "
         if(run) {
                 stage(name, block)

Jenkinsfile

-                      r2b4daf2
+                      r42f6e07
         //attach the build log to the email
         catch (Exception caughtError) {
+                // Store the result of the build log
+                currentBuild.result = "FAILURE"
+                // An error has occured, the build log is relevent
+                //rethrow error later
+                err = caughtError
+                echo err.toString()
+                //An error has occured, the build log is relevent
                 log_needed = true
+                // rethrow error later
+                err = caughtError
+                // print the error so it shows in the log
+                echo err.toString()
+                //Store the result of the build log
+                currentBuild.result = "${tools.StageName} FAILURE".trim()
+        }

benchmark/Makefile.am

-                      r2b4daf2
+                      r42f6e07
 size-cfa$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/size/size.cfa
-## =========================================================================================================
-%-tokio$(EXEEXT): $(srcdir)/readyQ/%.rs $(srcdir)/bench.rs
-        cd $(builddir) && cargo build --release
-        cp $(builddir)/target/release/$(basename $@) $@

benchmark/creation/node_cor.js

r2b4daf2	r42f6e07
6	6	function * coroutine() { yield }
7	7
8		for ( var i = 0; i < times; i += 1 ) { // warm ~~JIT~~
	8	for ( var i = 0; i < times; i += 1 ) { // warm jit
9	9	cor = coroutine()
10	10	}

benchmark/ctxswitch/node_cor.js

r2b4daf2	r42f6e07
11	11	cor = coroutine()
12	12
13		for ( var i = 0; i < times; i += 1 ) { // warm ~~JIT~~
	13	for ( var i = 0; i < times; i += 1 ) { // warm git
14	14	cor.next();
15	15	}

benchmark/readyQ/bench.go

-                      r2b4daf2
+                      r42f6e07
         "flag"
         "fmt"
-        "log"
         "os"
         "runtime"
-        "runtime/pprof"
         "sync/atomic"
         "time"
 …
+}
 func bench_init() func() {
+func bench_init() {
         nprocsOpt := flag.Int("p", 1, "The number of processors")
         nthreadsOpt := flag.Int("t", 1, "The number of threads")
         durationOpt := flag.Float64("d", 0, "Duration of the experiment in seconds")
         stopOpt := flag.Uint64("i", 0, "Duration of the experiment in iterations")
-        cpuprofile := flag.String("cpuprofile", "", "write cpu profile to file")
         flag.Parse()
 …
         runtime.GOMAXPROCS(nprocs)
-        if (*cpuprofile) != "" {
-                f, err := os.Create(*cpuprofile)
-                if err != nil {
-                    log.Fatal(err)
+                }
-                pprof.StartCPUProfile(f)
+        }
-        return func() {
-                if (*cpuprofile) != "" {
-                        pprof.StopCPUProfile()
+                }
+        }
+}

benchmark/readyQ/cycle.cpp

r2b4daf2	r42f6e07
71	71	{ 'r', "ringsize", "Number of threads in a cycle", ring_size }
72	72	};
73		BENCH_OPT_PARSE("~~libfibre~~ cycle benchmark");
	73	BENCH_OPT_PARSE("cforall cycle benchmark");
74	74
75	75	{

benchmark/readyQ/cycle.rs

-                      r2b4daf2
+                      r42f6e07
+#[cfg(any(
+        feature = "sync time rt-threaded",
+  ))]
+extern crate tokio;
+use std::io::{self, Write};
 use std::sync::Arc;
 use std::sync::atomic::Ordering;
 use std::time::Instant;
+use std::sync::atomic::{AtomicU64, AtomicBool,Ordering};
+use std::time::{Instant,Duration};
 use tokio::runtime::Builder;
 use tokio::sync;
+use tokio::time;
+extern crate isatty;
+use isatty::stdout_isatty;
+extern crate num_format;
+use num_format::{Locale, ToFormattedString};
+extern crate clap;
 use clap::{Arg, App};
+use num_format::{Locale, ToFormattedString};
+#[path = "../bench.rs"]
+mod bench;
+// ==================================================
+use std::cell::UnsafeCell;
+use std::mem::MaybeUninit;
+use std::ops;
+pub struct InitializeCell<T> {
+    inner: UnsafeCell<MaybeUninit<T>>,
+}
+unsafe impl<T> Sync for InitializeCell<T> {}
+impl<T> InitializeCell<T> {
+    pub const unsafe fn new_uninitialized() -> InitializeCell<T> {
+          InitializeCell {
+                inner: UnsafeCell::new(MaybeUninit::uninit()),
+          }
+    }
+    pub const fn new(init: T) -> InitializeCell<T> {
+          InitializeCell {
+                inner: UnsafeCell::new(MaybeUninit::new(init)),
+          }
+    }
+    pub unsafe fn init(&self, init: T) {
+          (*self.inner.get()) = MaybeUninit::new(init);
+    }
+}
+impl<T> ops::Deref for InitializeCell<T> {
+    type Target = T;
+    fn deref(&self) -> &T {
+          unsafe {
+                &*(*self.inner.get()).as_ptr()
+          }
+    }
+}
+static CLOCK_MODE: InitializeCell<bool> = unsafe { InitializeCell::new_uninitialized() };
+static STOP_COUNT: InitializeCell<u64>  = unsafe { InitializeCell::new_uninitialized() };
+static DURATION: InitializeCell<f64>    = unsafe { InitializeCell::new_uninitialized() };
+static STOP         : AtomicBool = AtomicBool::new(false);
+static THREADS_LEFT : AtomicU64  = AtomicU64 ::new(10);
 struct Partner {
         sem: sync::Semaphore,
 …
+}
 async fn partner_main(idx: usize, others: Arc<Vec<Arc<Partner>>>, exp: Arc<bench::BenchData> ) -> u64 {
+async fn partner_main(result: sync::oneshot::Sender<u64>, idx: usize, others: Arc<Vec<Arc<Partner>>> ) {
         let this = &others[idx];
         let mut count:u64 = 0;
 …
                 count += 1;
+                if  exp.clock_mode && exp.stop.load(Ordering::Relaxed) { break; }
+                if !exp.clock_mode && count >= exp.stop_count { break; }
+        }
+        exp.threads_left.fetch_sub(1, Ordering::SeqCst);
+        count
+}
+// ==================================================
+                if  *CLOCK_MODE && STOP.load(Ordering::Relaxed) { break; }
+                if !*CLOCK_MODE && count >= *STOP_COUNT { break; }
+        }
+        THREADS_LEFT.fetch_sub(1, Ordering::SeqCst);
+        result.send( count ).unwrap();
+}
+fn prep(nthreads: usize, tthreads: usize) -> Vec<Arc<Partner>> {
+        let mut thddata = Vec::with_capacity(tthreads);
+        for i in 0..tthreads {
+                let pi = (i + nthreads) % tthreads;
+                thddata.push(Arc::new(Partner{
+                        sem: sync::Semaphore::new(0),
+                        next: pi,
+                }));
+        }
+        return thddata;
+}
+async fn wait(start: &Instant, is_tty: bool) {
+        loop {
+                time::sleep(Duration::from_micros(100000)).await;
+                let delta = start.elapsed();
+                if is_tty {
+                        print!(" {:.1}\r", delta.as_secs_f32());
+                        io::stdout().flush().unwrap();
+                }
+                if *CLOCK_MODE && delta >= Duration::from_secs_f64(*DURATION)  {
+                        break;
+                }
+                else if !*CLOCK_MODE && THREADS_LEFT.load(Ordering::Relaxed) == 0 {
+                        break;
+                }
+        }
+}
 fn main() {
         let options = App::new("Cycle Tokio")
+                .args(&bench::args())
+                .arg(Arg::with_name("duration")  .short("d").long("duration")  .takes_value(true).default_value("5").help("Duration of the experiments in seconds"))
+                .arg(Arg::with_name("iterations").short("i").long("iterations").takes_value(true).conflicts_with("duration").help("Number of iterations of the experiments"))
+                .arg(Arg::with_name("nthreads")  .short("t").long("nthreads")  .takes_value(true).default_value("1").help("Number of threads to use"))
+                .arg(Arg::with_name("nprocs")    .short("p").long("nprocs")    .takes_value(true).default_value("1").help("Number of processors to use"))
                 .arg(Arg::with_name("ringsize")  .short("r").long("ringsize")  .takes_value(true).default_value("1").help("Number of threads in a cycle"))
                 .get_matches();
 …
         let nprocs    = options.value_of("nprocs").unwrap().parse::<usize>().unwrap();
+        let tthreads = nthreads * ring_size;
+        let exp = Arc::new(bench::BenchData::new(options, tthreads));
+        if options.is_present("iterations") {
+                unsafe{
+                        CLOCK_MODE.init( false );
+                        STOP_COUNT.init( options.value_of("iterations").unwrap().parse::<u64>().unwrap() );
+                }
+        }
+        else {
+                unsafe{
+                        CLOCK_MODE.init(true);
+                        DURATION  .init(options.value_of("duration").unwrap().parse::<f64>().unwrap());
+                }
+        }
         let s = (1000000 as u64).to_formatted_string(&Locale::en);
         assert_eq!(&s, "1,000,000");
+        let thddata : Arc<Vec<Arc<Partner>>> = Arc::new(
+                (0..tthreads).map(|i| {
+                        let pi = (i + nthreads) % tthreads;
+                        Arc::new(Partner{
+                                sem: sync::Semaphore::new(0),
+                                next: pi,
+                        })
+                }).collect()
+        );
+        let tthreads = nthreads * ring_size;
+        THREADS_LEFT.store(tthreads as u64, Ordering::SeqCst);
+        let thddata = Arc::new(prep(nthreads, tthreads));
         let mut global_counter :u64 = 0;
 …
         runtime.block_on(async {
+                let threads: Vec<_> = (0..tthreads).map(|i| {
+                        tokio::spawn(partner_main(i, thddata.clone(), exp.clone()))
+                }).collect();
+                println!("Starting");
+                let start = Instant::now();
+                for i in 0..nthreads {
+                        thddata[i].sem.add_permits(1);
+                }
+                duration = exp.wait(&start).await;
+                println!("\nDone");
+                for i in 0..tthreads {
+                        thddata[i].sem.add_permits(1);
+                }
+                for t in threads {
+                        global_counter += t.await.unwrap();
+                let mut result  : Vec<sync::oneshot::Receiver::<u64>> = Vec::with_capacity(tthreads);
+                {
+                        let mut threads = Vec::with_capacity(tthreads);
+                        for i in 0..tthreads {
+                                let (s, r) = sync::oneshot::channel::<u64>();
+                                result.push(r);
+                                threads.push(tokio::spawn(partner_main(s, i, thddata.clone())));
+                        }
+                        println!("Starting");
+                        let is_tty = stdout_isatty();
+                        let start = Instant::now();
+                        for i in 0..nthreads {
+                                thddata[i].sem.add_permits(1);
+                        }
+                        wait(&start, is_tty).await;
+                        STOP.store(true, Ordering::SeqCst);
+                        duration = start.elapsed();
+                        println!("\nDone");
+                        for i in 0..tthreads {
+                                thddata[i].sem.add_permits(1);
+                        }
+                        for _ in 0..tthreads {
+                                global_counter += result.pop().unwrap().await.unwrap();
+                        }
+                }
         });

benchmark/readyQ/locality.go

-                      r2b4daf2
+                      r42f6e07
 import (
-        "context"
         "flag"
         "fmt"
         "math/rand"
         "os"
-        "syscall"
         "sync/atomic"
         "time"
-        "unsafe"
-        "golang.org/x/sync/semaphore"
         "golang.org/x/text/language"
         "golang.org/x/text/message"
+)
+// ==================================================
+type MyData struct {
+        _p1 [16]uint64 // padding
+        ttid int
+        id int
+        data [] uint64
+        _p2 [16]uint64 // padding
+func handshake(stop chan struct {}, c chan [] uint64, data [] uint64, share bool) (bool, [] uint64) {
+        var s [] uint64 = data
+        if !share {
+                s = nil
+        }
+        // send the data
+        select {
+        case <- stop:
+                return true, nil
+        case c <- s:
+        }
+        // get the new data chunk
+        select {
+        case <- stop:
+                return true, nil
+        case n := <- c:
+                if share {
+                        return false, n
+                }
+                return false, data
+        }
+}
 func NewData(id int, size uint64) (*MyData) {
+func local(result chan uint64, start chan struct{}, stop chan struct{}, size uint64, cnt uint64, channels []chan [] uint64, chan_cnt uint64, share bool) {
         var data [] uint64
         data = make([]uint64, size)
 …
                 data[i] = 0
+        }
+        return &MyData{[16]uint64{0}, syscall.Gettid(), id, data,[16]uint64{0}}
+        count := uint64(0)
+        <- start
+        for true {
+                for i := uint64(0); i < cnt; i++ {
+                        data[rand.Uint64() % size] += 1
+                }
+                i := rand.Uint64() % chan_cnt
+                var closed bool
+                closed, data = handshake(stop, channels[i], data, share)
+                count += 1
+                if  closed { break }
+                if !clock_mode && count >= stop_count { break }
+        }
+        atomic.AddInt64(&threads_left, -1);
+        result <- count
+}
+func (this * MyData) moved( ttid int ) (uint64) {
+        if this.ttid == ttid {
+                return 0
+        }
+        this.ttid = ttid
+        return 1
+}
+func main() {
+func (this * MyData) access( idx uint64 ) {
+        this.data[idx % uint64(len(this.data))] += 1
+}
+// ==================================================
+type MyCtx struct {
+        _p1 [16]uint64 // padding
+        s * semaphore.Weighted
+        d unsafe.Pointer
+        c context.Context
+        ttid int
+        id int
+        _p2 [16]uint64 // padding
+}
+func NewCtx( data * MyData, id int ) (MyCtx) {
+        r := MyCtx{[16]uint64{0},semaphore.NewWeighted(1), unsafe.Pointer(data), context.Background(), syscall.Gettid(), id,[16]uint64{0}}
+        r.s.Acquire(context.Background(), 1)
+        return r
+}
+func (this * MyCtx) moved( ttid int ) (uint64) {
+        if this.ttid == ttid {
+                return 0
+        }
+        this.ttid = ttid
+        return 1
+}
+// ==================================================
+// Atomic object where a single thread can wait
+// May exchanges data
+type Spot struct {
+        _p1 [16]uint64 // padding
+        ptr uintptr // atomic variable use fo MES
+        id int      // id for debugging
+        _p2 [16]uint64 // padding
+}
+// Main handshake of the code
+// Single seat, first thread arriving waits
+// Next threads unblocks current one and blocks in its place
+// if share == true, exchange data in the process
+func (this * Spot) put( ctx * MyCtx, data * MyData, share bool) (* MyData, bool) {
+        new := uintptr(unsafe.Pointer(ctx))
+        // old_d := ctx.d
+        // Attempt to CAS our context into the seat
+        var raw uintptr
+        for true {
+                raw = this.ptr
+                if raw == uintptr(1) { // Seat is closed, return
+                        return nil, true
+                }
+                if atomic.CompareAndSwapUintptr(&this.ptr, raw, new) {
+                        break // We got the seat
+                }
+        }
+        // If we aren't the fist in, wake someone
+        if raw != uintptr(0) {
+                var val *MyCtx
+                val = (*MyCtx)(unsafe.Pointer(raw))
+                // If we are sharing, give them our data
+                if share {
+                        // fmt.Printf("[%d] - %d update %d: %p -> %p\n", this.id, ctx.id, val.id, val.d, data)
+                        atomic.StorePointer(&val.d, unsafe.Pointer(data))
+                }
+                // Wake them up
+                // fmt.Printf("[%d] - %d release %d\n", this.id, ctx.id, val.id)
+                val.s.Release(1)
+        }
+        // fmt.Printf("[%d] - %d enter\n", this.id, ctx.id)
+        // Block once on the seat
+        ctx.s.Acquire(ctx.c, 1)
+        // Someone woke us up, get the new data
+        ret := (* MyData)(atomic.LoadPointer(&ctx.d))
+        // fmt.Printf("[%d] - %d leave: %p -> %p\n", this.id, ctx.id, ret, old_d)
+        return ret, false
+}
+// Shutdown the spot
+// Wake current thread and mark seat as closed
+func (this * Spot) release() {
+        val := (*MyCtx)(unsafe.Pointer(atomic.SwapUintptr(&this.ptr, uintptr(1))))
+        if val == nil {
+                return
+        }
+        // Someone was there, release them
+        val.s.Release(1)
+}
+// ==================================================
+// Struct for result, Go doesn't support passing tuple in channels
+type Result struct {
+        count uint64
+        gmigs uint64
+        dmigs uint64
+}
+func NewResult() (Result) {
+        return Result{0, 0, 0}
+}
+// ==================================================
+// Random number generator, Go's native one is to slow and global
+func __xorshift64( state * uint64 ) (uint64) {
+        x := *state
+        x ^= x << 13
+        x ^= x >> 7
+        x ^= x << 17
+        *state = x
+        return x
+}
+// ==================================================
+// Do some work by accessing 'cnt' cells in the array
+func work(data * MyData, cnt uint64, state * uint64) {
+        for i := uint64(0); i < cnt; i++ {
+                data.access(__xorshift64(state))
+        }
+}
+// Main body of the threads
+func local(result chan Result, start chan struct{}, size uint64, cnt uint64, channels [] Spot, share bool, id int) {
+        // Initialize some data
+        state := rand.Uint64()    // RNG state
+        data := NewData(id, size) // Starting piece of data
+        ctx := NewCtx(data, id)   // Goroutine local context
+        // Prepare results
+        r := NewResult()
+        // Wait for start
+        <- start
+        // Main loop
+        for true {
+                // Touch our current data, write to invalidate remote cache lines
+                work(data, cnt, &state)
+                // Wait on a random spot
+                i := __xorshift64(&state) % uint64(len(channels))
+                var closed bool
+                data, closed = channels[i].put(&ctx, data, share)
+                // Check if the experiment is over
+                if closed { break }                                       // yes, spot was closed
+                if  clock_mode && atomic.LoadInt32(&stop) == 1 { break }  // yes, time's up
+                if !clock_mode && r.count >= stop_count { break }         // yes, iterations reached
+                // Check everything is consistent
+                if uint64(len(data.data)) != size { panic("Data has weird size") }
+                // write down progress and check migrations
+                ttid := syscall.Gettid()
+                r.count += 1
+                r.gmigs += ctx .moved(ttid)
+                r.dmigs += data.moved(ttid)
+        }
+        // Mark goroutine as done
+        atomic.AddInt64(&threads_left, -1);
+        // return result
+        result <- r
+}
+// ==================================================
+// Program main
+func main() {
+        // Benchmark specific command line arguments
+        nspotsOpt    := flag.Int   ("n", 0    , "Number of spots where threads sleep (nthreads - nspots are active at the same time)")
+        work_sizeOpt := flag.Uint64("w", 2    , "Size of the array for each threads, in words (64bit)")
+        countOpt     := flag.Uint64("c", 2    , "Number of words to touch when working (random pick, cells can be picked more than once)")
+        work_sizeOpt := flag.Uint64("w", 2    , "Number of words (uint64) per threads")
+        countOpt     := flag.Uint64("c", 2    , "Number of words (uint64) to touch")
         shareOpt     := flag.Bool  ("s", false, "Pass the work data to the next thread when blocking")
+        // General benchmark initialization and deinitialization
+        defer bench_init()()
+        bench_init()
-        // Eval command line arguments
-        nspots:= *nspotsOpt
         size  := *work_sizeOpt
         cnt   := *countOpt
         share := *shareOpt
-        if nspots == 0 { nspots = nthreads - nprocs; }
-        // Check params
         if ! (nthreads > nprocs) {
                 fmt.Fprintf(os.Stderr, "Must have more threads than procs\n")
 …
+        }
         // Make global data
         barrierStart := make(chan struct{})         // Barrier used at the start
         threads_left = int64(nthreads - nspots)                // Counter for active threads (not 'nthreads' because at all times 'nthreads - nprocs' are blocked)
         result  := make(chan Result)                // Channel for results
         channels := make([]Spot, nspots) // Number of spots
+        barrierStart := make(chan struct{})
+        barrierStop  := make(chan struct{})
+        threads_left = int64(nthreads)
+        result  := make(chan uint64)
+        channels := make([]chan [] uint64, nthreads - nprocs)
         for i := range channels {
                 channels[i] = Spot{[16]uint64{0},uintptr(0), i,[16]uint64{0}}     // init spots
+                channels[i] = make(chan [] uint64, 1)
+        }
-        // start the goroutines
         for i := 0; i < nthreads; i++ {
                 go local(result, barrierStart, size, cnt, channels, share, i)
+                go local(result, barrierStart, barrierStop, size, cnt, channels, uint64(nthreads - nprocs), share)
+        }
         fmt.Printf("Starting\n");
-        atomic.StoreInt32(&stop, 0)
         start := time.Now()
         close(barrierStart) // release barrier
+        close(barrierStart)
         wait(start, true);  // general benchmark wait
+        wait(start, true);
         atomic.StoreInt32(&stop, 1)
+        close(barrierStop)
         end := time.Now()
         delta := end.Sub(start)
 …
         fmt.Printf("\nDone\n")
         // release all the blocked threads
         for i := range channels {
                 channels[i].release()
+        global_counter := uint64(0)
+        for i := 0; i < nthreads; i++ {
+                global_counter += <- result
+        }
-        // Join and accumulate results
-        results := NewResult()
-        for i := 0; i < nthreads; i++ {
-                r := <- result
-                results.count += r.count
-                results.gmigs += r.gmigs
-                results.dmigs += r.dmigs
+        }
-        // Print with nice 's, i.e. 1'000'000 instead of 1000000
         p := message.NewPrinter(language.English)
         p.Printf("Duration (s)           : %f\n", delta.Seconds());
+        p.Printf("Duration (ms)          : %f\n", delta.Seconds());
         p.Printf("Number of processors   : %d\n", nprocs);
         p.Printf("Number of threads      : %d\n", nthreads);
         p.Printf("Work size (64bit words): %d\n", size);
+        p.Printf("Total Operations(ops)  : %15d\n", results.count)
+        p.Printf("Total G Migrations     : %15d\n", results.gmigs)
+        p.Printf("Total D Migrations     : %15d\n", results.dmigs)
+        p.Printf("Ops per second         : %18.2f\n", float64(results.count) / delta.Seconds())
+        p.Printf("ns per ops             : %18.2f\n", float64(delta.Nanoseconds()) / float64(results.count))
+        p.Printf("Ops per threads        : %15d\n", results.count / uint64(nthreads))
+        p.Printf("Ops per procs          : %15d\n", results.count / uint64(nprocs))
+        p.Printf("Ops/sec/procs          : %18.2f\n", (float64(results.count) / float64(nprocs)) / delta.Seconds())
+        p.Printf("ns per ops/procs       : %18.2f\n", float64(delta.Nanoseconds()) / (float64(results.count) / float64(nprocs)))
+        p.Printf("Total Operations(ops)  : %15d\n", 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(nthreads))
+        p.Printf("Ops per procs          : %15d\n", global_counter / uint64(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/rq_bench.hfa

r2b4daf2	r42f6e07
39	39	} else if(stop_count > 0) { \
40	40	clock_mode = false; \
41		printf("Running for %llu iterations\n", stop_count); \
	41	printf("Running for %lu iterations\n", stop_count); \
42	42	} else { \
43	43	duration = 5; clock_mode = true;\

benchmark/readyQ/rq_bench.hpp

-                      r2b4daf2
+                      r42f6e07
+}
-bool parse_truefalse(const char * arg, bool & value) {
-        if(strcmp(arg, "true") == 0) {
-                value = true;
-                return true;
+        }
-        if(strcmp(arg, "false") == 0) {
-                value = false;
-                return true;
+        }
-        return false;
+}
 bool parse_settrue (const char *, bool & value ) {
         value = true;
 …
+        {
                 int idx = 0;
                 for(size_t i = 0; i < opt_count; i++) {
+                for(int i = 0; i < opt_count; i++) {
                         if(options[i].long_name) {
                                 optarr[idx].name = options[i].long_name;
 …
+        {
                 int idx = 0;
                 for(size_t i = 0; i < opt_count; i++) {
+                for(int i = 0; i < opt_count; i++) {
                         optstring[idx] = options[i].short_name;
                         idx++;
 …
                         case 'h':
                                 out = stdout;
-                                [[fallthrough]];
                         case '?':
                                 usage(argv[0], options, opt_count, usage_msg, out);
                         default:
                                 for(size_t i = 0; i < opt_count; i++) {
+                                for(int i = 0; i < opt_count; i++) {
                                         if(opt == options[i].short_name) {
                                                 const char * arg = optarg ? optarg : "";
-                                                if( arg[0] == '=' ) { arg++; }
                                                 bool success = options[i].parse_fun( arg, options[i].variable );
                                                 if(success) goto NEXT_ARG;
 …
         int width = 0;
+        {
                 for(size_t i = 0; i < opt_count; i++) {
+                for(int i = 0; i < opt_count; i++) {
                         if(options[i].long_name) {
                                 int w = strlen(options[i].long_name);
 …
         fprintf(out, "Usage:\n  %s %s\n", cmd, help);
         for(size_t i = 0; i < opt_count; i++) {
+        for(int i = 0; i < opt_count; i++) {
                 printopt(out, width, max_width, options[i].short_name, options[i].long_name, options[i].help);
+        }

configure.ac

-                      r2b4daf2
+                      r42f6e07
 # Some of our makefile don't need to be distributed
 AM_CONDITIONAL([CFORALL_DISTRIBUTE], [test -e $TOP_SRCDIR/autogen.sh])
 AM_COND_IF([CFORALL_DISTRIBUTE], [
         AC_CONFIG_FILES([
+AM_COND_IF([CFORALL_DISTRIBUTE],
+        [AC_CONFIG_FILES([
                 longrun_tests/Makefile
                 benchmark/Makefile
 …
                 tools/Makefile
                 tools/prettyprinter/Makefile
+        ])
+        AC_OUTPUT(benchmark/Cargo.toml)
+])
+                ])])
 AC_CONFIG_LINKS([tests/test.py:tests/test.py])

doc/theses/thierry_delisle_PhD/thesis/Makefile

-                      r2b4daf2
+                      r42f6e07
         base \
         empty \
-        emptybit \
-        emptytls \
-        emptytree \
-        fairness \
         system \
+}
 …
         ${LaTeX} $<
-build/fairness.svg : fig/fairness.py | ${Build}
-        python3 $< $@
 ## Define the default recipes.
 …
         fig2dev -L pstex_t -p ${Build}/$@ $< > ${Build}/$@_t
-%.pstex : build/%.svg | ${Build}
-        inkscape -z -D --file=$< --export-eps=${Build}/$@ --export-latex
-        mv ${Build}/$@_tex ${Build}/$@_t
-        echo "sed -i 's/$@/${Build}/$@/g' ${Build}/$@_t"
-        sed -i 's/$@/${Build}\/$@/g' ${Build}/$@_t
 ## pstex with inverted colors
 %.dark.pstex : fig/%.fig Makefile | ${Build}

doc/theses/thierry_delisle_PhD/thesis/glossary.tex

r2b4daf2	r42f6e07
7	7	\newacronym{io}{I/O}{Input and Output}
8	8	\newacronym{numa}{NUMA}{Non-Uniform Memory Access}
9		~~\newacronym{prng}{PRNG}{Pseudo Random Number Generator}~~
10	9	\newacronym{raii}{RAII}{Resource Acquisition Is Initialization}
11	10	\newacronym{tls}{TLS}{Thread Local Storage}

doc/theses/thierry_delisle_PhD/thesis/local.bib

-                      r2b4daf2
+                      r42f6e07
   note = "[Online; accessed 23-October-2020]"
+}
-@misc{wiki:lcg,
-  author = "{Wikipedia contributors}",
-  title = "Linear congruential generator --- {W}ikipedia{,} The Free Encyclopedia",
-  year = "2020",
-  url = "https://en.wikipedia.org/wiki/Linear_congruential_generator",
-  note = "[Online; accessed 2-January-2021]"
+}

doc/theses/thierry_delisle_PhD/thesis/text/core.tex

-                      r2b4daf2
+                      r42f6e07
 \chapter{Scheduling Core}\label{core}
 Before discussing scheduling in general, where it is important to address systems that are changing states, this document discusses scheduling in a somewhat ideal scenerio, where the system has reached a steady state. For this purpose, a steady state is loosely defined as a state where there are always \glspl{thrd} ready to run and the system has the ressources necessary to accomplish the work, \eg, enough workers. In short, the system is neither overloaded nor underloaded.
+Before discussing scheduling in general, where it is important to address systems that are changing states, this document discusses scheduling in a somewhat ideal scenerio, where the system has reached a steady state. For this purpose, a steady state is loosely defined as a state where there are always \glspl{thrd} ready to run and but the system has the ressources necessary to accomplish the work. In short, the system is neither overloaded or underloaded.
 I believe it is important to discuss the steady state first because it is the easiest case to handle and, relatedly, the case in which the best performance is to be expected. As such, when the system is either overloaded or underloaded, a common approach is to try to adapt the system to the new load and return to the steady state, \eg, adding or removing workers. Flaws in the scheduling when the system is in the steady state can therefore to be pervasive in all states.
+I believe it is important to discuss the steady state first because it is the easiest case to handle and, relatedly, the case in which the best performance is to be expected. As such, when the system is either overloaded or underloaded, a common approach is to try to adapt the system to the new load and return to the steady state. Flaws in the scheduling in the steady state tend therefore to be pervasive in all states.
 \section{Design Goals}
 As with most of the design decisions behind \CFA, an important goal is to match the expectation of the programmer, according to their probable mental model. To match these expectations, the design must offer the programmers sufficient guarantees so that, as long as they respect the mental model, the system will also respect this model.
+As with most of the design decisions behind \CFA, the main goal is to match the expectation of the programmer, according to their probable mental model. To match these expectations, the design must offer the programmers sufficient guarantees so that, as long as the programmer respects the mental model, the system will also respect this model.
 For threading, a simple and common mental model is the ``Ideal multi-tasking CPU'' :
 …
 Applied to threads, this model states that every ready \gls{thrd} immediately runs in parallel with all other ready \glspl{thrd}. While a strict implementation of this model is not feasible, programmers still have expectations about scheduling that come from this model.
 In general, the expectation at the center of this model is that ready \glspl{thrd} do not interfere with eachother but simply share the hardware. This makes it easier to reason about threading because ready \glspl{thrd} can be taken in isolation and the effect of the scheduler can be virtually ignored. This expectation of \gls{thrd} independence means the scheduler is expected to offer two guarantees:
+In general, the expectation at the center of this model is that ready \glspl{thrd} do not interfere with eachother but simply share the hardware. This makes it easier to reason about threading because ready \glspl{thrd} can be taken in isolation and the effect of the scheduler can be virtually ignored. This expectation of \gls{thrd} independence means the scheduler is expected to offer 2 guarantees:
 \begin{enumerate}
         \item A fairness guarantee: a \gls{thrd} that is ready to run will not be prevented to do so by another thread.
 …
 It is important to note that these guarantees are expected only up to a point. \Glspl{thrd} that are ready to run should not be prevented to do so, but they still need to share a limited amount of hardware. Therefore, the guarantee is considered respected if a \gls{thrd} gets access to a \emph{fair share} of the hardware, even if that share is very small.
 Similarly the performance guarantee, the lack of interferance between threads, is only relevant up to a point. Ideally the cost of running and blocking would be constant regardless of contention, but the guarantee is considered satisfied if the cost is not \emph{too high} with or without contention. How much is an acceptable cost is obviously highly variable. For this document the performance experimentation will attempt to show that the cost of scheduling is at worst equivalent to existing algorithms used in popular languages. This demonstration can be made by comparing application built in \CFA to applications built with other languages or other models. Recall from a few paragraphs ago that the expectation of programmers is that the impact of the scheduler can be ignored. Therefore, if the cost of scheduling is equivalent or lower to other popular languages, I will consider the guarantee achieved.
+Similarly the performance guarantee, the lack of interferance between threads is only relevant op to a point. Ideally the cost of running and blocking would be constant regardless of contention, but the guarantee is considered satisfied if the cost is not \emph{too high} with or without contention. How much is an acceptable cost is obviously highly variable. For this document the performance experimentation will attempt to show that the cost of scheduling is not a major factor in application performance. This demonstration can be made by comparing application built in \CFA to applications built with other languages or other models. If the performance of an application built in \CFA is not meaningfully different than one built with a different runtime, then the scheduler has a negigeable impact on performance, \ie its impact can be ignored. Recall from a few paragraphs ago that the expectation of programmers is that the impact of the scheduler can be ignored. Therefore, if the cost of scheduling is not a significant portion of the runtime of several different application, I will consider the guarantee achieved.
+More precisely the scheduler should be:
+\begin{itemize}
+        \item As fast as other schedulers that are less fair.
+        \item Faster than other scheduler that have equal or better fairness.
+\end{itemize}
+\subsection{Fairness vs Scheduler Locality}
+An important performance factor in modern architectures is cache locality. Waiting for data not present in the cache can have a major impact on performance, and having multiple \glspl{hthrd} writing to the same cache lines can lead to cache lines that need to be waited on again. It is therefore preferable to divide the data among each \gls{hthrd}\footnote{This can be an explicit division up front or using data structures where different \glspl{hthrd} are naturally routed to different cache lines.}.
+For a scheduler, having good locality\footnote{This section discusses \emph{internal} locality, \ie, the locality of the data used by the scheduler. \emph{External locality}, \ie, how the data used by the application is affected by scheduling, is a much more complicated subject and will be discussed in the chapters on evaluation.}, \ie, having the data be local to each \gls{hthrd}, generally conflicts with fairness. Indeed, good locality often requires avoiding the movement of cache lines, while fairness requires dynamically moving \gls{thrd}, and as a consequence cache lines, to \glspl{hthrd} that are currently more appropriate.
+However, I claim that in practice it is possible to strike a balance between fairness and performance because the need for these do not necessarily overlap temporaly. Figure~\ref{fig:fair} shows an visual representation of this behaviour. As mentionned, a little bit of unfairness can be acceptable, therefore it can be desirable to have an algorithm that prioritizes cache locality as long as no threads is left behind for too long.
+\begin{figure}
+        \begin{center}
+                \input{fairness.pstex_t}
+        \end{center}
+        \caption{Fairness vs Locality}
+        \label{fig:fair}
+        Rule of thumb graph: Importance of Fairness and Locality while a ready \gls{thrd} waits run.
+        As the time a ready \gls{thrd} waits increases, ``Ready Time'', the chances that its data is still in cache decreases. At the same time, the need for fairness increases since other \glspl{thrd} may have the chance to run many times, breaking the fairness model mentionned above. Since the actual values and curves of this graph can be highly variable, the graph is left intentionally fuzzy and innacurate.
+\end{figure}
+\todo{This paragraph should be moved later}
+% The next step is then to decide what is considered a \emph{fair share}, \ie what metric is used to measure fairness. Since \CFA is intended to allow numerous short lived threads, I decided to avoid total CPU time as the measure of fairness. Total CPU time inherently favors new \glspl{thrd} over older ones which isn't necessarily a good thing. Instead, fairness is measured in terms of opportunities to run. This metric is more appropriate for a mix of short and long lived \glspl{thrd}.
 \section{Design}
+A naive strictly \glsxtrshort{fifo} ready-queue does not offer sufficient performance. As shown in the evaluation sections, most production schedulers scale when adding multiple \glspl{hthrd} and that is not possible with a single point of contention. Therefore it is vital to shard the ready-queue so that multiple \glspl{hthrd} can access the ready-queue without performance degradation.
+While avoiding the pitfalls of Feedback Scheduling is fairly easy, scheduling does not innately require feedback, avoiding prioritization of \glspl{thrd} is more difficult because of implicitly priorities, see Subsection~\ref{priority}. A strictly \glsxtrshort{fifo} rea
+\subsection{Sharding} \label{sec:sharding}
+An interesting approach to sharding a queue is presented in \cit{Trevors paper}. This algorithm represents a queue with relaxed \glsxtrshort{fifo} guarantee using an array of strictly \glsxtrshort{fifo} sublists as shown in Figure~\ref{fig:base}. Each cell of the array contains a linked-list with a lock and each node in these list is marked with a timestamp indicating when they were added to the list. Push operations are done by picking a random cell and attempting to push to its list. If the cell is already locked, the operation is simply retried on a new cell until a lock is acquired. Pop operations are done in a similar fashion except two random cells are picked. If both cells are not already locked and both cells contain non-empty lists, the operation pops the node with the oldest timestamp. If only one of the cell is unlocked and non-empty, the operation pops from that cell. If both cells are either locked or empty, the operation picks two new cells and tries again.
+\subsection{Sharding}
 \begin{figure}
 …
 \subsection{Finding threads}
+Once threads have been distributed onto multiple queues, indentifying which queues are empty and which are not can become a problem. Indeed, if the number of \glspl{thrd} does not far exceed the number of queues, it is probable that several of these queues are empty. Figure~\ref{fig:empty} shows an example with 2 \glspl{thrd} running on 8 queues, where the chances of getting an empty queue is 75\% per pick, meaning two random picks yield a \gls{thrd} only half the time.
+Once threads have been distributed onto multiple queues, indentifying which queues are empty and which aren't can become a problem.
+Indeed, if the number of \glspl{thrd} does not far exceed the number of queues, it is probable that several of these queues are empty.
+Figure~\ref{fig:empty} shows an example with 2 \glspl{thrd} running on 8 queues, where the chances of getting an empty queue is 75\% per pick, meaning two random picks yield a \gls{thrd} only half the time.
 …
 This can lead to performance problems since picks that do not yield a \gls{thrd} are not useful and do not necessarily help make more informed guesses.
 Solutions to this problem can take many forms, but they ultimately all have to encode where the threads are in some form. My results show that the density and locality of this encoding is generally the dominating factor in these scheme. Classic solutions to this problem use one of three techniques to encode the information:
+Solutions to this problem can take many forms, but they ultimately all have to encode where the threads are in some form. My results show that the density and locality of this encoding is generally the dominating factor in these scheme.
+\begin{figure}
+        \begin{center}
+                {\resizebox{0.73\textwidth}{!}{\input{emptybit.pstex_t}}}
+        \end{center}
+        \vspace*{-5pt}
+        \caption{Underloaded queue with added bitmask to indicate which array cells have items.}
+        \label{fig:emptybit}
+        \begin{center}
+                {\resizebox{0.73\textwidth}{!}{\input{emptytree.pstex_t}}}
+        \end{center}
+        \vspace*{-5pt}
+        \caption{Underloaded queue with added binary search tree indicate which array cells have items.}
+        \label{fig:emptytree}
+        \begin{center}
+                {\resizebox{0.9\textwidth}{!}{\input{emptytls.pstex_t}}}
+        \end{center}
+        \vspace*{-5pt}
+        \caption{Underloaded queue with added per processor bitmask to indicate which array cells have items.}
+        \label{fig:emptytls}
+\end{figure}
+\paragraph{Dense Information} Figure~\ref{fig:emptybit} shows a dense bitmask to identify which inner queues are currently in use. This approach means processors can often find \glspl{thrd} in constant time, regardless of how many underlying queues are empty. Furthermore, modern x86 CPUs have extended bit manipulation instructions (BMI2) that allow using the bitmask with very little overhead compared to the randomized selection approach for a filled ready queue, offering good performance even in cases with many empty inner queues. However, this technique has its limits: with a single word\footnote{Word refers here to however many bits can be written atomically.} bitmask, the total number of underlying queues in the ready queue is limited to the number of bits in the word. With a multi-word bitmask, this maximum limit can be increased arbitrarily, but the look-up will nolonger be constant time. Finally, a dense bitmap, either single or multi-word, causes additional contention problems which reduces performance because of cache misses after updates. This central update bottleneck also means the information in the bitmask is more often stale before a processor can use it to find an item, \ie mask read says there are available \glspl{thrd} but none on queue.
+\paragraph{Sparse Information} Figure~\ref{fig:emptytree} shows an approach using a hierarchical tree data-structure to reduce contention and has been shown to work in similar cases~\cite{ellen2007snzi}. However, this approach may lead to poorer performance due to the inherent pointer chasing cost while still allowing more contention on the nodes of the tree if the tree is not deep enough.
+\paragraph{Local Information} Figure~\ref{fig:emptytls} shows an approach using dense information, similar to the bitmap, but have each thread keep its own independent copy of it. While this approach can offer good scalability \emph{and} low latency, the liveliness and discovery of the information can become a problem. This case is made worst in systems with few processors where even blind random picks can find \glspl{thrd} in few tries.
+I built a prototype of these approach and none of these techniques offer satisfying performance when few threads are present. All of these approach hit the same 2 problems. First, blindly picking two sub-queues is very fast which means that any improvement to the hit rate can easily be countered by a slow-down in look-up speed. Second, the array is already as sharded as is needed to avoid contention bottlenecks, so any denser data structure will tend to become a bottleneck. In all cases, these factors meant that the best cases scenerio, many threads, would get worst throughput and the worst case scenario, few threads, would get a better hit rate, but an equivalent throughput. As a result I tried an entirely different approach.
+\subsection{Dynamic Entropy}\cit{https://xkcd.com/2318/}
+In the worst case scenario there are few \glspl{thrd} ready to run, or more accuratly given $P$ \glspl{proc}, $T$ \glspl{thrd} and $\epsilon$, as usual, a very small number, in this case $\epsilon \ll P$, we have $T = P + \epsilon$. An important thing to note is that in this case, fairness is effectively irrelevant. Indeed, this case is close to \emph{actually matching} the model of the ``Ideal multi-tasking CPU'' presented in this chapter\footnote{For simplicity, this assumes there is a one-to-one match between \glspl{proc} and \glspl{hthrd}.}. Therefore, in this context it is possible to use a purely internal locality based approach and still meet the fairness requirements. This approach would simply have each \gls{proc} running a single \gls{thrd} repeatedly. Or from the shared ready-queue viewpoint, each \gls{proc} would push to a given sub-queue and then pop from the \emph{same} subqueue. Ideally, the scheduler would achieve this without affecting the fairness guarantees in cases where $T \gg P$.
+To achieve this, I use a communication channel I have not mentionned yet and which I believe I use in a novel way : the \glsxtrshort{prng}. If the scheduler has a \glsxtrshort{prng} instance per \gls{proc} exclusively used for scheduling, its seed effectively encodes a list of all the accessed subqueues, from the latest to the oldest. The only requirement to achieve this is to be able to ``replay'' the \glsxtrshort{prng} backwards. As it turns out, this is an entirely reasonnable requirement and there already exist \glsxtrshort{prng}s that are fast, compact \emph{and} can be run forward and backwards. Linear congruential generators\cite{wiki:lcg} are an example of \glsxtrshort{prng}s that match these requirements.
+The algorithm works as follows :
+\begin{itemize}
+        \item Each \gls{proc} has two \glsxtrshort{prng} instances, $F$ and $B$.
+        \item Push and Pop operations happen as mentionned in Section~\ref{sec:sharding} with the following exceptions:
+        \begin{itemize}
+                \item Push operations use $F$ going forward on each try and on success $F$ is copied into $B$.
+                \item Pop operations use $B$ going backwards on each try.
+        \end{itemize}
+\end{itemize}
+The main benefit of this technique is that it basically repects the desired properties of Figure~\ref{fig:fair}. When looking for work, \glspl{proc} will look first at the last cells they pushed to, if any, and then move backwards through the cells. As the \glspl{proc} continue looking for work, $F$ moves back and $B$ stays in place. As a result the relation between the two becomes weaker, which means that the probablisitic fairness of the algorithm reverts to normal. Chapter~\ref{proofs} discusses more formally the fairness guarantees of this algorithm.
+\section{Details}
+\paragraph{Dense Information}

doc/theses/thierry_delisle_PhD/thesis/text/existing.tex

r2b4daf2	r42f6e07
42	42	\paragraph{Task Placement} Since modern computers rely heavily on cache hierarchies\cit{Do I need a citation for this}, migrating tasks from one core to another can be . \cite{DBLP:journals/tpds/SquillanteL93}
43	43
44		\~~todo~~{The survey is not great on this subject}
	44	\TODO{The survey is not great on this subject}
45	45
46	46	\paragraph{Complex Machine Architecture} Another aspect that has been looked at is how well Work Stealing is applicable to different machine architectures.

libcfa/src/Makefile.am

-                      r2b4daf2
+                      r42f6e07
         concurrency/iofwd.hfa \
         containers/list.hfa \
+        containers/stackLockFree.hfa \
+        vec/vec.hfa \
+        vec/vec2.hfa \
+        vec/vec3.hfa \
+        vec/vec4.hfa
+        containers/stackLockFree.hfa
 inst_headers_src = \
 …
         concurrency/clib/cfathread.h \
         concurrency/invoke.h \
-        concurrency/future.hfa \
         concurrency/kernel/fwd.hfa

libcfa/src/bits/collection.hfa

-                      r2b4daf2
+                      r42f6e07
 #pragma once
-#include <stdio.h> // REMOVE THIS AFTER DEBUGGING
 struct Colable {
         struct Colable * next;                                                                          // next node in the list
+        Colable * next;                                                                         // next node in the list
         // invariant: (next != 0) <=> listed()
 };
+#ifdef __cforall
 static inline {
+inline {
         // PUBLIC
 …
+        }
+        // // wrappers to make Collection have T
+        // forall( dtype T ) {
+        //      T *& Next( T * n ) {
+        //              return (T *)Next( (Colable *)n );
+        //      }
+        // } // distribution
+        // wrappers to make Collection have T
+        forall( dtype T ) {
+                T *& Next( T * n ) {
+                        return (T *)Next( (Colable *)n );
+                }
+                bool listed( T * n ) {
+                        return Next( (Colable *)n ) != 0p;
+                }
+        } // distribution
 } // distribution
-forall( dtype T | { T *& Next ( T * ); } ) {
-        bool listed( T * n ) {
-                return Next( n ) != 0p;
+        }
+}
 struct Collection {
 …
 };
 static inline {
+inline {
         // class invariant: root == 0 & empty() | *root in *this
         void ?{}( Collection &, const Collection & ) = void; // no copy
 …
 struct ColIter {
         void * curr;                                                                            // element returned by |
+        void * curr;                                                                            // element to be returned by >>
 };
 static inline {
+inline {
         void ?{}( ColIter & colIter ) with( colIter ) {
                 curr = 0p;
 …
         } // distribution
 } // distribution
-#endif

libcfa/src/bits/containers.hfa

r2b4daf2	r42f6e07
36	36	#define __small_array_t(T) __small_array(T)
37	37	#else
38		#define __small_array_t(T) __small_array
	38	#define __small_array_t(T) struct __small_array
39	39	#endif
40	40

libcfa/src/bits/defs.hfa

r2b4daf2	r42f6e07
29	29	#define __cfa_anonymous_object(x) inline struct x
30	30	#else
31		#define __cfa_anonymous_object(x) ~~struct~~ x __cfa_anonymous_object
	31	#define __cfa_anonymous_object(x) x __cfa_anonymous_object
32	32	#endif
33	33

libcfa/src/bits/locks.hfa

-                      r2b4daf2
+                      r42f6e07
                 void ^?{}(future_t &) {}
-                void reset(future_t & this) {
-                        // needs to be in 0p or 1p
-                        __atomic_exchange_n( &this.ptr, 0p, __ATOMIC_SEQ_CST);
+                }
                 // check if the future is available
                 bool available( future_t & this ) {
 …
                 // Mark the future as abandoned, meaning it will be deleted by the server
+                bool abandon( future_t & this ) {
+                        /* paranoid */ verify( this.ptr != 3p );
+                        // Mark the future as abandonned
+                void abandon( future_t & this ) {
                         struct oneshot * got = __atomic_exchange_n( &this.ptr, 3p, __ATOMIC_SEQ_CST);
-                        // If the future isn't already fulfilled, let the server delete it
-                        if( got == 0p ) return false;
                         // got == 2p: the future is ready but the context hasn't fully been consumed
 …
                         if( got == 2p ) {
                                 while( this.ptr != 1p ) Pause();
+                                got = 1p;
+                        }
+                        // The future is completed delete it now
+                        /* paranoid */ verify( this.ptr != 1p );
+                        free( &this );
+                        return true;
+                        }
+                        return;
+                }

libcfa/src/bits/queue.hfa

-                      r2b4daf2
+                      r42f6e07
 #include "bits/collection.hfa"
+// A Queue(T) is a Collection(T) defining the ordering that nodes are returned by drop() in the same order from those
+// added by add(). T must be a public descendant of uColable.
+// The implementation is a typical singly-linked list, except the next field of the last element points to itself
+// instead of being null.
+forall( dtype T | { T *& Next ( T * ); } ) {
+forall( dtype T ) {
         struct Queue {
                 inline Collection;                                                              // Plan 9 inheritance
 …
                 } // post: n == tail() & succ(n) == 0 | n != tail() & *succ(n) in *q
                 T & addHead( Queue(T) & q, T & n ) with( q ) {
+                void addHead( Queue(T) & q, T & n ) with( q ) {
                         #ifdef __CFA_DEBUG__
                         if ( listed( &n ) ) abort( "(Queue &)%p.addHead( %p ) : Node is already on another list.", &q, &n );
 …
                                 Next( &n ) = &n;                                                // last node points to itself
+                        }
-                        return n;
+                }
                 T & addTail( Queue(T) & q, T & n ) with( q ) {
+                void addTail( Queue(T) & q, T & n ) with( q ) {
                         #ifdef __CFA_DEBUG__
                         if ( listed( &n ) ) abort( "(Queue &)%p.addTail( %p ) : Node is already on another list.", &q, &n );
 …
                         last = &n;
                         Next( &n ) = &n;                                                        // last node points to itself
-                        return n;
+                }
                 T & add( Queue(T) & q, T & n ) with( q ) {
                         return addTail( q, n );
+                void add( Queue(T) & q, T & n ) with( q ) {
+                        addTail( q, n );
+                }
 …
                         T & t = head( q );
                         if ( root ) {
                                 root = Next( (T *)root );
+                                root = Next( root );
                                 if ( &head( q ) == &t ) {
                                         root = last = 0p;                                       // only one element
 …
+                }
                 T & remove( Queue(T) & q, T & n ) with( q ) {   // O(n)
+                void remove( Queue(T) & q, T & n ) with( q ) {  // O(n)
                         #ifdef __CFA_DEBUG__
                         if ( ! listed( (Colable &)n ) ) abort( "(Queue &)%p.remove( %p ) : Node is not on a list.", &q, &n );
 …
                                 curr = Next( curr );
+                        }
-                        return n;
                 } // post: ! listed( n )
                 T & dropTail( Queue(T) & q ) with( q ) {                // O(n)
+                T & dropTail( Queue(T) & q ) with( q ) { // O(n)
                         T & n = tail( q );
                         return &n ? remove( q, n ), n : *0p;
 …
 } // distribution
 forall( dtype T | { T *& Next ( T * ); } ) {
+forall( dtype T ) {
         struct QueueIter {
                 inline ColIter;                                                                 // Plan 9 inheritance
 …
                 } // post: curr == 0p
                 // create an iterator active in queue q
+                // create an iterator active in Queue q
                 void ?{}( QueueIter(T) & qi, Queue(T) & q ) with( qi ) {
                         curr = &head( q );
 …
                 } // post: curr = {e in q}
                 // make existing iterator active in queue q
+                // make existing iterator active in Queue q
                 void over( QueueIter(T) & qi, Queue(T) & q ) with( qi ) {
                         curr = &head( q );
                 } // post: curr = {e in q}
                 bool ?|?( QueueIter(T) & qi, T && tp ) with( qi ) {
+                bool ?>>?( QueueIter(T) & qi, T && tp ) with( qi ) {
                         if ( curr ) {
                                 &tp = Curr( qi );
 …
                         return &tp != 0p;
+                }
                 // post: elts == null & !operator|(tp) | elts != null & *tp' in elts & elts' == elts - *tp & operator|(tp)
+                // post: elts == null & !operator>>(tp) | elts != null & *tp' in elts & elts' == elts - *tp & operator>>(tp)
         } // distribution
 } // distribution

libcfa/src/bits/sequence.hfa

-                      r2b4daf2
+                      r42f6e07
 #include "bits/collection.hfa"
-#include "bits/defs.hfa"
 struct Seqable {
         __cfa_anonymous_object(Colable);
         struct Seqable * back;                                                                          // pointer to previous node in the list
+        inline Colable;
+        Seqable * back;                                                                         // pointer to previous node in the list
 };
+#ifdef __cforall
+static inline {
+inline {
         // PUBLIC
 …
+        }
         // // wrappers to make Collection have T
         // forall( dtype T ) {
         //      T *& Back( T * n ) {
         //              return (T *)Back( (Seqable *)n );
         //      }
         // } // distribution
+        // wrappers to make Collection have T
+        forall( dtype T ) {
+                T *& Back( T * n ) {
+                        return (T *)Back( (Seqable *)n );
+                }
+        } // distribution
 } // distribution
+// A Sequence(T) is a Collection(T) defining the ordering of a uStack and uQueue, and to insert and remove elements
+// anywhere in the sequence. T must be a public descendant of uSeqable.
+// The implementation is a typical doubly-linked list, except the next field of the last node points at the first node
+// and the back field of the last node points at the first node (circular).
+forall( dtype T | { T *& Back ( T * ); T *& Next ( T * ); } ) {
+forall( dtype T ) {
         struct Sequence {
                 inline Collection;                                                              // Plan 9 inheritance
         };
         static inline {
+        inline {
                 // wrappers to make Collection have T
                 T & head( Sequence(T) & s ) with( s ) {
 …
                 void ?{}( Sequence(T) & s ) with( s ) {
                         ((Collection &)s){};
                 }       // post: isEmpty()
                 // Return a pointer to the last sequence element, without removing it.
+                }       // post: isEmpty().
+                // Return a pointer to the last sequence element, without removing it.
                 T & tail( Sequence(T) & s ) with( s ) {
                         return root ? (T &)*Back( &head( s ) ) : *0p;
 …
                 } // post: n == tail() & succ(n) == 0 | n != tail() & *succ(n) in *s
                 // Return a pointer to the element before *n, or 0p if list empty.
+                // Return a pointer to the element before *n, or 0p if there isn't one.
                 T * pred( Sequence(T) & s, T * n ) with( s ) {  // pre: *n in *s
                         #ifdef __CFA_DEBUG__
 …
                         #endif // __CFA_DEBUG__
                         return n == &head( s ) ? 0p : Back( n );
                 } // post: n == head() & head(n) == 0 | n != head() & *pred(n) in *s
                 // Insert *n into the sequence before *bef, or at the end if bef == 0p.
                 T & insertBef( Sequence(T) & s, T & n, T & bef ) with( s ) { // pre: !n->listed() & *bef in *s
+                }       // post: n == head() & head(n) == 0 | n != head() & *pred(n) in *s
+                // Insert *n into the sequence before *bef, or at the end if bef == 0.
+                void insertBef( Sequence(T) & s, T & n, T & bef ) with( s ) { // pre: !n->listed() & *bef in *s
                         #ifdef __CFA_DEBUG__
                         if ( listed( &n ) ) abort( "(Sequence &)%p.insertBef( %p, %p ) : Node is already on another list.", &s, n, &bef );
 …
                                 Next( Back( &n ) ) = &n;
                         } // if
-                        return n;
                 }       // post: n->listed() & *n in *s & succ(n) == bef
                 // Insert *n into the sequence after *aft, or at the beginning if aft == 0.
                 T & insertAft( Sequence(T) & s, T & aft, T & n ) with( s ) {    // pre: !n->listed() & *aft in *s
+                void insertAft( Sequence(T) & s, T & aft, T & n ) with( s ) {   // pre: !n->listed() & *aft in *s
                         #ifdef __CFA_DEBUG__
                         if ( listed( &n ) ) abort( "(Sequence &)%p.insertAft( %p, %p ) : Node is already on another list.", &s, &aft, &n );
 …
                                 Next( &aft ) = &n;
                         } // if
+                        return n;
+                } // post: n->listed() & *n in *s & succ(n) == bef
+                }         // post: n->listed() & *n in *s & succ(n) == bef
                 // pre: n->listed() & *n in *s
                 T & remove( Sequence(T) & s, T & n ) with( s ) { // O(1)
+                void remove( Sequence(T) & s, T & n ) with( s ) { // O(1)
                         #ifdef __CFA_DEBUG__
                         if ( ! listed( &n ) ) abort( "(Sequence &)%p.remove( %p ) : Node is not on a list.", &s, &n );
 …
                         Next( Back( &n ) ) = Next( &n );
                         Next( &n ) = Back( &n ) = 0p;
+                        return n;
+                } // post: !n->listed()
+                }                                                       // post: !n->listed().
                 // Add an element to the head of the sequence.
+                T & addHead( Sequence(T) & s, T & n ) {                 // pre: !n->listed(); post: n->listed() & head() == n
+                        return insertAft( s, *0p, n );
+                }
+                void addHead( Sequence(T) & s, T & n ) {                // pre: !n->listed(); post: n->listed() & head() == n
+                        insertAft( s, *0p, n );
+                }
                 // Add an element to the tail of the sequence.
+                T & addTail( Sequence(T) & s, T & n ) {                 // pre: !n->listed(); post: n->listed() & head() == n
+                        return insertBef( s, n, *0p );
+                }
+                void addTail( Sequence(T) & s, T & n ) {                // pre: !n->listed(); post: n->listed() & head() == n
+                        insertBef( s, n, *0p );
+                }
                 // Add an element to the tail of the sequence.
+                T & add( Sequence(T) & s, T & n ) {                             // pre: !n->listed(); post: n->listed() & head() == n
+                        return addTail( s, n );
+                }
+                void add( Sequence(T) & s, T & n ) {                    // pre: !n->listed(); post: n->listed() & head() == n
+                        addTail( s, n );
+                }
                 // Remove and return the head element in the sequence.
                 T & dropHead( Sequence(T) & s ) {
 …
                         return &n ? remove( s, n ), n : *0p;
+                }
                 // Remove and return the head element in the sequence.
                 T & drop( Sequence(T) & s ) {
                         return dropHead( s );
+                }
                 // Remove and return the tail element in the sequence.
                 T & dropTail( Sequence(T) & s ) {
 …
                                 T * toEnd = Back( &head( s ) );
                                 T * fromEnd = Back( &head( from ) );
                                 Back( (T *)root ) = fromEnd;
+                                Back( root ) = fromEnd;
                                 Next( fromEnd ) = &head( s );
                                 Back( (T *)from.root ) = toEnd;
+                                Back( from.root ) = toEnd;
                                 Next( toEnd ) = &head( from );
                         } // if
 …
 } // distribution
 forall( dtype T | { T *& Back ( T * ); T *& Next ( T * ); } ) {
+forall( dtype T ) {
         // SeqIter(T) is used to iterate over a Sequence(T) in head-to-tail order.
         struct SeqIter {
 …
         };
         static inline {
+        inline {
                 void ?{}( SeqIter(T) & si ) with( si ) {
                         ((ColIter &)si){};
                         seq = 0p;
+                } // post: elts = null
+                // Create a iterator active in sequence s.
+                } // post: elts = null.
                 void ?{}( SeqIter(T) & si, Sequence(T) & s ) with( si ) {
                         ((ColIter &)si){};
                         seq = &s;
                         curr = &head( s );
                 } // post: elts = null
+                } // post: elts = null.
                 void ?{}( SeqIter(T) & si, Sequence(T) & s, T & start ) with( si ) {
 …
                         seq = &s;
                         curr = &start;
+                } // post: elts = null
+                // Make the iterator active in sequence s.
+                } // post: elts = null.
                 void over( SeqIter(T) & si, Sequence(T) & s ) with( si ) {
                         seq = &s;
                         curr = &head( s );
                 } // post: elts = {e in s}
                 bool ?|?( SeqIter(T) & si, T && tp ) with( si ) {
+                } // post: elts = {e in s}.
+                bool ?>>?( SeqIter(T) & si, T && tp ) with( si ) {
                         if ( curr ) {
                                 &tp = Curr( si );
 …
         };
         static inline {
+        inline {
                 void ?{}( SeqIterRev(T) & si ) with( si ) {
                         ((ColIter &)si){};
                         seq = 0p;
+                } // post: elts = null
+                // Create a iterator active in sequence s.
+                } // post: elts = null.
                 void ?{}( SeqIterRev(T) & si, Sequence(T) & s ) with( si ) {
                         ((ColIter &)si){};
                         seq = &s;
                         curr = &tail( s );
                 } // post: elts = null
+                } // post: elts = null.
                 void ?{}( SeqIterRev(T) & si, Sequence(T) & s, T & start ) with( si ) {
 …
                         seq = &s;
                         curr = &start;
+                } // post: elts = null
+                // Make the iterator active in sequence s.
+                } // post: elts = null.
                 void over( SeqIterRev(T) & si, Sequence(T) & s ) with( si ) {
                         seq = &s;
                         curr = &tail( s );
                 } // post: elts = {e in s}
                 bool ?|?( SeqIterRev(T) & si, T && tp ) with( si ) {
+                } // post: elts = {e in s}.
+                bool ?>>?( SeqIterRev(T) & si, T && tp ) with( si ) {
                         if ( curr ) {
                                 &tp = Curr( si );
 …
         } // distribution
 } // distribution
-#endif

libcfa/src/bits/stack.hfa

-                      r2b4daf2
+                      r42f6e07
 #include "bits/collection.hfa"
+// A Stack(T) is a Collection(T) defining the ordering that nodes are returned by drop() in the reverse order from those
+// added by add(). T must be a public descendant of uColable.
+// The implementation is a typical singly-linked list, except the next field of the last element points to itself
+// instead of being null.
+forall( dtype T | { T *& Next ( T * ); } ) {
+forall( dtype T ) {
         struct Stack {
                 inline Collection;                                                              // Plan 9 inheritance
 …
+                }
                 T & addHead( Stack(T) & s, T & n ) with( s ) {
+                void addHead( Stack(T) & s, T & n ) with( s ) {
                         #ifdef __CFA_DEBUG__
                         if ( listed( (Colable &)(n) ) ) abort( "(Stack &)%p.addHead( %p ) : Node is already on another list.", &s, n );
 …
                         Next( &n ) = &head( s ) ? &head( s ) : &n;
                         root = &n;
-                        return n;
+                }
                 T & add( Stack(T) & s, T & n ) with( s ) {
                         return addHead( s, n );
+                void add( Stack(T) & s, T & n ) with( s ) {
+                        addHead( s, n );
+                }
                 T & push( Stack(T) & s, T & n ) with( s ) {
                         return addHead( s, n );
+                void push( Stack(T) & s, T & n ) with( s ) {
+                        addHead( s, n );
+                }
 …
                         T & t = head( s );
                         if ( root ) {
                                 root = ( T *)Next( (T *)root );
+                                root = ( T *)Next( root );
                                 if ( &head( s ) == &t ) root = 0p;              // only one element ?
                                 Next( &t ) = 0p;
 …
 } // distribution
-// A StackIter(T) is a subclass of ColIter(T) that generates the elements of a Stack(T).  It returns the elements in the
-// order returned by drop().
 forall( dtype T | { T *& Next ( T * ); } ) {
+forall( dtype T ) {
         struct StackIter {
                 inline ColIter;                                                                 // Plan 9 inheritance
 …
                 } // post: curr == 0p
                 // create an iterator active in stack s
+                // create an iterator active in Stack s
                 void ?{}( StackIter(T) & si, Stack(T) & s ) with( si ) {
                         curr = &head( s );
 …
                 } // post: curr = {e in s}
                 // make existing iterator active in stack s
+                // make existing iterator active in Stack q
                 void over( StackIter(T) & si, Stack(T) & s ) with( si ) {
                         curr = &head( s );
                 } // post: curr = {e in s}
                 bool ?|?( StackIter(T) & si, T && tp ) with( si ) {
+                bool ?>>?( StackIter(T) & si, T && tp ) with( si ) {
                         if ( curr ) {
                                 &tp = Curr( si );

libcfa/src/concurrency/invoke.h

-                      r2b4daf2
+                      r42f6e07
                 struct __monitor_group_t monitors;
-                // used to put threads on user data structures
-                struct {
-                        struct $thread * next;
-                        struct $thread * back;
-                } seqable;
                 struct {
                         struct $thread * next;
 …
+                }
-                static inline $thread *& Back( $thread * this ) __attribute__((const)) {
-                        return this->seqable.back;
+                }
-                static inline $thread *& Next( $thread * this ) __attribute__((const)) {
-                        return this->seqable.next;
+                }
-                static inline bool listed( $thread * this ) {
-                        return this->seqable.next != 0p;
+                }
                 static inline void ?{}(__monitor_group_t & this) {
                         (this.data){0p};

libcfa/src/concurrency/kernel/startup.cfa

-                      r2b4daf2
+                      r42f6e07
 extern size_t __page_size;
-extern int __map_prot;
 //-----------------------------------------------------------------------------
 …
+                }
         #else
-                __cfaabi_dbg_debug_do(
-                        // pthread has no mechanism to create the guard page in user supplied stack.
-                        if ( mprotect( stack, __page_size, __map_prot ) == -1 ) {
-                                abort( "mprotect : internal error, mprotect failure, error(%d) %s.", errno, strerror( errno ) );
-                        } // if
-                );
                 free( stack );
         #endif

libcfa/src/concurrency/locks.cfa

-                      r2b4daf2
+                      r42f6e07
 #include "locks.hfa"
 #include "kernel_private.hfa"
+#include <stdlib.h>
+#include <stdio.h>
 #include <kernel.hfa>
 #include <stdlib.hfa>
+//-----------------------------------------------------------------------------
+// info_thread
+#include <thread.hfa>
+///////////////////////////////////////////////////////////////////
+//// info_thread
+///////////////////////////////////////////////////////////////////
 forall(dtype L | is_blocking_lock(L)) {
+        struct info_thread {
+                // used to put info_thread on a dl queue (aka sequence)
+                inline Seqable;
+                // waiting thread
+                struct $thread * t;
+                // shadow field
+                uintptr_t info;
+                // lock that is passed to wait() (if one is passed)
+                L * lock;
+                // true when signalled and false when timeout wakes thread
+                bool signalled;
+        };
+        void ?{}( info_thread(L) & this, $thread * t, uintptr_t info, L * l ) {
+        void ?{}( info_thread(L) & this, $thread * t ) {
+                ((Seqable &) this){};
+                this.t = t;
+                this.lock = 0p;
+                this.listed = false;
+        }
+        void ?{}( info_thread(L) & this, $thread * t, uintptr_t info ) {
                 ((Seqable &) this){};
                 this.t = t;
                 this.info = info;
+                this.lock = l;
+        }
+        void ^?{}( info_thread(L) & this ) {}
+        info_thread(L) *& Back( info_thread(L) * this ) {
+                return (info_thread(L) *)Back( (Seqable *)this );
+        }
+        info_thread(L) *& Next( info_thread(L) * this ) {
+                return (info_thread(L) *)Next( (Colable *)this );
+        }
+}
+//-----------------------------------------------------------------------------
+// Blocking Locks
+                this.lock = 0p;
+                this.listed = false;
+        }
+        void ^?{}( info_thread(L) & this ){ }
+}
+///////////////////////////////////////////////////////////////////
+//// Blocking Locks
+///////////////////////////////////////////////////////////////////
 void ?{}( blocking_lock & this, bool multi_acquisition, bool strict_owner ) {
         this.lock{};
 …
 void ^?{}( blocking_lock & this ) {}
 void  ?{}( single_acquisition_lock & this ) {((blocking_lock &)this){ false, false };}
+void ?{}( single_acquisition_lock & this ) {((blocking_lock &)this){ false, false };}
 void ^?{}( single_acquisition_lock & this ) {}
 void  ?{}( owner_lock & this ) {((blocking_lock &)this){ true, true };}
+void ?{}( owner_lock & this ) {((blocking_lock &)this){ true, true };}
 void ^?{}( owner_lock & this ) {}
 void  ?{}( multiple_acquisition_lock & this ) {((blocking_lock &)this){ true, false };}
+void ?{}( multiple_acquisition_lock & this ) {((blocking_lock &)this){ true, false };}
 void ^?{}( multiple_acquisition_lock & this ) {}
 void lock( blocking_lock & this ) with( this ) {
         lock( lock __cfaabi_dbg_ctx2 );
+        $thread * thrd = active_thread();
+        // single acquisition lock is held by current thread
+        /* paranoid */ verifyf( owner != thrd || multi_acquisition, "Single acquisition lock holder (%p) attempted to reacquire the lock %p resulting in a deadlock.", owner, &this );
+        // lock is held by some other thread
+        if ( owner != 0p && owner != thrd ) {
+                addTail( blocked_threads, *thrd );
+        if ( owner == active_thread() && !multi_acquisition) {
+                abort("A single acquisition lock holder attempted to reacquire the lock resulting in a deadlock.");
+        } else if ( owner != 0p && owner != active_thread() ) {
+                append( blocked_threads, active_thread() );
                 wait_count++;
                 unlock( lock );
                 park( );
+        }
+        // multi acquisition lock is held by current thread
+        else if ( owner == thrd && multi_acquisition ) {
+        } else if ( owner == active_thread() && multi_acquisition ) {
                 recursion_count++;
                 unlock( lock );
+        }
+        // lock isn't held
+        else {
+                owner = thrd;
+        } else {
+                owner = active_thread();
                 recursion_count = 1;
                 unlock( lock );
 …
         bool ret = false;
         lock( lock __cfaabi_dbg_ctx2 );
-        // lock isn't held
         if ( owner == 0p ) {
                 owner = active_thread();
                 recursion_count = 1;
                 ret = true;
+        }
+        // multi acquisition lock is held by current thread
+        else if ( owner == active_thread() && multi_acquisition ) {
+        } else if ( owner == active_thread() && multi_acquisition ) {
                 recursion_count++;
                 ret = true;
+        }
         unlock( lock );
         return ret;
+}
+void unlock_error_check( blocking_lock & this ) with( this ) {
+        if ( owner == 0p ){ // no owner implies lock isn't held
+                abort( "There was an attempt to release a lock that isn't held" );
+        } else if ( strict_owner && owner != active_thread() ) {
+                abort( "A thread other than the owner attempted to release an owner lock" );
+        }
+}
 void pop_and_set_new_owner( blocking_lock & this ) with( this ) {
         $thread * t = &dropHead( blocked_threads );
+        $thread * t = pop_head( blocked_threads );
         owner = t;
         recursion_count = ( t ? 1 : 0 );
 …
 void unlock( blocking_lock & this ) with( this ) {
         lock( lock __cfaabi_dbg_ctx2 );
+        /* paranoid */ verifyf( owner != 0p, "Attempt to release lock %p that isn't held", &this );
+        /* paranoid */ verifyf( owner == active_thread() || !strict_owner, "Thread %p other than the owner %p attempted to release owner lock %p", owner, active_thread(), &this );
+        // if recursion count is zero release lock and set new owner if one is waiting
+        unlock_error_check( this );
         recursion_count--;
         if ( recursion_count == 0 ) {
 …
+}
+void on_notify( blocking_lock & this, $thread * t ) with( this ) {
+        lock( lock __cfaabi_dbg_ctx2 );
+        // lock held
+void add_( blocking_lock & this, $thread * t ) with( this ) {
+    lock( lock __cfaabi_dbg_ctx2 );
         if ( owner != 0p ) {
                 addTail( blocked_threads, *t );
+                append( blocked_threads, t );
                 wait_count++;
                 unlock( lock );
+        }
+        // lock not held
+        else {
+        } else {
                 owner = t;
                 recursion_count = 1;
 …
+}
+void on_wait( blocking_lock & this ) with( this ) {
+        lock( lock __cfaabi_dbg_ctx2 );
+        /* paranoid */ verifyf( owner != 0p, "Attempt to release lock %p that isn't held", &this );
+        /* paranoid */ verifyf( owner == active_thread() || !strict_owner, "Thread %p other than the owner %p attempted to release owner lock %p", owner, active_thread(), &this );
+void remove_( blocking_lock & this ) with( this ) {
+    lock( lock __cfaabi_dbg_ctx2 );
+        unlock_error_check( this );
         pop_and_set_new_owner( this );
         unlock( lock );
+}
+//-----------------------------------------------------------------------------
+// Overloaded routines for traits
+// These routines are temporary until an inheritance bug is fixed
+void   lock      ( single_acquisition_lock & this ) { lock   ( (blocking_lock &)this ); }
+void   unlock    ( single_acquisition_lock & this ) { unlock ( (blocking_lock &)this ); }
+void   on_wait   ( single_acquisition_lock & this ) { on_wait( (blocking_lock &)this ); }
+void   on_notify ( single_acquisition_lock & this, struct $thread * t ) { on_notify( (blocking_lock &)this, t ); }
+void   set_recursion_count( single_acquisition_lock & this, size_t recursion ) { set_recursion_count( (blocking_lock &)this, recursion ); }
+size_t get_recursion_count( single_acquisition_lock & this ) { return get_recursion_count( (blocking_lock &)this ); }
+void   lock     ( owner_lock & this ) { lock   ( (blocking_lock &)this ); }
+void   unlock   ( owner_lock & this ) { unlock ( (blocking_lock &)this ); }
+void   on_wait  ( owner_lock & this ) { on_wait( (blocking_lock &)this ); }
+void   on_notify( owner_lock & this, struct $thread * t ) { on_notify( (blocking_lock &)this, t ); }
+void   set_recursion_count( owner_lock & this, size_t recursion ) { set_recursion_count( (blocking_lock &)this, recursion ); }
+size_t get_recursion_count( owner_lock & this ) { return get_recursion_count( (blocking_lock &)this ); }
+void   lock     ( multiple_acquisition_lock & this ) { lock   ( (blocking_lock &)this ); }
+void   unlock   ( multiple_acquisition_lock & this ) { unlock ( (blocking_lock &)this ); }
+void   on_wait  ( multiple_acquisition_lock & this ) { on_wait( (blocking_lock &)this ); }
+void   on_notify( multiple_acquisition_lock & this, struct $thread * t ){ on_notify( (blocking_lock &)this, t ); }
+void   set_recursion_count( multiple_acquisition_lock & this, size_t recursion ){ set_recursion_count( (blocking_lock &)this, recursion ); }
+///////////////////////////////////////////////////////////////////
+//// Overloaded routines for traits
+///////////////////////////////////////////////////////////////////
+// This is temporary until an inheritance bug is fixed
+void lock( single_acquisition_lock & this ){ lock( (blocking_lock &)this ); }
+void unlock( single_acquisition_lock & this ){ unlock( (blocking_lock &)this ); }
+void add_( single_acquisition_lock & this, struct $thread * t ){ add_( (blocking_lock &)this, t ); }
+void remove_( single_acquisition_lock & this ){ remove_( (blocking_lock &)this ); }
+void set_recursion_count( single_acquisition_lock & this, size_t recursion ){ set_recursion_count( (blocking_lock &)this, recursion ); }
+size_t get_recursion_count( single_acquisition_lock & this ){ return get_recursion_count( (blocking_lock &)this ); }
+void lock( owner_lock & this ){ lock( (blocking_lock &)this ); }
+void unlock( owner_lock & this ){ unlock( (blocking_lock &)this ); }
+void add_( owner_lock & this, struct $thread * t ){ add_( (blocking_lock &)this, t ); }
+void remove_( owner_lock & this ){ remove_( (blocking_lock &)this ); }
+void set_recursion_count( owner_lock & this, size_t recursion ){ set_recursion_count( (blocking_lock &)this, recursion ); }
+size_t get_recursion_count( owner_lock & this ){ return get_recursion_count( (blocking_lock &)this ); }
+void lock( multiple_acquisition_lock & this ){ lock( (blocking_lock &)this ); }
+void unlock( multiple_acquisition_lock & this ){ unlock( (blocking_lock &)this ); }
+void add_( multiple_acquisition_lock & this, struct $thread * t ){ add_( (blocking_lock &)this, t ); }
+void remove_( multiple_acquisition_lock & this ){ remove_( (blocking_lock &)this ); }
+void set_recursion_count( multiple_acquisition_lock & this, size_t recursion ){ set_recursion_count( (blocking_lock &)this, recursion ); }
 size_t get_recursion_count( multiple_acquisition_lock & this ){ return get_recursion_count( (blocking_lock &)this ); }
+//-----------------------------------------------------------------------------
+// alarm node wrapper
+///////////////////////////////////////////////////////////////////
+//// condition variable
+///////////////////////////////////////////////////////////////////
 forall(dtype L | is_blocking_lock(L)) {
-        struct alarm_node_wrap {
-                alarm_node_t alarm_node;
-                condition_variable(L) * cond;
-                info_thread(L) * i;
-        };
-        void ?{}( alarm_node_wrap(L) & this, Time alarm, Duration period, Alarm_Callback callback, condition_variable(L) * c, info_thread(L) * i ) {
-                this.alarm_node{ callback, alarm, period };
-                this.cond = c;
-                this.i = i;
+        }
-        void ^?{}( alarm_node_wrap(L) & this ) { }
         void timeout_handler ( alarm_node_wrap(L) & this ) with( this ) {
+                // This condition_variable member is called from the kernel, and therefore, cannot block, but it can spin.
+                lock( cond->lock __cfaabi_dbg_ctx2 );
+                // this check is necessary to avoid a race condition since this timeout handler
+                //      may still be called after a thread has been removed from the queue but
+                //      before the alarm is unregistered
+                if ( listed(i) ) {      // is thread on queue
+                        i->signalled = false;
+                        // remove this thread O(1)
+                        remove( cond->blocked_threads, *i );
+        // This condition_variable member is called from the kernel, and therefore, cannot block, but it can spin.
+            lock( cond->lock __cfaabi_dbg_ctx2 );
+            if ( i->listed ) {                  // is thread on queue
+                cond->last_thread = i;          // REMOVE THIS AFTER DEBUG
+                        remove( cond->blocked_threads, *i );             //remove this thread O(1)
                         cond->count--;
+                        if( i->lock ) {
+                                // call lock's on_notify if a lock was passed
+                                on_notify(*i->lock, i->t);
+                        } else {
+                                // otherwise wake thread
+                        if( !i->lock ) {
                                 unpark( i->t );
+                        }
+                }
+                unlock( cond->lock );
+        }
+        // this casts the alarm node to our wrapped type since we used type erasure
+                } else {
+                        add_(*i->lock, i->t);                   // call lock's add_
+                }
+            }
+            unlock( cond->lock );
+        }
         void alarm_node_wrap_cast( alarm_node_t & a ) { timeout_handler( (alarm_node_wrap(L) &)a ); }
+}
-//-----------------------------------------------------------------------------
-// condition variable
-forall(dtype L | is_blocking_lock(L)) {
         void ?{}( condition_variable(L) & this ){
 …
                 this.blocked_threads{};
                 this.count = 0;
+                this.last_thread = 0p; // REMOVE AFTER DEBUG
+        }
         void ^?{}( condition_variable(L) & this ){ }
+        void ?{}( alarm_node_wrap(L) & this, Time alarm, Duration period, Alarm_Callback callback ) {
+                this.alarm_node{ callback, alarm, period };
+        }
+        void ^?{}( alarm_node_wrap(L) & this ) { }
         void process_popped( condition_variable(L) & this, info_thread(L) & popped ) with( this ) {
                 if(&popped != 0p) {
                         popped.signalled = true;
+                        popped.listed = false;
                         count--;
                         if (popped.lock) {
+                                // if lock passed call on_notify
+                                on_notify(*popped.lock, popped.t);
+                                add_(*popped.lock, popped.t);
                         } else {
-                                // otherwise wake thread
                                 unpark(popped.t);
+                        }
 …
         size_t queue_and_get_recursion( condition_variable(L) & this, info_thread(L) * i ) with(this) {
-                // add info_thread to waiting queue
                 addTail( blocked_threads, *i );
                 count++;
+                i->listed = true;
                 size_t recursion_count = 0;
                 if (i->lock) {
                         // if lock was passed get recursion count to reset to after waking thread
+                        i->t->link.next = 1p;
                         recursion_count = get_recursion_count(*i->lock);
                         on_wait( *i->lock );
+                        remove_( *i->lock );
+                }
                 return recursion_count;
 …
                 size_t recursion_count = queue_and_get_recursion(this, &i);
                 unlock( lock );
+                // blocks here
+                park( );
+                // resets recursion count here after waking
+                if (i.lock) set_recursion_count(*i.lock, recursion_count);
+        }
+        #define WAIT( u, l ) \
+                info_thread( L ) i = { active_thread(), u, l }; \
+                queue_info_thread( this, i );
+                park( ); // blocks here
+                if (i.lock) set_recursion_count(*i.lock, recursion_count); // resets recursion count here after waking
+        }
         // helper for wait()'s' with a timeout
 …
                 lock( lock __cfaabi_dbg_ctx2 );
                 size_t recursion_count = queue_and_get_recursion(this, &info);
+                alarm_node_wrap(L) node_wrap = { t, 0`s, alarm_node_wrap_cast, &this, &info };
+                alarm_node_wrap(L) node_wrap = { t, 0`s, alarm_node_wrap_cast };
+                node_wrap.cond = &this;
+                node_wrap.i = &info;
                 register_self( &node_wrap.alarm_node );
                 unlock( lock );
-                // blocks here
                 park();
-                // unregisters alarm so it doesn't go off if this happens first
                 unregister_self( &node_wrap.alarm_node );
-                // resets recursion count here after waking
                 if (info.lock) set_recursion_count(*info.lock, recursion_count);
+        }
+        #define WAIT_TIME( u, l, t ) \
+                info_thread( L ) i = { active_thread(), u, l }; \
+                queue_info_thread_timeout(this, i, t ); \
+                return i.signalled;
+        void wait( condition_variable(L) & this                        ) with(this) { WAIT( 0, 0p    ) }
+        void wait( condition_variable(L) & this, uintptr_t info        ) with(this) { WAIT( info, 0p ) }
+        void wait( condition_variable(L) & this, L & l                 ) with(this) { WAIT( 0, &l    ) }
+        void wait( condition_variable(L) & this, L & l, uintptr_t info ) with(this) { WAIT( info, &l ) }
+        bool wait( condition_variable(L) & this, Duration duration                        ) with(this) { WAIT_TIME( 0   , 0p , __kernel_get_time() + duration ) }
+        bool wait( condition_variable(L) & this, uintptr_t info, Duration duration        ) with(this) { WAIT_TIME( info, 0p , __kernel_get_time() + duration ) }
+        bool wait( condition_variable(L) & this, Time time                                ) with(this) { WAIT_TIME( 0   , 0p , time ) }
+        bool wait( condition_variable(L) & this, uintptr_t info, Time time                ) with(this) { WAIT_TIME( info, 0p , time ) }
+        bool wait( condition_variable(L) & this, L & l, Duration duration                 ) with(this) { WAIT_TIME( 0   , &l , __kernel_get_time() + duration ) }
+        bool wait( condition_variable(L) & this, L & l, uintptr_t info, Duration duration ) with(this) { WAIT_TIME( info, &l , __kernel_get_time() + duration ) }
+        bool wait( condition_variable(L) & this, L & l, Time time                         ) with(this) { WAIT_TIME( 0   , &l , time ) }
+        bool wait( condition_variable(L) & this, L & l, uintptr_t info, Time time         ) with(this) { WAIT_TIME( info, &l , time ) }
+}
+        void wait( condition_variable(L) & this ) with(this) {
+                info_thread( L ) i = { active_thread() };
+                queue_info_thread( this, i );
+        }
+        void wait( condition_variable(L) & this, uintptr_t info ) with(this) {
+                info_thread( L ) i = { active_thread(), info };
+                queue_info_thread( this, i );
+        }
+        void wait( condition_variable(L) & this, Duration duration ) with(this) {
+                info_thread( L ) i = { active_thread() };
+                queue_info_thread_timeout(this, i, __kernel_get_time() + duration );
+        }
+        void wait( condition_variable(L) & this, uintptr_t info, Duration duration ) with(this) {
+                info_thread( L ) i = { active_thread(), info };
+                queue_info_thread_timeout(this, i, __kernel_get_time() + duration );
+        }
+        void wait( condition_variable(L) & this, Time time ) with(this) {
+                info_thread( L ) i = { active_thread() };
+                queue_info_thread_timeout(this, i, time);
+        }
+        void wait( condition_variable(L) & this, uintptr_t info, Time time ) with(this) {
+                info_thread( L ) i = { active_thread(), info };
+                queue_info_thread_timeout(this, i, time);
+        }
+        void wait( condition_variable(L) & this, L & l ) with(this) {
+                info_thread(L) i = { active_thread() };
+                i.lock = &l;
+                queue_info_thread( this, i );
+        }
+        void wait( condition_variable(L) & this, L & l, uintptr_t info ) with(this) {
+                info_thread(L) i = { active_thread(), info };
+                i.lock = &l;
+                queue_info_thread( this, i );
+        }
+        void wait( condition_variable(L) & this, L & l, Duration duration ) with(this) {
+                info_thread(L) i = { active_thread() };
+                i.lock = &l;
+                queue_info_thread_timeout(this, i, __kernel_get_time() + duration );
+        }
+        void wait( condition_variable(L) & this, L & l, uintptr_t info, Duration duration ) with(this) {
+                info_thread(L) i = { active_thread(), info };
+                i.lock = &l;
+                queue_info_thread_timeout(this, i, __kernel_get_time() + duration );
+        }
+        void wait( condition_variable(L) & this, L & l, Time time ) with(this) {
+                info_thread(L) i = { active_thread() };
+                i.lock = &l;
+                queue_info_thread_timeout(this, i, time );
+        }
+        void wait( condition_variable(L) & this, L & l, uintptr_t info, Time time ) with(this) {
+                info_thread(L) i = { active_thread(), info };
+                i.lock = &l;
+                queue_info_thread_timeout(this, i, time );
+        }
+}

libcfa/src/concurrency/locks.hfa

-                      r2b4daf2
+                      r42f6e07
 #include <stdbool.h>
+#include "bits/algorithm.hfa"
 #include "bits/locks.hfa"
 #include "bits/sequence.hfa"
+#include "bits/containers.hfa"
 #include "invoke.h"
 …
 #include "time_t.hfa"
 #include "time.hfa"
+#include <sys/time.h>
+#include "alarm.hfa"
+//-----------------------------------------------------------------------------
+// is_blocking_lock
+///////////////////////////////////////////////////////////////////
+//// is_blocking_lock
+///////////////////////////////////////////////////////////////////
 trait is_blocking_lock(dtype L | sized(L)) {
+        // For synchronization locks to use when acquiring
+        void on_notify( L &, struct $thread * );
+        // For synchronization locks to use when releasing
+        void on_wait( L & );
+        // to get recursion count for cond lock to reset after waking
+        size_t get_recursion_count( L & );
+        // to set recursion count after getting signalled;
+        void set_recursion_count( L &, size_t recursion );
+        void add_( L &, struct $thread * );             // For synchronization locks to use when acquiring
+        void remove_( L & );    // For synchronization locks to use when releasing
+        size_t get_recursion_count( L & ); // to get recursion count for cond lock to reset after waking
+        void set_recursion_count( L &, size_t recursion ); // to set recursion count after getting signalled;
 };
 //-----------------------------------------------------------------------------
 // info_thread
 // the info thread is a wrapper around a thread used
+// to store extra data for use in the condition variable
+///////////////////////////////////////////////////////////////////
+//// info_thread
+///////////////////////////////////////////////////////////////////
 forall(dtype L | is_blocking_lock(L)) {
+        struct info_thread;
+        struct info_thread {
+                inline Seqable;
+                struct $thread * t;
+                uintptr_t info;
+                L * lock;
+                bool listed;                                    // true if info_thread is on queue, false otherwise;
+        };
+        // for use by sequence
+        info_thread(L) *& Back( info_thread(L) * this );
+        info_thread(L) *& Next( info_thread(L) * this );
+        void ?{}( info_thread(L) & this, $thread * t );
+        void ?{}( info_thread(L) & this, $thread * t, uintptr_t info );
+        void ^?{}( info_thread(L) & this );
+}
+//-----------------------------------------------------------------------------
+// Blocking Locks
+///////////////////////////////////////////////////////////////////
+//// Blocking Locks
+///////////////////////////////////////////////////////////////////
+// struct lock_thread {
+//      struct $thread * t;
+//      lock_thread * next;
+// };
+// void ?{}( lock_thread & this, struct $thread * thd );
+// void ^?{}( lock_thread & this );
+// lock_thread *& get_next( lock_thread & );
 struct blocking_lock {
         // Spin lock used for mutual exclusion
 …
         // List of blocked threads
         Sequence( $thread ) blocked_threads;
+        __queue_t( $thread ) blocked_threads;
         // Count of current blocked threads
 …
 };
 void  ?{}( blocking_lock & this, bool multi_acquisition, bool strict_owner );
+void ?{}( blocking_lock & this, bool multi_acquisition, bool strict_owner );
 void ^?{}( blocking_lock & this );
 void  ?{}( single_acquisition_lock & this );
+void ?{}( single_acquisition_lock & this );
 void ^?{}( single_acquisition_lock & this );
 void  ?{}( owner_lock & this );
+void ?{}( owner_lock & this );
 void ^?{}( owner_lock & this );
 void  ?{}( multiple_acquisition_lock & this );
+void ?{}( multiple_acquisition_lock & this );
 void ^?{}( multiple_acquisition_lock & this );
 …
 bool try_lock( blocking_lock & this );
 void unlock( blocking_lock & this );
 void on_notify( blocking_lock & this, struct $thread * t );
 void on_wait( blocking_lock & this );
+void add_( blocking_lock & this, struct $thread * t );
+void remove_( blocking_lock & this );
 size_t wait_count( blocking_lock & this );
 void set_recursion_count( blocking_lock & this, size_t recursion );
 …
 void lock( single_acquisition_lock & this );
 void unlock( single_acquisition_lock & this );
 void on_notify( single_acquisition_lock & this, struct $thread * t );
 void on_wait( single_acquisition_lock & this );
+void add_( single_acquisition_lock & this, struct $thread * t );
+void remove_( single_acquisition_lock & this );
 void set_recursion_count( single_acquisition_lock & this, size_t recursion );
 size_t get_recursion_count( single_acquisition_lock & this );
 …
 void lock( owner_lock & this );
 void unlock( owner_lock & this );
 void on_notify( owner_lock & this, struct $thread * t );
 void on_wait( owner_lock & this );
+void add_( owner_lock & this, struct $thread * t );
+void remove_( owner_lock & this );
 void set_recursion_count( owner_lock & this, size_t recursion );
 size_t get_recursion_count( owner_lock & this );
 …
 void lock( multiple_acquisition_lock & this );
 void unlock( multiple_acquisition_lock & this );
 void on_notify( multiple_acquisition_lock & this, struct $thread * t );
 void on_wait( multiple_acquisition_lock & this );
+void add_( multiple_acquisition_lock & this, struct $thread * t );
+void remove_( multiple_acquisition_lock & this );
 void set_recursion_count( multiple_acquisition_lock & this, size_t recursion );
 size_t get_recursion_count( multiple_acquisition_lock & this );
+//-----------------------------------------------------------------------------
+// Synchronization Locks
+///////////////////////////////////////////////////////////////////
+//// Synchronization Locks
+///////////////////////////////////////////////////////////////////
 forall(dtype L | is_blocking_lock(L)) {
         struct condition_variable {
                 // Spin lock used for mutual exclusion
                 __spinlock_t lock;
+                info_thread(L) * last_thread;
                 // List of blocked threads
 …
         };
         void  ?{}( condition_variable(L) & this );
+        void ?{}( condition_variable(L) & this );
         void ^?{}( condition_variable(L) & this );
+        struct alarm_node_wrap {
+                alarm_node_t alarm_node;
+                condition_variable(L) * cond;
+                info_thread(L) * i;
+        };
+        void ?{}( alarm_node_wrap(L) & this, Time alarm, Duration period, Alarm_Callback callback );
+        void ^?{}( alarm_node_wrap(L) & this );
+        void alarm_node_callback( alarm_node_wrap(L) & this );
+        void alarm_node_wrap_cast( alarm_node_t & a );
         bool notify_one( condition_variable(L) & this );
 …
         uintptr_t front( condition_variable(L) & this );
         bool empty  ( condition_variable(L) & this );
         int  counter( condition_variable(L) & this );
+        bool empty( condition_variable(L) & this );
+        int counter( condition_variable(L) & this );
+        // TODO: look into changing timout routines to return bool showing if signalled or woken by kernel
         void wait( condition_variable(L) & this );
         void wait( condition_variable(L) & this, uintptr_t info );
         bool wait( condition_variable(L) & this, Duration duration );
         bool wait( condition_variable(L) & this, uintptr_t info, Duration duration );
         bool wait( condition_variable(L) & this, Time time );
         bool wait( condition_variable(L) & this, uintptr_t info, Time time );
+        void wait( condition_variable(L) & this, Duration duration );
+        void wait( condition_variable(L) & this, uintptr_t info, Duration duration );
+        void wait( condition_variable(L) & this, Time time );
+        void wait( condition_variable(L) & this, uintptr_t info, Time time );
         void wait( condition_variable(L) & this, L & l );
         void wait( condition_variable(L) & this, L & l, uintptr_t info );
         bool wait( condition_variable(L) & this, L & l, Duration duration );
         bool wait( condition_variable(L) & this, L & l, uintptr_t info, Duration duration );
         bool wait( condition_variable(L) & this, L & l, Time time );
         bool wait( condition_variable(L) & this, L & l, uintptr_t info, Time time );
+        void wait( condition_variable(L) & this, L & l, Duration duration );
+        void wait( condition_variable(L) & this, L & l, uintptr_t info, Duration duration );
+        void wait( condition_variable(L) & this, L & l, Time time );
+        void wait( condition_variable(L) & this, L & l, uintptr_t info, Time time );
+}

libcfa/src/concurrency/monitor.hfa

-                      r2b4daf2
+                      r42f6e07
               void wait        ( condition & this, uintptr_t user_info = 0 );
-static inline bool is_empty    ( condition & this ) { return this.blocked.head == 1p; }
               bool signal      ( condition & this );
               bool signal_block( condition & this );
 static inline bool signal_all  ( condition & this ) { bool ret = false; while(!is_empty(this)) { ret = signal(this) || ret; } return ret; }
+static inline bool is_empty    ( condition & this ) { return this.blocked.head == 1p; }
          uintptr_t front       ( condition & this );

libcfa/src/concurrency/thread.cfa

-                      r2b4daf2
+                      r42f6e07
                 canary = 0x0D15EA5E0D15EA5Ep;
         #endif
-        seqable.next = 0p;
-        seqable.back = 0p;
         node.next = 0p;
 …
         this_thrd->context.[SP, FP] = this_thrd->self_cor.context.[SP, FP];
         /* paranoid */ verify( this_thrd->context.SP );
+        verify( this_thrd->context.SP );
         __schedule_thread( this_thrd );

libcfa/src/heap.cfa

-                      r2b4daf2
+                      r42f6e07
 // Created On       : Tue Dec 19 21:58:35 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Dec 16 12:28:25 2020
 // Update Count     : 1023
+// Last Modified On : Tue Dec 15 21:37:54 2020
+// Update Count     : 1013
 //
 …
         header = headerAddr( addr );
   if ( unlikely( addr < heapBegin || heapEnd < addr ) ) { // mmapped ?
+  if ( unlikely( heapEnd < addr ) ) {                                   // mmapped ?
                 fakeHeader( header, alignment );
                 size = header->kind.real.blockSize & -3;                // mmap size
 …
         #ifdef __CFA_DEBUG__
         checkHeader( header < (HeapManager.Storage.Header *)heapBegin, name, addr ); // bad low address ?
+        checkHeader( addr < heapBegin, name, addr );            // bad low address ?
         #endif // __CFA_DEBUG__
 …
 #endif // __CFA_DEBUG__
 #define NO_MEMORY_MSG "insufficient heap memory available for allocating %zd new bytes."
+#include <unistd.h>
 static inline void * extend( size_t size ) with( heapManager ) {
         lock( extlock __cfaabi_dbg_ctx2 );
 …
                 #ifdef __CFA_DEBUG__
                 // Set new memory to garbage so subsequent uninitialized usages might fail.
                 memset( (char *)heapEnd + heapRemaining, '\xde', increase );
+                memset( (char *)heapEnd + heapRemaining, '\hde', increase );
                 //Memset( (char *)heapEnd + heapRemaining, increase );
                 #endif // __CFA_DEBUG__
 …
                 #ifdef __CFA_DEBUG__
                 // Set new memory to garbage so subsequent uninitialized usages might fail.
                 memset( block, '\xde', tsize );
+                memset( block, '\hde', tsize );
                 //Memset( block, tsize );
                 #endif // __CFA_DEBUG__
 …
                 #ifdef __CFA_DEBUG__
                 // Set free memory to garbage so subsequent usages might fail.
                 memset( ((HeapManager.Storage *)header)->data, '\xde', freeElem->blockSize - sizeof( HeapManager.Storage ) );
+                memset( ((HeapManager.Storage *)header)->data, '\hde', freeElem->blockSize - sizeof( HeapManager.Storage ) );
                 //Memset( ((HeapManager.Storage *)header)->data, freeElem->blockSize - sizeof( HeapManager.Storage ) );
                 #endif // __CFA_DEBUG__
 …
         } // cmemalign
         // Same as memalign(), but ISO/IEC 2011 C11 Section 7.22.2 states: the value of size shall be an integral multiple
     // of alignment. This requirement is universally ignored.
 …
                 return 0;
         } // posix_memalign
         // Allocates size bytes and returns a pointer to the allocated memory. The memory address shall be a multiple of the

libcfa/src/memory.cfa

-                      r2b4daf2
+                      r42f6e07
 forall(dtype T | sized(T), ttype Args | { void ?{}(T&, Args); })
 void ?{}(counter_ptr(T) & this, Args args) {
         this.data = (counter_data(T)*)new(args);
+        this.data = new(args);
+}
 …
 forall(dtype T | sized(T), ttype Args | { void ?{}(T &, Args); })
 void ?{}(unique_ptr(T) & this, Args args) {
         this.data = (T *)new(args);
+        this.data = new(args);
+}

libcfa/src/parseargs.cfa

-                      r2b4daf2
+                      r42f6e07
                                         if(opt == options[i].short_name) {
                                                 const char * arg = optarg ? optarg : "";
-                                                if( arg[0] == '=' ) { arg++; }
                                                 bool success = options[i].parse( arg, options[i].variable );
                                                 if(success) continue NEXT_ARG;
 …
+}
-bool parse_truefalse(const char * arg, bool & value) {
-        if(strcmp(arg, "true") == 0) {
-                value = true;
-                return true;
+        }
-        if(strcmp(arg, "false") == 0) {
-                value = false;
-                return true;
+        }
-        return false;
+}
 bool parse_settrue (const char *, bool & value ) {
         value = true;

libcfa/src/parseargs.hfa

-                      r2b4daf2
+                      r42f6e07
 void print_args_usage(int argc, char * argv[], cfa_option options[], size_t opt_count, const char * usage, bool error)  __attribute__ ((noreturn));
+bool parse_yesno    (const char *, bool & );
+bool parse_truefalse(const char *, bool & );
+bool parse_settrue  (const char *, bool & );
+bool parse_setfalse (const char *, bool & );
+bool parse_yesno   (const char *, bool & );
+bool parse_settrue (const char *, bool & );
+bool parse_setfalse(const char *, bool & );
 bool parse(const char *, const char * & );

libcfa/src/stdlib.hfa

r2b4daf2	r42f6e07
267	267	static inline forall( dtype T \| sized(T), ttype TT \| { void ?{}( T &, TT ); } )
268	268	T * new( TT p ) {
269		return &(~~(T )~~malloc()){ p }; // run constructor
	269	return &(*malloc()){ p }; // run constructor
270	270	} // new
271	271

longrun_tests/Makefile.am

r2b4daf2	r42f6e07
44	44	-DTEST_$(shell cat .type \| tr a-z A-Z)
45	45
46		TESTS = block coroutine create disjoint enter enter3 ~~locks~~ processor stack wait yield
	46	TESTS = block coroutine create disjoint enter enter3 processor stack wait yield
47	47
48	48	# .INTERMEDIATE: $(TESTS)

src/AST/Convert.cpp

-                      r2b4daf2
+                      r42f6e07
                 ftype->parameters = get<DeclarationWithType>().acceptL(node->params);
+                ftype->forall = get<TypeDecl>().acceptL( node->type_params );
+                if (!node->assertions.empty()) {
+                        assert(!ftype->forall.empty());
+                        // find somewhere to place assertions back, for convenience it is the last slot
+                        ftype->forall.back()->assertions = get<DeclarationWithType>().acceptL(node->assertions);
+                }
+                ftype->forall = get<TypeDecl>().acceptL( node->type->forall );
                 visitType(node->type, ftype);
 …
                 for (decltype(src->begin()) src_i = src->begin(); src_i != src->end(); src_i++) {
                         rslt->add( src_i->first.typeString(),
+                        rslt->add( src_i->first,
                                    get<Type>().accept1(src_i->second) );
+                }
+                for (decltype(src->beginVar()) src_i = src->beginVar(); src_i != src->endVar(); src_i++) {
+                        rslt->addVar( src_i->first,
+                                      get<Expression>().accept1(src_i->second) );
+                }
 …
                 // ty->returnVals = get<DeclarationWithType>().acceptL( node->returns );
                 // ty->parameters = get<DeclarationWithType>().acceptL( node->params );
+                auto types = get<TypeInstType>().acceptL( node->forall );
+                for (auto t : types) {
+                        auto newT = new TypeDecl(*t->baseType);
+                        newT->name = t->name; // converted by typeString()
+                        for (auto asst : newT->assertions) delete asst;
+                        newT->assertions.clear();
+                        ty->forall.push_back(newT);
+                }
+                auto assts = get<VariableExpr>().acceptL( node->assertions );
+                if (!assts.empty()) {
+                        assert(!types.empty());
+                        for (auto asst : assts) {
+                                auto newDecl = new ObjectDecl(*strict_dynamic_cast<ObjectDecl*>(asst->var));
+                                delete newDecl->type;
+                                newDecl->type = asst->result->clone();
+                                newDecl->storageClasses.is_extern = true; // hack
+                                ty->forall.back()->assertions.push_back(newDecl);
+                        }
+                }
+                ty->forall = get<TypeDecl>().acceptL( node->forall );
                 return visitType( node, ty );
+        }
 …
                         ty = new TypeInstType{
                                 cv( node ),
                                 node->typeString(),
+                                node->name,
                                 get<TypeDecl>().accept1( node->base ),
                                 get<Attribute>().acceptL( node->attributes )
 …
                         ty = new TypeInstType{
                                 cv( node ),
                                 node->typeString(),
+                                node->name,
                                 node->kind == ast::TypeDecl::Ftype,
                                 get<Attribute>().acceptL( node->attributes )
 …
         /// at conversion stage, all created nodes are guaranteed to be unique, therefore
         /// const_casting out of smart pointers is permitted.
         std::unordered_map< const BaseSyntaxNode *, ast::readonly<ast::Node> > cache = {};
+        std::unordered_map< const BaseSyntaxNode *, ast::ptr<ast::Node> > cache = {};
         // Local Utilities:
 …
                 // can function type have attributes? seems not to be the case.
                 // visitType(old->type, ftype);
-                // collect assertions and put directly in FunctionDecl
-                std::vector<ast::ptr<ast::DeclWithType>> assertions;
-                for (auto & param: forall) {
-                        for (auto & asst: param->assertions) {
-                                assertf(asst->unique(), "newly converted decl must be unique");
-                                assertions.emplace_back(asst);
+                        }
-                        auto mut = param.get_and_mutate();
-                        assertf(mut == param, "newly converted decl must be unique");
-                        mut->assertions.clear();
+                }
                 auto decl = new ast::FunctionDecl{
 …
                 cache.emplace( old, decl );
-                decl->assertions = std::move(assertions);
                 decl->withExprs = GET_ACCEPT_V(withExprs, Expr);
                 decl->stmts = GET_ACCEPT_1(statements, CompoundStmt);
 …
+        }
-        // TypeSubstitution shouldn't exist yet in old.
         ast::TypeSubstitution * convertTypeSubstitution(const TypeSubstitution * old) {
                 if (!old) return nullptr;
+                if (old->empty()) return nullptr;
+                assert(false);
+                /*
                 ast::TypeSubstitution *rslt = new ast::TypeSubstitution();
 …
+                }
+                for (decltype(old->beginVar()) old_i = old->beginVar(); old_i != old->endVar(); old_i++) {
+                        rslt->addVar( old_i->first,
+                                      getAccept1<ast::Expr>(old_i->second) );
+                }
                 return rslt;
-                */
+        }
 …
                         ty->params.emplace_back(v->get_type());
+                }
+                // xxx - when will this be non-null?
+                // will have to create dangling (no-owner) decls to be pointed to
+                auto foralls = GET_ACCEPT_V( forall, TypeDecl );
+                for (auto & param : foralls) {
+                        ty->forall.emplace_back(new ast::TypeInstType(param->name, param));
+                        for (auto asst : param->assertions) {
+                                ty->assertions.emplace_back(new ast::VariableExpr({}, asst));
+                        }
+                }
+                ty->forall = GET_ACCEPT_V( forall, TypeDecl );
                 visitType( old, ty );
+        }

src/AST/Decl.cpp

-                      r2b4daf2
+                      r42f6e07
 FunctionDecl::FunctionDecl( const CodeLocation & loc, const std::string & name,
+        std::vector<ptr<TypeDecl>>&& forall,
+        std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
+        CompoundStmt * stmts, Storage::Classes storage, Linkage::Spec linkage,
+        std::vector<ptr<Attribute>>&& attrs, Function::Specs fs, bool isVarArgs)
+: DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ), params(std::move(params)), returns(std::move(returns)),
+        type_params(std::move(forall)), stmts( stmts ) {
+        FunctionType * ftype = new FunctionType(static_cast<ArgumentFlag>(isVarArgs));
+        for (auto & param : this->params) {
+                ftype->params.emplace_back(param->get_type());
+        }
+        for (auto & ret : this->returns) {
+                ftype->returns.emplace_back(ret->get_type());
+        }
+        for (auto & tp : this->type_params) {
+                ftype->forall.emplace_back(new TypeInstType(tp->name, tp));
+        }
+        this->type = ftype;
+}
+                std::vector<ptr<TypeDecl>>&& forall,
+                std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
+                CompoundStmt * stmts, Storage::Classes storage, Linkage::Spec linkage,
+                std::vector<ptr<Attribute>>&& attrs, Function::Specs fs, bool isVarArgs)
+        : DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ), params(std::move(params)), returns(std::move(returns)),
+          stmts( stmts ) {
+                  FunctionType * ftype = new FunctionType(static_cast<ArgumentFlag>(isVarArgs));
+                  for (auto & param : this->params) {
+                          ftype->params.emplace_back(param->get_type());
+                  }
+                  for (auto & ret : this->returns) {
+                          ftype->returns.emplace_back(ret->get_type());
+                  }
+                  ftype->forall = std::move(forall);
+                  this->type = ftype;
+          }

src/AST/Decl.hpp

-                      r2b4daf2
+                      r42f6e07
         std::vector<ptr<DeclWithType>> params;
         std::vector<ptr<DeclWithType>> returns;
-        std::vector<ptr<TypeDecl>> type_params;
-        std::vector<ptr<DeclWithType>> assertions;
         // declared type, derived from parameter declarations
         ptr<FunctionType> type;
         ptr<CompoundStmt> stmts;
         std::vector< ptr<Expr> > withExprs;
         FunctionDecl( const CodeLocation & loc, const std::string & name, std::vector<ptr<TypeDecl>>&& forall,

src/AST/Expr.cpp

-                      r2b4daf2
+                      r42f6e07
         assert( aggregate->result );
+        result = mem->get_type();
+        // Deep copy on result type avoids mutation on transitively multiply referenced object.
+        //
+        // Example, adapted from parts of builtins and bootloader:
+        //
+        // forall(dtype T)
+        // struct __Destructor {
+        //   T * object;
+        //   void (*dtor)(T *);
+        // };
+        //
+        // forall(dtype S)
+        // void foo(__Destructor(S) &d) {
+        //   if (d.dtor) {  // here
+        //   }
+        // }
+        //
+        // Let e be the "d.dtor" guard espression, which is MemberExpr after resolve.  Let d be the
+        // declaration of member __Destructor.dtor (an ObjectDecl), as accessed via the top-level
+        // declaration of __Destructor.  Consider the types e.result and d.type.  In the old AST, one
+        // is a clone of the other.  Ordinary new-AST use would set them up as a multiply-referenced
+        // object.
+        //
+        // e.result: PointerType
+        // .base: FunctionType
+        // .params.front(): ObjectDecl, the anonymous parameter of type T*
+        // .type: PointerType
+        // .base: TypeInstType
+        // let x = that
+        // let y = similar, except start from d.type
+        //
+        // Consider two code lines down, genericSubstitution(...).apply(result).
+        //
+        // Applying this chosen-candidate's type substitution means modifying x, substituting
+        // S for T.  This mutation should affect x and not y.
+        result = deepCopy(mem->get_type());
         // substitute aggregate generic parameters into member type

src/AST/Node.hpp

-                      r2b4daf2
+                      r42f6e07
         const node_t & operator* () const { _check(); return *node; }
         explicit operator bool() const { _check(); return node; }
+        operator const node_t * () const & { _check(); return node; }
+        operator const node_t * () && = delete;
+        operator const node_t * () const { _check(); return node; }
         const node_t * release() {

src/AST/Pass.hpp

-                      r2b4daf2
+                      r42f6e07
 #include "AST/SymbolTable.hpp"
+#include "AST/ForallSubstitutionTable.hpp"
 // Private prelude header, needed for some of the magic tricks this class pulls off
 …
 // | WithVisitorRef        - provides an pointer to the templated visitor wrapper
 // | WithSymbolTable       - provides symbol table functionality
+// | WithForallSubstitutor - maintains links between TypeInstType and TypeDecl under mutation
 //
 // Other Special Members:
 …
         container_t< ptr<node_t> > call_accept( const container_t< ptr<node_t> > & container );
+        /// Mutate forall-list, accounting for presence of type substitution map
+        template<typename node_t>
+        void mutate_forall( const node_t *& );
 public:
         /// Logic to call the accept and mutate the parent if needed, delegates call to accept
 …
 };
+/// Use when the templated visitor needs to keep TypeInstType instances properly linked to TypeDecl
+struct WithForallSubstitutor {
+        ForallSubstitutionTable subs;
+};
+}

src/AST/Pass.impl.hpp

-                      r2b4daf2
+                      r42f6e07
+        }
+        template< typename core_t >
+        template< typename node_t >
+        void ast::Pass< core_t >::mutate_forall( const node_t *& node ) {
+                if ( auto subs = __pass::forall::subs( core, 0 ) ) {
+                        // tracking TypeDecl substitution, full clone
+                        if ( node->forall.empty() ) return;
+                        node_t * mut = __pass::mutate<core_t>( node );
+                        mut->forall = subs->clone( node->forall, *this );
+                        node = mut;
+                } else {
+                        // not tracking TypeDecl substitution, just mutate
+                        maybe_accept( node, &node_t::forall );
+                }
+        }
+}
 …
                         __pass::symtab::addId( core, 0, func );
                         VISIT(
                                 // parameter declarations
+                                // parameter declarations are now directly here
                                 maybe_accept( node, &FunctionDecl::params );
                                 maybe_accept( node, &FunctionDecl::returns );
+                                // type params and assertions
+                                maybe_accept( node, &FunctionDecl::type_params );
+                                maybe_accept( node, &FunctionDecl::assertions );
+                                // foralls are still in function type
+                                maybe_accept( node, &FunctionDecl::type );
                                 // First remember that we are now within a function.
                                 ValueGuard< bool > oldInFunction( inFunction );
 …
         VISIT({
+                // guard_forall_subs forall_guard { *this, node };
+                // mutate_forall( node );
+                maybe_accept( node, &FunctionType::assertions );
+                guard_forall_subs forall_guard { *this, node };
+                mutate_forall( node );
                 maybe_accept( node, &FunctionType::returns );
                 maybe_accept( node, &FunctionType::params  );
 …
+                {
                         bool mutated = false;
                         std::unordered_map< ast::TypeInstType::TypeEnvKey, ast::ptr< ast::Type > > new_map;
+                        std::unordered_map< std::string, ast::ptr< ast::Type > > new_map;
                         for ( const auto & p : node->typeEnv ) {
                                 guard_symtab guard { *this };
 …
+                        }
+                }
+                {
+                        bool mutated = false;
+                        std::unordered_map< std::string, ast::ptr< ast::Expr > > new_map;
+                        for ( const auto & p : node->varEnv ) {
+                                guard_symtab guard { *this };
+                                auto new_node = p.second->accept( *this );
+                                if (new_node != p.second) mutated = true;
+                                new_map.insert({ p.first, new_node });
+                        }
+                        if (mutated) {
+                                auto new_node = __pass::mutate<core_t>( node );
+                                new_node->varEnv.swap( new_map );
+                                node = new_node;
+                        }
+                }
+        )

src/AST/Pass.proto.hpp

-                      r2b4daf2
+                      r42f6e07
                 static inline auto leave( core_t &, long, const ast::FunctionType * ) {}
+                // Get the substitution table, if present
+                template<typename core_t>
+                static inline auto subs( core_t & core, int ) -> decltype( &core.subs ) {
+                        return &core.subs;
+                }
+                template<typename core_t>
+                static inline ast::ForallSubstitutionTable * subs( core_t &, long ) { return nullptr; }
                 // Replaces a TypeInstType's base TypeDecl according to the table
                 template<typename core_t>

src/AST/Print.cpp

-                      r2b4daf2
+                      r42f6e07
+        }
-        void print( const ast::FunctionType::AssertionList & assts ) {
-                if (assts.empty()) return;
-                os << "with assertions" << endl;
-                ++indent;
-                printAll(assts);
-                os << indent;
-                --indent;
+        }
         void print( const std::vector<ptr<Attribute>> & attrs ) {
                 if ( attrs.empty() ) return;
 …
         void preprint( const ast::NamedTypeDecl * node ) {
                 if ( ! node->name.empty() ) {
+                        os << node->name << ": ";
+                        if( deterministic_output && isUnboundType(node->name) ) os << "[unbound]:";
+                        else os << node->name << ": ";
+                }
 …
         void preprint( const ast::FunctionType * node ) {
                 print( node->forall );
-                print( node->assertions );
                 print( node->qualifiers );
+        }
 …
         virtual const ast::Type * visit( const ast::TypeInstType * node ) override final {
                 preprint( node );
                 const auto & _name = deterministic_output && isUnboundType(node) ? "[unbound]" : node->typeString();
+                const auto & _name = deterministic_output && isUnboundType(node) ? "[unbound]" : node->name;
                 os << "instance of type " << _name
                    << " (" << (node->kind == ast::TypeDecl::Ftype ? "" : "not ") << "function type)";
 …
                 os << indent << "Types:" << endl;
                 for ( const auto& i : *node ) {
                         os << indent+1 << i.first.typeString() << " -> ";
+                        os << indent+1 << i.first << " -> ";
                         indent += 2;
                         safe_print( i.second );
+                        indent -= 2;
+                        os << endl;
+                }
+                os << indent << "Non-types:" << endl;
+                for ( auto i = node->beginVar(); i != node->endVar(); ++i ) {
+                        os << indent+1 << i->first << " -> ";
+                        indent += 2;
+                        safe_print( i->second );
                         indent -= 2;
                         os << endl;

src/AST/SymbolTable.cpp

-                      r2b4daf2
+                      r42f6e07
 void SymbolTable::addFunction( const FunctionDecl * func ) {
+        for (auto & td : func->type_params) {
+                addType(td);
+        }
+        for (auto & asst : func->assertions) {
+                addId(asst);
+        }
+        // addTypes( func->type->forall );
+        addTypes( func->type->forall );
         addIds( func->returns );
         addIds( func->params );

src/AST/Type.cpp

-                      r2b4daf2
+                      r42f6e07
 #include "Decl.hpp"
+#include "ForallSubstitutor.hpp" // for substituteForall
 #include "Init.hpp"
 #include "Common/utility.h"      // for copy, move
 …
 // GENERATED END
+// --- ParameterizedType
+void FunctionType::initWithSub(
+        const FunctionType & o, Pass< ForallSubstitutor > & sub
+) {
+        forall = sub.core( o.forall );
+}
 // --- FunctionType
+FunctionType::FunctionType( const FunctionType & o )
+: Type( o.qualifiers, copy( o.attributes ) ), returns(), params(),
+  isVarArgs( o.isVarArgs ) {
+        Pass< ForallSubstitutor > sub;
+        initWithSub( o, sub );           // initialize substitution map
+        returns = sub.core( o.returns ); // apply to return and parameter types
+        params = sub.core( o.params );
+}
 namespace {
         bool containsTtype( const std::vector<ptr<Type>> & l ) {
 …
                 // TODO: once TypeInstType representation is updated, it should properly check
                 // if the context id is filled. this is a temporary hack for now
+                return typeInst->formal_usage > 0;
+                return isUnboundType(typeInst->name);
+        }
+        return false;
+}
+bool isUnboundType(const std::string & tname) {
+        // xxx - look for a type name produced by renameTyVars.
+        // TODO: once TypeInstType representation is updated, it should properly check
+        // if the context id is filled. this is a temporary hack for now
+        if (std::count(tname.begin(), tname.end(), '_') >= 3) {
+                return true;
+        }
         return false;

src/AST/Type.hpp

-                      r2b4daf2
+                      r42f6e07
 template< typename T > class Pass;
+struct ForallSubstitutor;
 class Type : public Node {
 …
 /// Type of a function `[R1, R2](*)(P1, P2, P3)`
 class FunctionType final : public Type {
+public:
+        using ForallList = std::vector<ptr<TypeInstType>>;
+        using AssertionList = std::vector<ptr<VariableExpr>>;
+        protected:
+        /// initializes forall with substitutor
+        void initWithSub( const FunctionType & o, Pass< ForallSubstitutor > & sub );
+public:
+        using ForallList = std::vector<ptr<TypeDecl>>;
         ForallList forall;
-        AssertionList assertions;
         std::vector<ptr<Type>> returns;
 …
         : Type(q), returns(), params(), isVarArgs(va) {}
         FunctionType( const FunctionType & o ) = default;
+        FunctionType( const FunctionType & o );
         /// true if either the parameters or return values contain a tttype
 …
 public:
         readonly<TypeDecl> base;
-        // previously from renameTyVars; now directly use integer fields instead of synthesized strings
-        // a nonzero value of formal_usage indicates a formal type (only used in function type)
-        // a zero value of formal_usage indicates an actual type (referenced inside body of parametric structs and functions)
         TypeDecl::Kind kind;
-        int formal_usage = 0;
-        int expr_id = 0;
-        // compact representation used for map lookups.
-        struct TypeEnvKey {
-                const TypeDecl * base;
-                int formal_usage;
-                int expr_id;
-                TypeEnvKey() = default;
-                TypeEnvKey(const TypeDecl * base, int formal_usage = 0, int expr_id = 0): base(base), formal_usage(formal_usage), expr_id(expr_id) {}
-                TypeEnvKey(const TypeInstType & inst): base(inst.base), formal_usage(inst.formal_usage), expr_id(inst.expr_id) {}
-                std::string typeString() const { return std::string("_") + std::to_string(formal_usage) + "_" + std::to_string(expr_id) + "_" + base->name; }
-                bool operator==(const TypeEnvKey & other) const { return base == other.base && formal_usage == other.formal_usage && expr_id == other.expr_id; }
-        };
-        bool operator==(const TypeInstType & other) const { return base == other.base && formal_usage == other.formal_usage && expr_id == other.expr_id; }
         TypeInstType(
 …
         TypeInstType( const TypeInstType & o ) = default;
-        TypeInstType( const TypeEnvKey & key )
-        : BaseInstType(key.base->name), base(key.base), kind(key.base->kind), formal_usage(key.formal_usage), expr_id(key.expr_id) {}
         /// sets `base`, updating `kind` correctly
         void set_base( const TypeDecl * );
 …
         const Type * accept( Visitor & v ) const override { return v.visit( this ); }
-        std::string typeString() const {
-                if (formal_usage > 0) return std::string("_") + std::to_string(formal_usage) + "_" + std::to_string(expr_id) + "_" + name;
-                else return name;
+        }
 private:
         TypeInstType * clone() const override { return new TypeInstType{ *this }; }
 …
 bool isUnboundType(const Type * type);
+}
+namespace std {
+        template<>
+        struct hash<typename ast::TypeInstType::TypeEnvKey> {
+                size_t operator() (const ast::TypeInstType::TypeEnvKey & x) const {
+                        const size_t p = 1000007;
+                        size_t res = reinterpret_cast<size_t>(x.base);
+                        res = p * res + x.formal_usage;
+                        res = p * res + x.expr_id;
+                        return res;
+                }
+        };
+bool isUnboundType(const std::string & tname);
+}

src/AST/TypeEnvironment.cpp

-                      r2b4daf2
+                      r42f6e07
         for ( const auto & i : open ) {
                 if ( first ) { first = false; } else { out << ' '; }
                 out << i.first.typeString() << "(" << i.second << ")";
+                out << i.first << "(" << i.second << ")";
+        }
+}
 …
                 if(first) first = false;
                 else out << " ";
+                if( deterministic_output ) out << "[unbound]";
+                else out << "_" << var.formal_usage << "_" << var.expr_id << "_";
+                out << var.base->name;
+                if( deterministic_output && isUnboundType(var) ) out << "[unbound]";
+                else out << var;
+        }
         out << ")";
 …
+}
 const EqvClass * TypeEnvironment::lookup( const TypeInstType::TypeEnvKey & var ) const {
+const EqvClass * TypeEnvironment::lookup( const std::string & var ) const {
         for ( ClassList::const_iterator i = env.begin(); i != env.end(); ++i ) {
                 if ( i->vars.find( var ) != i->vars.end() ) return &*i;
 …
 void TypeEnvironment::add( const FunctionType::ForallList & tyDecls ) {
         for ( auto & tyDecl : tyDecls ) {
+        for ( const TypeDecl * tyDecl : tyDecls ) {
                 env.emplace_back( tyDecl );
+        }
 …
 void TypeEnvironment::writeToSubstitution( TypeSubstitution & sub ) const {
         for ( const auto & clz : env ) {
+                TypeInstType::TypeEnvKey clzRep;
+                bool first = true;
+                std::string clzRep;
                 for ( const auto & var : clz.vars ) {
                         if ( clz.bound ) {
                                 sub.add( var, clz.bound );
                         } else if ( first ) {
+                        } else if ( clzRep.empty() ) {
                                 clzRep = var;
-                                first = false;
                         } else {
                                 sub.add( var, new TypeInstType{ clzRep } );
+                                sub.add( var, new TypeInstType{ clzRep, clz.data.kind } );
+                        }
+                }
 …
         struct Occurs : public ast::WithVisitorRef<Occurs> {
                 bool result;
                 std::unordered_set< TypeInstType::TypeEnvKey > vars;
+                std::set< std::string > vars;
                 const TypeEnvironment & tenv;
                 Occurs( const TypeInstType::TypeEnvKey & var, const TypeEnvironment & env )
+                Occurs( const std::string & var, const TypeEnvironment & env )
                 : result( false ), vars(), tenv( env ) {
                         if ( const EqvClass * clz = tenv.lookup( var ) ) {
 …
                 void previsit( const TypeInstType * typeInst ) {
                         if ( vars.count( *typeInst ) ) {
+                        if ( vars.count( typeInst->name ) ) {
                                 result = true;
                         } else if ( const EqvClass * clz = tenv.lookup( *typeInst ) ) {
+                        } else if ( const EqvClass * clz = tenv.lookup( typeInst->name ) ) {
                                 if ( clz->bound ) {
                                         clz->bound->accept( *visitor );
 …
         /// true if `var` occurs in `ty` under `env`
         bool occurs( const Type * ty, const TypeInstType::TypeEnvKey & var, const TypeEnvironment & env ) {
+        bool occurs( const Type * ty, const std::string & var, const TypeEnvironment & env ) {
                 Pass<Occurs> occur{ var, env };
                 maybe_accept( ty, occur );
 …
         // remove references from bound type, so that type variables can only bind to value types
         ptr<Type> target = bindTo->stripReferences();
         auto tyvar = open.find( *typeInst );
+        auto tyvar = open.find( typeInst->name );
         assert( tyvar != open.end() );
         if ( ! tyVarCompatible( tyvar->second, target ) ) return false;
         if ( occurs( target, *typeInst, *this ) ) return false;
         auto it = internal_lookup( *typeInst );
+        if ( occurs( target, typeInst->name, *this ) ) return false;
+        auto it = internal_lookup( typeInst->name );
         if ( it != env.end() ) {
                 if ( it->bound ) {
 …
         } else {
                 env.emplace_back(
                         *typeInst, target, widen.first && widen.second, data );
+                        typeInst->name, target, widen.first && widen.second, data );
+        }
         return true;
 …
                 WidenMode widen, const SymbolTable & symtab
 ) {
         auto c1 = internal_lookup( *var1 );
         auto c2 = internal_lookup( *var2 );
+        auto c1 = internal_lookup( var1->name );
+        auto c2 = internal_lookup( var2->name );
         // exit early if variables already bound together
 …
         if ( c1 != env.end() ) {
                 if ( c1->bound ) {
                         if ( occurs( c1->bound, *var2, *this ) ) return false;
+                        if ( occurs( c1->bound, var2->name, *this ) ) return false;
                         type1 = c1->bound;
+                }
 …
         if ( c2 != env.end() ) {
                 if ( c2->bound ) {
                         if ( occurs( c2->bound, *var1, *this ) ) return false;
+                        if ( occurs( c2->bound, var1->name, *this ) ) return false;
                         type2 = c2->bound;
+                }
 …
         } else if ( c1 != env.end() ) {
                 // var2 unbound, add to env[c1]
                 c1->vars.emplace( *var2 );
+                c1->vars.emplace( var2->name );
                 c1->allowWidening = widen1;
                 c1->data.isComplete |= data.isComplete;
         } else if ( c2 != env.end() ) {
                 // var1 unbound, add to env[c2]
                 c2->vars.emplace( *var1 );
+                c2->vars.emplace( var1->name );
                 c2->allowWidening = widen2;
                 c2->data.isComplete |= data.isComplete;
         } else {
                 // neither var bound, create new class
                 env.emplace_back( *var1, *var2, widen1 && widen2, data );
+                env.emplace_back( var1->name, var2->name, widen1 && widen2, data );
+        }
 …
+}
 TypeEnvironment::ClassList::iterator TypeEnvironment::internal_lookup( const TypeInstType::TypeEnvKey & var ) {
+TypeEnvironment::ClassList::iterator TypeEnvironment::internal_lookup( const std::string & var ) {
         for ( ClassList::iterator i = env.begin(); i != env.end(); ++i ) {
                 if ( i->vars.count( var ) ) return i;

src/AST/TypeEnvironment.hpp

-                      r2b4daf2
+                      r42f6e07
 /// recorded. More investigation is needed.
 struct AssertCompare {
         bool operator()( const VariableExpr * d1, const VariableExpr * d2 ) const {
                 int cmp = d1->var->name.compare( d2->var->name );
                 return cmp < 0 || ( cmp == 0 && d1->result < d2->result );
+        bool operator()( const DeclWithType * d1, const DeclWithType * d2 ) const {
+                int cmp = d1->name.compare( d2->name );
+                return cmp < 0 || ( cmp == 0 && d1->get_type() < d2->get_type() );
+        }
 };
 …
 /// Set of assertions pending satisfaction
 using AssertionSet = std::map< const VariableExpr *, AssertionSetValue, AssertCompare >;
+using AssertionSet = std::map< readonly<DeclWithType>, AssertionSetValue, AssertCompare >;
 /// Set of open variables
 using OpenVarSet = std::unordered_map< TypeInstType::TypeEnvKey, TypeDecl::Data >;
+using OpenVarSet = std::unordered_map< std::string, TypeDecl::Data >;
 /// Merges one set of open vars into another
 …
 /// they bind to.
 struct EqvClass {
         std::unordered_set< TypeInstType::TypeEnvKey > vars;
+        std::set< std::string > vars;
         ptr<Type> bound;
         bool allowWidening;
 …
         /// Singleton class constructor from TypeDecl
         EqvClass( const TypeInstType * inst )
         : vars{ *inst }, bound(), allowWidening( true ), data( inst->base ) {}
+        EqvClass( const TypeDecl * decl )
+        : vars{ decl->name }, bound(), allowWidening( true ), data( decl ) {}
         /// Singleton class constructor from substitution
         EqvClass( const TypeInstType::TypeEnvKey & v, const Type * b )
+        EqvClass( const std::string & v, const Type * b )
         : vars{ v }, bound( b ), allowWidening( false ), data( TypeDecl::Dtype, false ) {}
         /// Single-var constructor (strips qualifiers from bound type)
         EqvClass( const TypeInstType::TypeEnvKey & v, const Type * b, bool w, const TypeDecl::Data & d )
+        EqvClass( const std::string & v, const Type * b, bool w, const TypeDecl::Data & d )
         : vars{ v }, bound( b ), allowWidening( w ), data( d ) {
                 reset_qualifiers( bound );
 …
         /// Double-var constructor
         EqvClass( const TypeInstType::TypeEnvKey & v, const TypeInstType::TypeEnvKey & u, bool w, const TypeDecl::Data & d )
+        EqvClass( const std::string & v, const std::string & u, bool w, const TypeDecl::Data & d )
         : vars{ v, u }, bound(), allowWidening( w ), data( d ) {}
 …
 public:
         /// Finds the equivalence class containing a variable; nullptr for none such
         const EqvClass * lookup( const TypeInstType::TypeEnvKey & var ) const;
+        const EqvClass * lookup( const std::string & var ) const;
         /// Add a new equivalence class for each type variable
 …
         /// Private lookup API; returns array index of string, or env.size() for not found
         ClassList::iterator internal_lookup( const TypeInstType::TypeEnvKey & );
+        ClassList::iterator internal_lookup( const std::string & );
 };

src/AST/TypeSubstitution.cpp

-                      r2b4daf2
+                      r42f6e07
 void TypeSubstitution::initialize( const TypeSubstitution &src, TypeSubstitution &dest ) {
         dest.typeEnv.clear();
+        dest.varEnv.clear();
         dest.add( src );
+}
 …
                 typeEnv[ i->first ] = i->second;
         } // for
+}
+void TypeSubstitution::add( const TypeInstType * formalType, const Type *actualType ) {
+        typeEnv[ *formalType ] = actualType;
+}
+void TypeSubstitution::add( const TypeInstType::TypeEnvKey & key, const Type * actualType) {
+        typeEnv[ key ] = actualType;
+}
+void TypeSubstitution::remove( const TypeInstType * formalType ) {
+        TypeEnvType::iterator i = typeEnv.find( *formalType );
+        for ( VarEnvType::const_iterator i = other.varEnv.begin(); i != other.varEnv.end(); ++i ) {
+                varEnv[ i->first ] = i->second;
+        } // for
+}
+void TypeSubstitution::add( std::string formalType, const Type *actualType ) {
+        typeEnv[ formalType ] = actualType;
+}
+void TypeSubstitution::addVar( std::string formalExpr, const Expr *actualExpr ) {
+        varEnv[ formalExpr ] = actualExpr;
+}
+void TypeSubstitution::remove( std::string formalType ) {
+        TypeEnvType::iterator i = typeEnv.find( formalType );
         if ( i != typeEnv.end() ) {
                 typeEnv.erase( *formalType );
         } // if
+}
 const Type *TypeSubstitution::lookup( const TypeInstType * formalType ) const {
         TypeEnvType::const_iterator i = typeEnv.find( *formalType );
+                typeEnv.erase( formalType );
+        } // if
+}
+const Type *TypeSubstitution::lookup( std::string formalType ) const {
+        TypeEnvType::const_iterator i = typeEnv.find( formalType );
         // break on not in substitution set
 …
         // attempt to transitively follow TypeInstType links.
         while ( const TypeInstType *actualType = i->second.as<TypeInstType>()) {
+                const std::string& typeName = actualType->name;
                 // break cycles in the transitive follow
                 if ( *formalType == *actualType ) break;
+                if ( formalType == typeName ) break;
                 // Look for the type this maps to, returning previous mapping if none-such
                 i = typeEnv.find( *actualType );
+                i = typeEnv.find( typeName );
                 if ( i == typeEnv.end() ) return actualType;
+        }
 …
 bool TypeSubstitution::empty() const {
         return typeEnv.empty();
+        return typeEnv.empty() && varEnv.empty();
+}
 …
                 TypeSubstitution * newEnv;
                 EnvTrimmer( const TypeSubstitution * env, TypeSubstitution * newEnv ) : env( env ), newEnv( newEnv ){}
                 void previsit( FunctionType * ftype ) {
+                void previsit( TypeDecl * tyDecl ) {
                         // transfer known bindings for seen type variables
+                        for (auto & formal : ftype->forall) {
+                                if ( const Type * t = env->lookup( formal ) ) {
+                                        newEnv->add( formal, t );
+                                }
+                        if ( const Type * t = env->lookup( tyDecl->name ) ) {
+                                newEnv->add( tyDecl->name, t );
+                        }
+                }
 …
 const Type * TypeSubstitution::Substituter::postvisit( const TypeInstType *inst ) {
         BoundVarsType::const_iterator bound = boundVars.find( *inst );
+        BoundVarsType::const_iterator bound = boundVars.find( inst->name );
         if ( bound != boundVars.end() ) return inst;
         TypeEnvType::const_iterator i = sub.typeEnv.find( *inst );
+        TypeEnvType::const_iterator i = sub.typeEnv.find( inst->name );
         if ( i == sub.typeEnv.end() ) {
                 return inst;
 …
                 // TODO: investigate preventing type variables from being bound to themselves in the first place.
                 if ( const TypeInstType * replacement = i->second.as<TypeInstType>() ) {
                         if ( *inst == *replacement ) {
+                        if ( inst->name == replacement->name ) {
                                 return inst;
+                        }
 …
+}
+const Expr * TypeSubstitution::Substituter::postvisit( const NameExpr * nameExpr ) {
+        VarEnvType::const_iterator i = sub.varEnv.find( nameExpr->name );
+        if ( i == sub.varEnv.end() ) {
+                return nameExpr;
+        } else {
+                subCount++;
+                return i->second;
+        } // if
+}
 void TypeSubstitution::Substituter::previsit( const FunctionType * ptype ) {
         GuardValue( boundVars );
         // bind type variables from forall-qualifiers
         if ( freeOnly ) {
                 for ( auto & tyvar : ptype->forall ) {
                                 boundVars.insert( *tyvar );
+                for ( const TypeDecl * tyvar : ptype->forall ) {
+                                boundVars.insert( tyvar->name );
                 } // for
         } // if
+}
-/*
 void TypeSubstitution::Substituter::handleAggregateType( const BaseInstType * type ) {
         GuardValue( boundVars );
 …
                         if ( ! type->params.empty() ) {
                                 for ( const TypeDecl * tyvar : decl->params ) {
                                         boundVars.insert( *tyvar );
+                                        boundVars.insert( tyvar->name );
                                 } // for
                         } // if
 …
         handleAggregateType( aggregateUseType );
+}
-*/
 } // namespace ast

src/AST/TypeSubstitution.hpp

-                      r2b4daf2
+                      r42f6e07
+        }
+        void add( const TypeInstType * formalType, const Type *actualType );
+        void add( const TypeInstType::TypeEnvKey & key, const Type *actualType );
+        void add( std::string formalType, const Type *actualType );
         void add( const TypeSubstitution &other );
         void remove( const TypeInstType * formalType );
         const Type *lookup( const TypeInstType * formalType ) const;
+        void remove( std::string formalType );
+        const Type *lookup( std::string formalType ) const;
         bool empty() const;
+        void addVar( std::string formalExpr, const Expr *actualExpr );
         template< typename FormalIterator, typename ActualIterator >
 …
         friend class Pass;
+        typedef std::unordered_map< TypeInstType::TypeEnvKey, ptr<Type> > TypeEnvType;
+        typedef std::unordered_map< std::string, ptr<Type> > TypeEnvType;
+        typedef std::unordered_map< std::string, ptr<Expr> > VarEnvType;
         TypeEnvType typeEnv;
+        VarEnvType varEnv;
   public:
 …
         auto   end() const -> decltype( typeEnv.  end() ) { return typeEnv.  end(); }
+        auto beginVar()       -> decltype( varEnv.begin() ) { return varEnv.begin(); }
+        auto   endVar()       -> decltype( varEnv.  end() ) { return varEnv.  end(); }
+        auto beginVar() const -> decltype( varEnv.begin() ) { return varEnv.begin(); }
+        auto   endVar() const -> decltype( varEnv.  end() ) { return varEnv.  end(); }
 };
-// this is the only place where type parameters outside a function formal may be substituted.
 template< typename FormalIterator, typename ActualIterator >
 void TypeSubstitution::add( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actualBegin ) {
 …
                         if ( const TypeExpr *actual = actualIt->template as<TypeExpr>() ) {
                                 if ( formal->name != "" ) {
                                         typeEnv[ formal ] = actual->type;
+                                        typeEnv[ formal->name ] = actual->type;
                                 } // if
                         } else {
 …
                         } // if
                 } else {
+                        // TODO: type check the formal and actual parameters
+                        if ( (*formalIt)->name != "" ) {
+                                varEnv[ (*formalIt)->name ] = *actualIt;
+                        } // if
                 } // if
         } // for
+}
 template< typename FormalIterator, typename ActualIterator >
 …
         add( formalBegin, formalEnd, actualBegin );
+}
 } // namespace ast
 …
                 const Type * postvisit( const TypeInstType * aggregateUseType );
+                const Expr * postvisit( const NameExpr * nameExpr );
                 /// Records type variable bindings from forall-statements
                 void previsit( const FunctionType * type );
                 /// Records type variable bindings from forall-statements and instantiations of generic types
                 // void handleAggregateType( const BaseInstType * type );
                 // void previsit( const StructInstType * aggregateUseType );
                 // void previsit( const UnionInstType * aggregateUseType );
+                void handleAggregateType( const BaseInstType * type );
+                void previsit( const StructInstType * aggregateUseType );
+                void previsit( const UnionInstType * aggregateUseType );
                 const TypeSubstitution & sub;
                 int subCount = 0;
                 bool freeOnly;
                 typedef std::unordered_set< TypeInstType::TypeEnvKey > BoundVarsType;
+                typedef std::unordered_set< std::string > BoundVarsType;
                 BoundVarsType boundVars;

src/AST/module.mk

-                      r2b4daf2
+                      r42f6e07
         AST/Expr.cpp \
         AST/Expr.hpp \
+        AST/ForallSubstitutionTable.cpp \
+        AST/ForallSubstitutionTable.hpp \
+        AST/ForallSubstitutor.hpp \
         AST/FunctionSpec.hpp \
         AST/Fwd.hpp \

src/GenPoly/GenPoly.cc

-                      r2b4daf2
+                      r42f6e07
                 if (!env) return type;
                 if (auto typeInst = dynamic_cast<const ast::TypeInstType*> (type)) {
                         auto newType = env->lookup(typeInst);
+                        auto newType = env->lookup(typeInst->name);
                         if (newType) return newType;
+                }
 …
                 if ( auto typeInst = dynamic_cast< const ast::TypeInstType * >( type ) ) {
                         return tyVars.find(typeInst->typeString()) != tyVars.end() ? type : nullptr;
+                        return tyVars.find(typeInst->name) != tyVars.end() ? type : nullptr;
                 } else if ( auto arrayType = dynamic_cast< const ast::ArrayType * >( type ) ) {
                         return isPolyType( arrayType->base, env );
 …
+        }
         void addToTyVarMap( const ast::TypeInstType * tyVar, TyVarMap & tyVarMap) {
                 tyVarMap.insert(tyVar->typeString(), convData(ast::TypeDecl::Data{tyVar->base}));
+        void addToTyVarMap( const ast::TypeDecl * tyVar, TyVarMap & tyVarMap) {
+                tyVarMap.insert(tyVar->name, convData(ast::TypeDecl::Data{tyVar}));
+        }

src/InitTweak/GenInit.cc

-                      r2b4daf2
+                      r42f6e07
         };
-        struct HoistArrayDimension_NoResolve final : public WithDeclsToAdd, public WithShortCircuiting, public WithGuards {
-                /// hoist dimension from array types in object declaration so that it uses a single
-                /// const variable of type size_t, so that side effecting array dimensions are only
-                /// computed once.
-                static void hoistArrayDimension( std::list< Declaration * > & translationUnit );
-                void premutate( ObjectDecl * objectDecl );
-                DeclarationWithType * postmutate( ObjectDecl * objectDecl );
-                void premutate( FunctionDecl *functionDecl );
-                // should not traverse into any of these declarations to find objects
-                // that need to be constructed or destructed
-                void premutate( AggregateDecl * ) { visit_children = false; }
-                void premutate( NamedTypeDecl * ) { visit_children = false; }
-                void premutate( FunctionType * ) { visit_children = false; }
-                void hoist( Type * type );
-                Type::StorageClasses storageClasses;
-                bool inFunction = false;
-        };
         void genInit( std::list< Declaration * > & translationUnit ) {
+                if (!useNewAST) {
+                        HoistArrayDimension::hoistArrayDimension( translationUnit );
+                }
+                else {
+                        HoistArrayDimension_NoResolve::hoistArrayDimension( translationUnit );
+                }
+                HoistArrayDimension::hoistArrayDimension( translationUnit );
                 fixReturnStatements( translationUnit );
 …
                         // need to resolve array dimensions in order to accurately determine if constexpr
+                        ResolvExpr::findSingleExpression( arrayType->dimension, Validate::SizeType->clone(), indexer );
+                        // array is variable-length when the dimension is not constexpr
+                        arrayType->isVarLen = ! isConstExpr( arrayType->dimension );
+                        if (!useNewAST) {
+                                ResolvExpr::findSingleExpression( arrayType->dimension, Validate::SizeType->clone(), indexer );
+                                // array is variable-length when the dimension is not constexpr
+                                arrayType->isVarLen = ! isConstExpr( arrayType->dimension );
+                        }
                         // don't need to hoist dimension if it's definitely pure - only need to if there's potential for side effects.
                         // xxx - hoisting has no side effects anyways, so don't skip since we delay resolve
 …
         void HoistArrayDimension::premutate( FunctionDecl * ) {
-                GuardValue( inFunction );
-                inFunction = true;
+        }
-        // precompute array dimension expression, because constructor generation may duplicate it,
-        // which would be incorrect if it is a side-effecting computation.
-        void HoistArrayDimension_NoResolve::hoistArrayDimension( std::list< Declaration * > & translationUnit ) {
-                PassVisitor<HoistArrayDimension_NoResolve> hoister;
-                mutateAll( translationUnit, hoister );
+        }
-        void HoistArrayDimension_NoResolve::premutate( ObjectDecl * objectDecl ) {
-                GuardValue( storageClasses );
-                storageClasses = objectDecl->get_storageClasses();
+        }
-        DeclarationWithType * HoistArrayDimension_NoResolve::postmutate( ObjectDecl * objectDecl ) {
-                hoist( objectDecl->get_type() );
-                return objectDecl;
+        }
-        void HoistArrayDimension_NoResolve::hoist( Type * type ) {
-                // if in function, generate const size_t var
-                static UniqueName dimensionName( "_array_dim" );
-                // C doesn't allow variable sized arrays at global scope or for static variables, so don't hoist dimension.
-                if ( ! inFunction ) return;
-                if ( storageClasses.is_static ) return;
-                if ( ArrayType * arrayType = dynamic_cast< ArrayType * >( type ) ) {
-                        if ( ! arrayType->get_dimension() ) return; // xxx - recursive call to hoist?
-                        // don't need to hoist dimension if it's definitely pure - only need to if there's potential for side effects.
-                        // xxx - hoisting has no side effects anyways, so don't skip since we delay resolve
-                        // still try to detect constant expressions
-                        if ( ! Tuples::maybeImpure( arrayType->dimension ) ) return;
-                        ObjectDecl * arrayDimension = new ObjectDecl( dimensionName.newName(), storageClasses, LinkageSpec::C, 0, Validate::SizeType->clone(), new SingleInit( arrayType->get_dimension() ) );
-                        arrayDimension->get_type()->set_const( true );
-                        arrayType->set_dimension( new VariableExpr( arrayDimension ) );
-                        declsToAddBefore.push_back( arrayDimension );
-                        hoist( arrayType->get_base() );
-                        return;
+                }
+        }
-        void HoistArrayDimension_NoResolve::premutate( FunctionDecl * ) {
                 GuardValue( inFunction );
                 inFunction = true;

src/ResolvExpr/AdjustExprType.cc

r2b4daf2	r42f6e07
133	133	const ast::Type * postvisit( const ast::TypeInstType * inst ) {
134	134	// replace known function-type-variables with pointer-to-function
135		if ( const ast::EqvClass * eqvClass = tenv.lookup( *inst ) ) {
	135	if ( const ast::EqvClass * eqvClass = tenv.lookup( inst->name ) ) {
136	136	if ( eqvClass->data.kind == ast::TypeDecl::Ftype ) {
137	137	return new ast::PointerType{ inst };

src/ResolvExpr/CandidateFinder.cpp

-                      r2b4daf2
+                      r42f6e07
                 // mark type variable and specialization cost of forall clause
                 convCost.incVar( function->forall.size() );
+                convCost.decSpec( function->assertions.size() );
+                for ( const ast::TypeDecl * td : function->forall ) {
+                        convCost.decSpec( td->assertions.size() );
+                }
                 return convCost;
 …
                 ast::AssertionSet & need
         ) {
                 for ( auto & tyvar : type->forall ) {
                         unifiableVars[ *tyvar ] = ast::TypeDecl::Data{ tyvar->base };
+                }
                 for ( auto & assn : type->assertions ) {
                         need[ assn ].isUsed = true;
+                for ( const ast::TypeDecl * tyvar : type->forall ) {
+                        unifiableVars[ tyvar->name ] = ast::TypeDecl::Data{ tyvar };
+                        for ( const ast::DeclWithType * assn : tyvar->assertions ) {
+                                need[ assn ].isUsed = true;
+                        }
+                }
+        }
 …
                         // xxx - is it possible that handleTupleAssignment and main finder both produce candidates?
                         // this means there exists ctor/assign functions with a tuple as first parameter.
+                        ResolvMode mode = {
+                                true, // adjust
+                                !untypedExpr->func.as<ast::NameExpr>(), // prune if not calling by name
+                                selfFinder.candidates.empty() // failfast if other options are not found
+                        };
+                        funcFinder.find( untypedExpr->func, mode );
+                        funcFinder.find( untypedExpr->func, selfFinder.candidates.empty() ? ResolvMode::withAdjustment() : ResolvMode::withoutFailFast() );
                         // short-circuit if no candidates
                         // if ( funcFinder.candidates.empty() ) return;
 …
                                                 auto inst = dynamic_cast< const ast::TypeInstType * >( funcResult )
                                         ) {
                                                 if ( const ast::EqvClass * clz = func->env.lookup( *inst ) ) {
+                                                if ( const ast::EqvClass * clz = func->env.lookup( inst->name ) ) {
                                                         if ( auto function = clz->bound.as< ast::FunctionType >() ) {
                                                                 CandidateRef newFunc{ new Candidate{ *func } };
 …
                         assert( toType );
                         toType = resolveTypeof( toType, symtab );
                         // toType = SymTab::validateType( castExpr->location, toType, symtab );
+                        toType = SymTab::validateType( castExpr->location, toType, symtab );
                         toType = adjustExprType( toType, tenv, symtab );
 …
                                         if(auto insttype = dynamic_cast<const ast::TypeInstType*>(expr)) {
                                                 auto td = cand->env.lookup(*insttype);
+                                                auto td = cand->env.lookup(insttype->name);
                                                 if(!td) { continue; }
                                                 expr = td->bound.get();
 …
                                 // calculate target type
                                 const ast::Type * toType = resolveTypeof( initAlt.type, symtab );
                                 // toType = SymTab::validateType( initExpr->location, toType, symtab );
+                                toType = SymTab::validateType( initExpr->location, toType, symtab );
                                 toType = adjustExprType( toType, tenv, symtab );
                                 // The call to find must occur inside this loop, otherwise polymorphic return

src/ResolvExpr/CastCost.cc

r2b4daf2	r42f6e07
202	202	) {
203	203	if ( auto typeInst = dynamic_cast< const ast::TypeInstType * >( dst ) ) {
204		if ( const ast::EqvClass * eqvClass = env.lookup( *typeInst ) ) {
	204	if ( const ast::EqvClass * eqvClass = env.lookup( typeInst->name ) ) {
205	205	// check cast cost against bound type, if present
206	206	if ( eqvClass->bound ) {

src/ResolvExpr/CommonType.cc

r2b4daf2	r42f6e07
713	713	const ast::Type * base = oPtr->base;
714	714	if ( auto var = dynamic_cast< const ast::TypeInstType * >( base ) ) {
715		auto entry = open.find( *var );
	715	auto entry = open.find( var->name );
716	716	if ( entry != open.end() ) {
717	717	ast::AssertionSet need, have;

src/ResolvExpr/ConversionCost.cc

-                      r2b4daf2
+                      r42f6e07
 ) {
         if ( const ast::TypeInstType * inst = dynamic_cast< const ast::TypeInstType * >( dst ) ) {
                 if ( const ast::EqvClass * eqv = env.lookup( *inst ) ) {
+                if ( const ast::EqvClass * eqv = env.lookup( inst->name ) ) {
                         if ( eqv->bound ) {
                                 return conversionCost(src, eqv->bound, srcIsLvalue, symtab, env );
 …
 void ConversionCost_new::postvisit( const ast::TypeInstType * typeInstType ) {
         if ( const ast::EqvClass * eqv = env.lookup( *typeInstType ) ) {
+        if ( const ast::EqvClass * eqv = env.lookup( typeInstType->name ) ) {
                 cost = costCalc( eqv->bound, dst, srcIsLvalue, symtab, env );
         } else if ( const ast::TypeInstType * dstAsInst =
                         dynamic_cast< const ast::TypeInstType * >( dst ) ) {
                 if ( *typeInstType == *dstAsInst ) {
+                if ( typeInstType->name == dstAsInst->name ) {
                         cost = Cost::zero;
+                }

src/ResolvExpr/FindOpenVars.cc

-                      r2b4daf2
+                      r42f6e07
                                 // mark open/closed variables
                                 if ( nextIsOpen ) {
                                         for ( auto & decl : type->forall ) {
                                                 open[ *decl ] = ast::TypeDecl::Data{ decl->base };
+                                        }
                                         for ( auto & assert : type->assertions ) {
                                                 need[ assert ].isUsed = false;
+                                        for ( const ast::TypeDecl * decl : type->forall ) {
+                                                open[ decl->name ] = ast::TypeDecl::Data{ decl };
+                                                for ( const ast::DeclWithType * assert : decl->assertions ) {
+                                                        need[ assert ].isUsed = false;
+                                                }
+                                        }
                                 } else {
                                         for ( auto & decl : type->forall ) {
                                                 closed[ *decl ] = ast::TypeDecl::Data{ decl->base };
+                                        }
                                         for ( auto & assert : type->assertions ) {
                                                 have[ assert ].isUsed = false;
+                                        for ( const ast::TypeDecl * decl : type->forall ) {
+                                                closed[ decl->name ] = ast::TypeDecl::Data{ decl };
+                                                for ( const ast::DeclWithType * assert : decl->assertions ) {
+                                                        have[ assert ].isUsed = false;
+                                                }
+                                        }
+                                }

src/ResolvExpr/PolyCost.cc

r2b4daf2	r42f6e07
68	68
69	69	void previsit( const ast::TypeInstType * type ) {
70		if ( const ast::EqvClass * eqv = env_.lookup( type ) ) / && */ if ( eqv->bound ) {
	70	if ( const ast::EqvClass * eqv = env_.lookup( type->name ) ) /* && */ if ( eqv->bound ) {
71	71	if ( const ast::TypeInstType * otherType = eqv->bound.as< ast::TypeInstType >() ) {
72	72	if ( symtab.lookupType( otherType->name ) ) {

src/ResolvExpr/PtrsAssignable.cc

-                      r2b4daf2
+                      r42f6e07
+        }
         void postvisit( const ast::TypeInstType * inst ) {
                 if ( const ast::EqvClass * eqv = typeEnv.lookup( *inst ) ) {
+                if ( const ast::EqvClass * eqv = typeEnv.lookup( inst->name ) ) {
                         if ( eqv->bound ) {
                                 // T * = S * for any S depends on the type bound to T
 …
                 const ast::TypeEnvironment & env ) {
         if ( const ast::TypeInstType * dstAsInst = dynamic_cast< const ast::TypeInstType * >( dst ) ) {
                 if ( const ast::EqvClass * eqv = env.lookup( *dstAsInst ) ) {
+                if ( const ast::EqvClass * eqv = env.lookup( dstAsInst->name ) ) {
                         return ptrsAssignable( src, eqv->bound, env );
+                }

src/ResolvExpr/PtrsCastable.cc

r2b4daf2	r42f6e07
180	180	}
181	181	}
182		} else if ( const ast::EqvClass * eqvClass = env.lookup( *inst ) ) {
	182	} else if ( const ast::EqvClass * eqvClass = env.lookup( inst->name ) ) {
183	183	if ( eqvClass->data.kind == ast::TypeDecl::Ftype ) {
184	184	return -1;
…	…
283	283	) {
284	284	if ( auto inst = dynamic_cast< const ast::TypeInstType * >( dst ) ) {
285		if ( const ast::EqvClass * eqvClass = env.lookup( *inst ) ) {
	285	if ( const ast::EqvClass * eqvClass = env.lookup( inst->name ) ) {
286	286	return ptrsAssignable( src, eqvClass->bound, env );
287	287	}

src/ResolvExpr/RenameVars.cc

-                      r2b4daf2
+                      r42f6e07
 #include <utility>                 // for pair
+#include "AST/ForallSubstitutionTable.hpp"
 #include "AST/Pass.hpp"
 #include "AST/Type.hpp"
 …
                 int level = 0;
                 int resetCount = 0;
+                ScopedMap< std::string, std::string > nameMap;
+        public:
+                ast::ForallSubstitutionTable subs;
-                int next_expr_id = 1;
-                int next_usage_id = 1;
-                ScopedMap< std::string, std::string > nameMap;
-                ScopedMap< std::string, ast::TypeInstType::TypeEnvKey > idMap;
-        public:
                 void reset() {
                         level = 0;
 …
                                 type->name = it->second;
+                        }
+                }
-                void nextUsage() {
-                        ++next_usage_id;
+                }
 …
                 const ast::TypeInstType * rename( const ast::TypeInstType * type ) {
+                        // re-linking of base type handled by WithForallSubstitutor
                         // rename
+                        auto it = idMap.find( type->name );
+                        if ( it != idMap.end() ) {
+                                // unconditionally mutate because map will *always* have different name
+                                ast::TypeInstType * mut = ast::shallowCopy( type );
+                                // reconcile base node since some copies might have been made
+                                mut->base = it->second.base;
+                                mut->formal_usage = it->second.formal_usage;
+                                mut->expr_id = it->second.expr_id;
+                        auto it = nameMap.find( type->name );
+                        if ( it != nameMap.end() ) {
+                                // unconditionally mutate because map will *always* have different name,
+                                // if this mutates, will *always* have been mutated by ForallSubstitutor above
+                                ast::TypeInstType * mut = ast::mutate( type );
+                                mut->name = it->second;
                     type = mut;
+                        }
 …
+                }
                 const ast::FunctionType * openLevel( const ast::FunctionType * type, RenameMode mode ) {
+                const ast::FunctionType * openLevel( const ast::FunctionType * type ) {
                         if ( type->forall.empty() ) return type;
+                        idMap.beginScope();
+                        nameMap.beginScope();
                         // Load new names from this forall clause and perform renaming.
+                        auto mutType = ast::shallowCopy( type );
+                        // assert( type == mutType && "mutated type must be unique from ForallSubstitutor" );
+                        for ( auto & td : mutType->forall ) {
+                                auto mut = ast::shallowCopy( td.get() );
+                                // assert( td == mutDecl && "mutated decl must be unique from ForallSubstitutor" );
+                        auto mutType = ast::mutate( type );
+                        assert( type == mutType && "mutated type must be unique from ForallSubstitutor" );
+                        for ( ast::ptr< ast::TypeDecl > & td : mutType->forall ) {
+                                assertf(dynamic_cast<ast::FunctionType *>(mutType), "renaming vars in non-function type");
+                                std::ostringstream output;
+                                output << "_" << resetCount << "_" << level << "_" << td->name;
+                                std::string newname =  output.str();
+                                nameMap[ td->name ] = newname;
+                                ++level;
+                                if (mode == GEN_EXPR_ID) {
+                                        mut->expr_id = next_expr_id;
+                                        mut->formal_usage = -1;
+                                        ++next_expr_id;
+                                }
+                                else if (mode == GEN_USAGE) {
+                                        assertf(mut->expr_id, "unfilled expression id in generating candidate type");
+                                        mut->formal_usage = next_usage_id;
+                                }
+                                else {
+                                        assert(false);
+                                }
+                                idMap[ td->name ] = ast::TypeInstType::TypeEnvKey(*mut);
+                                td = mut;
+                                ast::TypeDecl * mutDecl = ast::mutate( td.get() );
+                                assert( td == mutDecl && "mutated decl must be unique from ForallSubstitutor" );
+                                mutDecl->name = newname;
+                                // assertion above means `td = mutDecl;` is unnecessary
+                        }
+                        // assertion above means `type = mutType;` is unnecessary
                         return mutType;
+                        return type;
+                }
                 void closeLevel( const ast::FunctionType * type ) {
                         if ( type->forall.empty() ) return;
+                        idMap.endScope();
+                        nameMap.endScope();
+                }
         };
 …
         };
+        struct RenameVars_new : public ast::PureVisitor /*: public ast::WithForallSubstitutor*/ {
+                RenameMode mode;
+        struct RenameVars_new /*: public ast::WithForallSubstitutor*/ {
+                #warning when old RenameVars goes away, replace hack below with global pass inheriting from WithForallSubstitutor
+                ast::ForallSubstitutionTable & subs = renaming.subs;
                 const ast::FunctionType * previsit( const ast::FunctionType * type ) {
                         return renaming.openLevel( type, mode );
+                        return renaming.openLevel( type );
+                }
 …
                 const ast::TypeInstType * previsit( const ast::TypeInstType * type ) {
-                        if (mode == GEN_USAGE && !type->formal_usage) return type; // do not rename an actual type
                         return renaming.rename( type );
+                }
 …
+}
 const ast::Type * renameTyVars( const ast::Type * t, RenameMode mode, bool reset ) {
         // ast::Type *tc = ast::deepCopy(t);
+const ast::Type * renameTyVars( const ast::Type * t ) {
+        ast::Type *tc = ast::deepCopy(t);
         ast::Pass<RenameVars_new> renamer;
+        renamer.core.mode = mode;
+        if (mode == GEN_USAGE && reset) {
+                renaming.nextUsage();
+        }
+        return t->accept( renamer );
+//      return t->accept( renamer );
+        return tc->accept( renamer );
+}
 void resetTyVarRenaming() {
         renaming.reset();
-        renaming.nextUsage();
+}

src/ResolvExpr/RenameVars.h

-                      r2b4daf2
+                      r42f6e07
         /// Provides a consistent renaming of forall type names in a hierarchy by prefixing them with a unique "level" ID
         void renameTyVars( Type * );
+        enum RenameMode {
+                GEN_USAGE, // for type in VariableExpr
+                GEN_EXPR_ID // for type in decl
+        };
+        const ast::Type * renameTyVars( const ast::Type *, RenameMode mode = GEN_USAGE, bool reset = true );
+        const ast::Type * renameTyVars( const ast::Type * );
         /// resets internal state of renamer to avoid overflow
         void resetTyVarRenaming();
 } // namespace ResolvExpr

src/ResolvExpr/ResolvMode.h

-                      r2b4daf2
+                      r42f6e07
                 const bool failFast;         ///< Fail on no resulting alternatives? [true]
+        private:
                 constexpr ResolvMode(bool a, bool p, bool ff)
                 : adjust(a), prune(p), failFast(ff) {}
+        public:
                 /// Default settings
                 constexpr ResolvMode() : adjust(false), prune(true), failFast(true) {}

src/ResolvExpr/ResolveAssertions.cc

r2b4daf2	r42f6e07
397	397
398	398	/// Limit to depth of recursion of assertion satisfaction
399		static const int recursionLimit = 7;
	399	static const int recursionLimit = 4;
400	400	/// Maximum number of simultaneously-deferred assertions to attempt concurrent satisfaction of
401	401	static const int deferLimit = 10;

src/ResolvExpr/ResolveTypeof.cc

-                      r2b4daf2
+                      r42f6e07
 #include "ResolveTypeof.h"
-#include "RenameVars.h"
 #include <cassert>               // for assert
 …
                         mutDecl->mangleName = Mangle::mangle(mutDecl); // do not mangle unnamed variables
-                mutDecl->type = renameTyVars(mutDecl->type, RenameMode::GEN_EXPR_ID);
                 mutDecl->isTypeFixed = true;
                 return mutDecl;

src/ResolvExpr/Resolver.cc

-                      r2b4daf2
+                      r42f6e07
                 };
         } // anonymous namespace
         /// Check if this expression is or includes a deleted expression
         const ast::DeletedExpr * findDeletedExpr( const ast::Expr * expr ) {
 …
                         const ast::Expr * untyped, const ast::SymbolTable & symtab
                 ) {
+                        resetTyVarRenaming();
                         ast::TypeEnvironment env;
                         ast::ptr< ast::Expr > newExpr = resolveInVoidContext( untyped, symtab, env );
 …
+        }
         const ast::Expr * resolveStmtExpr(
+        ast::ptr< ast::Expr > resolveStmtExpr(
                 const ast::StmtExpr * stmtExpr, const ast::SymbolTable & symtab
         ) {
                 assert( stmtExpr );
                 ast::Pass< Resolver_new > resolver{ symtab };
+                auto ret = mutate(stmtExpr->accept(resolver));
+                strict_dynamic_cast< ast::StmtExpr * >( ret )->computeResult();
+                ast::ptr< ast::Expr > ret = stmtExpr;
+                ret = ret->accept( resolver );
+                strict_dynamic_cast< ast::StmtExpr * >( ret.get_and_mutate() )->computeResult();
                 return ret;
+        }
 …
+                        }
                         // handle assertions
+                        // handle assertions. (seems deep)
                         symtab.enterScope();
+                        mutType->forall.clear();
+                        mutType->assertions.clear();
+                        for (auto & typeParam : mutDecl->type_params) {
+                                symtab.addType(typeParam);
+                                mutType->forall.emplace_back(new ast::TypeInstType(typeParam->name, typeParam));
+                        }
+                        for (auto & asst : mutDecl->assertions) {
+                                asst = fixObjectType(asst.strict_as<ast::ObjectDecl>(), symtab);
+                                symtab.addId(asst);
+                                mutType->assertions.emplace_back(new ast::VariableExpr(functionDecl->location, asst));
+                        for (auto & typeParam : mutType->forall) {
+                                auto mutParam = typeParam.get_and_mutate();
+                                symtab.addType(mutParam);
+                                for (auto & asst : mutParam->assertions) {
+                                        asst = fixObjectType(asst.strict_as<ast::ObjectDecl>(), symtab);
+                                        symtab.addId(asst);
+                                }
+                                typeParam = mutParam;
+                        }
 …
                         mutType->returns = std::move(returnTypes);
-                        auto renamedType = strict_dynamic_cast<const ast::FunctionType *>(renameTyVars(mutType, RenameMode::GEN_EXPR_ID));
                         std::list<ast::ptr<ast::Stmt>> newStmts;
                         resolveWithExprs (mutDecl->withExprs, newStmts);
 …
                         symtab.leaveScope();
-                        mutDecl->type = renamedType;
                         mutDecl->mangleName = Mangle::mangle(mutDecl);
                         mutDecl->isTypeFixed = true;
 …
         const PtrType * handlePtrType( const PtrType * type, const ast::SymbolTable & symtab ) {
                 if ( type->dimension ) {
+                        ast::ptr< ast::Type > sizeType = ast::sizeType;
+                        #warning should use new equivalent to Validate::SizeType rather than sizeType here
+                        ast::ptr< ast::Type > sizeType = new ast::BasicType{ ast::BasicType::LongUnsignedInt };
                         ast::mutate_field(
                                 type, &PtrType::dimension,

src/ResolvExpr/Resolver.h

-                      r2b4daf2
+                      r42f6e07
         ast::ptr< ast::Init > resolveCtorInit(
                 const ast::ConstructorInit * ctorInit, const ast::SymbolTable & symtab );
         /// Resolves a statement expression
         const ast::Expr * resolveStmtExpr(
+        /// Resolves a statement expression
+        ast::ptr< ast::Expr > resolveStmtExpr(
                 const ast::StmtExpr * stmtExpr, const ast::SymbolTable & symtab );
 } // namespace ResolvExpr

src/ResolvExpr/SatisfyAssertions.cpp

-                      r2b4daf2
+                      r42f6e07
                 ast::UniqueId resnSlot;          ///< Slot for any recursive assertion IDs
                 AssnCandidate(
                         const ast::SymbolTable::IdData c, const ast::Type * at, ast::TypeEnvironment && e,
+                AssnCandidate(
+                        const ast::SymbolTable::IdData c, const ast::Type * at, ast::TypeEnvironment && e,
                         ast::AssertionSet && h, ast::AssertionSet && n, ast::OpenVarSet && o, ast::UniqueId rs )
                 : cdata( c ), adjType( at ), env( std::move( e ) ), have( std::move( h ) ),
+                : cdata( c ), adjType( at ), env( std::move( e ) ), have( std::move( h ) ),
                   need( std::move( n ) ), open( std::move( o ) ), resnSlot( rs ) {}
         };
 …
         /// Reference to a single deferred item
         struct DeferRef {
                 const ast::VariableExpr * expr;
+                const ast::DeclWithType * decl;
                 const ast::AssertionSetValue & info;
                 const AssnCandidate & match;
         };
         /// Wrapper for the deferred items from a single assertion satisfaction.
+        /// Wrapper for the deferred items from a single assertion satisfaction.
         /// Acts like an indexed list of DeferRef
         struct DeferItem {
                 const ast::VariableExpr * expr;
+                const ast::DeclWithType * decl;
                 const ast::AssertionSetValue & info;
                 AssnCandidateList matches;
                 DeferItem(
                         const ast::VariableExpr * d, const ast::AssertionSetValue & i, AssnCandidateList && ms )
                 : expr( d ), info( i ), matches( std::move( ms ) ) {}
+                DeferItem(
+                        const ast::DeclWithType * d, const ast::AssertionSetValue & i, AssnCandidateList && ms )
+                : decl( d ), info( i ), matches( std::move( ms ) ) {}
                 bool empty() const { return matches.empty(); }
 …
                 AssnCandidateList::size_type size() const { return matches.size(); }
                 DeferRef operator[] ( unsigned i ) const { return { expr, info, matches[i] }; }
+                DeferRef operator[] ( unsigned i ) const { return { decl, info, matches[i] }; }
         };
 …
                 /// Initial satisfaction state for a candidate
                 SatState( CandidateRef & c, const ast::SymbolTable & syms )
                 : cand( c ), need(), newNeed(), deferred(), inferred(), costs{ Cost::zero },
+                : cand( c ), need(), newNeed(), deferred(), inferred(), costs{ Cost::zero },
                   symtab( syms ) { need.swap( c->need ); }
                 /// Update satisfaction state for next step after previous state
                 SatState( SatState && o, IterateFlag )
                 : cand( std::move( o.cand ) ), need( o.newNeed.begin(), o.newNeed.end() ), newNeed(),
                   deferred(), inferred( std::move( o.inferred ) ), costs( std::move( o.costs ) ),
+                : cand( std::move( o.cand ) ), need( o.newNeed.begin(), o.newNeed.end() ), newNeed(),
+                  deferred(), inferred( std::move( o.inferred ) ), costs( std::move( o.costs ) ),
                   symtab( o.symtab ) { costs.emplace_back( Cost::zero ); }
                 /// Field-wise next step constructor
                 SatState(
                         CandidateRef && c, ast::AssertionSet && nn, InferCache && i, CostVec && cs,
+                        CandidateRef && c, ast::AssertionSet && nn, InferCache && i, CostVec && cs,
                         ast::SymbolTable && syms )
                 : cand( std::move( c ) ), need( nn.begin(), nn.end() ), newNeed(), deferred(),
+                : cand( std::move( c ) ), need( nn.begin(), nn.end() ), newNeed(), deferred(),
                   inferred( std::move( i ) ), costs( std::move( cs ) ), symtab( std::move( syms ) )
                   { costs.emplace_back( Cost::zero ); }
 …
         void addToSymbolTable( const ast::AssertionSet & have, ast::SymbolTable & symtab ) {
                 for ( auto & i : have ) {
                         if ( i.second.isUsed ) { symtab.addId( i.first->var ); }
+                        if ( i.second.isUsed ) { symtab.addId( i.first ); }
+                }
+        }
         /// Binds a single assertion, updating satisfaction state
         void bindAssertion(
                 const ast::VariableExpr * expr, const ast::AssertionSetValue & info, CandidateRef & cand,
+        void bindAssertion(
+                const ast::DeclWithType * decl, const ast::AssertionSetValue & info, CandidateRef & cand,
                 AssnCandidate & match, InferCache & inferred
         ) {
                 const ast::DeclWithType * candidate = match.cdata.id;
                 assertf( candidate->uniqueId,
+                assertf( candidate->uniqueId,
                         "Assertion candidate does not have a unique ID: %s", toString( candidate ).c_str() );
                 ast::Expr * varExpr = match.cdata.combine( cand->expr->location, cand->cvtCost );
                 varExpr->result = match.adjType;
 …
                 // place newly-inferred assertion in proper location in cache
                 inferred[ info.resnSlot ][ expr->var->uniqueId ] = ast::ParamEntry{
                         candidate->uniqueId, candidate, match.adjType, expr->result, varExpr };
+                inferred[ info.resnSlot ][ decl->uniqueId ] = ast::ParamEntry{
+                        candidate->uniqueId, candidate, match.adjType, decl->get_type(), varExpr };
+        }
 …
                 std::vector<ast::SymbolTable::IdData> candidates;
                 auto kind = ast::SymbolTable::getSpecialFunctionKind(assn.first->var->name);
+                auto kind = ast::SymbolTable::getSpecialFunctionKind(assn.first->name);
                 if (kind != ast::SymbolTable::SpecialFunctionKind::NUMBER_OF_KINDS) {
                         // prefilter special decls by argument type, if already known
                         ast::ptr<ast::Type> thisArgType = assn.first->result.strict_as<ast::PointerType>()->base
+                        ast::ptr<ast::Type> thisArgType = strict_dynamic_cast<const ast::PointerType *>(assn.first->get_type())->base
                                 .strict_as<ast::FunctionType>()->params[0]
                                 .strict_as<ast::ReferenceType>()->base;
 …
+                }
                 else {
                         candidates = sat.symtab.lookupId(assn.first->var->name);
+                        candidates = sat.symtab.lookupId(assn.first->name);
+                }
                 for ( const ast::SymbolTable::IdData & cdata : candidates ) {
 …
                         ast::TypeEnvironment newEnv{ sat.cand->env };
                         ast::OpenVarSet newOpen{ sat.cand->open };
                         ast::ptr< ast::Type > toType = assn.first->result;
                         ast::ptr< ast::Type > adjType =
                                 renameTyVars( adjustExprType( candidate->get_type(), newEnv, sat.symtab ), GEN_USAGE, false );
+                        ast::ptr< ast::Type > toType = assn.first->get_type();
+                        ast::ptr< ast::Type > adjType =
+                                renameTyVars( adjustExprType( candidate->get_type(), newEnv, sat.symtab ) );
                         // only keep candidates which unify
 …
+                                }
                                 matches.emplace_back(
+                                matches.emplace_back(
                                         cdata, adjType, std::move( newEnv ), std::move( have ), std::move( newNeed ),
                                         std::move( newOpen ), crntResnSlot );
 …
         };
         /// Replace ResnSlots with InferParams and add alternative to output list, if it meets pruning
+        /// Replace ResnSlots with InferParams and add alternative to output list, if it meets pruning
         /// threshold.
         void finalizeAssertions(
                 CandidateRef & cand, InferCache & inferred, PruneMap & thresholds, CostVec && costs,
                 CandidateList & out
+        void finalizeAssertions(
+                CandidateRef & cand, InferCache & inferred, PruneMap & thresholds, CostVec && costs,
+                CandidateList & out
         ) {
                 // prune if cheaper alternative for same key has already been generated
 …
+        }
         /// Combo iterator that combines candidates into an output list, merging their environments.
         /// Rejects an appended candidate if environments cannot be merged. See `Common/FilterCombos.h`
+        /// Combo iterator that combines candidates into an output list, merging their environments.
+        /// Rejects an appended candidate if environments cannot be merged. See `Common/FilterCombos.h`
         /// for description of "combo iterator".
         class CandidateEnvMerger {
 …
                                         // compute conversion cost from satisfying decl to assertion
                                         cost += computeConversionCost(
                                                 assn.match.adjType, assn.expr->result, false, symtab, env );
+                                                assn.match.adjType, assn.decl->get_type(), false, symtab, env );
                                         // mark vars+specialization on function-type assertions
 …
                                         cost.incVar( func->forall.size() );
+                                        cost.decSpec( func->assertions.size() );
+                                        for ( const ast::TypeDecl * td : func->forall ) {
+                                                cost.decSpec( td->assertions.size() );
+                                        }
+                                }
+                        }
 …
         /// Limit to depth of recursion of assertion satisfaction
         static const int recursionLimit = 8;
+        static const int recursionLimit = 4;
         /// Maximum number of simultaneously-deferred assertions to attempt concurrent satisfaction of
         static const int deferLimit = 10;
 } // anonymous namespace
 void satisfyAssertions(
         CandidateRef & cand, const ast::SymbolTable & symtab, CandidateList & out,
+void satisfyAssertions(
+        CandidateRef & cand, const ast::SymbolTable & symtab, CandidateList & out,
         std::vector<std::string> & errors
 ) {
 …
                         if ( it != thresholds.end() && it->second < sat.costs ) goto nextSat;
+                        // should a limit be imposed? worst case here is O(n^2) but very unlikely to happen.
+                        for (unsigned resetCount = 0; ; ++resetCount) {
+                                ast::AssertionList next;
+                                resetTyVarRenaming();
+                                // make initial pass at matching assertions
+                                for ( auto & assn : sat.need ) {
+                                        // fail early if any assertion is not satisfiable
+                                        if ( ! satisfyAssertion( assn, sat ) ) {
+                                                next.emplace_back(assn);
+                                                // goto nextSat;
+                                        }
+                                }
+                                // success
+                                if (next.empty()) break;
+                                // fail if nothing resolves
+                                else if (next.size() == sat.need.size()) {
+                        // make initial pass at matching assertions
+                        for ( auto & assn : sat.need ) {
+                                // fail early if any assertion is not satisfiable
+                                if ( ! satisfyAssertion( assn, sat ) ) {
                                         Indenter tabs{ 3 };
                                         std::ostringstream ss;
 …
                                         print( ss, *sat.cand, ++tabs );
                                         ss << (tabs-1) << "Could not satisfy assertion:\n";
                                         ast::print( ss, next[0].first, tabs );
+                                        ast::print( ss, assn.first, tabs );
                                         errors.emplace_back( ss.str() );
                                         goto nextSat;
+                                }
-                                sat.need = std::move(next);
+                        }
 …
                                 // either add successful match or push back next state
                                 if ( sat.newNeed.empty() ) {
                                         finalizeAssertions(
+                                        finalizeAssertions(
                                                 sat.cand, sat.inferred, thresholds, std::move( sat.costs ), out );
                                 } else {
 …
                                 ss << (tabs-1) << "Too many non-unique satisfying assignments for assertions:\n";
                                 for ( const auto & d : sat.deferred ) {
                                         ast::print( ss, d.expr, tabs );
+                                        ast::print( ss, d.decl, tabs );
+                                }
 …
                                 std::vector< CandidateEnvMerger::OutType > compatible = filterCombos(
                                         sat.deferred, CandidateEnvMerger{ sat.cand->env, sat.cand->open, sat.symtab } );
                                 // fail early if no mutually-compatible assertion satisfaction
                                 if ( compatible.empty() ) {
 …
                                         ss << (tabs-1) << "No mutually-compatible satisfaction for assertions:\n";
                                         for ( const auto& d : sat.deferred ) {
                                                 ast::print( ss, d.expr, tabs );
+                                                ast::print( ss, d.decl, tabs );
+                                        }
 …
                                         // set up next satisfaction state
                                         CandidateRef nextCand = std::make_shared<Candidate>(
                                                 sat.cand->expr, std::move( compat.env ), std::move( compat.open ),
+                                                sat.cand->expr, std::move( compat.env ), std::move( compat.open ),
                                                 ast::AssertionSet{} /* need moved into satisfaction state */,
                                                 sat.cand->cost, sat.cand->cvtCost );
 …
                                         ast::AssertionSet nextNewNeed{ sat.newNeed };
                                         InferCache nextInferred{ sat.inferred };
                                         CostVec nextCosts{ sat.costs };
                                         nextCosts.back() += compat.cost;
                                         ast::SymbolTable nextSymtab{ sat.symtab };
 …
                                                 nextNewNeed.insert( match.need.begin(), match.need.end() );
                                                 bindAssertion( r.expr, r.info, nextCand, match, nextInferred );
+                                                bindAssertion( r.decl, r.info, nextCand, match, nextInferred );
+                                        }
                                         // either add successful match or push back next state
                                         if ( nextNewNeed.empty() ) {
                                                 finalizeAssertions(
+                                                finalizeAssertions(
                                                         nextCand, nextInferred, thresholds, std::move( nextCosts ), out );
                                         } else {
                                                 nextSats.emplace_back(
                                                         std::move( nextCand ), std::move( nextNewNeed ),
                                                         std::move( nextInferred ), std::move( nextCosts ),
+                                                nextSats.emplace_back(
+                                                        std::move( nextCand ), std::move( nextNewNeed ),
+                                                        std::move( nextInferred ), std::move( nextCosts ),
                                                         std::move( nextSymtab ) );
+                                        }
 …
                 nextSats.clear();
+        }
         // exceeded recursion limit if reaches here
         if ( out.empty() ) {

src/ResolvExpr/Unify.cc

-                      r2b4daf2
+                      r42f6e07
                         const ast::Type * postvisit( const ast::TypeInstType * typeInst ) {
                                 if ( const ast::EqvClass * clz = tenv.lookup( *typeInst ) ) {
+                                if ( const ast::EqvClass * clz = tenv.lookup( typeInst->name ) ) {
                                         // expand ttype parameter into its actual type
                                         if ( clz->data.kind == ast::TypeDecl::Ttype && clz->bound ) {
 …
                 /// Creates a tuple type based on a list of DeclWithType
                 template< typename Iter >
                 static const ast::Type * tupleFromTypes( Iter crnt, Iter end ) {
+                static ast::ptr< ast::Type > tupleFromTypes( Iter crnt, Iter end ) {
                         std::vector< ast::ptr< ast::Type > > types;
                         while ( crnt != end ) {
 …
+                        }
                         return new ast::TupleType{ std::move(types) };
+                        return { new ast::TupleType{ std::move(types) } };
+                }
 …
+                }
                 static void markAssertionSet( ast::AssertionSet & assns, const ast::VariableExpr * assn ) {
+                static void markAssertionSet( ast::AssertionSet & assns, const ast::DeclWithType * assn ) {
                         auto i = assns.find( assn );
                         if ( i != assns.end() ) {
 …
                         const ast::FunctionType * type
                 ) {
+                        for ( auto & assert : type->assertions ) {
+                                markAssertionSet( assn1, assert );
+                                markAssertionSet( assn2, assert );
+                        for ( const auto & tyvar : type->forall ) {
+                                for ( const ast::DeclWithType * assert : tyvar->assertions ) {
+                                        markAssertionSet( assn1, assert );
+                                        markAssertionSet( assn2, assert );
+                                }
+                        }
+                }
 …
                 void postvisit( const ast::TypeInstType * typeInst ) {
                         assert( open.find( *typeInst ) == open.end() );
+                        assert( open.find( typeInst->name ) == open.end() );
                         handleRefType( typeInst, type2 );
+                }
 …
         private:
                 /// Creates a tuple type based on a list of Type
                 static const ast::Type * tupleFromTypes(
+                static ast::ptr< ast::Type > tupleFromTypes(
                         const std::vector< ast::ptr< ast::Type > > & tys
                 ) {
 …
                 auto var2 = dynamic_cast< const ast::TypeInstType * >( type2 );
                 ast::OpenVarSet::const_iterator
                         entry1 = var1 ? open.find( *var1 ) : open.end(),
                         entry2 = var2 ? open.find( *var2 ) : open.end();
+                        entry1 = var1 ? open.find( var1->name ) : open.end(),
+                        entry2 = var2 ? open.find( var2->name ) : open.end();
                 bool isopen1 = entry1 != open.end();
                 bool isopen2 = entry2 != open.end();

src/SymTab/Mangler.cc

-                      r2b4daf2
+                      r42f6e07
                                         int dcount = 0, fcount = 0, vcount = 0, acount = 0;
                                         mangleName += Encoding::forall;
                                         for ( auto & decl : ptype->forall ) {
+                                        for ( const ast::TypeDecl * decl : ptype->forall ) {
                                                 switch ( decl->kind ) {
                                                 case ast::TypeDecl::Kind::Dtype:
 …
                                                 } // switch
                                                 varNums[ decl->name ] = std::make_pair( nextVarNum, (int)decl->kind );
                                         } // for
                                         for ( auto & assert : ptype->assertions ) {
                                                 ast::Pass<Mangler_new> sub_mangler(
                                                         mangleOverridable, typeMode, mangleGenericParams, nextVarNum, varNums );
                                                 assert->var->accept( sub_mangler );
                                                 assertionNames.push_back( sub_mangler.core.get_mangleName() );
                                                 acount++;
+                                                for ( const ast::DeclWithType * assert : decl->assertions ) {
+                                                        ast::Pass<Mangler_new> sub_mangler(
+                                                                mangleOverridable, typeMode, mangleGenericParams, nextVarNum, varNums );
+                                                        assert->accept( sub_mangler );
+                                                        assertionNames.push_back( sub_mangler.core.get_mangleName() );
+                                                        acount++;
+                                                } // for
                                         } // for
                                         mangleName += std::to_string( dcount ) + "_" + std::to_string( fcount ) + "_" + std::to_string( vcount ) + "_" + std::to_string( acount ) + "_";

src/SymTab/Validate.cc

-                      r2b4daf2
+                      r42f6e07
         };
         struct InitializerLength {
+        struct ArrayLength : public WithIndexer {
                 /// for array types without an explicit length, compute the length and store it so that it
                 /// is known to the rest of the phases. For example,
 …
                 void previsit( ObjectDecl * objDecl );
-        };
-        struct ArrayLength : public WithIndexer {
-                static void computeLength( std::list< Declaration * > & translationUnit );
                 void previsit( ArrayType * arrayType );
         };
 …
                                         FixObjectType::fix, translationUnit);
+                        }
+                        Stats::Time::TimeCall("Initializer Length",
+                                InitializerLength::computeLength, translationUnit);
+                        if (!useNewAST) {
+                                Stats::Time::TimeCall("Array Length",
+                                        ArrayLength::computeLength, translationUnit);
+                        }
+                        Stats::Time::TimeCall("Array Length",
+                                ArrayLength::computeLength, translationUnit);
                         Stats::Time::TimeCall("Find Special Declarations",
                                 Validate::findSpecialDecls, translationUnit);
 …
+        }
-        void InitializerLength::computeLength( std::list< Declaration * > & translationUnit ) {
-                PassVisitor<InitializerLength> len;
-                acceptAll( translationUnit, len );
+        }
         void ArrayLength::computeLength( std::list< Declaration * > & translationUnit ) {
                 PassVisitor<ArrayLength> len;
 …
+        }
         void InitializerLength::previsit( ObjectDecl * objDecl ) {
+        void ArrayLength::previsit( ObjectDecl * objDecl ) {
                 if ( ArrayType * at = dynamic_cast< ArrayType * >( objDecl->type ) ) {
                         if ( at->dimension ) return;
 …
         void ArrayLength::previsit( ArrayType * type ) {
+                if ( type->dimension ) {
+                        // need to resolve array dimensions early so that constructor code can correctly determine
+                        // if a type is a VLA (and hence whether its elements need to be constructed)
+                        ResolvExpr::findSingleExpression( type->dimension, Validate::SizeType->clone(), indexer );
+                        // must re-evaluate whether a type is a VLA, now that more information is available
+                        // (e.g. the dimension may have been an enumerator, which was unknown prior to this step)
+                        type->isVarLen = ! InitTweak::isConstExpr( type->dimension );
+                if (!useNewAST) {
+                        if ( type->dimension ) {
+                                // need to resolve array dimensions early so that constructor code can correctly determine
+                                // if a type is a VLA (and hence whether its elements need to be constructed)
+                                ResolvExpr::findSingleExpression( type->dimension, Validate::SizeType->clone(), indexer );
+                                // must re-evaluate whether a type is a VLA, now that more information is available
+                                // (e.g. the dimension may have been an enumerator, which was unknown prior to this step)
+                                type->isVarLen = ! InitTweak::isConstExpr( type->dimension );
+                        }
+                }
+        }
 …
+                }
+        }
-        /*
         /// Associates forward declarations of aggregates with their definitions
 …
+                }
         };
-        */
 } // anonymous namespace
-/*
 const ast::Type * validateType(
                 const CodeLocation & loc, const ast::Type * type, const ast::SymbolTable & symtab ) {
 …
         return type->accept( lrt )->accept( fpd );
+}
-*/
 } // namespace SymTab

src/Tuples/TupleAssignment.cc

-                      r2b4daf2
+                      r42f6e07
                         std::vector< ast::ptr< ast::Expr > > match() override {
+                                static UniqueName lhsNamer( "__massassign_L" );
+                                static UniqueName rhsNamer( "__massassign_R" );
+                                // temporary workaround for new and old ast to coexist and avoid name collision
+                                static UniqueName lhsNamer( "__massassign_Ln" );
+                                static UniqueName rhsNamer( "__massassign_Rn" );
                                 // empty tuple case falls into this matcher
                                 assert( lhs.empty() ? rhs.empty() : rhs.size() <= 1 );
 …
                         std::vector< ast::ptr< ast::Expr > > match() override {
+                                static UniqueName lhsNamer( "__multassign_L" );
+                                static UniqueName rhsNamer( "__multassign_R" );
+                                // temporary workaround for new and old ast to coexist and avoid name collision
+                                static UniqueName lhsNamer( "__multassign_Ln" );
+                                static UniqueName rhsNamer( "__multassign_Rn" );
                                 if ( lhs.size() != rhs.size() ) return {};

tests/.expect/KRfunctions.nast.x86.txt

r2b4daf2	r42f6e07
86	86	__attribute__ ((unused)) signed int (*_X11_retval_f11PA0i_1)[];
87	87	}
88		signed int (_X3f12FPA0A0i_iPiPi__1(signed int _X1ai_1, signed int _X1bPi_1, signed int *_X1cPi_1))[][((unsigned int )10)]{
89		__attribute__ ((unused)) signed int (*_X11_retval_f12PA0A0i_1)[][((unsigned int )10)];
	88	signed int (_X3f12FPA0A0i_iPiPi__1(signed int _X1ai_1, signed int _X1bPi_1, signed int *_X1cPi_1))[][((unsigned long int )10)]{
	89	__attribute__ ((unused)) signed int (*_X11_retval_f12PA0A0i_1)[][((unsigned long int )10)];
90	90	}
91		signed int (_X3f13FPA0A0i_iPiPi__1(signed int _X1ai_1, signed int _X1bPi_1, signed int *_X1cPi_1))[][((unsigned int )10)]{
92		__attribute__ ((unused)) signed int (*_X11_retval_f13PA0A0i_1)[][((unsigned int )10)];
	91	signed int (_X3f13FPA0A0i_iPiPi__1(signed int _X1ai_1, signed int _X1bPi_1, signed int *_X1cPi_1))[][((unsigned long int )10)]{
	92	__attribute__ ((unused)) signed int (*_X11_retval_f13PA0A0i_1)[][((unsigned long int )10)];
93	93	}
94		signed int (_X3f14FPA0A0i_iPiPi__1(signed int _X1ai_1, signed int _X1bPi_1, signed int *_X1cPi_1))[][((unsigned int )10)]{
95		__attribute__ ((unused)) signed int (*_X11_retval_f14PA0A0i_1)[][((unsigned int )10)];
	94	signed int (_X3f14FPA0A0i_iPiPi__1(signed int _X1ai_1, signed int _X1bPi_1, signed int *_X1cPi_1))[][((unsigned long int )10)]{
	95	__attribute__ ((unused)) signed int (*_X11_retval_f14PA0A0i_1)[][((unsigned long int )10)];
96	96	}
97	97	signed int _X3f15Fi_iii__1(signed int _X1ai_1, signed int _X1bi_1, signed int _X1ci_1){

tests/.expect/attributes.nast.x86.txt

-                      r2b4daf2
+                      r42f6e07
 __attribute__ ((used,used,used,used)) const signed int *_X3vd3PKi_1;
 __attribute__ ((used,used,unused,used,unused)) const signed int *_X3vd4PKi_1;
 __attribute__ ((used,used,used)) const signed int _X3vd5A0Ki_1[((unsigned int )5)];
 __attribute__ ((used,used,unused,used)) const signed int _X3vd6A0Ki_1[((unsigned int )5)];
+__attribute__ ((used,used,used)) const signed int _X3vd5A0Ki_1[((unsigned long int )5)];
+__attribute__ ((used,used,unused,used)) const signed int _X3vd6A0Ki_1[((unsigned long int )5)];
 __attribute__ ((used,used,used,used)) const signed int (*_X3vd7Fi___1)();
 __attribute__ ((used,used,unused,used,used)) const signed int (*_X3vd8Fi___1)();
 …
     __attribute__ ((unused,unused,used)) signed int _X2t1i_2;
     __attribute__ ((unused,unused,unused,unused,unused)) signed int **_X2t2PPi_2;
     __attribute__ ((unused,unused,unused)) signed int _X2t3A0i_2[((unsigned int )5)];
     __attribute__ ((unused,unused,unused,unused,unused)) signed int **_X2t4A0PPi_2[((unsigned int )5)];
+    __attribute__ ((unused,unused,unused)) signed int _X2t3A0i_2[((unsigned long int )5)];
+    __attribute__ ((unused,unused,unused,unused,unused)) signed int **_X2t4A0PPi_2[((unsigned long int )5)];
     __attribute__ ((unused,unused,unused)) signed int _X2t5Fi___2();
     __attribute__ ((unused,unused,unused,unused)) signed int *_X2t6FPi___2();
 …
 signed int _X4tpr2Fi_PPi__1(__attribute__ ((unused,unused,unused,unused,unused,unused)) signed int **_X3FooPPi_1);
 signed int _X4tpr3Fi_Pi__1(__attribute__ ((unused,unused,unused)) signed int *_X3FooPi_1);
 signed int _X4tpr4Fi_Fi_Pi___1(__attribute__ ((unused,unused)) signed int (*__anonymous_object1)(signed int __param_0[((unsigned int )5)]));
+signed int _X4tpr4Fi_Fi_Pi___1(__attribute__ ((unused,unused)) signed int (*__anonymous_object1)(signed int __param_0[((unsigned long int )5)]));
 signed int _X4tpr5Fi_Fi____1(__attribute__ ((unused,unused,unused)) signed int (*_X3FooFi___1)());
 signed int _X4tpr6Fi_Fi____1(__attribute__ ((unused,unused,unused)) signed int (*_X3FooFi___1)());
 …
     __attribute__ ((used,unused)) signed int _X3ad1i_2;
     __attribute__ ((unused,unused,unused)) signed int *_X3ad2Pi_2;
     __attribute__ ((unused,unused,unused)) signed int _X3ad3A0i_2[((unsigned int )5)];
     __attribute__ ((unused,unused,unused,unused,unused)) signed int (*_X3ad4PA0i_2)[((unsigned int )10)];
+    __attribute__ ((unused,unused,unused)) signed int _X3ad3A0i_2[((unsigned long int )5)];
+    __attribute__ ((unused,unused,unused,unused,unused)) signed int (*_X3ad4PA0i_2)[((unsigned long int )10)];
     __attribute__ ((unused,unused,unused,unused,used)) signed int _X3ad5i_2;
     __attribute__ ((unused,unused,unused,unused,unused)) signed int _X3ad6Fi___2();

tests/.expect/functions.nast.x86.txt

-                      r2b4daf2
+                      r42f6e07
     __attribute__ ((unused)) signed int (*_X11_retval_f10PA0i_1)[];
+}
 signed int (*_X3f11FPA0A0i___1())[][((unsigned int )3)]{
     __attribute__ ((unused)) signed int (*_X11_retval_f11PA0A0i_1)[][((unsigned int )3)];
+}
 signed int (*_X3f12FPA0A0i___1())[][((unsigned int )3)]{
     __attribute__ ((unused)) signed int (*_X11_retval_f12PA0A0i_1)[][((unsigned int )3)];
+signed int (*_X3f11FPA0A0i___1())[][((unsigned long int )3)]{
+    __attribute__ ((unused)) signed int (*_X11_retval_f11PA0A0i_1)[][((unsigned long int )3)];
+}
+signed int (*_X3f12FPA0A0i___1())[][((unsigned long int )3)]{
+    __attribute__ ((unused)) signed int (*_X11_retval_f12PA0A0i_1)[][((unsigned long int )3)];
+}
 signed int _X4fII1Fi_i__1(signed int _X1ii_1){
 …
 signed int _X1fFi_Fi_ii_Fi_i___1(__attribute__ ((unused)) signed int (*__anonymous_object20)(signed int __param_0, signed int __param_1), __attribute__ ((unused)) signed int (*__anonymous_object21)(signed int __param_0)){
     __attribute__ ((unused)) signed int _X9_retval_fi_1;
     signed int (*(*_X2pcPA0A0PA0A0i_2)[][((unsigned int )10)])[][((unsigned int )3)];
     signed int (*(*_X1pPA0A0PA0A0i_2)[][((unsigned int )10)])[][((unsigned int )3)];
+    signed int (*(*_X2pcPA0A0PA0A0i_2)[][((unsigned long int )10)])[][((unsigned long int )3)];
+    signed int (*(*_X1pPA0A0PA0A0i_2)[][((unsigned long int )10)])[][((unsigned long int )3)];
     signed int (*(*_X1pPA0Fi_i__2)[])(signed int __param_0);
+}

tests/Makefile.am

-                      r2b4daf2
+                      r42f6e07
 mostlyclean-local :
-        find ${builddir} -not -path './__pycache__/*' -path '*.o' -delete
-        find ${builddir} -not -path './__pycache__/*' -path '*/.err/*.log' -delete
-        find ${builddir} -not -path './__pycache__/*' -path '*/.out/*.log' -delete
         rm -f ${EXTRA_PROGRAMS}
         rm -rf __pycache__
+        find ${builddir} -path '*.o' -delete
+        find ${builddir} -path '*/.err/*.log' -delete
+        find ${builddir} -path '*/.out/*.log' -delete
 distclean-local :

tests/concurrent/futures/.expect/basic.txt

r2b4daf2	r42f6e07
1		~~start~~
2	1	done

tests/concurrent/futures/basic.cfa

-                      r2b4daf2
+                      r42f6e07
 #include <thread.hfa>
 enum {NFUTURES = 10};
 …
 int main() {
-        printf( "start\n" );                            // non-empty .expect file
         processor procs[2];
+        {

tests/errors/.expect/completeType.nast.x64.txt

-                      r2b4daf2
+                      r42f6e07
       Application of
         Variable Expression: *?: forall
           instance of type DT (not function type)
+          DT: data type
           function
         ... with parameters
 …
         ... with resolved type:
           pointer to forall
             instance of type [unbound] (not function type)
+            [unbound]:data type
             function
           ... with parameters
 …
     void
+  )
   Environment:([unbound]DT) -> instance of struct A without body (no widening)
+  Environment:([unbound]) -> instance of struct A without body (no widening)
 …
       Application of
         Variable Expression: *?: forall
           instance of type DT (not function type)
+          DT: data type
           function
         ... with parameters
 …
         ... with resolved type:
           pointer to forall
             instance of type [unbound] (not function type)
+            [unbound]:data type
             function
           ... with parameters
 …
     void
+  )
   Environment:([unbound]DT) -> instance of struct B with body (no widening)
+  Environment:([unbound]) -> instance of struct B with body (no widening)
 …
 Cost ( 0, 1, 0, 0, 1, -5, 0 ): Application of
             Variable Expression: baz: forall
+              instance of type T (not function type)
+              with assertions
+              Variable Expression: ?=?: pointer to function
+              ... with parameters
+                reference to instance of type T (not function type)
+                instance of type T (not function type)
+              ... returning
+                instance of type T (not function type)
+              ... with resolved type:
+                pointer to function
+              T: sized data type
+              ... with assertions
+                ?=?: pointer to function
                 ... with parameters
                   reference to instance of type T (not function type)
 …
                   instance of type T (not function type)
+              Variable Expression: ?{}: pointer to function
+              ... with parameters
+                reference to instance of type T (not function type)
+              ... returning nothing
+              ... with resolved type:
+                pointer to function
+                ?{}: pointer to function
                 ... with parameters
                   reference to instance of type T (not function type)
                 ... returning nothing
+              Variable Expression: ?{}: pointer to function
+              ... with parameters
+                reference to instance of type T (not function type)
+                instance of type T (not function type)
+              ... returning nothing
+              ... with resolved type:
+                pointer to function
+                ?{}: pointer to function
                 ... with parameters
                   reference to instance of type T (not function type)
 …
                 ... returning nothing
+              Variable Expression: ^?{}: pointer to function
+              ... with parameters
+                reference to instance of type T (not function type)
+              ... returning nothing
+              ... with resolved type:
+                pointer to function
+                ^?{}: pointer to function
                 ... with parameters
                   reference to instance of type T (not function type)
                 ... returning nothing
               function
 …
             ... with resolved type:
               pointer to forall
+                instance of type [unbound] (not function type)
+                with assertions
+                Variable Expression: ?=?: pointer to function
+                ... with parameters
+                  reference to instance of type T (not function type)
+                  instance of type T (not function type)
+                ... returning
+                  instance of type T (not function type)
+                ... with resolved type:
+                  pointer to function
+                [unbound]:sized data type
+                ... with assertions
+                  ?=?: pointer to function
                   ... with parameters
                     reference to instance of type [unbound] (not function type)
 …
                     instance of type [unbound] (not function type)
+                Variable Expression: ?{}: pointer to function
+                ... with parameters
+                  reference to instance of type T (not function type)
+                ... returning nothing
+                ... with resolved type:
+                  pointer to function
+                  ?{}: pointer to function
                   ... with parameters
                     reference to instance of type [unbound] (not function type)
                   ... returning nothing
+                Variable Expression: ?{}: pointer to function
+                ... with parameters
+                  reference to instance of type T (not function type)
+                  instance of type T (not function type)
+                ... returning nothing
+                ... with resolved type:
+                  pointer to function
+                  ?{}: pointer to function
                   ... with parameters
                     reference to instance of type [unbound] (not function type)
 …
                   ... returning nothing
+                Variable Expression: ^?{}: pointer to function
+                ... with parameters
+                  reference to instance of type T (not function type)
+                ... returning nothing
+                ... with resolved type:
+                  pointer to function
+                  ^?{}: pointer to function
                   ... with parameters
                     reference to instance of type [unbound] (not function type)
                   ... returning nothing
                 function
 …
           void
+        )
         Environment:([unbound]T) -> instance of type T (not function type) (no widening)
+        Environment:([unbound]) -> instance of type T (not function type) (no widening)
       Could not satisfy assertion:
 Variable Expression: ?=?: pointer to function
+?=?: pointer to function
         ... with parameters
           reference to instance of type T (not function type)
           instance of type T (not function type)
+          reference to instance of type [unbound] (not function type)
+          instance of type [unbound] (not function type)
         ... returning
           instance of type T (not function type)
+          instance of type [unbound] (not function type)
-        ... with resolved type:
-          pointer to function
-          ... with parameters
-            reference to instance of type [unbound] (not function type)
-            instance of type [unbound] (not function type)
-          ... returning
-            instance of type [unbound] (not function type)

tests/errors/.expect/completeType.nast.x86.txt

-                      r2b4daf2
+                      r42f6e07
       Application of
         Variable Expression: *?: forall
           instance of type DT (not function type)
+          DT: data type
           function
         ... with parameters
 …
         ... with resolved type:
           pointer to forall
             instance of type [unbound] (not function type)
+            [unbound]:data type
             function
           ... with parameters
 …
     void
+  )
   Environment:([unbound]DT) -> instance of struct A without body (no widening)
+  Environment:([unbound]) -> instance of struct A without body (no widening)
 …
       Application of
         Variable Expression: *?: forall
           instance of type DT (not function type)
+          DT: data type
           function
         ... with parameters
 …
         ... with resolved type:
           pointer to forall
             instance of type [unbound] (not function type)
+            [unbound]:data type
             function
           ... with parameters
 …
     void
+  )
   Environment:([unbound]DT) -> instance of struct B with body (no widening)
+  Environment:([unbound]) -> instance of struct B with body (no widening)
 …
 Cost ( 0, 1, 0, 0, 1, -5, 0 ): Application of
             Variable Expression: baz: forall
+              instance of type T (not function type)
+              with assertions
+              Variable Expression: ?=?: pointer to function
+              ... with parameters
+                reference to instance of type T (not function type)
+                instance of type T (not function type)
+              ... returning
+                instance of type T (not function type)
+              ... with resolved type:
+                pointer to function
+              T: sized data type
+              ... with assertions
+                ?=?: pointer to function
                 ... with parameters
                   reference to instance of type T (not function type)
 …
                   instance of type T (not function type)
+              Variable Expression: ?{}: pointer to function
+              ... with parameters
+                reference to instance of type T (not function type)
+              ... returning nothing
+              ... with resolved type:
+                pointer to function
+                ?{}: pointer to function
                 ... with parameters
                   reference to instance of type T (not function type)
                 ... returning nothing
+              Variable Expression: ?{}: pointer to function
+              ... with parameters
+                reference to instance of type T (not function type)
+                instance of type T (not function type)
+              ... returning nothing
+              ... with resolved type:
+                pointer to function
+                ?{}: pointer to function
                 ... with parameters
                   reference to instance of type T (not function type)
 …
                 ... returning nothing
+              Variable Expression: ^?{}: pointer to function
+              ... with parameters
+                reference to instance of type T (not function type)
+              ... returning nothing
+              ... with resolved type:
+                pointer to function
+                ^?{}: pointer to function
                 ... with parameters
                   reference to instance of type T (not function type)
                 ... returning nothing
               function
 …
             ... with resolved type:
               pointer to forall
+                instance of type [unbound] (not function type)
+                with assertions
+                Variable Expression: ?=?: pointer to function
+                ... with parameters
+                  reference to instance of type T (not function type)
+                  instance of type T (not function type)
+                ... returning
+                  instance of type T (not function type)
+                ... with resolved type:
+                  pointer to function
+                [unbound]:sized data type
+                ... with assertions
+                  ?=?: pointer to function
                   ... with parameters
                     reference to instance of type [unbound] (not function type)
 …
                     instance of type [unbound] (not function type)
+                Variable Expression: ?{}: pointer to function
+                ... with parameters
+                  reference to instance of type T (not function type)
+                ... returning nothing
+                ... with resolved type:
+                  pointer to function
+                  ?{}: pointer to function
                   ... with parameters
                     reference to instance of type [unbound] (not function type)
                   ... returning nothing
+                Variable Expression: ?{}: pointer to function
+                ... with parameters
+                  reference to instance of type T (not function type)
+                  instance of type T (not function type)
+                ... returning nothing
+                ... with resolved type:
+                  pointer to function
+                  ?{}: pointer to function
                   ... with parameters
                     reference to instance of type [unbound] (not function type)
 …
                   ... returning nothing
+                Variable Expression: ^?{}: pointer to function
+                ... with parameters
+                  reference to instance of type T (not function type)
+                ... returning nothing
+                ... with resolved type:
+                  pointer to function
+                  ^?{}: pointer to function
                   ... with parameters
                     reference to instance of type [unbound] (not function type)
                   ... returning nothing
                 function
 …
           void
+        )
         Environment:([unbound]T) -> instance of type T (not function type) (no widening)
+        Environment:([unbound]) -> instance of type T (not function type) (no widening)
       Could not satisfy assertion:
 Variable Expression: ?=?: pointer to function
+?=?: pointer to function
         ... with parameters
           reference to instance of type T (not function type)
           instance of type T (not function type)
+          reference to instance of type [unbound] (not function type)
+          instance of type [unbound] (not function type)
         ... returning
           instance of type T (not function type)
+          instance of type [unbound] (not function type)
-        ... with resolved type:
-          pointer to function
-          ... with parameters
-            reference to instance of type [unbound] (not function type)
-            instance of type [unbound] (not function type)
-          ... returning
-            instance of type [unbound] (not function type)

tests/raii/.expect/ctor-autogen-ERR1.nast.txt

r2b4daf2	r42f6e07
70	70	... with environment:
71	71	Types:
	72	Non-types:
72	73
73	74

Context Navigation

Changes in / [2b4daf2:42f6e07]

Legend:

Download in other formats: