gofront 1.8.0 → 1.9.1

package/stdlib/sync/sync.go

@@ -0,0 +1,268 @@
+//go:build gofront
+
+//gofront:target both
+
+// Package sync provides the basic synchronization primitives for a single
+// thread of execution.
+//
+// GoFront has no goroutines, so nothing here ever blocks: a lock that would
+// have to wait for another goroutine can never be released, and reports the
+// deadlock Go's runtime would. Like Go, a Mutex, RWMutex, Once or WaitGroup
+// must not be copied after first use; a copy is an independent value that
+// starts in the state of the original (this is not diagnosed).
+package sync
+
+// deadlock is the message of Go's runtime when every goroutine is blocked.
+const deadlock = "fatal error: all goroutines are asleep - deadlock!"
+
+// A Locker represents an object that can be locked and unlocked.
+type Locker interface {
+	Lock()
+	Unlock()
+}
+
+// A Mutex is a mutual exclusion lock. The zero value is an unlocked mutex.
+type Mutex struct {
+	locked bool
+}
+
+// Lock locks m. Locking a mutex that is already locked can never succeed
+// without another goroutine, so it reports a deadlock.
+func (m *Mutex) Lock() {
+	if m.locked {
+		panic(deadlock)
+	}
+	m.locked = true
+}
+
+// TryLock tries to lock m and reports whether it succeeded.
+func (m *Mutex) TryLock() bool {
+	if m.locked {
+		return false
+	}
+	m.locked = true
+	return true
+}
+
+// Unlock unlocks m. It is a run-time error if m is not locked on entry.
+func (m *Mutex) Unlock() {
+	if !m.locked {
+		panic("sync: unlock of unlocked mutex")
+	}
+	m.locked = false
+}
+
+// A RWMutex is a reader/writer mutual exclusion lock. The zero value is an
+// unlocked mutex.
+type RWMutex struct {
+	writer  bool
+	readers int
+}
+
+// Lock locks rw for writing. It reports a deadlock when rw is already locked
+// for reading or writing.
+func (rw *RWMutex) Lock() {
+	if rw.writer || rw.readers > 0 {
+		panic(deadlock)
+	}
+	rw.writer = true
+}
+
+// TryLock tries to lock rw for writing and reports whether it succeeded.
+func (rw *RWMutex) TryLock() bool {
+	if rw.writer || rw.readers > 0 {
+		return false
+	}
+	rw.writer = true
+	return true
+}
+
+// Unlock unlocks rw for writing. It is a run-time error if rw is not locked
+// for writing on entry.
+func (rw *RWMutex) Unlock() {
+	if !rw.writer {
+		panic("sync: Unlock of unlocked RWMutex")
+	}
+	rw.writer = false
+}
+
+// RLock locks rw for reading. It reports a deadlock when rw is locked for
+// writing.
+func (rw *RWMutex) RLock() {
+	if rw.writer {
+		panic(deadlock)
+	}
+	rw.readers++
+}
+
+// TryRLock tries to lock rw for reading and reports whether it succeeded.
+func (rw *RWMutex) TryRLock() bool {
+	if rw.writer {
+		return false
+	}
+	rw.readers++
+	return true
+}
+
+// RUnlock undoes a single RLock call. It is a run-time error if rw is not
+// locked for reading on entry.
+func (rw *RWMutex) RUnlock() {
+	if rw.readers <= 0 {
+		panic("sync: RUnlock of unlocked RWMutex")
+	}
+	rw.readers--
+}
+
+type rlocker struct {
+	rw *RWMutex
+}
+
+func (r *rlocker) Lock() { r.rw.RLock() }
+
+func (r *rlocker) Unlock() { r.rw.RUnlock() }
+
+// RLocker returns a Locker interface that implements the Lock and Unlock
+// methods by calling rw.RLock and rw.RUnlock.
+func (rw *RWMutex) RLocker() Locker {
+	return &rlocker{rw: rw}
+}
+
+// Once is an object that will perform exactly one action.
+type Once struct {
+	done bool
+	m    Mutex
+}
+
+// Do calls the function f if and only if Do is being called for the first
+// time for this instance of Once. If f panics, Do considers it to have
+// returned; future calls of Do return without calling f. Calling Do from
+// within f reports a deadlock, as in Go.
+func (o *Once) Do(f func()) {
+	if !o.done {
+		o.doSlow(f)
+	}
+}
+
+func (o *Once) doSlow(f func()) {
+	o.m.Lock()
+	defer o.m.Unlock()
+	if !o.done {
+		defer func() { o.done = true }()
+		f()
+	}
+}
+
+// A WaitGroup waits for a collection of goroutines to finish. Without
+// goroutines the counter only moves with Add and Done.
+type WaitGroup struct {
+	n int
+}
+
+// Add adds delta, which may be negative, to the WaitGroup counter.
+// If the counter becomes negative, Add panics.
+func (wg *WaitGroup) Add(delta int) {
+	n := wg.n + delta
+	if n < 0 {
+		panic("sync: negative WaitGroup counter")
+	}
+	wg.n = n
+}
+
+// Done decrements the WaitGroup counter by one.
+func (wg *WaitGroup) Done() {
+	wg.Add(-1)
+}
+
+// Wait returns when the counter is zero. With a positive counter nothing
+// could ever call Done, so it reports a deadlock.
+func (wg *WaitGroup) Wait() {
+	if wg.n > 0 {
+		panic(deadlock)
+	}
+}
+
+// OnceFunc returns a function that invokes f only once. The returned function
+// may be called concurrently.
+//
+// If f panics, the returned function will panic with the same value on every call.
+func OnceFunc(f func()) func() {
+	var (
+		once  Once
+		valid bool
+		p     any
+	)
+	return func() {
+		once.Do(func() {
+			defer func() {
+				p = recover()
+				if !valid {
+					panic(p)
+				}
+			}()
+			f()
+			valid = true
+		})
+		if !valid {
+			panic(p)
+		}
+	}
+}
+
+// OnceValue returns a function that invokes f only once and returns the value
+// returned by f. The returned function may be called concurrently.
+//
+// If f panics, the returned function will panic with the same value on every call.
+func OnceValue[T any](f func() T) func() T {
+	var (
+		once   Once
+		valid  bool
+		p      any
+		result T
+	)
+	return func() T {
+		once.Do(func() {
+			defer func() {
+				p = recover()
+				if !valid {
+					panic(p)
+				}
+			}()
+			result = f()
+			valid = true
+		})
+		if !valid {
+			panic(p)
+		}
+		return result
+	}
+}
+
+// OnceValues returns a function that invokes f only once and returns the values
+// returned by f. The returned function may be called concurrently.
+//
+// If f panics, the returned function will panic with the same value on every call.
+func OnceValues[T1, T2 any](f func() (T1, T2)) func() (T1, T2) {
+	var (
+		once  Once
+		valid bool
+		p     any
+		r1    T1
+		r2    T2
+	)
+	return func() (T1, T2) {
+		once.Do(func() {
+			defer func() {
+				p = recover()
+				if !valid {
+					panic(p)
+				}
+			}()
+			r1, r2 = f()
+			valid = true
+		})
+		if !valid {
+			panic(p)
+		}
+		return r1, r2
+	}
+}

package/stdlib/testing/async_js.go

@@ -0,0 +1,61 @@
+//go:build gofront
+
+//gofront:target js
+
+package testing
+
+// Async tests and subtests, for js packages. The body of an `async func`
+// test returns a promise that the call through testing_call keeps; the
+// driver awaits it before it reports the test.
+
+// call calls f(t) and returns what the function returned: a promise when f
+// is async, nil otherwise.
+//
+//gofront:intrinsic testing_call
+func call(f any, t any) any
+
+func jsCall(f func(*T), t *T) any {
+	return call(f, t)
+}
+
+// settle waits for the async subtests of t, in the order they started, and
+// reports them.
+async func (t *T) settle() {
+	for len(t.pending) > 0 {
+		p := t.pending[0]
+		t.pending = t.pending[1:]
+		await p.sub.wait(p.res)
+		await p.sub.settle()
+		p.sub.finish()
+	}
+}
+
+// wait waits for the promise of a test body, recording a rejection as a
+// failure of the test.
+async func (t *T) wait(res any) {
+	defer t.Guard()
+	await res
+}
+
+// RunAsync is Run for a js package: the bodies of async tests are awaited,
+// in order, and so are the async subtests they start. TestMain cannot use
+// it.
+async func (m *M) RunAsync() int {
+	callHook = jsCall
+	tests, benches := m.plan()
+	for _, tt := range tests {
+		t := &T{common: common{name: tt.Name}}
+		t.begin()
+		await t.wait(t.invoke(tt.F))
+		await t.settle()
+		t.finish()
+		if t.failed {
+			m.failures++
+		}
+	}
+	callHook = nil
+	for _, bb := range benches {
+		m.runBenchmark(bb)
+	}
+	return m.conclude()
+}

package/stdlib/testing/benchmark.go

@@ -0,0 +1,297 @@
+//go:build gofront
+
+//gofront:target both
+
+package testing
+
+import (
+	"fmt"
+	"time"
+)
+
+// B is a type passed to Benchmark functions to manage benchmark timing and
+// control the number of iterations.
+type B struct {
+	common
+	// N is the number of iterations the benchmark function must run.
+	N          int
+	timerOn    bool
+	timerStart int64
+	elapsedNs  int64
+	bytes      int64
+	targetNs   int64
+
+	// hasSub is set once b.Run has run a sub-benchmark: the parent then
+	// reports no result of its own and is not grown.
+	hasSub bool
+
+	loopStarted bool
+	loopIters   int
+	nextCheck   int
+}
+
+func newB(name string, targetNs int64) *B {
+	return &B{
+		common:     common{name: name},
+		N:          1,
+		timerOn:    true,
+		timerStart: nanotime(),
+		targetNs:   targetNs,
+	}
+}
+
+// ResetTimer zeroes the elapsed benchmark time.
+func (b *B) ResetTimer() {
+	b.timerStart = nanotime()
+	b.elapsedNs = 0
+}
+
+// StartTimer starts timing a test.
+func (b *B) StartTimer() {
+	if !b.timerOn {
+		b.timerStart = nanotime()
+		b.timerOn = true
+	}
+}
+
+// StopTimer stops timing a test.
+func (b *B) StopTimer() {
+	if b.timerOn {
+		b.elapsedNs += nanotime() - b.timerStart
+		b.timerOn = false
+	}
+}
+
+// ReportAllocs enables malloc statistics. They are not collected.
+func (b *B) ReportAllocs() {}
+
+// ReportMetric adds a custom metric. It is not recorded.
+func (b *B) ReportMetric(n float64, unit string) {}
+
+// SetBytes records the number of bytes processed in a single operation.
+func (b *B) SetBytes(n int64) { b.bytes = n }
+
+// Elapsed returns the measured elapsed time of the benchmark.
+func (b *B) Elapsed() time.Duration {
+	ns := b.elapsedNs
+	if b.timerOn {
+		ns += nanotime() - b.timerStart
+	}
+	return time.Duration(ns)
+}
+
+// Loop returns true as long as the benchmark should continue running.
+func (b *B) Loop() bool {
+	if !b.loopStarted {
+		b.loopStarted = true
+		b.ResetTimer()
+		if b.targetNs == 0 {
+			b.targetNs = 1000000000
+		}
+		b.loopIters = 0
+		b.nextCheck = 1
+	}
+	if b.failed || b.skipped {
+		return false
+	}
+	b.loopIters++
+	b.N = b.loopIters
+	if b.loopIters >= b.nextCheck {
+		elapsed := nanotime() - b.timerStart
+		if elapsed >= b.targetNs || b.loopIters >= 1000000000 {
+			// This call starts no iteration.
+			b.loopIters--
+			b.N = b.loopIters
+			b.StopTimer()
+			return false
+		}
+		nsPerOp := max(int64(1), elapsed/int64(b.loopIters))
+		remaining := b.targetNs - elapsed
+		add := max(int64(1), min(int64(100000), remaining/(nsPerOp*2)))
+		b.nextCheck = b.loopIters + int(add)
+	}
+	return true
+}
+
+func (b *B) invoke(f func(*B)) {
+	defer b.Guard()
+	f(b)
+}
+
+// Run runs f as a sub-benchmark of b called name, growing b.N until the run
+// takes the target time, and reports its result. It reports whether f
+// succeeded.
+func (b *B) Run(name string, f func(b *B)) bool {
+	full := name
+	if b.name != "" {
+		full = b.name + "/" + name
+	}
+	if !selected(full) {
+		return true
+	}
+	b.hasSub = true
+	sub := newB(full, b.targetNs)
+	sub.parent = &b.common
+	sub.begin()
+	sub.ResetTimer()
+	sub.invoke(f)
+	sub.grow(f)
+	sub.StopTimer()
+	sub.runCleanups()
+	if sub.failed {
+		// A failure in a regrown run did not reach the parent.
+		b.Fail()
+	}
+	if !sub.onlyParent() {
+		sub.reportBenchmark()
+	}
+	return !sub.failed
+}
+
+// BenchmarkResult contains the results of a benchmark run.
+type BenchmarkResult struct {
+	N         int
+	T         time.Duration
+	Bytes     int64
+	MemAllocs uint64
+	MemBytes  uint64
+	Extra     map[string]float64
+}
+
+// NsPerOp returns the "ns/op" metric.
+func (r BenchmarkResult) NsPerOp() int64 {
+	if r.N <= 0 {
+		return 0
+	}
+	return int64(r.T) / int64(r.N)
+}
+
+// AllocsPerOp returns the "allocs/op" metric.
+func (r BenchmarkResult) AllocsPerOp() int64 {
+	if r.N <= 0 {
+		return 0
+	}
+	return int64(r.MemAllocs) / int64(r.N)
+}
+
+// AllocedBytesPerOp returns the "B/op" metric.
+func (r BenchmarkResult) AllocedBytesPerOp() int64 {
+	if r.N <= 0 {
+		return 0
+	}
+	return int64(r.MemBytes) / int64(r.N)
+}
+
+// MemString returns r.AllocedBytesPerOp and r.AllocsPerOp in the same format
+// as 'go test'.
+func (r BenchmarkResult) MemString() string {
+	return fmt.Sprintf("%d B/op\t%d allocs/op", r.AllocedBytesPerOp(), r.AllocsPerOp())
+}
+
+// String returns a summary of the benchmark results.
+func (r BenchmarkResult) String() string {
+	s := fmt.Sprintf("%d\t%d ns/op", r.N, r.NsPerOp())
+	if r.Bytes > 0 && r.T > 0 {
+		mbPerSec := float64(r.Bytes*int64(r.N)) / (float64(r.T) / 1e9) / (1024 * 1024)
+		s += fmt.Sprintf("\t%.2f MB/s", mbPerSec)
+	}
+	return s
+}
+
+// grow reruns f with a larger b.N until the run takes the target time. A
+// benchmark that calls b.Loop sizes itself.
+func (b *B) grow(f func(*B)) {
+	if b.loopStarted || b.hasSub || b.failed || b.skipped {
+		return
+	}
+	b.StopTimer()
+	b.runCleanups()
+	n := 1
+	for !b.failed && !b.skipped {
+		elapsed := int64(b.Elapsed())
+		if elapsed >= b.targetNs || n >= 1000000000 {
+			break
+		}
+		var next int
+		if elapsed == 0 {
+			next = n * 100
+		} else {
+			next = max(n+1, min(1000000000, int(float64(n)*(float64(b.targetNs)/float64(elapsed))*1.2)))
+		}
+		if next <= n {
+			break
+		}
+		n = next
+		nb := newB(b.name, b.targetNs)
+		nb.N = n
+		nb.ResetTimer()
+		nb.invoke(f)
+		nb.StopTimer()
+		nb.runCleanups()
+		b.N = nb.N
+		b.elapsedNs = nb.elapsedNs
+		b.timerOn = false
+		b.failed = nb.failed
+		b.skipped = nb.skipped
+		b.logs = nb.logs
+	}
+}
+
+// Benchmark benchmarks a single function.
+func Benchmark(f func(b *B)) BenchmarkResult {
+	b := newB("Benchmark", 1000000000)
+	b.ResetTimer()
+	b.invoke(f)
+	b.grow(f)
+	b.runCleanups()
+	return BenchmarkResult{N: b.N, T: b.Elapsed(), Bytes: b.bytes}
+}
+
+// runBenchmark runs one benchmark of the table and prints its line.
+func (m *M) runBenchmark(bb GofrontBenchmark) {
+	if cfg.verbose {
+		say(dim("=== RUN   ") + bb.Name)
+	}
+	b := newB(bb.Name, 100000000)
+	b.ResetTimer()
+	b.invoke(bb.F)
+	b.grow(bb.F)
+	b.runCleanups()
+	if b.failed {
+		m.failures++
+	}
+	if !b.onlyParent() {
+		b.reportBenchmark()
+	}
+}
+
+// onlyParent reports whether b just ran sub-benchmarks, which reported their
+// own results, so it has none of its own.
+func (b *B) onlyParent() bool {
+	return b.hasSub && !b.failed && !b.skipped
+}
+
+func (b *B) reportBenchmark() {
+	if b.skipped {
+		say("--- " + yellow("SKIP") + ": " + b.name)
+		b.printLogs(plain)
+		return
+	}
+	if b.failed {
+		say("--- " + bold(red("FAIL")) + ": " + b.name)
+		b.printLogs(red)
+		return
+	}
+	elapsed := int64(b.Elapsed())
+	nsPerOp := 0.0
+	if b.N > 0 {
+		nsPerOp = float64(elapsed) / float64(b.N)
+	}
+	line := fmt.Sprintf("%-20s\t%8d\t%10.0f ns/op", b.name, b.N, nsPerOp)
+	if b.bytes > 0 && elapsed > 0 {
+		mbPerSec := float64(b.bytes*int64(b.N)) / (float64(elapsed) / 1e9) / (1024 * 1024)
+		line += fmt.Sprintf("\t%8.2f MB/s", mbPerSec)
+	}
+	say(line)
+	b.printLogs(plain)
+}