shithub: mc

Download patch

ref: b2d29ed0eebd0e3e2c162b5e83d6d0e8b6ddee57
parent: d21343766fc75075e9246b386b60e264bfd1860e
parent: 920e16ca93f648b551af2b688de6a1d5fe1cb802
author: Ori Bernstein <ori@eigenstate.org>
date: Thu May 5 18:59:19 EDT 2016 

Merge ../integrate-libthread


--- /dev/null
+++ b/lib/thread/atomic-impl+plan9-x64.s
@@ -1,0 +1,71 @@
+TEXT thread$xget32+0(SB),1,$0
+	MOVL	(DI), AX
+	RET
+TEXT thread$xget64+0(SB),1,$0
+	MOVQ	(DI), AX
+	RET
+TEXT thread$xgetp+0(SB),1,$0
+	MOVQ	(DI), AX
+	RET
+
+TEXT thread$xset32+0(SB),1,$0
+	MOVL	SI, (DI)
+	RET
+TEXT thread$xset64+0(SB),1,$0
+	MOVQ	SI, (DI)
+	RET
+TEXT thread$xsetp+0(SB),1,$0
+	MOVQ	SI, (DI)
+	RET
+
+TEXT thread$xadd32+0(SB),1,$0
+	LOCK; XADDL	SI, (DI)
+	MOVL	SI, AX
+	RET
+TEXT thread$xadd64+0(SB),1,$0
+	LOCK; XADDQ	SI, (DI)
+	MOVQ	SI, AX
+	RET
+TEXT thread$xaddp+0(SB),1,$0
+	LOCK; XADDQ	SI, (DI)
+	MOVQ	SI, AX
+	RET
+
+TEXT thread$xsub32+0(SB),1,$0
+	LOCK; XSUBL	SI, (DI)
+	MOVL	SI, AX
+	RET
+TEXT thread$xsub64+0(SB),1,$0
+	LOCK; XSUBQ	SI, (DI)
+	MOVQ	SI, AX
+	RET
+TEXT thread$xsubp+0(SB),1,$0
+	LOCK; XSUBQ	SI, (DI)
+	MOVQ	SI, AX
+	RET
+
+TEXT thread$xcas32+0(SB),1,$0
+	MOVL	SI, AX
+	LOCK; CMPXCHGL	DX, (DI)
+	RET
+TEXT thread$xcas64+0(SB),1,$0
+	MOVQ	SI, AX
+	LOCK; CMPXCHGQ	DX, (DI)
+	RET
+TEXT thread$xcasp+0(SB),1,$0
+	MOVQ	SI, AX
+	LOCK; CMPXCHGQ	DX, (DI)
+	RET
+
+TEXT thread$xchg32+0(SB),1,$0
+	MOVL	SI, AX
+	LOCK; XCHGL	(DI), AX
+	RET
+TEXT thread$xchg64+0(SB),1,$0
+	MOVQ	SI, AX
+	LOCK; XCHGQ	(DI), AX
+	RET
+TEXT thread$xchgp+0(SB),1,$0
+	MOVQ	SI, AX
+	LOCK; XCHGQ	(DI), AX
+	RET
--- /dev/null
+++ b/lib/thread/atomic-impl+x64.s
@@ -1,0 +1,90 @@
+.globl thread$xget32
+.globl _thread$xget32
+thread$xget32:
+_thread$xget32:
+	movl	(%rdi), %eax
+	ret
+.globl thread$xget64
+.globl thread$xgetp
+.globl _thread$xget64
+.globl _thread$xgetp
+thread$xget64:
+thread$xgetp:
+_thread$xget64:
+_thread$xgetp:
+	movq	(%rdi), %rax
+	ret
+
+.globl thread$xset32
+.globl _thread$xset32
+thread$xset32:
+_thread$xset32:
+	movl	%esi, (%rdi)
+	ret
+.globl thread$xset64
+.globl thread$xsetp
+.globl _thread$xset64
+.globl _thread$xsetp
+thread$xset64:
+thread$xsetp:
+_thread$xset64:
+_thread$xsetp:
+	movq	%rsi, (%rdi)
+	ret
+
+.globl thread$xadd32
+.globl _thread$xadd32
+thread$xadd32:
+_thread$xadd32:
+	lock xaddl	%esi, (%rdi)
+	movl %esi,%eax
+	ret
+.globl thread$xadd64
+.globl thread$xaddp
+.globl _thread$xadd64
+.globl _thread$xaddp
+thread$xadd64:
+thread$xaddp:
+_thread$xadd64:
+_thread$xaddp:
+	lock xaddq	%rsi, (%rdi)
+	movq %rsi,%rax
+	ret
+
+.globl thread$xcas32
+.globl _thread$xcas32
+thread$xcas32:
+_thread$xcas32:
+	movl	%esi, %eax
+	lock cmpxchgl	%edx, (%rdi)
+	ret
+.globl thread$xcas64
+.globl thread$xcasp
+.globl _thread$xcas64
+.globl _thread$xcasp
+thread$xcas64:
+thread$xcasp:
+_thread$xcas64:
+_thread$xcasp:
+	movq	%rsi, %rax
+	lock cmpxchgq	%rdx, (%rdi)
+	ret
+
+.globl thread$xchg32
+.globl _thread$xchg32
+thread$xchg32:
+_thread$xchg32:
+	movl	%esi, %eax
+	lock xchgl	(%rdi), %eax
+	ret
+.globl thread$xchg64
+.globl thread$xchgp
+.globl _thread$xchg64
+.globl _thread$xchgp
+thread$xchg64:
+thread$xchgp:
+_thread$xchg64:
+_thread$xchgp:
+	movq	%rsi, %rax
+	lock xchgq	(%rdi), %rax
+	ret
--- /dev/null
+++ b/lib/thread/atomic.myr
@@ -1,0 +1,78 @@
+use std
+
+pkg thread =
+	trait atomic @a::(integral,numeric) =
+		xget	: (p : @a# -> @a)
+		xset	: (p : @a#, v : @a -> void)
+		xadd	: (p : @a#, v : @a -> @a)
+		xcas	: (p : @a#, old : @a, new : @a -> @a)
+		xchg	: (p : @a#, new : @a -> @a)
+	;;
+
+	impl atomic int32
+	impl atomic int64
+	impl atomic uint32
+	impl atomic uint64
+;;
+
+impl atomic int32 =
+	xget	= {p; -> xget32(p castto(uint32#)) castto(int32)}
+	xset	= {p, v; xset32(p castto(uint32#), v castto(uint32))}
+	xadd	= {p, v; -> xadd32(p castto(uint32#), v castto(uint32)) castto(int32)}
+	xcas	= {p, old, new; -> xcas32(p castto(uint32#), old castto(uint32), new castto(uint32)) castto(int32)}
+	xchg	= {p, v; -> xchg32(p castto(uint32#), v castto(uint32)) castto(int32)}
+;;
+
+
+impl atomic int64 =
+	xget	= {p; -> xget64(p castto(uint64#)) castto(int64)}
+	xset	= {p, v; xset64(p castto(uint64#), v castto(uint64))}
+	xadd	= {p, v; -> xadd64(p castto(uint64#), v castto(uint64)) castto(int64)}
+	xcas	= {p, old, new; -> xcas64(p castto(uint64#), old castto(uint64), new castto(uint64)) castto(int64)}
+	xchg	= {p, v; -> xchg64(p castto(uint64#), v castto(uint64)) castto(int64)}
+;;
+
+impl atomic uint32 =
+	xget	= {p; -> xget32(p)}
+	xset	= {p, v; xset32(p, v)}
+	xadd	= {p, v; -> xadd32(p, v)}
+	xcas	= {p, old, new; -> xcas32(p, old, new)}
+	xchg	= {p, v; -> xchg32(p, v)}
+;;
+
+
+impl atomic uint64 =
+	xget	= {p; -> xget64(p)}
+	xset	= {p, v; xset64(p, v)}
+	xadd	= {p, v; -> xadd64(p, v)}
+	xcas	= {p, old, new; -> xcas64(p, old, new)}
+	xchg	= {p, v; -> xchg64(p, v)}
+;;
+
+impl atomic std.intptr =
+	xget	= {p; -> xgetp(p)}
+	xset	= {p, v; xsetp(p, v)}
+	xadd	= {p, v; -> xaddp(p, v)}
+	xcas	= {p, old, new; -> xcasp(p, old, new)}
+	xchg	= {p, v; -> xchgp(p, v)}
+;;
+
+extern const xget32	: (p : uint32# -> uint32)
+extern const xget64	: (p : uint64# -> uint64)
+extern const xgetp	: (p : std.intptr# -> std.intptr)
+
+extern const xset32	: (p : uint32#, v : uint32 -> void)
+extern const xset64	: (p : uint64#, v : uint64 -> void)
+extern const xsetp	: (p : std.intptr#, v : std.intptr -> void)
+
+extern const xadd32	: (p : uint32#, v : uint32 -> uint32)
+extern const xadd64	: (p : uint64#, v : uint64 -> uint64)
+extern const xaddp	: (p : std.intptr#, v : std.intptr -> std.intptr)
+
+extern const xcas32	: (p : uint32#, old: uint32, new : uint32 -> uint32)
+extern const xcas64	: (p : uint64#, old: uint64, new : uint64 -> uint64)
+extern const xcasp	: (p : std.intptr#, old: std.intptr, new : std.intptr -> std.intptr)
+
+extern const xchg32	: (p : uint32#, v : uint32 -> uint32)
+extern const xchg64	: (p : uint64#, v : uint64 -> uint64)
+extern const xchgp	: (p : std.intptr#, v : std.intptr -> std.intptr)
--- /dev/null
+++ b/lib/thread/bld.proj
@@ -1,0 +1,31 @@
+lib thread =
+	common.myr
+
+	# linux impl of basic thread primitives
+	condvar+linux.myr
+	mutex+linux.myr
+	spawn+linux.myr
+	exit+linux-x64.s
+
+	# freebsd impl of thread primitives
+	condvar+freebsd.myr
+	mutex+freebsd.myr
+	spawn+freebsd.myr
+	exit+freebsd-x64.s
+
+	# osx impl of thread primitives
+	#condvar+osx.myr
+	mutex+osx.myr
+	spawn+osx.myr
+	start+osx-x64.s
+
+	# 9front impl of thread primitives
+	#condvar+plan9.myr
+	mutex+plan9.myr
+	spawn+plan9.myr
+	atomic-impl+plan9-x64.s
+
+	atomic-impl+x64.s
+	atomic.myr
+;;
+
--- /dev/null
+++ b/lib/thread/common.myr
@@ -1,0 +1,5 @@
+use std
+
+pkg thread = 
+	generic Zptr = 0 castto(@a#)
+;;
--- /dev/null
+++ b/lib/thread/condvar+freebsd.myr
@@ -1,0 +1,59 @@
+use std
+use sys
+
+use "atomic.use"
+use "common.use"
+use "mutex.use"
+
+pkg thread =
+	type cond = struct
+		_mtx	: mutex#
+		_seq	: uint32
+	;;
+
+	const mkcond	: (mtx : mutex# -> cond)
+	const condwait	: (cond : cond# -> void)
+	const condsignal	: (cond : cond# -> void)
+	const condbroadcast	: (cond : cond# -> void)
+;;
+
+const mkcond = {mtx
+	-> [._mtx = mtx, ._seq = 0]
+}
+
+const condwait = {cond
+	var seq
+	var mtx
+
+	mtx = cond._mtx
+	seq = cond._seq
+
+	mtxunlock(mtx)
+	sys.umtx_op(&cond._seq castto(void#), \
+		sys.Umtxwaituintpriv, \
+		seq castto(uint64), \
+		Zptr, Zptr)
+
+	/*
+	We need to atomically set the mutex to contended. This allows us to
+	pass responsibility for waking up the potential other waiters on to the
+	unlocker of the mutex.
+	*/
+	while xchg(&mtx._state, Contended) != Unlocked
+		sys.umtx_op(&mtx._state castto(void#), \
+			sys.Umtxwaituintpriv, \
+			Contended castto(uint64), \
+			Zptr, Zptr)
+	;;
+}
+
+const condsignal = {cond : cond#
+	xadd(&cond._seq, 1)
+	sys.umtx_op(&cond._seq castto(void#), sys.Umtxwakepriv, 1, Zptr, Zptr)
+}
+
+const condbroadcast = {cond : cond#
+	xadd(&cond._seq, 1)
+	sys.umtx_op(&cond._seq castto(void#), sys.Umtxwakepriv, 0x7ffffff, Zptr, Zptr)
+}
+
--- /dev/null
+++ b/lib/thread/condvar+linux.myr
@@ -1,0 +1,61 @@
+use std
+use sys
+
+use "atomic.use"
+use "common.use"
+use "mutex.use"
+
+pkg thread =
+	type cond = struct
+		_mtx	: mutex#
+		_seq	: int32
+	;;
+
+	const mkcond	: (mtx : mutex# -> cond)
+	const condwait	: (cond : cond# -> void)
+	const condsignal	: (cond : cond# -> void)
+	const condbroadcast	: (cond : cond# -> void)
+;;
+
+const mkcond = {mtx
+	-> [._mtx = mtx, ._seq = 0]
+}
+
+const condwait = {cond
+	var seq
+	var mtx
+
+	mtx = cond._mtx
+	seq = cond._seq
+
+	mtxunlock(mtx)
+	sys.futex(&cond._seq, sys.Futexwait | sys.Futexpriv, seq, Zptr, Zptr, 0)
+
+	/*
+	We need to atomically set the mutex to contended. This allows us to
+	pass responsibility for waking up the potential other waiters on to the
+	unlocker of the mutex.
+	*/
+	while xchg(&mtx._state, Contended) != Unlocked
+		sys.futex(&mtx._state, sys.Futexwait | sys.Futexpriv, \
+			Contended, Zptr, Zptr, 0)
+	;;
+}
+
+const condsignal = {cond : cond#
+	xadd(&cond._seq, 1)
+	sys.futex(&cond._seq, sys.Futexwake | sys.Futexpriv, 1, Zptr, Zptr, 0)
+}
+
+const condbroadcast = {cond : cond#
+	xadd(&cond._seq, 1)
+	/*
+	The futex docs seem to be broken -- the timeout parameter seems to be
+	used for the number of threads to move, and is not ignored when
+	requeueing
+	*/
+	sys.futex(&cond._seq, sys.Futexcmprequeue | sys.Futexpriv, \
+		1, 0x7fffffff castto(sys.timespec#), \
+		&cond._mtx._state, cond._seq)
+}
+
--- /dev/null
+++ b/lib/thread/exit+freebsd-x64.s
@@ -1,0 +1,23 @@
+/*
+const thread.exit	: (stacksz : std.size -> void)
+NOTE: must be called from the bottom of the stack, since
+we assume that %rbp is in the top 4k of the stack.
+*/
+.globl thread$exit
+thread$exit:
+	/* find top of stack */
+	movq	%rbp,%rdi	/* addr */
+	andq	$~0xfff,%rdi	/* align it */
+	addq	$0x1000,%rdi
+
+	/* munmap(base, size) */
+	movq	$73,%rax	/* munmap */
+	movq	-8(%rdi),%rsi	/* size */
+	subq	%rsi,%rdi	/* move to base ptr */
+	syscall
+
+	/* thr_exit(null) */
+	movq	$431,%rax	/* exit */
+	xorq	%rdi,%rdi	/* 0 */
+	syscall
+	
--- /dev/null
+++ b/lib/thread/exit+linux-x64.s
@@ -1,0 +1,23 @@
+/*
+const thread.exit	: (stacksz : std.size -> void)
+NOTE: must be called from the bottom of the stack, since
+we assume that %rbp is in the top 4k of the stack.
+*/
+.globl thread$exit
+thread$exit:
+	/* find top of stack */
+	movq	%rbp,%rdi	/* addr */
+	andq	$~0xfff,%rdi	/* align it */
+	addq	$0x1000,%rdi
+
+	/* munmap(base, size) */
+	movq	$11,%rax	/* munmap */
+	movq	-8(%rdi),%rsi	/* size */
+	subq	%rsi,%rdi	/* move to base ptr */
+	syscall
+
+	/* thread_exit(0) */
+	movq	$60,%rax	/* exit */
+	xorq	%rdi,%rdi	/* 0 */
+	syscall
+	
--- /dev/null
+++ b/lib/thread/future.myr
@@ -1,0 +1,63 @@
+use std
+
+use "mutex.use"
+
+pkg thread =
+	type future(@a) = struct
+		mtx	: mutex
+		set	: bool
+		val	: @a
+	;;
+
+	generic mkfut	: (-> future(@a))
+	generic futset	: (fut : future(@a)#, val : @a -> bool)
+	generic futget	: (fut : future(@a)# -> @a)
+	generic futtryget	: (fut : future(@a)# -> std.option(@a))
+	generic futclear	: (fut : future(@a)# -> void)
+;;
+
+const Unset = 0
+const Waiting = 1
+const Set = 2
+
+generic mkfut = {
+	var fut
+
+	fut = [.mtx = mkmtx() ]
+	mtxlock(&fut.mtx)
+	-> fut
+}
+
+generic futset = {fut, val
+	if fut.set
+		-> false
+	;;
+	/* compiler doesn't reorder shit */
+	fut.val = val
+	fut.set = true
+	mtxunlock(&fut.mtx)
+	-> true
+}
+
+generic futtryget = {fut
+	var val
+
+	if !fut.set
+		-> `std.None
+	;;
+	mtxlock(&fut.mtx)
+	val = fut.val
+	mtxunlock(&fut.mtx)
+	-> `std.Some val
+}
+
+generic futget = {fut
+	var val
+
+	mtxlock(&fut.mtx)
+	val = fut.val
+	mtxunlock(&fut.mtx)
+	-> val
+}
+
+
--- /dev/null
+++ b/lib/thread/mutex+freebsd.myr
@@ -1,0 +1,80 @@
+use std
+use sys
+
+use "atomic.use"
+use "common.use"
+
+pkg thread =
+	type mutex = struct
+		_state	: uint32
+	;;	
+
+	const mkmtx	: (-> mutex)
+	const mtxlock	: (mtx : mutex# -> void)
+	const mtxtrylock	: (mtx : mutex# -> bool)
+	const mtxunlock	: (mtx : mutex# -> void)
+
+	pkglocal const Unlocked = 0
+	pkglocal const Locked = 1
+	pkglocal const Contended = 2
+;;
+
+var nspin = 10	/* FIXME: pick a sane number, based on CPU count */
+
+const mkmtx = {
+	-> [._state = Unlocked]
+}
+
+const mtxlock = {mtx
+	var c
+
+	/* 
+	Uncontended case: we get an unlocked mutex, and we lock it.
+	*/
+        c = Locked
+	for var i = 0; i < nspin; i++
+		c = xcas(&mtx._state, Unlocked, Locked) 
+		if c == Unlocked
+			->
+		;;
+	;;
+
+	/*
+	Contended case: we set the lock state to Contended. This indicates that there
+	the lock is locked, and we potentially have threads waiting on it, which means
+	that we will need to wake them up.
+	*/
+	if c == Locked
+		c = xchg(&mtx._state, Contended)
+	;;
+
+	while c != Unlocked
+		sys.umtx_op( \
+			&mtx._state castto(void#), \
+			sys.Umtxwaituintpriv, \
+			Contended castto(uint64), \
+			Zptr, Zptr)
+		c = xchg(&mtx._state, Contended)
+	;;
+}
+
+const mtxtrylock = {mtx
+	-> xcas(&mtx._state, Unlocked, Locked) == Unlocked
+}
+
+const mtxunlock = {mtx
+	/*
+	Uncontended case: If the mutex state is not contended, and we still
+	are uncontended by the xchg() call, then it's safe to simply return;
+	nobody was waiting for us.
+	*/
+	if mtx._state == Contended
+		mtx._state = Unlocked
+	elif xchg(&mtx._state, Unlocked) == Locked
+		->
+	;;
+
+	/* wake all threads: for some reason nwake */
+	sys.umtx_op(&mtx._state castto(void#), sys.Umtxwakepriv, 1, Zptr, Zptr)
+}
+
--- /dev/null
+++ b/lib/thread/mutex+linux.myr
@@ -1,0 +1,76 @@
+use std
+use sys
+
+use "atomic.use"
+use "common.use"
+
+pkg thread =
+	type mutex = struct
+		_state	: int32
+	;;	
+
+	const mkmtx	: (-> mutex)
+	const mtxlock	: (mtx : mutex# -> void)
+	const mtxtrylock	: (mtx : mutex# -> bool)
+	const mtxunlock	: (mtx : mutex# -> void)
+
+	pkglocal const Unlocked = 0
+	pkglocal const Locked = 1
+	pkglocal const Contended = 2
+;;
+
+var nspin = 10	/* FIXME: pick a sane number, based on CPU count */
+
+const mkmtx = {
+	-> [._state = Unlocked]
+}
+
+const mtxlock = {mtx
+	var c
+
+	/* 
+	Uncontended case: we get an unlocked mutex, and we lock it.
+	*/
+        c = Locked
+	for var i = 0; i < nspin; i++
+		c = xcas(&mtx._state, Unlocked, Locked) 
+		if c == Unlocked
+			-> void
+		;;
+	;;
+
+	/*
+	Contended case: we set the lock state to Contended. This indicates that there
+	the lock is locked, and we potentially have threads waiting on it, which means
+	that we will need to wake them up.
+	*/
+	if c == Locked
+		c = xchg(&mtx._state, Contended)
+	;;
+
+	while c != Unlocked
+		sys.futex(&mtx._state, sys.Futexwait | sys.Futexpriv, Contended, Zptr, Zptr, 0)
+		c = xchg(&mtx._state, Contended)
+	;;
+}
+
+const mtxtrylock = {mtx
+	-> xcas(&mtx._state, Unlocked, Locked) == Unlocked
+}
+
+const mtxunlock = {mtx
+	/*
+	Uncontended case: If the mutex state is not contended, and we still
+	are uncontended by the xchg() call, then it's safe to simply return;
+	nobody was waiting for us.
+	*/
+	if mtx._state == Contended
+		mtx._state = Unlocked
+	elif xchg(&mtx._state, Unlocked) == Locked
+		-> void
+	;;
+
+	/* wake one thread */
+	sys.futex(&mtx._state, sys.Futexwake | sys.Futexpriv, 1, Zptr, Zptr, 0)
+}
+
--- /dev/null
+++ b/lib/thread/mutex+osx.myr
@@ -1,0 +1,65 @@
+use std
+use sys
+
+
+use "atomic.use"
+use "common.use"
+
+pkg thread =
+	type mutex = struct
+		_state	: uint32
+	;;	
+
+	const mkmtx	: (-> mutex)
+	const mtxlock	: (mtx : mutex# -> void)
+	const mtxtrylock	: (mtx : mutex# -> bool)
+	const mtxunlock	: (mtx : mutex# -> void)
+;;
+
+const mkmtx = {
+	-> [._state = 0]
+}
+
+/* a shitty spinlock */
+const mtxlock = {mtx
+	/* first fast */
+	for var i = 0; i < 1000; i++
+		if xcas(&mtx._state, 0, 1) == 0
+			-> void
+		;;
+		std.nanosleep(0)
+	;;
+	
+	/* then slower */
+	for var i = 0; i < 1000; i++
+		if xcas(&mtx._state, 0, 1) == 0
+			-> void
+		;;
+		std.nanosleep(10_000) /* 10 us */
+	;;
+
+	/* even slower */
+	for var i = 0; i < 1000; i++
+		if xcas(&mtx._state, 0, 1) == 0
+			-> void
+		;;
+		std.nanosleep(100_000) /* 100 us */
+	;;
+
+	/* I'm rip van winkle! */
+	while true
+		if xcas(&mtx._state, 0, 1) == 0
+			-> void
+		;;
+		std.nanosleep(1000_000) /* 1 ms */
+	;;
+}
+
+const mtxtrylock = {mtx
+	-> xcas(&mtx._state, 0, 1) == 0
+}
+
+	
+const mtxunlock = {mtx
+	xset(&mtx._state, 0)
+}
--- /dev/null
+++ b/lib/thread/mutex+plan9.myr
@@ -1,0 +1,47 @@
+use std
+use sys
+
+
+use "atomic.use"
+use "common.use"
+
+pkg thread =
+	type mutex = struct
+		_state	: uint32
+		_sem	: uint32
+	;;	
+
+	const mkmtx	: (-> mutex)
+	const mtxlock	: (mtx : mutex# -> void)
+	const mtxtrylock	: (mtx : mutex# -> bool)
+	const mtxunlock	: (mtx : mutex# -> void)
+;;
+
+const mkmtx = {
+	-> [._state = 0, ._sem=0]
+}
+
+const mtxlock = {mtx
+	/* if the old value was 0, we aren't contended */
+	if xadd(&mtx._state, 1) == 0
+		-> void
+	;;
+	
+	while sys.semacquire(&mtx._sem, 1) < 0
+		/* interrupted; retry */
+	;;
+}
+
+const mtxtrylock = {mtx
+	-> xcas(&mtx._state, 0, 1) == 0
+}
+
+	
+const mtxunlock = {mtx
+	/* if we were the only thread waiting on the lock, there was no contention */
+	if xadd(&mtx._state, -1) == 1
+		-> void
+	;;
+
+	sys.semrelease(&mtx._sem, 1)
+}
--- /dev/null
+++ b/lib/thread/spawn+freebsd.myr
@@ -1,0 +1,74 @@
+use sys
+use std
+
+pkg thread =
+	type tid = uint64
+
+	const spawn : (fn : (-> void) -> std.result(tid, byte[:]))
+;;
+
+
+const Stacksz = 8*std.MiB
+extern const exit : (-> void)
+
+const spawn = {fn
+	-> spawnstk(fn, Stacksz)
+}
+
+const spawnstk = {fn, sz
+	var stk : byte#, tid, ctid, ret
+	var szp, fp, tos
+
+	stk = getstk(sz)
+	if stk == sys.Mapbad
+		-> `std.Fail "couldn't get stack"
+	;;
+	tid = -1
+	/* find top of stack */
+	tos = (stk castto(std.intptr)) + (sz castto(std.intptr))
+
+	/* store the stack size */
+	tos -= sizeof(sys.size)
+	sz -= sizeof(sys.size)
+	szp = tos castto(sys.size#)
+	szp# = Stacksz
+
+	/* store the function we call */
+	tos -= sizeof((->void))
+	sz -= sizeof((->void))
+	fp = tos castto((->void)#)
+	fp# = fn
+
+	ret = sys.thr_new(&[
+		.startfn = startthread castto(void#),
+		.arg = tos castto(void#),
+		.stkbase = stk castto(byte#),
+		.stksz = sz,
+		.tid = &ctid,
+		.ptid = &tid,
+		.flags = 2,
+		.rtp = 0 castto(sys.rtprio#)
+	], sizeof(sys.thrparam))
+
+	if ret < 0
+		-> `std.Fail "couldn't spawn thread"
+	;;
+	-> `std.Ok tid castto(tid)
+}
+
+const getstk = {sz
+	var p, m
+
+	p = sys.mmap(0 castto(byte#), sz, sys.Mprotrw, sys.Mpriv | sys.Manon, -1, 0)
+	if p == sys.Mapbad
+		-> p
+	;;
+	m = p castto(std.intptr)
+	-> m castto(byte#)
+}
+
+const startthread = {fn : (-> void)#
+	fn#()
+	exit()
+}
+
--- /dev/null
+++ b/lib/thread/spawn+linux.myr
@@ -1,0 +1,68 @@
+use sys
+use std
+
+pkg thread =
+	type tid = sys.pid
+
+	const spawn : (fn : (-> void) -> std.result(tid, byte[:]))
+;;
+
+extern const exit : (-> void)
+
+/* Holy shit flag mania. */
+const Thrflag = sys.Clonevm | sys.Clonefs | sys.Clonefiles  | \
+	sys.Clonesighand | sys.Clonethread |sys.Clonesysvsem | \
+	sys.Clonesettls | sys.Cloneparentsettid | sys.Clonechildcleartid
+
+const Stacksz = 8*std.MiB
+
+const spawn = {fn
+	-> spawnstk(fn, Stacksz)
+}
+
+const spawnstk = {fn, sz
+	var stk : byte#, tid, ctid, ret
+	var szp, fp, tos
+
+	stk = getstk(sz)
+	if stk == sys.Mapbad
+		-> `std.Fail "couldn't get stack"
+	;;
+	tos = stk castto(std.intptr)
+	tos -= sizeof(int64)
+	szp = tos castto(sys.size#)
+	szp# = Stacksz
+	tos -= sizeof((->void))
+	fp = tos castto((->void)#)
+	fp# = fn
+
+	ret = sys.fnclone(Thrflag, \
+		tos castto(byte#),\
+		&tid, 0 castto(byte#), \
+		&ctid, 0 castto(byte#), \
+		startthread castto(void#)) castto(tid)
+	if ret < 0
+		std.put("errno={}\n", -ret)
+		-> `std.Fail "couldn't spawn thread"
+	;;
+	-> `std.Ok ret
+}
+
+const getstk = {sz
+	var p, m
+
+	p = sys.mmap(0 castto(byte#), sz, sys.Mprotrw, sys.Mpriv | sys.Manon, -1, 0)
+	if p == sys.Mapbad
+		-> p
+	;;
+	/* stack starts at the top of memory and grows down. */
+	m = p castto(std.intptr)
+	m += sz castto(std.intptr)
+	-> m castto(byte#)
+}
+
+const startthread = {fn : (-> void)
+	fn()
+	exit()
+}
+
--- /dev/null
+++ b/lib/thread/spawn+osx.myr
@@ -1,0 +1,60 @@
+use sys
+use std
+
+pkg thread =
+	type tid = uint64
+
+	const spawn : (fn : (-> void) -> std.result(tid, byte[:]))
+;;
+
+
+const Stacksz = 8*std.MiB
+extern const exit : (-> void)
+extern const start : (-> void)
+
+const __init__ = {
+	var ret
+
+	ret = sys.bsdthread_register(\
+		start castto(void#), \	/* start */
+		0 castto(void#), \	/* wqthread */
+		0 castto(uint32), \	/* sz */
+		0 castto(uint32), \	/* dummy */
+		0 castto(void#), \	/* targconc */
+		0 castto(uint32))	/* queueoff */
+	if ret < 0
+		std.fatal("unable to init threads: {}", ret)
+	;;
+}
+
+
+
+const spawn = {fn
+	-> spawnstk(fn, Stacksz)
+}
+
+const spawnstk = {fn, sz
+	var tid : tid, ret
+
+
+	std.put("...hi? fn={}\n", fn castto(void#))
+	ret = sys.bsdthread_create( \
+		fn castto(void#), \
+		envptr(&fn), \
+		sz castto(void#), \
+		0 castto(void#), \
+		0)
+
+	if ret == (-1 castto(void#))
+		-> `std.Fail "couldn't spawn thread"
+	;;
+	-> `std.Ok ret castto(tid)
+}
+
+const envptr = {fn
+	var repr : std.intptr[2]
+
+	repr = (fn castto(std.intptr[2]#))#
+	-> repr[0] castto(void#)
+}
+
--- /dev/null
+++ b/lib/thread/spawn+plan9.myr
@@ -1,0 +1,18 @@
+use std
+use sys
+
+pkg thread =
+	type tid = uint64
+
+	const spawn : (fn : (-> void) -> std.result(tid, byte[:]))
+;;
+
+const spawn = {fn
+	match sys.rfork(sys.Rfproc | sys.Rfmem | sys.Rfnowait)
+	| 0:
+		fn()
+		std.exit(0)
+	| -1:	-> `std.Fail "unable to spawn thread"
+	| thr:	-> `std.Ok thr castto(tid)
+	;;
+}
\ No newline at end of file
--- /dev/null
+++ b/lib/thread/start+osx-x64.s
@@ -1,0 +1,22 @@
+// The entry point for thread start, registered with bsdthread_register
+//      %rdi: pthread (0, for us)
+//      %rsi: mach thread port (ignored)
+//      %rdx: func
+//      %rcx: env
+//      %r8: stack
+//      %r9: flags (= 0)
+//      %rsp: stack - C_64_REDZONE_LEN (= stack - 128)
+.globl _thread$start
+_thread$start:
+	/* call the function */
+#	movq	%r8, %rsp	/* set up stack */
+	movq	%rcx, %rax	/* set up env */
+        callq    *%rdx		/* call function */
+
+	/* exit the thread */
+	movq	$0x2000169, %rax	/* Sysbsdthread_terminate */
+	movq	%rsp, %rdi	/* stack */
+	movq	$0, %rsi	/* len */
+	movq	$0, %rdx	/* sem */
+	syscall
+	
--- /dev/null
+++ b/lib/thread/test/atomic.myr
@@ -1,0 +1,29 @@
+use std
+use thread
+
+use "test/util.use"
+
+const Nherd = 20
+
+var val : uint64 = 0
+var done : uint32 = 0
+
+const main = {
+	done = 0
+	val = 0
+	mkherd(Nherd, incvar)
+	while thread.xget(&done) != Nherd
+		/* nothing */
+	;;
+	std.assert(val == 2_000_000, "atomics are broken\n")
+}
+
+const incvar = {
+	var i
+
+	for i = 0; i < 100_000; i++
+		thread.xadd(&val, 1)
+	;;
+	thread.xadd(&done, 1)
+}
+
--- /dev/null
+++ b/lib/thread/test/condvar.myr
@@ -1,0 +1,88 @@
+use std
+use thread
+
+use "test/util.use"
+
+const Nwakes = 1000
+
+var cv
+var mtx
+var val
+
+var done : int32
+var nwoken : int32
+var nready : int32
+var locked : int32
+
+const main = {
+	done = 0
+	val = 123
+
+	mtx = thread.mkmtx()
+	cv = thread.mkcond(&mtx)
+	thread.spawn(cvwait)
+	thread.spawn(cvwake)
+	while done == 0
+		/* nothing */
+	;;
+	std.assert(nwoken == Nwakes, "wrong number of wakes")
+	std.assert(val == 123, "wrong val after all are done")
+
+	nwoken = 0
+	nready = 0
+	mkherd(100, cvwaitonce)
+
+	/* wait until the herd is ready */
+	while nready != 100	/* 0 to 99 */
+		/* nothing */
+	;;
+	while locked == 0
+		/* nothing */
+	;;
+	thread.condbroadcast(&cv)
+	while nwoken != 100
+		/* nothing */
+	;;
+	std.assert(nwoken == 100, "wrong thread count woken")
+
+}
+
+const cvwait = {
+	for var i = 0; i < Nwakes; i++
+		thread.mtxlock(&mtx)
+		thread.condwait(&cv)
+		std.assert(val == 456, "wrong val after signal\n")
+		val = 123
+		thread.mtxunlock(&mtx)
+
+		thread.xadd(&nwoken, 1)
+	;;
+	val = 123
+	thread.xadd(&done, 1)
+
+}
+
+const cvwake = {
+	while true
+		thread.mtxlock(&mtx)
+		val = 456
+		thread.mtxunlock(&mtx)
+
+		thread.condsignal(&cv)
+		if nwoken >= Nwakes
+			break
+		;;
+	;;
+}
+
+const cvwaitonce = {
+	thread.xadd(&nready, 1)
+
+	thread.mtxlock(&mtx)
+	thread.xadd(&locked, 1)
+	thread.condwait(&cv)
+	thread.mtxunlock(&mtx)
+
+	thread.xadd(&nwoken, 1)
+}
+
--- /dev/null
+++ b/lib/thread/test/future.myr
@@ -1,0 +1,50 @@
+use std
+use sys
+use thread
+
+use "test/util.use"
+
+var fut
+var nready : int32
+var ndone : int32
+
+const main = {
+	nready = 0
+	ndone = 0
+	fut = thread.mkfut()
+	/* set after we have some waiters */
+	mkherd(100, getfuture)
+	while nready != 100
+		/* spin */
+	;;
+	std.put("done waiting for ready\n")
+	std.assert(ndone == 0, "thread proceeded too soon\n")
+	thread.futset(&fut, 666)
+	std.assert(thread.futset(&fut, 1) == false, "double set future\n")
+	while ndone != 100
+		/* spin */
+	;;
+	std.put("double set future ok")
+	/* start up a few more to make sure we can still read */
+	mkherd(50, getfuture)
+	while ndone != 150
+		/* spin */
+	;;
+
+	
+	/* set ahead of time */
+	ndone = 0
+	fut = thread.mkfut()
+	thread.futset(&fut, 666)
+	std.assert(thread.futset(&fut, 666) == false, "double set future\n")
+	mkherd(100, getfuture)
+	while ndone != 100
+		/* spin */
+	;;
+}
+
+const getfuture = {
+	thread.xadd(&nready, 1)
+	std.assert(thread.futget(&fut) == 666, "wrong value gotten from future")
+	thread.xadd(&ndone, 1)
+}
--- /dev/null
+++ b/lib/thread/test/mutex.myr
@@ -1,0 +1,33 @@
+use std
+use thread
+
+use "test/util.use"
+
+const Nherd = 20
+
+var val : uint64 = 0
+var done : uint32 = 0
+var mtx : thread.mutex
+
+const main = {
+	done = 0
+	val = 0
+
+	mtx = thread.mkmtx()
+	mkherd(Nherd, incvar)
+	while thread.xget(&done) != Nherd
+		/* nothing */
+	;;
+	if val != 10_000 * 20
+		std.fatal("mutexes are broken, got {}\n", val)
+	;;
+}
+
+const incvar = {
+	for var i = 0; i < 10_000; i++
+		thread.mtxlock(&mtx)
+		val++
+		thread.mtxunlock(&mtx)
+	;;
+	thread.xadd(&done, 1)
+}
--- /dev/null
+++ b/lib/thread/test/spawn.myr
@@ -1,0 +1,25 @@
+use std
+use thread
+
+var done : int32
+var capture
+
+const main = {
+	var ptr
+
+	capture = 666
+	ptr = &capture
+	thread.spawn({
+		std.assert(capture==666, "wrong captured value\n")
+		std.assert(ptr#==666, "wrong captured ptr value\n")
+		ptr# = 333
+		thread.xadd(&done, 1)
+	})
+
+	while done == 0
+		/* nothing */
+	;;
+
+	std.assert(capture == 333, "capture wasn't written to correctly\n")
+}
+
--- /dev/null
+++ b/lib/thread/test/util.myr
@@ -1,0 +1,12 @@
+use std
+use thread
+
+pkg =
+	const mkherd : (n : uint32, fn : (-> void) ->void)
+;;
+
+const mkherd = {n, fn
+	for var i = 0; i < n; i++
+		std.try(thread.spawn(fn))
+	;;
+}