runtime: release completed Asyncify stacks

Author: jakebailey

main_test.go

@@ -1125,7 +1125,7 @@ func TestGoexitCrash(t *testing.T) {
 		panicStrategy string
 		want          string
 	}{
-		{"wasip1-deadlock", "deadlock", "", "deadlocked: no event source"},
+		{"wasip1-deadlock", "deadlock", "", "fatal error: all goroutines are asleep - deadlock!"},
 		{"wasip1-goexit-panic-trap", "defer", "trap", "defer ran"},
 	} {
 		t.Run(tc.name, func(t *testing.T) {

src/internal/task/task.go

@@ -30,6 +30,9 @@ type Task struct {
 	// since it falls into the padding of the FipsIndicator bit above.
 	RunState uint8
 
+	// Exited is set after a task with a releasable stack has finished.
+	Exited bool
+
 	// DeferFrame stores a pointer to the (stack allocated) defer frame of the
 	// goroutine that is used for the recover builtin.
 	DeferFrame unsafe.Pointer
@@ -72,5 +75,8 @@ func getGoroutineStackSize(fn uintptr) uintptr
 //go:linkname runtime_alloc runtime.alloc
 func runtime_alloc(size uintptr, layout unsafe.Pointer) unsafe.Pointer
 
+//go:linkname runtime_freeTaskStack runtime.freeTaskStack
+func runtime_freeTaskStack(ptr uintptr)
+
 //go:linkname scheduleTask runtime.scheduleTask
 func scheduleTask(*Task)

src/internal/task/task_asyncify.go

@@ -24,6 +24,7 @@ type state struct {
 	// stackState is the state of the stack while unwound.
 	stackState
 
+	stackBase uintptr
 	launched bool
 
 	// finishing marks a goroutine that paused after it completed.
@@ -35,6 +36,8 @@ type state struct {
 	panicTarget    uintptr
 }
 
+const hasReleasableStack = true
+
 // stackState is the saved state of a stack while unwound.
 // The stack is arranged with asyncify at the bottom, C stack at the top, and a gap of available stack space between the two.
 type stackState struct {
@@ -76,8 +79,8 @@ func (s *state) initialize(fn uintptr, args unsafe.Pointer, stackSize uintptr) {
 	s.entry = fn
 	s.args = args
 
-	// Create a stack.
 	stack := runtime_alloc(stackSize, nil)
+	s.stackBase = uintptr(stack)
 
 	// Set up the stack canary, a random number that should be checked when
 	// switching from the task back to the scheduler. The stack canary pointer
@@ -152,6 +155,7 @@ func StopPanicUnwind(replay, target uintptr) {
 		currentTask.state.panicReplay = replay
 		currentTask.state.panicTarget = target
 	}
+	panicStackState = stackState{}
 }
 
 func ClearPanicReplay() {
@@ -164,6 +168,7 @@ func ClearPanicReplay() {
 	currentTask.state.panicOrigin = stackState{}
 	currentTask.state.panicReplay = 0
 	currentTask.state.panicTarget = 0
+	panicStackState = stackState{}
 }
 
 func PanicRewindData() unsafe.Pointer {
@@ -210,7 +215,12 @@ func (t *Task) Resume() {
 	if uintptr(t.state.asyncifysp) > uintptr(t.state.csp) {
 		runtimeFatal("stack overflow")
 	}
-	if t.state.finishing {
+	if t.Exited {
+		runtime_freeTaskStack(t.state.stackBase)
+		t.state = state{}
+		t.gcData = gcData{}
+		t.DeferFrame = nil
+	} else if t.state.finishing {
 		// The task is complete. Clear stale stack pointers and release its argument bundle.
 		t.state.finishing = false
 		t.clearStack()

src/internal/task/task_exit.go

@@ -22,8 +22,16 @@ func Goexit() {
 	exit(true)
 }
 
+// Exit exits the current task after its entry function returns.
+func Exit() {
+	exit(false)
+}
+
 func exit(goexit bool) {
 	t := Current()
+	if hasReleasableStack {
+		t.Exited = true
+	}
 	remaining := atomic.AddUint32(&liveTasks, ^uint32(0))
 	if t == mainTask {
 		if goexit {

src/internal/task/task_stack.go

@@ -28,6 +28,8 @@ type state struct {
 	canaryPtr *uintptr
 }
 
+const hasReleasableStack = false
+
 //export tinygo_task_exit
 func taskExit() {
 	exit(false)

src/runtime/gc_blocks.go

@@ -537,6 +537,22 @@ func free(ptr unsafe.Pointer) {
 	// TODO: free blocks on request, when the compiler knows they're unused.
 }
 
+//go:noinline
+func freeTaskStack(addr uintptr) {
+	ptr := unsafe.Pointer(addr)
+	gcLock.Lock()
+	firstBlock := blockFromAddr(addr)
+	if gcAsserts && firstBlock.pointer() != ptr {
+		runtimeFatal("gc: freeing pointer inside allocation")
+	}
+	lastBlock := firstBlock.findHead()
+	for block := firstBlock; block <= lastBlock; block++ {
+		block.free()
+	}
+	insertFreeRange(ptr, uintptr(lastBlock-firstBlock+1))
+	gcLock.Unlock()
+}
+
 // GC performs a garbage collection cycle.
 func GC() {
 	gcLock.Lock()

src/runtime/gc_boehm.go

@@ -102,6 +102,11 @@ func free(ptr unsafe.Pointer) {
 	libgc_free(ptr)
 }
 
+//go:noinline
+func freeTaskStack(ptr uintptr) {
+	free(unsafe.Pointer(ptr))
+}
+
 func GC() {
 	gcLock.Lock()
 	libgc_gcollect()

src/runtime/gc_custom.go

@@ -47,6 +47,11 @@ func alloc(size uintptr, layout unsafe.Pointer) unsafe.Pointer
 // free is called to explicitly free a previously allocated pointer.
 func free(ptr unsafe.Pointer)
 
+//go:noinline
+func freeTaskStack(ptr uintptr) {
+	free(unsafe.Pointer(ptr))
+}
+
 // markRoots is called with the start and end addresses to scan for references.
 // It is currently only called with the top and bottom of the stack.
 func markRoots(start, end uintptr)

src/runtime/gc_leaking.go

@@ -84,6 +84,10 @@ func free(ptr unsafe.Pointer) {
 	// Memory is never freed.
 }
 
+//go:noinline
+func freeTaskStack(ptr uintptr) {
+}
+
 func markRoots(start, end uintptr) {
 	runtimeFatal("unreachable: markRoots")
 }

src/runtime/gc_none.go

@@ -28,6 +28,10 @@ func free(ptr unsafe.Pointer) {
 	// Nothing to free when nothing gets allocated.
 }
 
+//go:noinline
+func freeTaskStack(ptr uintptr) {
+}
+
 func GC() {
 	// Unimplemented.
 }