runtime: release completed Asyncify stacks

Author: jakebailey

main_test.go

@@ -1173,7 +1173,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

@@ -25,7 +25,8 @@ type state struct {
 	// stackState is the state of the stack while unwound.
 	stackState
 
-	launched bool
+	stackBase uintptr
+	launched  bool
 
 	// finishing marks a goroutine that paused after it completed.
 	// Resume uses this per task flag to clear the stack.
@@ -36,6 +37,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 {
@@ -79,6 +82,7 @@ func (s *state) initialize(fn uintptr, args unsafe.Pointer, stackSize uintptr) {
 
 	// Create a stack.
 	stack := runtime_alloc(stackSize, gclayout.Conservative.AsPtr())
+	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
@@ -153,6 +157,7 @@ func StopPanicUnwind(replay, target uintptr) {
 		currentTask.state.panicReplay = replay
 		currentTask.state.panicTarget = target
 	}
+	panicStackState = stackState{}
 }
 
 func ClearPanicReplay() {
@@ -165,6 +170,7 @@ func ClearPanicReplay() {
 	currentTask.state.panicOrigin = stackState{}
 	currentTask.state.panicReplay = 0
 	currentTask.state.panicTarget = 0
+	panicStackState = stackState{}
 }
 
 func PanicRewindData() unsafe.Pointer {
@@ -211,7 +217,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

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

src/runtime/gc_blocks.go

@@ -559,6 +559,22 @@ func free(ptr unsafe.Pointer) {
 	gcLock.Unlock()
 }
 
+//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

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

src/runtime/gc_custom.go

@@ -40,6 +40,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.
 func markRoots(start, end uintptr)
 

src/runtime/gc_leaking.go

@@ -72,6 +72,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

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