runtime: remove the asyncScheduler constant

aykevl · deadprogram · commit 8cd2a462b919 · 2021-05-08T23:08:12.000+02:00
There is no reason to specialize this per chip as it is only ever used
for JavaScript. Not only that, it is causing confusion and is yet
another quirk to learn when porting the runtime to a new
microcontroller.
diff --git a/src/runtime/runtime_arm7tdmi.go b/src/runtime/runtime_arm7tdmi.go
@@ -71,8 +71,6 @@ func ticks() timeUnit {
 	return 0
 }
 
-const asyncScheduler = false
-
 func sleepTicks(d timeUnit) {
 	// TODO
 }
diff --git a/src/runtime/runtime_atsamd21.go b/src/runtime/runtime_atsamd21.go
@@ -243,8 +243,6 @@ var rtcOverflows volatile.Register32 // number of times the RTC wrapped around
 
 var timerWakeup volatile.Register8
 
-const asyncScheduler = false
-
 // ticksToNanoseconds converts RTC ticks (at 32768Hz) to nanoseconds.
 func ticksToNanoseconds(ticks timeUnit) int64 {
 	// The following calculation is actually the following, but with both sides
diff --git a/src/runtime/runtime_atsamd51.go b/src/runtime/runtime_atsamd51.go
@@ -232,8 +232,6 @@ var rtcOverflows volatile.Register32 // number of times the RTC wrapped around
 
 var timerWakeup volatile.Register8
 
-const asyncScheduler = false
-
 // ticksToNanoseconds converts RTC ticks (at 32768Hz) to nanoseconds.
 func ticksToNanoseconds(ticks timeUnit) int64 {
 	// The following calculation is actually the following, but with both sides
diff --git a/src/runtime/runtime_avr.go b/src/runtime/runtime_avr.go
@@ -58,8 +58,6 @@ func init() {
 	initUART()
 }
 
-const asyncScheduler = false
-
 const tickNanos = 1024 * 16384 // roughly 16ms in nanoseconds
 
 func ticksToNanoseconds(ticks timeUnit) int64 {
diff --git a/src/runtime/runtime_cortexm_qemu.go b/src/runtime/runtime_cortexm_qemu.go
@@ -27,8 +27,6 @@ func main() {
 	abort()
 }
 
-const asyncScheduler = false
-
 func ticksToNanoseconds(ticks timeUnit) int64 {
 	return int64(ticks)
 }
diff --git a/src/runtime/runtime_esp32.go b/src/runtime/runtime_esp32.go
@@ -97,8 +97,6 @@ func ticks() timeUnit {
 	return timeUnit(uint64(esp.TIMG0.T0LO.Get()) | uint64(esp.TIMG0.T0HI.Get())<<32)
 }
 
-const asyncScheduler = false
-
 func nanosecondsToTicks(ns int64) timeUnit {
 	// Calculate the number of ticks from the number of nanoseconds. At a 80MHz
 	// APB clock, that's 25 nanoseconds per tick with a timer prescaler of 2:
diff --git a/src/runtime/runtime_esp8266.go b/src/runtime/runtime_esp8266.go
@@ -89,8 +89,6 @@ func ticks() timeUnit {
 	return currentTime
 }
 
-const asyncScheduler = false
-
 const tickNanos = 3200 // time.Second / (80MHz / 256)
 
 func ticksToNanoseconds(ticks timeUnit) int64 {
diff --git a/src/runtime/runtime_fe310.go b/src/runtime/runtime_fe310.go
@@ -100,8 +100,6 @@ func putchar(c byte) {
 	machine.UART0.WriteByte(c)
 }
 
-const asyncScheduler = false
-
 var timerWakeup volatile.Register8
 
 func ticks() timeUnit {
diff --git a/src/runtime/runtime_k210.go b/src/runtime/runtime_k210.go
@@ -112,8 +112,6 @@ func putchar(c byte) {
 	machine.UART0.WriteByte(c)
 }
 
-const asyncScheduler = false
-
 var timerWakeup volatile.Register8
 
 func ticks() timeUnit {
diff --git a/src/runtime/runtime_mimxrt1062.go b/src/runtime/runtime_mimxrt1062.go
@@ -10,8 +10,6 @@ import (
 	"unsafe"
 )
 
-const asyncScheduler = false
-
 //go:extern _svectors
 var _svectors [0]byte
 
diff --git a/src/runtime/runtime_nintendoswitch.go b/src/runtime/runtime_nintendoswitch.go
@@ -6,8 +6,6 @@ import "unsafe"
 
 type timeUnit int64
 
-const asyncScheduler = false
-
 const (
 	// Handles
 	infoTypeTotalMemorySize = 6          // Total amount of memory available for process.
diff --git a/src/runtime/runtime_nrf.go b/src/runtime/runtime_nrf.go
@@ -67,8 +67,6 @@ func putchar(c byte) {
 	machine.UART0.WriteByte(c)
 }
 
-const asyncScheduler = false
-
 func sleepTicks(d timeUnit) {
 	for d != 0 {
 		ticks := uint32(d) & 0x7fffff // 23 bits (to be on the safe side)
diff --git a/src/runtime/runtime_nxpmk66f18.go b/src/runtime/runtime_nxpmk66f18.go
@@ -232,9 +232,6 @@ func putchar(c byte) {
 	machine.PutcharUART(&machine.UART0, c)
 }
 
-// ???
-const asyncScheduler = false
-
 func abort() {
 	println("!!! ABORT !!!")
 
diff --git a/src/runtime/runtime_stm32f103.go b/src/runtime/runtime_stm32f103.go
@@ -24,8 +24,6 @@ const (
 
 type arrtype = uint32
 
-const asyncScheduler = false
-
 func init() {
 	initCLK()
 
diff --git a/src/runtime/runtime_stm32f405.go b/src/runtime/runtime_stm32f405.go
@@ -80,8 +80,6 @@ const (
 
 type arrtype = uint32
 
-const asyncScheduler = false
-
 func init() {
 	initOSC() // configure oscillators
 	initCLK()
diff --git a/src/runtime/runtime_stm32f407.go b/src/runtime/runtime_stm32f407.go
@@ -42,8 +42,6 @@ const (
 
 type arrtype = uint32
 
-const asyncScheduler = false
-
 func init() {
 	initCLK()
 
diff --git a/src/runtime/runtime_stm32f7x2.go b/src/runtime/runtime_stm32f7x2.go
@@ -41,8 +41,6 @@ const (
 
 type arrtype = uint32
 
-const asyncScheduler = false
-
 func init() {
 	initCLK()
 
diff --git a/src/runtime/runtime_stm32l0.go b/src/runtime/runtime_stm32l0.go
@@ -13,8 +13,6 @@ const (
 
 type arrtype = uint16
 
-const asyncScheduler = false
-
 func putchar(c byte) {
 	machine.UART0.WriteByte(c)
 }
diff --git a/src/runtime/runtime_stm32l4x2.go b/src/runtime/runtime_stm32l4x2.go
@@ -66,8 +66,6 @@ const (
 
 type arrtype = uint32
 
-const asyncScheduler = false
-
 func init() {
 	initCLK()
 
diff --git a/src/runtime/runtime_stm32l5x2.go b/src/runtime/runtime_stm32l5x2.go
@@ -42,8 +42,6 @@ const (
 
 type arrtype = uint32
 
-const asyncScheduler = false
-
 func init() {
 	initCLK()
 
diff --git a/src/runtime/runtime_tinygoriscv_qemu.go b/src/runtime/runtime_tinygoriscv_qemu.go
@@ -24,8 +24,6 @@ func main() {
 	abort()
 }
 
-const asyncScheduler = false
-
 func ticksToNanoseconds(ticks timeUnit) int64 {
 	return int64(ticks)
 }
diff --git a/src/runtime/runtime_unix.go b/src/runtime/runtime_unix.go
@@ -123,8 +123,6 @@ func putchar(c byte) {
 	_putchar(int(c))
 }
 
-const asyncScheduler = false
-
 func ticksToNanoseconds(ticks timeUnit) int64 {
 	// The OS API works in nanoseconds so no conversion necessary.
 	return int64(ticks)
diff --git a/src/runtime/runtime_wasm_js.go b/src/runtime/runtime_wasm_js.go
@@ -40,8 +40,6 @@ func go_scheduler() {
 	scheduler()
 }
 
-const asyncScheduler = true
-
 func ticksToNanoseconds(ticks timeUnit) int64 {
 	// The JavaScript API works in float64 milliseconds, so convert to
 	// nanoseconds first before converting to a timeUnit (which is a float64),
diff --git a/src/runtime/runtime_wasm_wasi.go b/src/runtime/runtime_wasm_wasi.go
@@ -59,10 +59,7 @@ func nanosecondsToTicks(ns int64) timeUnit {
 	return timeUnit(ns)
 }
 
-const (
-	asyncScheduler           = false
-	timePrecisionNanoseconds = 1000 // TODO: how can we determine the appropriate `precision`?
-)
+const timePrecisionNanoseconds = 1000 // TODO: how can we determine the appropriate `precision`?
 
 var (
 	sleepTicksSubscription = __wasi_subscription_t{
diff --git a/src/runtime/scheduler.go b/src/runtime/scheduler.go
@@ -20,6 +20,10 @@ import (
 
 const schedulerDebug = false
 
+// On JavaScript, we can't do a blocking sleep. Instead we have to return and
+// queue a new scheduler invocation using setTimeout.
+const asyncScheduler = GOOS == "js"
+
 var schedulerDone bool
 
 // Queues used by the scheduler.
@@ -138,6 +142,7 @@ func scheduler() {
 		if t == nil {
 			if sleepQueue == nil {
 				if asyncScheduler {
+					// JavaScript is treated specially, see below.
 					return
 				}
 				waitForEvents()
@@ -154,7 +159,8 @@ func scheduler() {
 			if asyncScheduler {
 				// The sleepTicks function above only sets a timeout at which
 				// point the scheduler will be called again. It does not really
-				// sleep.
+				// sleep. So instead of sleeping, we return and expect to be
+				// called again.
 				break
 			}
 			continue

Original file line number	Diff line number	Diff line change
`@@ -71,8 +71,6 @@ func ticks() timeUnit {`
`71`	`71`	`return 0`
`72`	`72`	`}`
`73`	`73`
`74`		`-const asyncScheduler = false`
`75`		`-`
`76`	`74`	`func sleepTicks(d timeUnit) {`
`77`	`75`	`// TODO`
`78`	`76`	`}`
Original file line number	Diff line number	Diff line change
`@@ -58,8 +58,6 @@ func init() {`
`58`	`58`	`initUART()`
`59`	`59`	`}`
`60`	`60`
`61`		`-const asyncScheduler = false`
`62`		`-`
`63`	`61`	`const tickNanos = 1024 * 16384 // roughly 16ms in nanoseconds`
`64`	`62`
`65`	`63`	`func ticksToNanoseconds(ticks timeUnit) int64 {`
Original file line number	Diff line number	Diff line change
`@@ -27,8 +27,6 @@ func main() {`
`27`	`27`	`abort()`
`28`	`28`	`}`
`29`	`29`
`30`		`-const asyncScheduler = false`
`31`		`-`
`32`	`30`	`func ticksToNanoseconds(ticks timeUnit) int64 {`
`33`	`31`	`return int64(ticks)`
`34`	`32`	`}`
Original file line number	Diff line number	Diff line change
`@@ -97,8 +97,6 @@ func ticks() timeUnit {`
`97`	`97`	`return timeUnit(uint64(esp.TIMG0.T0LO.Get()) \| uint64(esp.TIMG0.T0HI.Get())<<32)`
`98`	`98`	`}`
`99`	`99`
`100`		`-const asyncScheduler = false`
`101`		`-`
`102`	`100`	`func nanosecondsToTicks(ns int64) timeUnit {`
`103`	`101`	`// Calculate the number of ticks from the number of nanoseconds. At a 80MHz`
`104`	`102`	`// APB clock, that's 25 nanoseconds per tick with a timer prescaler of 2:`
Original file line number	Diff line number	Diff line change
`@@ -89,8 +89,6 @@ func ticks() timeUnit {`
`89`	`89`	`return currentTime`
`90`	`90`	`}`
`91`	`91`
`92`		`-const asyncScheduler = false`
`93`		`-`
`94`	`92`	`const tickNanos = 3200 // time.Second / (80MHz / 256)`
`95`	`93`
`96`	`94`	`func ticksToNanoseconds(ticks timeUnit) int64 {`
Original file line number	Diff line number	Diff line change
`@@ -100,8 +100,6 @@ func putchar(c byte) {`
`100`	`100`	`machine.UART0.WriteByte(c)`
`101`	`101`	`}`
`102`	`102`
`103`		`-const asyncScheduler = false`
`104`		`-`
`105`	`103`	`var timerWakeup volatile.Register8`
`106`	`104`
`107`	`105`	`func ticks() timeUnit {`
Original file line number	Diff line number	Diff line change
`@@ -112,8 +112,6 @@ func putchar(c byte) {`
`112`	`112`	`machine.UART0.WriteByte(c)`
`113`	`113`	`}`
`114`	`114`
`115`		`-const asyncScheduler = false`
`116`		`-`
`117`	`115`	`var timerWakeup volatile.Register8`
`118`	`116`
`119`	`117`	`func ticks() timeUnit {`
Original file line number	Diff line number	Diff line change
`@@ -10,8 +10,6 @@ import (`
`10`	`10`	`"unsafe"`
`11`	`11`	`)`
`12`	`12`
`13`		`-const asyncScheduler = false`
`14`		`-`
`15`	`13`	`//go:extern _svectors`
`16`	`14`	`var _svectors [0]byte`
`17`	`15`