all: add support for multicore scheduler

This commit adds support for a scheduler that runs a scheduler on all
available cores. It is meant to be used on baremetal systems with a
fixed number of cores, such as the RP2040.

The initial implementation adds support for multicore scheduling to the
riscv-qemu target as a convenient testing target. This means that this
new multicore scheduler is tested in CI, including a bunch of standard
library tests (`make tinygo-test-baremetal`). This should ensure the new
scheduler is reasonably well tested before trying to use it on
harder-to-debug targets like the RP2040.

Author: aykevl

builder/sizes.go

@@ -490,7 +490,7 @@ func loadProgramSize(path string, packagePathMap map[string]string) (*programSiz
 				continue
 			}
 			if section.Type == elf.SHT_NOBITS {
-				if section.Name == ".stack" {
+				if strings.HasPrefix(section.Name, ".stack") {
 					// TinyGo emits stack sections on microcontroller using the
 					// ".stack" name.
 					// This is a bit ugly, but I don't think there is a way to

builder/sizes_test.go

@@ -42,7 +42,7 @@ func TestBinarySize(t *testing.T) {
 	// This is a small number of very diverse targets that we want to test.
 	tests := []sizeTest{
 		// microcontrollers
-		{"hifive1b", "examples/echo", 4556, 280, 0, 2268},
+		{"hifive1b", "examples/echo", 4556, 280, 0, 2264},
 		{"microbit", "examples/serial", 2920, 388, 8, 2272},
 		{"wioterminal", "examples/pininterrupt", 7379, 1489, 116, 6912},
 

compileopts/config.go

@@ -110,6 +110,11 @@ func (c *Config) BuildTags() []string {
 		"math_big_pure_go",                           // to get math/big to work
 		"gc." + c.GC(), "scheduler." + c.Scheduler(), // used inside the runtime package
 		"serial." + c.Serial()}...) // used inside the machine package
+	switch c.Scheduler() {
+	case "threads", "cores":
+	default:
+		tags = append(tags, "tinygo.unicore")
+	}
 	for i := 1; i <= c.GoMinorVersion; i++ {
 		tags = append(tags, fmt.Sprintf("go1.%d", i))
 	}

compileopts/options.go

@@ -10,7 +10,7 @@ import (
 var (
 	validBuildModeOptions     = []string{"default", "c-shared", "wasi-legacy"}
 	validGCOptions            = []string{"none", "leaking", "conservative", "custom", "precise", "boehm"}
-	validSchedulerOptions     = []string{"none", "tasks", "asyncify", "threads"}
+	validSchedulerOptions     = []string{"none", "tasks", "asyncify", "threads", "cores"}
 	validSerialOptions        = []string{"none", "uart", "usb", "rtt"}
 	validPrintSizeOptions     = []string{"none", "short", "full", "html"}
 	validPanicStrategyOptions = []string{"print", "trap"}

compileopts/options_test.go

@@ -10,7 +10,7 @@ import (
 func TestVerifyOptions(t *testing.T) {
 
 	expectedGCError := errors.New(`invalid gc option 'incorrect': valid values are none, leaking, conservative, custom, precise, boehm`)
-	expectedSchedulerError := errors.New(`invalid scheduler option 'incorrect': valid values are none, tasks, asyncify, threads`)
+	expectedSchedulerError := errors.New(`invalid scheduler option 'incorrect': valid values are none, tasks, asyncify, threads, cores`)
 	expectedPrintSizeError := errors.New(`invalid size option 'incorrect': valid values are none, short, full, html`)
 	expectedPanicStrategyError := errors.New(`invalid panic option 'incorrect': valid values are print, trap`)
 

src/device/riscv/start.S

@@ -3,8 +3,47 @@
 .type _start,@function
 
 _start:
+    // If we're on a multicore system, we need to wait for hart 0 to wake us up.
+#if TINYGO_CORES > 1
+    csrr a0, mhartid
+
+    // Hart 0 stack
+    bnez a0, 1f
+    la sp,      _stack0_top
+
+1:
+    // Hart 1 stack
+    li a1, 1
+    bne a0, a1, 2f
+    la sp,      _stack1_top
+
+2:
+    // Hart 2 stack
+    #if TINYGO_CORES >= 3
+    li a1, 2
+    bne a0, a1, 3f
+    la sp,      _stack2_top
+    #endif
+
+3:
+    // Hart 3 stack
+    #if TINYGO_CORES >= 4
+    li a1, 3
+    bne a0, a1, 4f
+    la sp,      _stack3_top
+    #endif
+
+4:
+    // done
+
+#if TINYGO_CORES > 4
+#error only up to 4 cores are supported at the moment!
+#endif
+
+#else
     // Load the stack pointer.
     la sp,      _stack_top
+#endif
 
     // Load the globals pointer. The program will load pointers relative to this
     // register, so it must be set to the right value on startup.

src/internal/task/atomic-cooperative.go

@@ -1,4 +1,4 @@
-//go:build !scheduler.threads
+//go:build tinygo.unicore
 
 package task
 

src/internal/task/atomic-preemptive.go

@@ -1,4 +1,4 @@
-//go:build scheduler.threads
+//go:build !tinygo.unicore
 
 package task
 

src/internal/task/futex-cooperative.go

@@ -1,4 +1,4 @@
-//go:build !scheduler.threads
+//go:build tinygo.unicore
 
 package task
 

src/internal/task/futex-cores.go

@@ -0,0 +1,64 @@
+//go:build scheduler.cores
+
+package task
+
+import "runtime/interrupt"
+
+// A futex is a way for userspace to wait with the pointer as the key, and for
+// another thread to wake one or all waiting threads keyed on the same pointer.
+//
+// A futex does not change the underlying value, it only reads it before to prevent
+// lost wake-ups.
+type Futex struct {
+	Uint32
+
+	waiters Stack
+}
+
+// Atomically check for cmp to still be equal to the futex value and if so, go
+// to sleep. Return true if we were definitely awoken by a call to Wake or
+// WakeAll, and false if we can't be sure of that.
+func (f *Futex) Wait(cmp uint32) (awoken bool) {
+	mask := lockFutex()
+
+	if f.Uint32.Load() != cmp {
+		unlockFutex(mask)
+		return false
+	}
+
+	// Push the current goroutine onto the waiter stack.
+	f.waiters.Push(Current())
+
+	unlockFutex(mask)
+
+	// Pause until this task is awoken by Wake/WakeAll.
+	Pause()
+
+	// We were awoken by a call to Wake or WakeAll. There is no chance for
+	// spurious wakeups.
+	return true
+}
+
+// Wake a single waiter.
+func (f *Futex) Wake() {
+	mask := lockFutex()
+	if t := f.waiters.Pop(); t != nil {
+		scheduleTask(t)
+	}
+	unlockFutex(mask)
+}
+
+// Wake all waiters.
+func (f *Futex) WakeAll() {
+	mask := lockFutex()
+	for t := f.waiters.Pop(); t != nil; t = f.waiters.Pop() {
+		scheduleTask(t)
+	}
+	unlockFutex(mask)
+}
+
+//go:linkname lockFutex runtime.lockFutex
+func lockFutex() interrupt.State
+
+//go:linkname unlockFutex runtime.unlockFutex
+func unlockFutex(interrupt.State)

src/internal/task/futex-preemptive.go renamed to src/internal/task/futex-threads.go

@@ -1,4 +1,4 @@
-//go:build !scheduler.threads
+//go:build tinygo.unicore
 
 package task
 

src/internal/task/mutex-cooperative.go

@@ -1,4 +1,4 @@
-//go:build scheduler.threads
+//go:build !tinygo.unicore
 
 package task
 

src/internal/task/mutex-preemptive.go

@@ -1,4 +1,4 @@
-//go:build !scheduler.threads
+//go:build tinygo.unicore
 
 package task
 

src/internal/task/pmutex-cooperative.go

@@ -1,4 +1,4 @@
-//go:build scheduler.threads
+//go:build !tinygo.unicore
 
 package task
 

src/internal/task/pmutex-preemptive.go

@@ -12,9 +12,9 @@ type Queue struct {
 
 // Push a task onto the queue.
 func (q *Queue) Push(t *Task) {
-	i := interrupt.Disable()
+	mask := lockAtomics()
 	if asserts && t.Next != nil {
-		interrupt.Restore(i)
+		unlockAtomics(mask)
 		panic("runtime: pushing a task to a queue with a non-nil Next pointer")
 	}
 	if q.tail != nil {
@@ -25,44 +25,44 @@ func (q *Queue) Push(t *Task) {
 	if q.head == nil {
 		q.head = t
 	}
-	interrupt.Restore(i)
+	unlockAtomics(mask)
 }
 
 // Pop a task off of the queue.
 func (q *Queue) Pop() *Task {
-	i := interrupt.Disable()
+	mask := lockAtomics()
 	t := q.head
 	if t == nil {
-		interrupt.Restore(i)
+		unlockAtomics(mask)
 		return nil
 	}
 	q.head = t.Next
 	if q.tail == t {
 		q.tail = nil
 	}
 	t.Next = nil
-	interrupt.Restore(i)
+	unlockAtomics(mask)
 	return t
 }
 
 // Append pops the contents of another queue and pushes them onto the end of this queue.
 func (q *Queue) Append(other *Queue) {
-	i := interrupt.Disable()
+	mask := lockAtomics()
 	if q.head == nil {
 		q.head = other.head
 	} else {
 		q.tail.Next = other.head
 	}
 	q.tail = other.tail
 	other.head, other.tail = nil, nil
-	interrupt.Restore(i)
+	unlockAtomics(mask)
 }
 
 // Empty checks if the queue is empty.
 func (q *Queue) Empty() bool {
-	i := interrupt.Disable()
+	mask := lockAtomics()
 	empty := q.head == nil
-	interrupt.Restore(i)
+	unlockAtomics(mask)
 	return empty
 }
 
@@ -75,24 +75,24 @@ type Stack struct {
 
 // Push a task onto the stack.
 func (s *Stack) Push(t *Task) {
-	i := interrupt.Disable()
+	mask := lockAtomics()
 	if asserts && t.Next != nil {
-		interrupt.Restore(i)
+		unlockAtomics(mask)
 		panic("runtime: pushing a task to a stack with a non-nil Next pointer")
 	}
 	s.top, t.Next = t, s.top
-	interrupt.Restore(i)
+	unlockAtomics(mask)
 }
 
 // Pop a task off of the stack.
 func (s *Stack) Pop() *Task {
-	i := interrupt.Disable()
+	mask := lockAtomics()
 	t := s.top
 	if t != nil {
 		s.top = t.Next
 		t.Next = nil
 	}
-	interrupt.Restore(i)
+	unlockAtomics(mask)
 	return t
 }
 
@@ -112,13 +112,26 @@ func (t *Task) tail() *Task {
 // Queue moves the contents of the stack into a queue.
 // Elements can be popped from the queue in the same order that they would be popped from the stack.
 func (s *Stack) Queue() Queue {
-	i := interrupt.Disable()
+	mask := lockAtomics()
 	head := s.top
 	s.top = nil
 	q := Queue{
 		head: head,
 		tail: head.tail(),
 	}
-	interrupt.Restore(i)
+	unlockAtomics(mask)
 	return q
 }
+
+// Use runtime.lockAtomics and runtime.unlockAtomics so that Queue and Stack
+// work correctly even on multicore systems. These functions are normally used
+// to implement atomic operations, but the same spinlock can also be used for
+// Queue/Stack operations which are very fast.
+// These functions are just plain old interrupt disable/restore on non-multicore
+// systems.
+
+//go:linkname lockAtomics runtime.lockAtomics
+func lockAtomics() interrupt.State
+
+//go:linkname unlockAtomics runtime.unlockAtomics
+func unlockAtomics(mask interrupt.State)

src/internal/task/queue.go

@@ -24,11 +24,28 @@ type Task struct {
 	// This is needed for some crypto packages.
 	FipsIndicator uint8
 
+	// State of the goroutine: running, paused, or must-resume-next-pause.
+	// This extra field doesn't increase memory usage on 32-bit CPUs and above,
+	// since it falls into the padding of the FipsIndicator bit above.
+	RunState uint8
+
 	// DeferFrame stores a pointer to the (stack allocated) defer frame of the
 	// goroutine that is used for the recover builtin.
 	DeferFrame unsafe.Pointer
 }
 
+const (
+	// Initial state: the goroutine state is saved on the stack.
+	RunStatePaused = iota
+
+	// The goroutine is running right now.
+	RunStateRunning
+
+	// The goroutine is running, but already marked as "can resume".
+	// The next call to Pause() won't actually pause the goroutine.
+	RunStateResuming
+)
+
 // DataUint32 returns the Data field as a uint32. The value is only valid after
 // setting it through SetDataUint32 or by storing to it using DataAtomicUint32.
 func (t *Task) DataUint32() uint32 {