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

Jenkins/FullBuild

-                      r42f6e07
+                      r2b4daf2
                         stage('Package') {
                                 build job: 'Cforall_Distribute_Ref', parameters: [string(name: 'GitRef', value: commitId), string(name: 'Build', value: currentBuild.number.toString())]
+                                trigger_dist( commitId, 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

-                      r42f6e07
+                      r2b4daf2
 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 ) {
+        StageName = name
+        echo " -------- ${StageName} -------- "
+        echo " -------- ${name} -------- "
         if(run) {
                 stage(name, block)

Jenkinsfile

-                      r42f6e07
+                      r2b4daf2
         //attach the build log to the email
         catch (Exception caughtError) {
+                //rethrow error later
+                // Store the result of the build log
+                currentBuild.result = "FAILURE"
+                // 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()
-                //An error has occured, the build log is relevent
-                log_needed = true
-                //Store the result of the build log
-                currentBuild.result = "${tools.StageName} FAILURE".trim()
+        }

benchmark/Makefile.am

-                      r42f6e07
+                      r2b4daf2
 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

r42f6e07	r2b4daf2
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

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

benchmark/readyQ/bench.go

-                      r42f6e07
+                      r2b4daf2
         "flag"
         "fmt"
+        "log"
         "os"
         "runtime"
+        "runtime/pprof"
         "sync/atomic"
         "time"
 …
+}
 func bench_init() {
+func bench_init() func() {
         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

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

benchmark/readyQ/cycle.rs

-                      r42f6e07
+                      r2b4daf2
-#[cfg(any(
-        feature = "sync time rt-threaded",
-  ))]
-extern crate tokio;
-use std::io::{self, Write};
 use std::sync::Arc;
 use std::sync::atomic::{AtomicU64, AtomicBool,Ordering};
 use std::time::{Instant,Duration};
+use std::sync::atomic::Ordering;
+use std::time::Instant;
 use tokio::runtime::Builder;
 use tokio::sync;
-use tokio::time;
+extern crate isatty;
+use isatty::stdout_isatty;
+extern crate num_format;
+use clap::{Arg, App};
 use num_format::{Locale, ToFormattedString};
+extern crate clap;
 use clap::{Arg, App};
+#[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(result: sync::oneshot::Sender<u64>, idx: usize, others: Arc<Vec<Arc<Partner>>> ) {
+async fn partner_main(idx: usize, others: Arc<Vec<Arc<Partner>>>, exp: Arc<bench::BenchData> ) -> u64 {
         let this = &others[idx];
         let mut count:u64 = 0;
 …
                 count += 1;
                 if  *CLOCK_MODE && STOP.load(Ordering::Relaxed) { break; }
                 if !*CLOCK_MODE && count >= *STOP_COUNT { break; }
+                if  exp.clock_mode && exp.stop.load(Ordering::Relaxed) { break; }
+                if !exp.clock_mode && count >= exp.stop_count { break; }
+        }
         THREADS_LEFT.fetch_sub(1, Ordering::SeqCst);
         result.send( count ).unwrap();
+        exp.threads_left.fetch_sub(1, Ordering::SeqCst);
+        count
+}
+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")
+                .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"))
+                .args(&bench::args())
                 .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();
+        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 tthreads = nthreads * ring_size;
+        let exp = Arc::new(bench::BenchData::new(options, tthreads));
         let s = (1000000 as u64).to_formatted_string(&Locale::en);
         assert_eq!(&s, "1,000,000");
+        let tthreads = nthreads * ring_size;
+        THREADS_LEFT.store(tthreads as u64, Ordering::SeqCst);
+        let thddata = Arc::new(prep(nthreads, tthreads));
+        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 mut global_counter :u64 = 0;
 …
         runtime.block_on(async {
+                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 threads: Vec<_> = (0..tthreads).map(|i| {
+                        tokio::spawn(partner_main(i, thddata.clone(), exp.clone()))
+                }).collect();
+                println!("Starting");
+                        let is_tty = stdout_isatty();
+                        let start = Instant::now();
+                let start = Instant::now();
                         for i in 0..nthreads {
                                 thddata[i].sem.add_permits(1);
+                        }
+                for i in 0..nthreads {
+                        thddata[i].sem.add_permits(1);
+                }
                         wait(&start, is_tty).await;
+                duration = exp.wait(&start).await;
+                        STOP.store(true, Ordering::SeqCst);
+                        duration = start.elapsed();
+                println!("\nDone");
+                        println!("\nDone");
+                for i in 0..tthreads {
+                        thddata[i].sem.add_permits(1);
+                }
+                        for i in 0..tthreads {
+                                thddata[i].sem.add_permits(1);
+                        }
+                        for _ in 0..tthreads {
+                                global_counter += result.pop().unwrap().await.unwrap();
+                        }
+                for t in threads {
+                        global_counter += t.await.unwrap();
+                }
         });

benchmark/readyQ/locality.go

-                      r42f6e07
+                      r2b4daf2
 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"
+)
+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 local(result chan uint64, start chan struct{}, stop chan struct{}, size uint64, cnt uint64, channels []chan [] uint64, chan_cnt uint64, share bool) {
+// ==================================================
+type MyData struct {
+        _p1 [16]uint64 // padding
+        ttid int
+        id int
+        data [] uint64
+        _p2 [16]uint64 // padding
+}
+func NewData(id int, size uint64) (*MyData) {
         var data [] uint64
         data = make([]uint64, size)
 …
                 data[i] = 0
+        }
+        count := uint64(0)
+        return &MyData{[16]uint64{0}, syscall.Gettid(), id, data,[16]uint64{0}}
+}
+func (this * MyData) moved( ttid int ) (uint64) {
+        if this.ttid == ttid {
+                return 0
+        }
+        this.ttid = ttid
+        return 1
+}
+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 {
                 for i := uint64(0); i < cnt; i++ {
                         data[rand.Uint64() % size] += 1
+                }
                 i := rand.Uint64() % chan_cnt
+                // 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
+                closed, data = handshake(stop, channels[i], data, share)
+                count += 1
+                if  closed { break }
+                if !clock_mode && count >= stop_count { break }
+        }
+                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);
+        result <- count
+}
+        // return result
+        result <- r
+}
+// ==================================================
+// Program main
 func main() {
+        work_sizeOpt := flag.Uint64("w", 2    , "Number of words (uint64) per threads")
+        countOpt     := flag.Uint64("c", 2    , "Number of words (uint64) to touch")
+        // 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)")
         shareOpt     := flag.Bool  ("s", false, "Pass the work data to the next thread when blocking")
+        bench_init()
+        // General benchmark initialization and deinitialization
+        defer 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")
 …
+        }
         barrierStart := make(chan struct{})
         barrierStop  := make(chan struct{})
         threads_left = int64(nthreads)
         result  := make(chan uint64)
         channels := make([]chan [] uint64, nthreads - nprocs)
+        // 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
         for i := range channels {
+                channels[i] = make(chan [] uint64, 1)
+        }
+                channels[i] = Spot{[16]uint64{0},uintptr(0), i,[16]uint64{0}}     // init spots
+        }
+        // start the goroutines
         for i := 0; i < nthreads; i++ {
                 go local(result, barrierStart, barrierStop, size, cnt, channels, uint64(nthreads - nprocs), share)
+                go local(result, barrierStart, size, cnt, channels, share, i)
+        }
         fmt.Printf("Starting\n");
+        atomic.StoreInt32(&stop, 0)
         start := time.Now()
         close(barrierStart)
         wait(start, true);
         close(barrierStop)
+        close(barrierStart) // release barrier
+        wait(start, true);  // general benchmark wait
+        atomic.StoreInt32(&stop, 1)
         end := time.Now()
         delta := end.Sub(start)
 …
         fmt.Printf("\nDone\n")
+        global_counter := uint64(0)
+        // release all the blocked threads
+        for i := range channels {
+                channels[i].release()
+        }
+        // Join and accumulate results
+        results := NewResult()
         for i := 0; i < nthreads; i++ {
+                global_counter += <- result
+        }
+                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 (ms)          : %f\n", delta.Seconds());
+        p.Printf("Duration (s)           : %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", 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)))
+}
+        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)))
+}

benchmark/readyQ/rq_bench.hfa

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

benchmark/readyQ/rq_bench.hpp

-                      r42f6e07
+                      r2b4daf2
+}
+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(int i = 0; i < opt_count; i++) {
+                for(size_t i = 0; i < opt_count; i++) {
                         if(options[i].long_name) {
                                 optarr[idx].name = options[i].long_name;
 …
+        {
                 int idx = 0;
                 for(int i = 0; i < opt_count; i++) {
+                for(size_t 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(int i = 0; i < opt_count; i++) {
+                                for(size_t 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(int i = 0; i < opt_count; i++) {
+                for(size_t 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(int i = 0; i < opt_count; i++) {
+        for(size_t i = 0; i < opt_count; i++) {
                 printopt(out, width, max_width, options[i].short_name, options[i].long_name, options[i].help);
+        }

configure.ac

-                      r42f6e07
+                      r2b4daf2
 # 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

-                      r42f6e07
+                      r2b4daf2
         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

r42f6e07	r2b4daf2
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}
9	10	\newacronym{raii}{RAII}{Resource Acquisition Is Initialization}
10	11	\newacronym{tls}{TLS}{Thread Local Storage}

doc/theses/thierry_delisle_PhD/thesis/local.bib

-                      r42f6e07
+                      r2b4daf2
   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

-                      r42f6e07
+                      r2b4daf2
 \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 but the system has the ressources necessary to accomplish the work. In short, the system is neither overloaded or 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 the system has the ressources necessary to accomplish the work, \eg, enough workers. In short, the system is neither overloaded nor 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. Flaws in the scheduling in the steady state tend 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, \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.
 \section{Design Goals}
 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.
+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.
 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 2 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 two 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 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.
+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.
+\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}.
+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}
 \section{Design}
+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
+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.
+\subsection{Sharding}
+\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.
 \begin{figure}
 …
 \subsection{Finding threads}
+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.
+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.
 …
 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.
+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:
+\paragraph{Dense Information}
+\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}

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

r42f6e07	r2b4daf2
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

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

libcfa/src/bits/collection.hfa

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

libcfa/src/bits/containers.hfa

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

libcfa/src/bits/defs.hfa

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

libcfa/src/bits/locks.hfa

-                      r42f6e07
+                      r2b4daf2
                 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
+                void abandon( future_t & this ) {
+                bool abandon( future_t & this ) {
+                        /* paranoid */ verify( this.ptr != 3p );
+                        // Mark the future as abandonned
                         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();
+                        }
+                        return;
+                                got = 1p;
+                        }
+                        // The future is completed delete it now
+                        /* paranoid */ verify( this.ptr != 1p );
+                        free( &this );
+                        return true;
+                }

libcfa/src/bits/queue.hfa

-                      r42f6e07
+                      r2b4daf2
 #include "bits/collection.hfa"
+forall( dtype T ) {
+// 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 * ); } ) {
         struct Queue {
                 inline Collection;                                                              // Plan 9 inheritance
 …
                 } // post: n == tail() & succ(n) == 0 | n != tail() & *succ(n) in *q
                 void addHead( Queue(T) & q, T & n ) with( q ) {
+                T & 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;
+                }
                 void addTail( Queue(T) & q, T & n ) with( q ) {
+                T & 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;
+                }
                 void add( Queue(T) & q, T & n ) with( q ) {
                         addTail( q, n );
+                T & add( Queue(T) & q, T & n ) with( q ) {
+                        return addTail( q, n );
+                }
 …
                         T & t = head( q );
                         if ( root ) {
                                 root = Next( root );
+                                root = Next( (T *)root );
                                 if ( &head( q ) == &t ) {
                                         root = last = 0p;                                       // only one element
 …
+                }
                 void remove( Queue(T) & q, T & n ) with( q ) {  // O(n)
+                T & 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 ) {
+forall( dtype T | { T *& Next ( 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

-                      r42f6e07
+                      r2b4daf2
 #include "bits/collection.hfa"
+#include "bits/defs.hfa"
 struct Seqable {
         inline Colable;
         Seqable * back;                                                                         // pointer to previous node in the list
+        __cfa_anonymous_object(Colable);
+        struct Seqable * back;                                                                          // pointer to previous node in the list
 };
+inline {
+#ifdef __cforall
+static 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
+forall( dtype T ) {
+// 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 * ); } ) {
         struct Sequence {
                 inline Collection;                                                              // Plan 9 inheritance
         };
         inline {
+        static 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 there isn't one.
+                // Return a pointer to the element before *n, or 0p if list empty.
                 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 == 0.
                 void 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 == 0p.
+                T & 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.
                 void insertAft( Sequence(T) & s, T & aft, T & n ) with( s ) {   // pre: !n->listed() & *aft in *s
+                T & 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
+                }         // post: n->listed() & *n in *s & succ(n) == bef
+                        return n;
+                } // post: n->listed() & *n in *s & succ(n) == bef
                 // pre: n->listed() & *n in *s
                 void remove( Sequence(T) & s, T & n ) with( s ) { // O(1)
+                T & 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;
+                }                                                       // post: !n->listed().
+                        return n;
+                } // post: !n->listed()
                 // Add an element to the head of the sequence.
+                void addHead( Sequence(T) & s, T & n ) {                // pre: !n->listed(); post: n->listed() & head() == n
+                        insertAft( s, *0p, n );
+                }
+                T & addHead( Sequence(T) & s, T & n ) {                 // pre: !n->listed(); post: n->listed() & head() == n
+                        return insertAft( s, *0p, n );
+                }
                 // Add an element to the tail of the sequence.
+                void addTail( Sequence(T) & s, T & n ) {                // pre: !n->listed(); post: n->listed() & head() == n
+                        insertBef( s, n, *0p );
+                }
+                T & addTail( Sequence(T) & s, T & n ) {                 // pre: !n->listed(); post: n->listed() & head() == n
+                        return insertBef( s, n, *0p );
+                }
                 // Add an element to the tail of the sequence.
+                void add( Sequence(T) & s, T & n ) {                    // pre: !n->listed(); post: n->listed() & head() == n
+                        addTail( s, n );
+                }
+                T & add( Sequence(T) & s, T & n ) {                             // pre: !n->listed(); post: n->listed() & head() == n
+                        return 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( root ) = fromEnd;
+                                Back( (T *)root ) = fromEnd;
                                 Next( fromEnd ) = &head( s );
                                 Back( from.root ) = toEnd;
+                                Back( (T *)from.root ) = toEnd;
                                 Next( toEnd ) = &head( from );
                         } // if
 …
 } // distribution
 forall( dtype T ) {
+forall( dtype T | { T *& Back ( T * ); T *& Next ( T * ); } ) {
         // SeqIter(T) is used to iterate over a Sequence(T) in head-to-tail order.
         struct SeqIter {
 …
         };
         inline {
+        static inline {
                 void ?{}( SeqIter(T) & si ) with( si ) {
                         ((ColIter &)si){};
                         seq = 0p;
+                } // post: elts = null.
+                } // post: elts = null
+                // Create a iterator active in sequence s.
                 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.
+                } // post: elts = null
+                // Make the iterator active in sequence s.
                 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 );
 …
         };
         inline {
+        static inline {
                 void ?{}( SeqIterRev(T) & si ) with( si ) {
                         ((ColIter &)si){};
                         seq = 0p;
+                } // post: elts = null.
+                } // post: elts = null
+                // Create a iterator active in sequence s.
                 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.
+                } // post: elts = null
+                // Make the iterator active in sequence s.
                 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

-                      r42f6e07
+                      r2b4daf2
 #include "bits/collection.hfa"
+forall( dtype T ) {
+// 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 * ); } ) {
         struct Stack {
                 inline Collection;                                                              // Plan 9 inheritance
 …
+                }
                 void addHead( Stack(T) & s, T & n ) with( s ) {
+                T & 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;
+                }
                 void add( Stack(T) & s, T & n ) with( s ) {
                         addHead( s, n );
+                T & add( Stack(T) & s, T & n ) with( s ) {
+                        return addHead( s, n );
+                }
                 void push( Stack(T) & s, T & n ) with( s ) {
                         addHead( s, n );
+                T & push( Stack(T) & s, T & n ) with( s ) {
+                        return addHead( s, n );
+                }
 …
                         T & t = head( s );
                         if ( root ) {
                                 root = ( T *)Next( root );
+                                root = ( T *)Next( (T *)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 ) {
+forall( dtype T | { T *& Next ( 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 q
+                // make existing iterator active in stack s
                 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

-                      r42f6e07
+                      r2b4daf2
                 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

-                      r42f6e07
+                      r2b4daf2
 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

-                      r42f6e07
+                      r2b4daf2
 #include "locks.hfa"
 #include "kernel_private.hfa"
-#include <stdlib.h>
-#include <stdio.h>
 #include <kernel.hfa>
 #include <stdlib.hfa>
+#include <thread.hfa>
+///////////////////////////////////////////////////////////////////
+//// info_thread
+///////////////////////////////////////////////////////////////////
+//-----------------------------------------------------------------------------
+// info_thread
 forall(dtype L | is_blocking_lock(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 ) {
+        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 ) {
                 ((Seqable &) this){};
                 this.t = t;
                 this.info = info;
+                this.lock = 0p;
+                this.listed = false;
+        }
+        void ^?{}( info_thread(L) & this ){ }
+}
+///////////////////////////////////////////////////////////////////
+//// Blocking Locks
+///////////////////////////////////////////////////////////////////
+                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
 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 );
+        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() );
+        $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 );
                 wait_count++;
                 unlock( lock );
                 park( );
+        } else if ( owner == active_thread() && multi_acquisition ) {
+        }
+        // multi acquisition lock is held by current thread
+        else if ( owner == thrd && multi_acquisition ) {
                 recursion_count++;
                 unlock( lock );
+        } else {
+                owner = active_thread();
+        }
+        // lock isn't held
+        else {
+                owner = thrd;
                 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;
+        } else if ( owner == active_thread() && multi_acquisition ) {
+        }
+        // multi acquisition lock is held by current thread
+        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 = pop_head( blocked_threads );
+        $thread * t = &dropHead( blocked_threads );
         owner = t;
         recursion_count = ( t ? 1 : 0 );
 …
 void unlock( blocking_lock & this ) with( this ) {
         lock( lock __cfaabi_dbg_ctx2 );
+        unlock_error_check( this );
+        /* 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
         recursion_count--;
         if ( recursion_count == 0 ) {
 …
+}
+void add_( blocking_lock & this, $thread * t ) with( this ) {
+    lock( lock __cfaabi_dbg_ctx2 );
+void on_notify( blocking_lock & this, $thread * t ) with( this ) {
+        lock( lock __cfaabi_dbg_ctx2 );
+        // lock held
         if ( owner != 0p ) {
                 append( blocked_threads, t );
+                addTail( blocked_threads, *t );
                 wait_count++;
                 unlock( lock );
+        } else {
+        }
+        // lock not held
+        else {
                 owner = t;
                 recursion_count = 1;
 …
+}
+void remove_( blocking_lock & this ) with( this ) {
+    lock( lock __cfaabi_dbg_ctx2 );
+        unlock_error_check( this );
+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 );
         pop_and_set_new_owner( this );
         unlock( lock );
+}
+///////////////////////////////////////////////////////////////////
+//// 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 ); }
+//-----------------------------------------------------------------------------
+// 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 ); }
 size_t get_recursion_count( multiple_acquisition_lock & this ){ return get_recursion_count( (blocking_lock &)this ); }
+///////////////////////////////////////////////////////////////////
+//// condition variable
+///////////////////////////////////////////////////////////////////
+//-----------------------------------------------------------------------------
+// alarm node wrapper
 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 );
+            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)
+                // 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 );
                         cond->count--;
+                        if( !i->lock ) {
+                        if( i->lock ) {
+                                // call lock's on_notify if a lock was passed
+                                on_notify(*i->lock, i->t);
+                        } else {
+                                // otherwise wake thread
                                 unpark( i->t );
+                } else {
+                        add_(*i->lock, i->t);                   // call lock's add_
+                }
+            }
+            unlock( cond->lock );
+        }
+                        }
+                }
+                unlock( cond->lock );
+        }
+        // this casts the alarm node to our wrapped type since we used type erasure
         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.listed = false;
+                        popped.signalled = true;
                         count--;
                         if (popped.lock) {
+                                add_(*popped.lock, popped.t);
+                                // if lock passed call on_notify
+                                on_notify(*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) {
                         i->t->link.next = 1p;
+                        // if lock was passed get recursion count to reset to after waking thread
                         recursion_count = get_recursion_count(*i->lock);
                         remove_( *i->lock );
+                        on_wait( *i->lock );
+                }
                 return recursion_count;
 …
                 size_t recursion_count = queue_and_get_recursion(this, &i);
                 unlock( lock );
+                park( ); // blocks here
+                if (i.lock) set_recursion_count(*i.lock, recursion_count); // resets recursion count here after waking
+        }
+                // 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 );
         // 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 };
+                node_wrap.cond = &this;
+                node_wrap.i = &info;
+                alarm_node_wrap(L) node_wrap = { t, 0`s, alarm_node_wrap_cast, &this, &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);
+        }
+        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 );
+        }
+}
+        #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 ) }
+}

libcfa/src/concurrency/locks.hfa

-                      r42f6e07
+                      r2b4daf2
 #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 * );
+trait is_blocking_lock(dtype L | sized(L)) {
+        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;
+        // 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 );
 };
+///////////////////////////////////////////////////////////////////
+//// info_thread
+///////////////////////////////////////////////////////////////////
+//-----------------------------------------------------------------------------
+// info_thread
+// the info thread is a wrapper around a thread used
+// to store extra data for use in the condition variable
+forall(dtype L | is_blocking_lock(L)) {
+        struct info_thread;
+forall(dtype L | is_blocking_lock(L)) {
+        struct info_thread {
+                inline Seqable;
+                struct $thread * t;
+                uintptr_t info;
+                L * lock;
+                bool listed;                                    // true if info_thread is on queue, false otherwise;
+        };
+        void ?{}( info_thread(L) & this, $thread * t );
+        void ?{}( info_thread(L) & this, $thread * t, uintptr_t info );
+        void ^?{}( info_thread(L) & this );
+        // for use by sequence
+        info_thread(L) *& Back( info_thread(L) * this );
+        info_thread(L) *& Next( info_thread(L) * this );
+}
+///////////////////////////////////////////////////////////////////
+//// 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 & );
+//-----------------------------------------------------------------------------
+// Blocking Locks
 struct blocking_lock {
         // Spin lock used for mutual exclusion
 …
         // List of blocked threads
         __queue_t( $thread ) blocked_threads;
+        Sequence( $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 add_( blocking_lock & this, struct $thread * t );
 void remove_( blocking_lock & this );
+void on_notify( blocking_lock & this, struct $thread * t );
+void on_wait( 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 add_( single_acquisition_lock & this, struct $thread * t );
 void remove_( single_acquisition_lock & this );
+void on_notify( single_acquisition_lock & this, struct $thread * t );
+void on_wait( 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 add_( owner_lock & this, struct $thread * t );
 void remove_( owner_lock & this );
+void on_notify( owner_lock & this, struct $thread * t );
+void on_wait( 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 add_( multiple_acquisition_lock & this, struct $thread * t );
 void remove_( multiple_acquisition_lock & this );
+void on_notify( multiple_acquisition_lock & this, struct $thread * t );
+void on_wait( 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 );
         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 );
+        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, L & l );
         void wait( condition_variable(L) & this, L & l, uintptr_t info );
         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 );
+        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 );
+}

libcfa/src/concurrency/monitor.hfa

-                      r42f6e07
+                      r2b4daf2
               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 is_empty    ( condition & this ) { return this.blocked.head == 1p; }
+static inline bool signal_all  ( condition & this ) { bool ret = false; while(!is_empty(this)) { ret = signal(this) || ret; } return ret; }
          uintptr_t front       ( condition & this );

libcfa/src/concurrency/thread.cfa

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

libcfa/src/heap.cfa

-                      r42f6e07
+                      r2b4daf2
 // Created On       : Tue Dec 19 21:58:35 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Dec 15 21:37:54 2020
 // Update Count     : 1013
+// Last Modified On : Wed Dec 16 12:28:25 2020
+// Update Count     : 1023
 //
 …
         header = headerAddr( addr );
   if ( unlikely( heapEnd < addr ) ) {                                   // mmapped ?
+  if ( unlikely( addr < heapBegin || heapEnd < addr ) ) { // mmapped ?
                 fakeHeader( header, alignment );
                 size = header->kind.real.blockSize & -3;                // mmap size
 …
         #ifdef __CFA_DEBUG__
         checkHeader( addr < heapBegin, name, addr );            // bad low address ?
+        checkHeader( header < (HeapManager.Storage.Header *)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, '\hde', increase );
+                memset( (char *)heapEnd + heapRemaining, '\xde', 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, '\hde', tsize );
+                memset( block, '\xde', 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, '\hde', freeElem->blockSize - sizeof( HeapManager.Storage ) );
+                memset( ((HeapManager.Storage *)header)->data, '\xde', 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

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

libcfa/src/parseargs.cfa

-                      r42f6e07
+                      r2b4daf2
                                         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

-                      r42f6e07
+                      r2b4daf2
 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_settrue (const char *, bool & );
+bool parse_setfalse(const char *, bool & );
+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(const char *, const char * & );

libcfa/src/stdlib.hfa

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

longrun_tests/Makefile.am

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

src/AST/Convert.cpp

-                      r42f6e07
+                      r2b4daf2
                 ftype->parameters = get<DeclarationWithType>().acceptL(node->params);
+                ftype->forall = get<TypeDecl>().acceptL( node->type->forall );
+                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);
+                }
                 visitType(node->type, ftype);
 …
                 for (decltype(src->begin()) src_i = src->begin(); src_i != src->end(); src_i++) {
                         rslt->add( src_i->first,
+                        rslt->add( src_i->first.typeString(),
                                    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 );
+                ty->forall = get<TypeDecl>().acceptL( node->forall );
+                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);
+                        }
+                }
                 return visitType( node, ty );
+        }
 …
                         ty = new TypeInstType{
                                 cv( node ),
                                 node->name,
+                                node->typeString(),
                                 get<TypeDecl>().accept1( node->base ),
                                 get<Attribute>().acceptL( node->attributes )
 …
                         ty = new TypeInstType{
                                 cv( node ),
                                 node->name,
+                                node->typeString(),
                                 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::ptr<ast::Node> > cache = {};
+        std::unordered_map< const BaseSyntaxNode *, ast::readonly<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());
+                }
+                ty->forall = GET_ACCEPT_V( forall, TypeDecl );
+                // 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));
+                        }
+                }
                 visitType( old, ty );
+        }

src/AST/Decl.cpp

-                      r42f6e07
+                      r2b4daf2
 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)),
+          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;
+          }
+        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;
+}

src/AST/Decl.hpp

-                      r42f6e07
+                      r2b4daf2
         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

-                      r42f6e07
+                      r2b4daf2
         assert( aggregate->result );
+        // 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());
+        result = mem->get_type();
         // substitute aggregate generic parameters into member type

src/AST/Node.hpp

-                      r42f6e07
+                      r2b4daf2
         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 * () const & { _check(); return node; }
+        operator const node_t * () && = delete;
         const node_t * release() {

src/AST/Pass.hpp

-                      r42f6e07
+                      r2b4daf2
 #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

-                      r42f6e07
+                      r2b4daf2
+        }
-        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 are now directly here
+                                // parameter declarations
                                 maybe_accept( node, &FunctionDecl::params );
                                 maybe_accept( node, &FunctionDecl::returns );
+                                // foralls are still in function type
+                                maybe_accept( node, &FunctionDecl::type );
+                                // type params and assertions
+                                maybe_accept( node, &FunctionDecl::type_params );
+                                maybe_accept( node, &FunctionDecl::assertions );
                                 // First remember that we are now within a function.
                                 ValueGuard< bool > oldInFunction( inFunction );
 …
         VISIT({
+                guard_forall_subs forall_guard { *this, node };
+                mutate_forall( node );
+                // guard_forall_subs forall_guard { *this, node };
+                // mutate_forall( node );
+                maybe_accept( node, &FunctionType::assertions );
                 maybe_accept( node, &FunctionType::returns );
                 maybe_accept( node, &FunctionType::params  );
 …
+                {
                         bool mutated = false;
                         std::unordered_map< std::string, ast::ptr< ast::Type > > new_map;
+                        std::unordered_map< ast::TypeInstType::TypeEnvKey, 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

-                      r42f6e07
+                      r2b4daf2
                 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

-                      r42f6e07
+                      r2b4daf2
+        }
+        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() ) {
+                        if( deterministic_output && isUnboundType(node->name) ) os << "[unbound]:";
+                        else os << node->name << ": ";
+                        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->name;
+                const auto & _name = deterministic_output && isUnboundType(node) ? "[unbound]" : node->typeString();
                 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 << " -> ";
+                        os << indent+1 << i.first.typeString() << " -> ";
                         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

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

src/AST/Type.cpp

-                      r42f6e07
+                      r2b4daf2
 #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 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 typeInst->formal_usage > 0;
+        }
         return false;

src/AST/Type.hpp

-                      r42f6e07
+                      r2b4daf2
 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 {
+        protected:
+        /// initializes forall with substitutor
+        void initWithSub( const FunctionType & o, Pass< ForallSubstitutor > & sub );
+public:
+        using ForallList = std::vector<ptr<TypeDecl>>;
+public:
+        using ForallList = std::vector<ptr<TypeInstType>>;
+        using AssertionList = std::vector<ptr<VariableExpr>>;
         ForallList forall;
+        AssertionList assertions;
         std::vector<ptr<Type>> returns;
 …
         : Type(q), returns(), params(), isVarArgs(va) {}
         FunctionType( const FunctionType & o );
+        FunctionType( const FunctionType & o ) = default;
         /// 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);
+bool isUnboundType(const std::string & tname);
+}
+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;
+                }
+        };
+}

src/AST/TypeEnvironment.cpp

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

src/AST/TypeEnvironment.hpp

-                      r42f6e07
+                      r2b4daf2
 /// recorded. More investigation is needed.
 struct AssertCompare {
         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() );
+        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 );
+        }
 };
 …
 /// Set of assertions pending satisfaction
 using AssertionSet = std::map< readonly<DeclWithType>, AssertionSetValue, AssertCompare >;
+using AssertionSet = std::map< const VariableExpr *, AssertionSetValue, AssertCompare >;
 /// Set of open variables
 using OpenVarSet = std::unordered_map< std::string, TypeDecl::Data >;
+using OpenVarSet = std::unordered_map< TypeInstType::TypeEnvKey, TypeDecl::Data >;
 /// Merges one set of open vars into another
 …
 /// they bind to.
 struct EqvClass {
         std::set< std::string > vars;
+        std::unordered_set< TypeInstType::TypeEnvKey > vars;
         ptr<Type> bound;
         bool allowWidening;
 …
         /// Singleton class constructor from TypeDecl
         EqvClass( const TypeDecl * decl )
         : vars{ decl->name }, bound(), allowWidening( true ), data( decl ) {}
+        EqvClass( const TypeInstType * inst )
+        : vars{ *inst }, bound(), allowWidening( true ), data( inst->base ) {}
         /// Singleton class constructor from substitution
         EqvClass( const std::string & v, const Type * b )
+        EqvClass( const TypeInstType::TypeEnvKey & v, const Type * b )
         : vars{ v }, bound( b ), allowWidening( false ), data( TypeDecl::Dtype, false ) {}
         /// Single-var constructor (strips qualifiers from bound type)
         EqvClass( const std::string & v, const Type * b, bool w, const TypeDecl::Data & d )
+        EqvClass( const TypeInstType::TypeEnvKey & 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 std::string & v, const std::string & u, bool w, const TypeDecl::Data & d )
+        EqvClass( const TypeInstType::TypeEnvKey & v, const TypeInstType::TypeEnvKey & 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 std::string & var ) const;
+        const EqvClass * lookup( const TypeInstType::TypeEnvKey & 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 std::string & );
+        ClassList::iterator internal_lookup( const TypeInstType::TypeEnvKey & );
 };

src/AST/TypeSubstitution.cpp

-                      r42f6e07
+                      r2b4daf2
 void TypeSubstitution::initialize( const TypeSubstitution &src, TypeSubstitution &dest ) {
         dest.typeEnv.clear();
-        dest.varEnv.clear();
         dest.add( src );
+}
 …
                 typeEnv[ i->first ] = i->second;
         } // for
-        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::add( const TypeInstType * formalType, const Type *actualType ) {
+        typeEnv[ *formalType ] = actualType;
+}
 void TypeSubstitution::addVar( std::string formalExpr, const Expr *actualExpr ) {
         varEnv[ formalExpr ] = actualExpr;
+void TypeSubstitution::add( const TypeInstType::TypeEnvKey & key, const Type * actualType) {
+        typeEnv[ key ] = actualType;
+}
 void TypeSubstitution::remove( std::string formalType ) {
         TypeEnvType::iterator i = typeEnv.find( formalType );
+void TypeSubstitution::remove( const TypeInstType * formalType ) {
+        TypeEnvType::iterator i = typeEnv.find( *formalType );
         if ( i != typeEnv.end() ) {
                 typeEnv.erase( formalType );
+                typeEnv.erase( *formalType );
         } // if
+}
 const Type *TypeSubstitution::lookup( std::string formalType ) const {
         TypeEnvType::const_iterator i = typeEnv.find( formalType );
+const Type *TypeSubstitution::lookup( const TypeInstType * 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 == typeName ) break;
+                if ( *formalType == *actualType ) break;
                 // Look for the type this maps to, returning previous mapping if none-such
                 i = typeEnv.find( typeName );
+                i = typeEnv.find( *actualType );
                 if ( i == typeEnv.end() ) return actualType;
+        }
 …
 bool TypeSubstitution::empty() const {
         return typeEnv.empty() && varEnv.empty();
+        return typeEnv.empty();
+}
 …
                 TypeSubstitution * newEnv;
                 EnvTrimmer( const TypeSubstitution * env, TypeSubstitution * newEnv ) : env( env ), newEnv( newEnv ){}
                 void previsit( TypeDecl * tyDecl ) {
+                void previsit( FunctionType * ftype ) {
                         // transfer known bindings for seen type variables
+                        if ( const Type * t = env->lookup( tyDecl->name ) ) {
+                                newEnv->add( tyDecl->name, t );
+                        for (auto & formal : ftype->forall) {
+                                if ( const Type * t = env->lookup( formal ) ) {
+                                        newEnv->add( formal, t );
+                                }
+                        }
+                }
 …
 const Type * TypeSubstitution::Substituter::postvisit( const TypeInstType *inst ) {
         BoundVarsType::const_iterator bound = boundVars.find( inst->name );
+        BoundVarsType::const_iterator bound = boundVars.find( *inst );
         if ( bound != boundVars.end() ) return inst;
         TypeEnvType::const_iterator i = sub.typeEnv.find( inst->name );
+        TypeEnvType::const_iterator i = sub.typeEnv.find( *inst );
         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->name == replacement->name ) {
+                        if ( *inst == *replacement ) {
                                 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 ( const TypeDecl * tyvar : ptype->forall ) {
                                 boundVars.insert( tyvar->name );
+                for ( auto & tyvar : ptype->forall ) {
+                                boundVars.insert( *tyvar );
                 } // for
         } // if
+}
+/*
 void TypeSubstitution::Substituter::handleAggregateType( const BaseInstType * type ) {
         GuardValue( boundVars );
 …
                         if ( ! type->params.empty() ) {
                                 for ( const TypeDecl * tyvar : decl->params ) {
                                         boundVars.insert( tyvar->name );
+                                        boundVars.insert( *tyvar );
                                 } // for
                         } // if
 …
         handleAggregateType( aggregateUseType );
+}
+*/
 } // namespace ast

src/AST/TypeSubstitution.hpp

-                      r42f6e07
+                      r2b4daf2
+        }
+        void add( std::string formalType, const Type *actualType );
+        void add( const TypeInstType * formalType, const Type *actualType );
+        void add( const TypeInstType::TypeEnvKey & key, const Type *actualType );
         void add( const TypeSubstitution &other );
         void remove( std::string formalType );
         const Type *lookup( std::string formalType ) const;
+        void remove( const TypeInstType * formalType );
+        const Type *lookup( const TypeInstType * 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< std::string, ptr<Type> > TypeEnvType;
+        typedef std::unordered_map< std::string, ptr<Expr> > VarEnvType;
+        typedef std::unordered_map< TypeInstType::TypeEnvKey, ptr<Type> > TypeEnvType;
         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->name ] = actual->type;
+                                        typeEnv[ formal ] = 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 handleAggregateType( const BaseInstType * type );
                 void previsit( const StructInstType * aggregateUseType );
                 void previsit( const UnionInstType * aggregateUseType );
+                // void previsit( const StructInstType * aggregateUseType );
+                // void previsit( const UnionInstType * aggregateUseType );
                 const TypeSubstitution & sub;
                 int subCount = 0;
                 bool freeOnly;
                 typedef std::unordered_set< std::string > BoundVarsType;
+                typedef std::unordered_set< TypeInstType::TypeEnvKey > BoundVarsType;
                 BoundVarsType boundVars;

src/AST/module.mk

-                      r42f6e07
+                      r2b4daf2
         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

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

src/InitTweak/GenInit.cc

-                      r42f6e07
+                      r2b4daf2
         };
+        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 ) {
+                HoistArrayDimension::hoistArrayDimension( translationUnit );
+                if (!useNewAST) {
+                        HoistArrayDimension::hoistArrayDimension( translationUnit );
+                }
+                else {
+                        HoistArrayDimension_NoResolve::hoistArrayDimension( translationUnit );
+                }
                 fixReturnStatements( translationUnit );
 …
                         // need to resolve array dimensions in order to accurately determine if constexpr
+                        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 );
+                        }
+                        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

r42f6e07	r2b4daf2
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->name~~ ) ) {
	135	if ( const ast::EqvClass * eqvClass = tenv.lookup( *inst ) ) {
136	136	if ( eqvClass->data.kind == ast::TypeDecl::Ftype ) {
137	137	return new ast::PointerType{ inst };

src/ResolvExpr/CandidateFinder.cpp

-                      r42f6e07
+                      r2b4daf2
                 // mark type variable and specialization cost of forall clause
                 convCost.incVar( function->forall.size() );
+                for ( const ast::TypeDecl * td : function->forall ) {
+                        convCost.decSpec( td->assertions.size() );
+                }
+                convCost.decSpec( function->assertions.size() );
                 return convCost;
 …
                 ast::AssertionSet & need
         ) {
                 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;
+                        }
+                for ( auto & tyvar : type->forall ) {
+                        unifiableVars[ *tyvar ] = ast::TypeDecl::Data{ tyvar->base };
+                }
+                for ( auto & assn : type->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.
+                        funcFinder.find( untypedExpr->func, selfFinder.candidates.empty() ? ResolvMode::withAdjustment() : ResolvMode::withoutFailFast() );
+                        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 );
                         // 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->name ) ) {
+                                                if ( const ast::EqvClass * clz = func->env.lookup( *inst ) ) {
                                                         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->name);
+                                                auto td = cand->env.lookup(*insttype);
                                                 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

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

src/ResolvExpr/CommonType.cc

r42f6e07	r2b4daf2
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->name~~ );
	715	auto entry = open.find( *var );
716	716	if ( entry != open.end() ) {
717	717	ast::AssertionSet need, have;

src/ResolvExpr/ConversionCost.cc

-                      r42f6e07
+                      r2b4daf2
 ) {
         if ( const ast::TypeInstType * inst = dynamic_cast< const ast::TypeInstType * >( dst ) ) {
                 if ( const ast::EqvClass * eqv = env.lookup( inst->name ) ) {
+                if ( const ast::EqvClass * eqv = env.lookup( *inst ) ) {
                         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->name ) ) {
+        if ( const ast::EqvClass * eqv = env.lookup( *typeInstType ) ) {
                 cost = costCalc( eqv->bound, dst, srcIsLvalue, symtab, env );
         } else if ( const ast::TypeInstType * dstAsInst =
                         dynamic_cast< const ast::TypeInstType * >( dst ) ) {
                 if ( typeInstType->name == dstAsInst->name ) {
+                if ( *typeInstType == *dstAsInst ) {
                         cost = Cost::zero;
+                }

src/ResolvExpr/FindOpenVars.cc

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

src/ResolvExpr/PolyCost.cc

r42f6e07	r2b4daf2
68	68
69	69	void previsit( const ast::TypeInstType * type ) {
70		if ( const ast::EqvClass * eqv = env_.lookup( ~~type->nam~~e ) ) /* && */ if ( eqv->bound ) {
	70	if ( const ast::EqvClass * eqv = env_.lookup( type ) ) / && */ 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

-                      r42f6e07
+                      r2b4daf2
+        }
         void postvisit( const ast::TypeInstType * inst ) {
                 if ( const ast::EqvClass * eqv = typeEnv.lookup( inst->name ) ) {
+                if ( const ast::EqvClass * eqv = typeEnv.lookup( *inst ) ) {
                         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->name ) ) {
+                if ( const ast::EqvClass * eqv = env.lookup( *dstAsInst ) ) {
                         return ptrsAssignable( src, eqv->bound, env );
+                }

src/ResolvExpr/PtrsCastable.cc

r42f6e07	r2b4daf2
180	180	}
181	181	}
182		} else if ( const ast::EqvClass * eqvClass = env.lookup( ~~inst->name~~ ) ) {
	182	} else if ( const ast::EqvClass * eqvClass = env.lookup( *inst ) ) {
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->name~~ ) ) {
	285	if ( const ast::EqvClass * eqvClass = env.lookup( *inst ) ) {
286	286	return ptrsAssignable( src, eqvClass->bound, env );
287	287	}

src/ResolvExpr/RenameVars.cc

-                      r42f6e07
+                      r2b4daf2
 #include <utility>                 // for pair
-#include "AST/ForallSubstitutionTable.hpp"
 #include "AST/Pass.hpp"
 #include "AST/Type.hpp"
 …
                 int level = 0;
                 int resetCount = 0;
+                int next_expr_id = 1;
+                int next_usage_id = 1;
                 ScopedMap< std::string, std::string > nameMap;
+                ScopedMap< std::string, ast::TypeInstType::TypeEnvKey > idMap;
         public:
-                ast::ForallSubstitutionTable subs;
                 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 = 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;
+                        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;
                     type = mut;
+                        }
 …
+                }
                 const ast::FunctionType * openLevel( const ast::FunctionType * type ) {
+                const ast::FunctionType * openLevel( const ast::FunctionType * type, RenameMode mode ) {
                         if ( type->forall.empty() ) return type;
+                        nameMap.beginScope();
+                        idMap.beginScope();
                         // Load new names from this forall clause and perform renaming.
+                        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;
+                                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 type;
+                        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" );
+                                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;
+                        }
+                        return mutType;
+                }
                 void closeLevel( const ast::FunctionType * type ) {
                         if ( type->forall.empty() ) return;
+                        nameMap.endScope();
+                        idMap.endScope();
+                }
         };
 …
         };
+        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;
+        struct RenameVars_new : public ast::PureVisitor /*: public ast::WithForallSubstitutor*/ {
+                RenameMode mode;
                 const ast::FunctionType * previsit( const ast::FunctionType * type ) {
                         return renaming.openLevel( type );
+                        return renaming.openLevel( type, mode );
+                }
 …
                 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 ) {
         ast::Type *tc = ast::deepCopy(t);
+const ast::Type * renameTyVars( const ast::Type * t, RenameMode mode, bool reset ) {
+        // ast::Type *tc = ast::deepCopy(t);
         ast::Pass<RenameVars_new> renamer;
+//      return t->accept( renamer );
+        return tc->accept( renamer );
+        renamer.core.mode = mode;
+        if (mode == GEN_USAGE && reset) {
+                renaming.nextUsage();
+        }
+        return t->accept( renamer );
+}
 void resetTyVarRenaming() {
         renaming.reset();
+        renaming.nextUsage();
+}

src/ResolvExpr/RenameVars.h

-                      r42f6e07
+                      r2b4daf2
         /// Provides a consistent renaming of forall type names in a hierarchy by prefixing them with a unique "level" ID
         void renameTyVars( Type * );
+        const ast::Type * renameTyVars( const ast::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 );
         /// resets internal state of renamer to avoid overflow
         void resetTyVarRenaming();
 } // namespace ResolvExpr

src/ResolvExpr/ResolvMode.h

-                      r42f6e07
+                      r2b4daf2
                 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

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

src/ResolvExpr/ResolveTypeof.cc

-                      r42f6e07
+                      r2b4daf2
 #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

-                      r42f6e07
+                      r2b4daf2
                 };
         } // 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 );
 …
+        }
         ast::ptr< ast::Expr > resolveStmtExpr(
+        const ast::Expr * resolveStmtExpr(
                 const ast::StmtExpr * stmtExpr, const ast::SymbolTable & symtab
         ) {
                 assert( stmtExpr );
                 ast::Pass< Resolver_new > resolver{ symtab };
+                ast::ptr< ast::Expr > ret = stmtExpr;
+                ret = ret->accept( resolver );
+                strict_dynamic_cast< ast::StmtExpr * >( ret.get_and_mutate() )->computeResult();
+                auto ret = mutate(stmtExpr->accept(resolver));
+                strict_dynamic_cast< ast::StmtExpr * >( ret )->computeResult();
                 return ret;
+        }
 …
+                        }
                         // handle assertions. (seems deep)
+                        // handle assertions
                         symtab.enterScope();
+                        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->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));
+                        }
 …
                         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 ) {
+                        #warning should use new equivalent to Validate::SizeType rather than sizeType here
+                        ast::ptr< ast::Type > sizeType = new ast::BasicType{ ast::BasicType::LongUnsignedInt };
+                        ast::ptr< ast::Type > sizeType = ast::sizeType;
                         ast::mutate_field(
                                 type, &PtrType::dimension,

src/ResolvExpr/Resolver.h

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

src/ResolvExpr/SatisfyAssertions.cpp

-                      r42f6e07
+                      r2b4daf2
                 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::DeclWithType * decl;
+                const ast::VariableExpr * expr;
                 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::DeclWithType * decl;
+                const ast::VariableExpr * expr;
                 const ast::AssertionSetValue & info;
                 AssnCandidateList matches;
                 DeferItem(
                         const ast::DeclWithType * d, const ast::AssertionSetValue & i, AssnCandidateList && ms )
                 : decl( d ), info( i ), matches( std::move( ms ) ) {}
+                DeferItem(
+                        const ast::VariableExpr * d, const ast::AssertionSetValue & i, AssnCandidateList && ms )
+                : expr( 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 { decl, info, matches[i] }; }
+                DeferRef operator[] ( unsigned i ) const { return { expr, 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 ); }
+                        if ( i.second.isUsed ) { symtab.addId( i.first->var ); }
+                }
+        }
         /// Binds a single assertion, updating satisfaction state
         void bindAssertion(
                 const ast::DeclWithType * decl, const ast::AssertionSetValue & info, CandidateRef & cand,
+        void bindAssertion(
+                const ast::VariableExpr * expr, 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 ][ decl->uniqueId ] = ast::ParamEntry{
                         candidate->uniqueId, candidate, match.adjType, decl->get_type(), varExpr };
+                inferred[ info.resnSlot ][ expr->var->uniqueId ] = ast::ParamEntry{
+                        candidate->uniqueId, candidate, match.adjType, expr->result, varExpr };
+        }
 …
                 std::vector<ast::SymbolTable::IdData> candidates;
                 auto kind = ast::SymbolTable::getSpecialFunctionKind(assn.first->name);
+                auto kind = ast::SymbolTable::getSpecialFunctionKind(assn.first->var->name);
                 if (kind != ast::SymbolTable::SpecialFunctionKind::NUMBER_OF_KINDS) {
                         // prefilter special decls by argument type, if already known
                         ast::ptr<ast::Type> thisArgType = strict_dynamic_cast<const ast::PointerType *>(assn.first->get_type())->base
+                        ast::ptr<ast::Type> thisArgType = assn.first->result.strict_as<ast::PointerType>()->base
                                 .strict_as<ast::FunctionType>()->params[0]
                                 .strict_as<ast::ReferenceType>()->base;
 …
+                }
                 else {
                         candidates = sat.symtab.lookupId(assn.first->name);
+                        candidates = sat.symtab.lookupId(assn.first->var->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->get_type();
                         ast::ptr< ast::Type > adjType =
                                 renameTyVars( adjustExprType( candidate->get_type(), newEnv, sat.symtab ) );
+                        ast::ptr< ast::Type > toType = assn.first->result;
+                        ast::ptr< ast::Type > adjType =
+                                renameTyVars( adjustExprType( candidate->get_type(), newEnv, sat.symtab ), GEN_USAGE, false );
                         // 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.decl->get_type(), false, symtab, env );
+                                                assn.match.adjType, assn.expr->result, false, symtab, env );
                                         // mark vars+specialization on function-type assertions
 …
                                         cost.incVar( func->forall.size() );
+                                        for ( const ast::TypeDecl * td : func->forall ) {
+                                                cost.decSpec( td->assertions.size() );
+                                        }
+                                        cost.decSpec( func->assertions.size() );
+                                }
+                        }
 …
         /// Limit to depth of recursion of assertion satisfaction
         static const int recursionLimit = 4;
+        static const int recursionLimit = 8;
         /// 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;
+                        // make initial pass at matching assertions
+                        for ( auto & assn : sat.need ) {
+                                // fail early if any assertion is not satisfiable
+                                if ( ! satisfyAssertion( assn, sat ) ) {
+                        // 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()) {
                                         Indenter tabs{ 3 };
                                         std::ostringstream ss;
 …
                                         print( ss, *sat.cand, ++tabs );
                                         ss << (tabs-1) << "Could not satisfy assertion:\n";
                                         ast::print( ss, assn.first, tabs );
+                                        ast::print( ss, next[0].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.decl, tabs );
+                                        ast::print( ss, d.expr, 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.decl, tabs );
+                                                ast::print( ss, d.expr, 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.decl, r.info, nextCand, match, nextInferred );
+                                                bindAssertion( r.expr, 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

-                      r42f6e07
+                      r2b4daf2
                         const ast::Type * postvisit( const ast::TypeInstType * typeInst ) {
                                 if ( const ast::EqvClass * clz = tenv.lookup( typeInst->name ) ) {
+                                if ( const ast::EqvClass * clz = tenv.lookup( *typeInst ) ) {
                                         // 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 ast::ptr< ast::Type > tupleFromTypes( Iter crnt, Iter end ) {
+                static const 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::DeclWithType * assn ) {
+                static void markAssertionSet( ast::AssertionSet & assns, const ast::VariableExpr * assn ) {
                         auto i = assns.find( assn );
                         if ( i != assns.end() ) {
 …
                         const ast::FunctionType * type
                 ) {
+                        for ( const auto & tyvar : type->forall ) {
+                                for ( const ast::DeclWithType * assert : tyvar->assertions ) {
+                                        markAssertionSet( assn1, assert );
+                                        markAssertionSet( assn2, assert );
+                                }
+                        for ( auto & assert : type->assertions ) {
+                                markAssertionSet( assn1, assert );
+                                markAssertionSet( assn2, assert );
+                        }
+                }
 …
                 void postvisit( const ast::TypeInstType * typeInst ) {
                         assert( open.find( typeInst->name ) == open.end() );
+                        assert( open.find( *typeInst ) == open.end() );
                         handleRefType( typeInst, type2 );
+                }
 …
         private:
                 /// Creates a tuple type based on a list of Type
                 static ast::ptr< ast::Type > tupleFromTypes(
+                static const 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->name ) : open.end(),
                         entry2 = var2 ? open.find( var2->name ) : open.end();
+                        entry1 = var1 ? open.find( *var1 ) : open.end(),
+                        entry2 = var2 ? open.find( *var2 ) : open.end();
                 bool isopen1 = entry1 != open.end();
                 bool isopen2 = entry2 != open.end();

src/SymTab/Mangler.cc

-                      r42f6e07
+                      r2b4daf2
                                         int dcount = 0, fcount = 0, vcount = 0, acount = 0;
                                         mangleName += Encoding::forall;
                                         for ( const ast::TypeDecl * decl : ptype->forall ) {
+                                        for ( auto & decl : ptype->forall ) {
                                                 switch ( decl->kind ) {
                                                 case ast::TypeDecl::Kind::Dtype:
 …
                                                 } // switch
                                                 varNums[ decl->name ] = std::make_pair( nextVarNum, (int)decl->kind );
                                                 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
+                                        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
                                         mangleName += std::to_string( dcount ) + "_" + std::to_string( fcount ) + "_" + std::to_string( vcount ) + "_" + std::to_string( acount ) + "_";

src/SymTab/Validate.cc

-                      r42f6e07
+                      r2b4daf2
         };
         struct ArrayLength : public WithIndexer {
+        struct InitializerLength {
                 /// 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("Array Length",
+                                ArrayLength::computeLength, translationUnit);
+                        Stats::Time::TimeCall("Initializer Length",
+                                InitializerLength::computeLength, translationUnit);
+                        if (!useNewAST) {
+                                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 ArrayLength::previsit( ObjectDecl * objDecl ) {
+        void InitializerLength::previsit( ObjectDecl * objDecl ) {
                 if ( ArrayType * at = dynamic_cast< ArrayType * >( objDecl->type ) ) {
                         if ( at->dimension ) return;
 …
         void ArrayLength::previsit( ArrayType * type ) {
+                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 );
+                        }
+                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

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

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

r42f6e07	r2b4daf2
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 ~~long~~ int )10)]{
89		__attribute__ ((unused)) signed int (*_X11_retval_f12PA0A0i_1)[][((unsigned ~~long~~ int )10)];
	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)];
90	90	}
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)];
	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)];
93	93	}
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)];
	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)];
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

-                      r42f6e07
+                      r2b4daf2
 __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 long int )5)];
 __attribute__ ((used,used,unused,used)) const signed int _X3vd6A0Ki_1[((unsigned long int )5)];
+__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,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 long int )5)];
     __attribute__ ((unused,unused,unused,unused,unused)) signed int **_X2t4A0PPi_2[((unsigned long int )5)];
+    __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 _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 long int )5)]));
+signed int _X4tpr4Fi_Fi_Pi___1(__attribute__ ((unused,unused)) signed int (*__anonymous_object1)(signed int __param_0[((unsigned 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 long int )5)];
     __attribute__ ((unused,unused,unused,unused,unused)) signed int (*_X3ad4PA0i_2)[((unsigned long int )10)];
+    __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,unused,used)) signed int _X3ad5i_2;
     __attribute__ ((unused,unused,unused,unused,unused)) signed int _X3ad6Fi___2();

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

-                      r42f6e07
+                      r2b4daf2
     __attribute__ ((unused)) signed int (*_X11_retval_f10PA0i_1)[];
+}
 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 (*_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 _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 long int )10)])[][((unsigned long int )3)];
     signed int (*(*_X1pPA0A0PA0A0i_2)[][((unsigned long int )10)])[][((unsigned long int )3)];
+    signed int (*(*_X2pcPA0A0PA0A0i_2)[][((unsigned int )10)])[][((unsigned int )3)];
+    signed int (*(*_X1pPA0A0PA0A0i_2)[][((unsigned int )10)])[][((unsigned int )3)];
     signed int (*(*_X1pPA0Fi_i__2)[])(signed int __param_0);
+}

tests/Makefile.am

-                      r42f6e07
+                      r2b4daf2
 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

r42f6e07	r2b4daf2
	1	start
1	2	done

tests/concurrent/futures/basic.cfa

-                      r42f6e07
+                      r2b4daf2
 #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

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

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

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

Context Navigation

Changes in / [42f6e07:2b4daf2]

Legend:

Download in other formats: