add garbage-counting tests for long/deep chains

Inspecting the object reference graph with a simple DFS through properties
is possible as Creed does not use any closures for its internals
The tests are currently failing :-)

Author: bergus

test/garbage-test.js

@@ -0,0 +1,92 @@
+import { describe, it } from 'mocha'
+import assert from 'assert'
+
+import { resolve, reject, fulfill, never } from '../src/main'
+import getCounts, { collect, formatResults, sumResults } from './lib/refcount-util'
+
+describe('reference counts', () => {
+	const C = 3
+	const len = C*C*C
+	it('should be constant for recursive resolving with no handler', () => {
+		return getCounts(delay => {
+			// return delay(1).chain( ()=>delay(2).chain( ()=>delay(3) ) )
+			function recurse(i) {
+				return i < len ? delay(i+1).chain(recurse) : fulfill()
+			}
+			return recurse(1)
+		}, (na, ev, co) => sumResults(co)).then(logs => { for (let sum of logs) assert(sum <= C+5, sum+"<="+(C+5)) })
+	})
+	it('should be constant for recursive resolving with a result', () => {
+		return getCounts(delay => {
+			// return delay(1).chain( ()=>delay(2).chain( ()=>delay(3) ) ).map(l => 3-l)
+			function recurse(i) {
+				return i < len ? delay(i+1).chain(recurse) : fulfill(i)
+			}
+			return recurse(1).map(l => len - l)
+		}, (na, ev, co) => sumResults(co)).then(logs => { for (let sum of logs) assert(sum <= C+6, sum+"<="+(C+6)) })
+	})
+	it('should be constant for recursive resolving with a late handler', () => {
+		return getCounts((delay, timeout) => {
+			// p = delay(1).chain( ()=>delay(2).chain( ()=>delay(3) ) )
+			// largeDelay().then(() => p.map(l => 3-l))
+			function recurse(i) {
+				if (i < len) return delay(i+1).chain(recurse)
+				timeout(i+1, () => p.map(l => len - l))
+				return fulfill(i)
+			}
+			var p = recurse(1)
+			return p
+		}, (na, ev, co) => sumResults(co)).then(logs => { for (let sum of logs) assert(sum <= C+5, sum+"<="+(C+5)) })
+	})
+	it('should be not more than linear for recursive resolving with many handlers', () => {
+		return getCounts(delay => {
+			function recurse(i) {
+				if (i>1) p.map(l => len - l)
+				return i < len ? delay(i+1).chain(recurse) : fulfill(i)
+			}
+			var p = recurse(1)
+			return p
+		}, (na, ev, co) => [na, co.Futures, co.Maps, sumResults(co)]).then(logs => {
+			for (let [i, f, m, sum] of logs) {
+				assert(f <= C+i, f+"<="+(C+i)+" Futures") // 1 Future result per handler
+				assert(m <= C+i, m+"<="+(C+i)+" Maps") // 1 Map action per handler
+				sum -= f + m
+				assert(sum <= C+5, sum+"<="+(C+5)+" others")
+			}
+		})
+	})
+	it('should be constant for recursive resolving with many late handlers', () => {
+		return getCounts((delay, timeout) => {
+			// p = delay(1).chain( ()=>delay(2).chain( ()=>delay(3) ) )
+			// largeDelay().then(() => { p.map(l => 3-l); p.map(l => 3-l); p.map(l => 3-l); })
+			function recurse(i) {
+				if (i < len) return delay(i+1).chain(recurse)
+				timeout(i+1, () => { for (var j=0; j<len/2; j++) p.map(l => len - l) }) // dropping the results
+				return fulfill(i)
+			}
+			var p = recurse(1)
+			return p
+		}, (na, ev, co) => sumResults(co)).then(logs => { for (let sum of logs) assert(sum <= C+5, sum+"<="+(C+5)) })
+	})
+	
+	/*
+	function log (na, ev, co) {
+		console.log("\t"+na+" - "+ev+" ["+formatResults(co)+"]")
+	}
+	it('should be interesting1', () => {
+		return getCounts(delay => {
+			return delay(1).chain(()=>delay(2)).chain(()=>delay(3))
+		}, log)
+	})
+	it('should be interesting2', () => {
+		return getCounts(delay => {
+			return delay(1).chain(()=>delay(2).chain(()=>delay(3).chain(()=>delay(4).chain(()=>delay(5)))))
+		}, log)
+	})
+	it('should be interesting3', () => {
+		return getCounts(delay => {
+			return delay(delay(delay(0, 1), 2), 3)
+		}, log)
+	})
+	*/
+})

test/lib/refcount-util.js

@@ -0,0 +1,125 @@
+import { resolve, isRejected, isNever } from '../../src/main'
+import { Future } from '../../src/Promise'
+import Action from '../../src/Action'
+
+const knownNames = ['Handle', 'Action',
+	'Then', 'Chain', 'Map', 'Delay',
+	'Future', 'Fulfilled', 'Rejected',
+	'Settle', 'Merge', 'Any', 'Race']
+const DELAY_TIME = 5
+
+export default function getCounts(exec, report, targets = knownNames, withResult = false) {
+	function asyncReport(x) {
+		timeoutCount++
+		setTimeout(() => {
+			res.push(report(x, 'result after', collect([result], targets, seenBefore)))
+			if (globals.size > +withResult) res.push(report(x, 'globals after', collect(globals, targets, seenBefore)))
+			if (--timeoutCount == 0) promise._fulfill(res)
+		}, 2) // after the TaskQueue is drained
+	}
+	function monitoredTimeout(log, fn, captures = []) {
+		for (let c of captures)
+			globals.add(c)
+		timeoutCount++
+		setTimeout(() => {
+			for (let c of captures)
+				globals.delete(c)
+			if (captures.length) res.push(report(log, 'captures from timeout', collect(captures, targets, seenBefore)))
+			res.push(report(log, 'result before', collect([result], targets, seenBefore)))
+			if (globals.size > +withResult) res.push(report(log, 'globals before', collect(globals, targets, seenBefore)))
+			fn()
+			asyncReport(log)
+			if (--timeoutCount == 0) promise._fulfill(res)
+		}, DELAY_TIME)
+	}
+	function monitoredDelay (x, id) {
+		const p = resolve(x)
+		if (isRejected(p) || isNever(p)) {
+			return p
+		} else {
+			var promise = new Future()
+			p._runAction(new Delay(promise, id))
+			return promise
+		}
+	}
+	class Delay extends Action {
+		constructor (promise, id) {
+			super(promise)
+			this.id = id
+		}
+
+		fulfilled (p) {
+			monitoredTimeout(this.id || p.value, () => this.promise._become(p), [this.promise, p])
+		}
+	}
+	
+	const promise = new Future
+	var timeoutCount = 0
+	const res = []
+	const seenBefore = new WeakSet
+	const globals = new Set
+	const result = exec(monitoredDelay, monitoredTimeout);
+	if (withResult) {
+		globals.add(result)
+	}
+	asyncReport(0) // 'init'
+	return promise
+}
+
+export function collect(sources, targets = knownNames, seenBefore = new WeakSet) {
+	var counts = {}
+	for (let name of targets) {
+		counts[name+'s'] = 0
+		counts['new'+name+'s'] = 0
+	}
+	var seen = new WeakSet([])
+	function test(o) {
+		if (seen.has(o)) {
+			return
+		} else {
+			seen.add(o)
+		}
+		
+		const name = o.constructor.name
+		if (targets.includes(name)) {
+			counts[name+'s']++
+			if (!seenBefore.has(o)) {
+				counts['new'+name+'s']++
+			}
+		} else {
+			console.log('unknown kind:', o)
+		}
+		seenBefore.add(o)
+		
+		for (let property in o) {
+			let value = o[property]
+			if (value && typeof value == 'object') { // ignore function objects
+				test(value)
+			}
+		}
+	}
+	for (let source of sources) {
+		test(source)
+	}
+	return counts
+}
+export function formatResults(counts) {
+	var x = []
+	for (let name in counts) {
+		if (counts[name] == 0) continue
+		if (/^new/.test(name)) continue
+		let r = name+': '+counts[name]
+		if (counts['new'+name] > 0)
+			r += ' (+'+counts['new'+name]+')'
+		x.push(r)
+	}
+	return x.join(', ')
+}
+
+export function sumResults(counts) {
+	var c = 0;
+	for (let name in counts)
+		if (!/^new/.test(name))
+			c += counts[name]
+	return c
+}