Fuse guarded square and take pipelines

Author: jfhamlin

benchmark/RESULTS.md

@@ -7,15 +7,19 @@ benchmarks; allocations are reported by Go's benchmark harness.
 | --- | ---: | ---: | ---: |
 | AOT float kernel | 232 ms, ~17.0M allocs | 1.265 ms, 1 alloc | ~183× |
 | AOT reduce pipeline | 95 ms, ~5.87M allocs | 1.905 ms, 48 allocs | ~50× |
+| Exact let-go map/filter, AOT hot path | 33.42 µs, 46.0 KiB, 1,208 allocs | 7.40 µs, 1.12 KiB, 49 allocs | ~4.5× |
 | Boxed common-int arithmetic | 18.1 ns, 19 B, 2 allocs | 1.98 ns, 0 B, 0 allocs | ~9.1× |
 | AOT Game of Life | 982.22 ms, ~31.1M allocs | 686.85 ms, ~1.57M allocs | ~1.43× |
 | Interpreter constant arithmetic | 113.27 ms | 101.99 ms | ~10% |
 | Interpreter constant branch | 304.61 ms, ~20.0M allocs | 59.45 ms, 6 allocs | ~5.1× |
+| Exact let-go map/filter, interpreter hot path | 40.09 µs, 49.9 KiB, 1,224 allocs | 7.64 µs, 1.12 KiB, 48 allocs | ~5.2× |
 
 The AOT baselines were captured before primitive float specialization and
 integer pipeline fusion. The interpreter comparison uses
 `benchmark/interpreter/constant_arithmetic_test.go` immediately before and
-after literal `lang.Numbers` folding.
+after literal `lang.Numbers` folding. The exact let-go rows compare commit
+`eaf816e` with the guarded square/filter/take pipeline optimization using the
+fixtures committed in the corresponding benchmark directories.
 
 The portable programs shared with let-go currently produce these median
 wall-clock ratios, where a value below 1.0 favors Glojure:

benchmark/aot/README.md

@@ -23,6 +23,8 @@ The fixtures deliberately cover optimization gaps:
   subexpression, through a direct function call.
 - `float-kernel.glj`: repeated floating-point arithmetic through a direct
   function call.
+- `letgo-map-filter.glj`: let-go's exact map/filter/take benchmark, including
+  its anonymous integer-square callback.
 - `reduce-pipeline.glj`: reduction over lazy `map` and `filter` producers.
 
 Run a baseline before changing the compiler and compare it with the same

benchmark/aot/fixtures/letgo-map-filter.glj

@@ -0,0 +1,10 @@
+(ns bench.letgo-map-filter)
+
+(defn run []
+  (reduce + 0
+          (take 100
+                (filter even?
+                        (map #(* % %)
+                             (range 10000))))))
+
+(def expected 1313400)

benchmark/aot/main.go

@@ -189,6 +189,14 @@ func writeBenchmark(temp string, fixtures []fixture) {
 	source.WriteString("\tif got := reduce_pipelineRun.Invoke(); !lang.Equals(got, int64(250000000000)) {\n")
 	source.WriteString("\t\tt.Fatalf(\"reduce pipeline ignored Var redefinition: got %v, want 250000000000\", got)\n")
 	source.WriteString("\t}\n")
+	source.WriteString("\tincVar.BindRoot(originalInc)\n")
+	source.WriteString("\ttakeVar := lang.FindNamespace(lang.NewSymbol(\"clojure.core\")).FindInternedVar(lang.NewSymbol(\"take\"))\n")
+	source.WriteString("\toriginalTake := takeVar.Get()\n")
+	source.WriteString("\ttakeVar.BindRoot(lang.FnFunc2(func(any, any) any { return lang.NewVector(int64(7)) }))\n")
+	source.WriteString("\tdefer takeVar.BindRoot(originalTake)\n")
+	source.WriteString("\tif got := letgo_map_filterRun.Invoke(); !lang.Equals(got, int64(7)) {\n")
+	source.WriteString("\t\tt.Fatalf(\"let-go map/filter pipeline ignored take redefinition: got %v, want 7\", got)\n")
+	source.WriteString("\t}\n")
 	source.WriteString("}\n\n")
 	for _, fixture := range fixtures {
 		benchmarkName := exportedName(strings.TrimPrefix(fixture.nsName, "bench."))

benchmark/interpreter/README.md

@@ -15,3 +15,7 @@ startup.
 `constant-branch` measures whether a literal predicate inside a numeric loop
 prevents the interpreter's existing typed-loop compiler from recognizing the
 surrounding loop.
+
+`let-go-map-filter` and `let-go-tak` reproduce the two official let-go
+interpreter workloads that are closest to Glojure. Keeping them in-process
+removes executable startup noise while profiling and validating changes.

benchmark/interpreter/letgo_workloads_test.go

@@ -0,0 +1,71 @@
+package interpreterbench
+
+import (
+	"testing"
+
+	"github.com/glojurelang/glojure/pkg/lang"
+	"github.com/glojurelang/glojure/pkg/runtime"
+)
+
+const (
+	letGoMapFilterExpression = `
+		(reduce + 0
+		  (take 100
+		    (filter even?
+		      (map #(* % %) (range 10000)))))`
+	letGoMapFilterSource = `
+		(defn benchmark-let-go-map-filter-run []
+		  ` + letGoMapFilterExpression + `)`
+)
+
+func BenchmarkLetGoMapFilter(b *testing.B) {
+	runtime.ReadEval(letGoMapFilterSource)
+	run := benchmarkFn(b, "benchmark-let-go-map-filter-run")
+	if got := run.Invoke(); got != int64(1_313_400) {
+		b.Fatalf("run = %v, want 1313400", got)
+	}
+
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		benchmarkResult = run.Invoke()
+	}
+}
+
+func BenchmarkLoadLetGoMapFilter(b *testing.B) {
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		benchmarkResult = runtime.ReadEval(letGoMapFilterExpression)
+	}
+}
+
+func BenchmarkLetGoTak(b *testing.B) {
+	runtime.ReadEval(`
+		(defn benchmark-let-go-tak [x y z]
+		  (if (< y x)
+		    (benchmark-let-go-tak
+		      (benchmark-let-go-tak (dec x) y z)
+		      (benchmark-let-go-tak (dec y) z x)
+		      (benchmark-let-go-tak (dec z) x y))
+		    z))
+
+		(defn benchmark-let-go-tak-run []
+		  (benchmark-let-go-tak 30 22 12))`)
+	run := benchmarkFn(b, "benchmark-let-go-tak-run")
+	if got := run.Invoke(); got != int64(13) {
+		b.Fatalf("run = %v, want 13", got)
+	}
+
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		benchmarkResult = run.Invoke()
+	}
+}
+
+func benchmarkFn(tb testing.TB, name string) lang.IFn {
+	tb.Helper()
+	return lang.GlobalEnv.CurrentNamespace().
+		FindInternedVar(lang.NewSymbol(name)).
+		Get().(lang.IFn)
+}

pkg/lang/interfaces.go

@@ -59,6 +59,18 @@ type (
 		ReduceInt64(acc, value int64) int64
 	}
 
+	// Int64ReductionStepper is an optional unboxed reduction path that can
+	// terminate early without manufacturing a boxed Reduced value.
+	Int64ReductionStepper interface {
+		ReduceInt64Step(acc, value int64) (result int64, reduced bool)
+	}
+
+	// Int64StepReducible is an optional unboxed reduction path for sources
+	// that can stop when an Int64ReductionStepper signals completion.
+	Int64StepReducible interface {
+		ReduceInt64Steps(reducer Int64ReductionStepper, initial int64) int64
+	}
+
 	IKVReduce interface {
 		KVReduce(f IFn, init any) any
 	}

pkg/lang/longrange.go

@@ -20,19 +20,19 @@ type (
 	LongChunk struct {
 		start, step int64
 		count       int
-		nthFn       FnFunc1
 	}
 )
 
 var (
-	_ ISeq        = (*LongRange)(nil)
-	_ Sequential  = (*LongRange)(nil)
-	_ IReduce     = (*LongRange)(nil)
-	_ IReduceInit = (*LongRange)(nil)
-	_ ASeq        = (*LongRange)(nil)
-	_ IDrop       = (*LongRange)(nil)
-	_ IChunkedSeq = (*LongRange)(nil)
-	_ Counted     = (*LongRange)(nil)
+	_ ISeq               = (*LongRange)(nil)
+	_ Sequential         = (*LongRange)(nil)
+	_ IReduce            = (*LongRange)(nil)
+	_ IReduceInit        = (*LongRange)(nil)
+	_ Int64StepReducible = (*LongRange)(nil)
+	_ ASeq               = (*LongRange)(nil)
+	_ IDrop              = (*LongRange)(nil)
+	_ IChunkedSeq        = (*LongRange)(nil)
+	_ Counted            = (*LongRange)(nil)
 
 	_ IChunk      = (*LongChunk)(nil)
 	_ IReduceInit = (*LongChunk)(nil)
@@ -236,6 +236,25 @@ func (r *LongRange) ReduceInit(f IFn, init any) any {
 	return ret
 }
 
+func (r *LongRange) ReduceInt64Steps(
+	reducer Int64ReductionStepper,
+	initial int64,
+) int64 {
+	result := initial
+	value := r.start
+	for index := 0; index < r.count; index++ {
+		var reduced bool
+		result, reduced = reducer.ReduceInt64Step(result, value)
+		if reduced {
+			return result
+		}
+		if index+1 < r.count {
+			value += r.step
+		}
+	}
+	return result
+}
+
 func (r *LongRange) Drop(n int) Sequential {
 	if n < 0 {
 		return r
@@ -251,13 +270,11 @@ func (r *LongRange) Drop(n int) Sequential {
 // LongChunk
 
 func NewLongChunk(start, step int64, count int) *LongChunk {
-	chunk := &LongChunk{
+	return &LongChunk{
 		start: start,
 		step:  step,
 		count: count,
 	}
-	chunk.nthFn = func(i any) any { return chunk.Nth(MustAsInt(i)) }
-	return chunk
 }
 
 func (c *LongChunk) First() any {
@@ -282,7 +299,9 @@ func (c *LongChunk) Count() int {
 func (c *LongChunk) fieldOrMethod(name string) (interface{}, bool) {
 	switch name {
 	case "nth", "Nth":
-		return c.nthFn, true
+		return FnFunc1(func(i any) any {
+			return c.Nth(MustAsInt(i))
+		}), true
 	case "nthDefault", "NthDefault":
 		return FnFunc2(func(i, notFound any) any {
 			return c.NthDefault(MustAsInt(i), notFound)

pkg/lang/longrange_test.go

@@ -2,6 +2,19 @@ package lang
 
 import "testing"
 
+type stoppingInt64Reducer struct {
+	FnFunc2
+	calls     int
+	stopAfter int
+}
+
+func (r *stoppingInt64Reducer) ReduceInt64Step(
+	acc, value int64,
+) (int64, bool) {
+	r.calls++
+	return acc + value, r.calls == r.stopAfter
+}
+
 func TestLongRangeChunksAreBounded(t *testing.T) {
 	r := NewLongRange(0, 100, 1).(*LongRange)
 
@@ -48,3 +61,15 @@ func TestDescendingLongRangeChunksAreBounded(t *testing.T) {
 		t.Fatalf("first value after first chunk = %v, want 68", got)
 	}
 }
+
+func TestLongRangeInt64StepsCanStopDescendingReduction(t *testing.T) {
+	r := NewLongRange(10, 0, -2).(*LongRange)
+	reducer := &stoppingInt64Reducer{stopAfter: 3}
+	got := r.ReduceInt64Steps(reducer, int64(0))
+	if got != int64(24) {
+		t.Fatalf("ReduceInt64Steps = %v, want 24", got)
+	}
+	if reducer.calls != 3 {
+		t.Fatalf("reducer calls = %d, want 3", reducer.calls)
+	}
+}

pkg/lang/slicechunk.go

@@ -4,8 +4,7 @@ import "errors"
 
 type (
 	SliceChunk struct {
-		slc   []interface{}
-		nthFn FnFunc1
+		slc []interface{}
 	}
 )
 
@@ -14,11 +13,7 @@ var (
 )
 
 func NewSliceChunk(slc []interface{}) *SliceChunk {
-	chunk := &SliceChunk{
-		slc: slc,
-	}
-	chunk.nthFn = func(i any) any { return chunk.Nth(MustAsInt(i)) }
-	return chunk
+	return &SliceChunk{slc: slc}
 }
 
 func (sc *SliceChunk) Count() int {
@@ -48,7 +43,9 @@ func (sc *SliceChunk) NthDefault(i int, def interface{}) interface{} {
 func (sc *SliceChunk) fieldOrMethod(name string) (interface{}, bool) {
 	switch name {
 	case "nth", "Nth":
-		return sc.nthFn, true
+		return FnFunc1(func(i any) any {
+			return sc.Nth(MustAsInt(i))
+		}), true
 	case "nthDefault", "NthDefault":
 		return FnFunc2(func(i, notFound any) any {
 			return sc.NthDefault(MustAsInt(i), notFound)