runtime (gc): generalize the AVR "list" GC to work on all targets

Author: niaow

compileopts/config.go

@@ -79,7 +79,12 @@ func (c *Config) GOARCH() string {
 
 // BuildTags returns the complete list of build tags used during this build.
 func (c *Config) BuildTags() []string {
-	tags := append(c.Target.BuildTags, []string{"tinygo", "gc." + c.GC(), "scheduler." + c.Scheduler()}...)
+	gc := c.GC()
+	tags := append(c.Target.BuildTags, []string{"tinygo", "gc." + gc, "scheduler." + c.Scheduler()}...)
+	switch gc {
+	case "list", "blocks", "extalloc":
+		tags = append(tags, "gc.conservative")
+	}
 	for i := 1; i <= c.GoMinorVersion; i++ {
 		tags = append(tags, fmt.Sprintf("go1.%d", i))
 	}
@@ -96,7 +101,7 @@ func (c *Config) CgoEnabled() bool {
 }
 
 // GC returns the garbage collection strategy in use on this platform. Valid
-// values are "none", "leaking", "extalloc", and "conservative".
+// values are "none", "leaking", "list", "extalloc", and "blocks".
 func (c *Config) GC() string {
 	if c.Options.GC != "" {
 		return c.Options.GC
@@ -106,7 +111,7 @@ func (c *Config) GC() string {
 	}
 	for _, tag := range c.Target.BuildTags {
 		if tag == "baremetal" || tag == "wasm" {
-			return "conservative"
+			return "blocks"
 		}
 	}
 	return "extalloc"
@@ -116,7 +121,7 @@ func (c *Config) GC() string {
 // that can be traced by the garbage collector.
 func (c *Config) NeedsStackObjects() bool {
 	switch c.GC() {
-	case "conservative", "extalloc":
+	case "list", "blocks", "extalloc":
 		for _, tag := range c.BuildTags() {
 			if tag == "wasm" {
 				return true

compileopts/options.go

@@ -6,7 +6,7 @@ import (
 )
 
 var (
-	validGCOptions            = []string{"none", "leaking", "extalloc", "conservative"}
+	validGCOptions            = []string{"none", "leaking", "list", "extalloc", "blocks"}
 	validSchedulerOptions     = []string{"none", "tasks", "coroutines"}
 	validPrintSizeOptions     = []string{"none", "short", "full"}
 	validPanicStrategyOptions = []string{"print", "trap"}

compileopts/options_test.go

@@ -9,7 +9,7 @@ import (
 
 func TestVerifyOptions(t *testing.T) {
 
-	expectedGCError := errors.New(`invalid gc option 'incorrect': valid values are none, leaking, extalloc, conservative`)
+	expectedGCError := errors.New(`invalid gc option 'incorrect': valid values are none, leaking, list, extalloc, blocks`)
 	expectedSchedulerError := errors.New(`invalid scheduler option 'incorrect': valid values are none, tasks, coroutines`)
 	expectedPrintSizeError := errors.New(`invalid size option 'incorrect': valid values are none, short, full`)
 	expectedPanicStrategyError := errors.New(`invalid panic option 'incorrect': valid values are print, trap`)
@@ -42,16 +42,22 @@ func TestVerifyOptions(t *testing.T) {
 				GC: "leaking",
 			},
 		},
+		{
+			name: "GCOptionList",
+			opts: compileopts.Options{
+				GC: "list",
+			},
+		},
 		{
 			name: "GCOptionExtalloc",
 			opts: compileopts.Options{
 				GC: "extalloc",
 			},
 		},
 		{
-			name: "GCOptionConservative",
+			name: "GCOptionBlocks",
 			opts: compileopts.Options{
-				GC: "conservative",
+				GC: "blocks",
 			},
 		},
 		{

main.go

@@ -812,7 +812,7 @@ func main() {
 	command := os.Args[1]
 
 	opt := flag.String("opt", "z", "optimization level: 0, 1, 2, s, z")
-	gc := flag.String("gc", "", "garbage collector to use (none, leaking, extalloc, conservative)")
+	gc := flag.String("gc", "", "garbage collector to use (none, leaking, extalloc, blocks, list)")
 	panicStrategy := flag.String("panic", "print", "panic strategy (print, trap)")
 	scheduler := flag.String("scheduler", "", "which scheduler to use (none, coroutines, tasks)")
 	printIR := flag.Bool("printir", false, "print LLVM IR")

src/runtime/gc_conservative.go renamed to src/runtime/gc_blocks.go

@@ -1,5 +1,4 @@
-// +build gc.conservative
-// +build !avr
+// +build gc.blocks
 
 package runtime
 

src/runtime/gc_globals_conservative.go

@@ -1,4 +1,4 @@
-// +build gc.conservative gc.extalloc
+// +build gc.conservative
 // +build baremetal
 
 package runtime

src/runtime/gc_globals_precise.go

@@ -1,4 +1,4 @@
-// +build gc.conservative gc.extalloc
+// +build gc.conservative
 // +build !baremetal
 
 package runtime

src/runtime/gc_avr.go renamed to src/runtime/gc_list.go

@@ -1,17 +1,20 @@
-// +build gc.conservative
-// +build avr
+// +build gc.list
 
 package runtime
 
+import (
+	"internal/task"
+	"runtime/interrupt"
+	"unsafe"
+)
+
 // This memory manager is partially inspired by the memory allocator included in avr-libc.
 // Unlike avr-libc malloc, this memory manager stores an allocation list instead of a free list.
-// This gives an overhead of 4 bytes/allocation (up from avr-libc's 2 bytes/allocation).
+// This gives an overhead of 2 pointers/allocation (up from avr-libc's 1 pointer-width/allocation).
 // The allocation list is stored in ascending address order.
 // The set of free spans is implicitly derived from the gaps between allocations.
 // This allocator has an effective allocation complexity of O(n) and worst-case GC complexity of O(n^2).
-// Due to architectural quirks of AVR, as well as tiny heaps, this should almost always be faster than the standard conservative collector.
-
-import "unsafe"
+// Due to architectural quirks, as well as tiny heaps, this should almost always be faster than the standard conservative collector on AVR.
 
 // isInHeap checks if an address is inside the heap.
 func isInHeap(addr uintptr) bool {
@@ -73,25 +76,28 @@ func markAddr(addr uintptr) {
 	}
 }
 
-// markMem scans a memory region for pointers and marks anything that is pointed to.
-func markMem(start, end uintptr) {
-	if start >= end {
-		return
-	}
-	prevByte := *(*byte)(unsafe.Pointer(start))
-	for ; start != end; start++ {
-		b := *(*byte)(unsafe.Pointer(start))
-		addr := (uintptr(b) << 8) | uintptr(prevByte)
-		markAddr(addr)
-		prevByte = b
-	}
-}
-
 // GC runs a garbage collection cycle.
 func GC() {
 	// Mark phase: mark all reachable objects, recursively.
 	markGlobals()
 	markStack()
+	var markedTaskQueue task.Queue
+runqueueScan:
+	if baremetal && hasScheduler {
+		// Channel operations in interrupts may move task pointers around while we are marking.
+		// Therefore we need to scan the runqueue seperately.
+		for !runqueue.Empty() {
+			// Pop the next task off of the runqueue.
+			t := runqueue.Pop()
+
+			// Mark the task if it has not already been marked.
+			markRoot(uintptr(unsafe.Pointer(&runqueue)), uintptr(unsafe.Pointer(t)))
+
+			// Push the task onto our temporary queue.
+			markedTaskQueue.Push(t)
+		}
+	}
+
 	var keep *allocNode
 	for scanList != nil {
 		// Pop a node off of the scan list.
@@ -117,6 +123,18 @@ func GC() {
 		}
 	}
 
+	if baremetal && hasScheduler {
+		// Restore the runqueue.
+		i := interrupt.Disable()
+		if !runqueue.Empty() {
+			// Something new came in while finishing the mark.
+			interrupt.Restore(i)
+			goto runqueueScan
+		}
+		runqueue = markedTaskQueue
+		interrupt.Restore(i)
+	}
+
 	// Sweep phase: replace the heap.
 	allocList = keep
 }
@@ -172,7 +190,7 @@ searchLoop:
 			// That was the last free region.
 			break searchLoop
 		}
-		start = uintptr(unsafe.Pointer(&node.base)) + node.len
+		start = align(uintptr(unsafe.Pointer(&node.base)) + node.len)
 		dst = &node.next
 	}
 

src/runtime/gc_list_avr.go

@@ -0,0 +1,19 @@
+// +build gc.list,avr
+
+package runtime
+
+import "unsafe"
+
+// markMem scans a memory region for pointers and marks anything that is pointed to.
+func markMem(start, end uintptr) {
+	if start >= end {
+		return
+	}
+	prevByte := *(*byte)(unsafe.Pointer(start))
+	for ; start != end; start++ {
+		b := *(*byte)(unsafe.Pointer(start))
+		addr := (uintptr(b) << 8) | uintptr(prevByte)
+		markAddr(addr)
+		prevByte = b
+	}
+}

src/runtime/gc_list_generic.go

@@ -0,0 +1,14 @@
+// +build gc.list,!avr
+
+package runtime
+
+import "unsafe"
+
+// markMem scans a memory region for pointers and marks anything that is pointed to.
+func markMem(start, end uintptr) {
+	start = align(start)
+	end &^= unsafe.Alignof(unsafe.Pointer(nil)) - 1
+	for ; start < end; start += unsafe.Alignof(unsafe.Pointer(nil)) {
+		markAddr(*(*uintptr)(unsafe.Pointer(start)))
+	}
+}