Eliminate constant branches during analysis

Author: jfhamlin

benchmark/RESULTS.md

@@ -8,6 +8,7 @@ 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× |
 | 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× |
 
 The AOT baselines were captured before primitive float specialization and
 integer pipeline fusion. The interpreter comparison uses

benchmark/interpreter/README.md

@@ -11,3 +11,7 @@ go test ./benchmark/interpreter -bench . -benchmem -count 5 -benchtime 2s
 subexpression through a function call. It is intended to show whether shared
 compiler optimizations improve interpreted execution rather than parsing or
 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.

benchmark/interpreter/constant_branch_test.go

@@ -0,0 +1,34 @@
+package interpreterbench
+
+import (
+	"testing"
+
+	"github.com/glojurelang/glojure/pkg/lang"
+	"github.com/glojurelang/glojure/pkg/runtime"
+)
+
+func BenchmarkConstantBranch(b *testing.B) {
+	runtime.ReadEval(`
+		(defn benchmark-interpreter-constant-branch-run []
+		  (loop [i 0
+		         total 0]
+		    (if (< i 10000000)
+		      (recur (inc i)
+		             (if (< (+ 1 2) 4)
+		               (inc total)
+		               (+ total 2)))
+		      total)))`)
+	ns := lang.GlobalEnv.CurrentNamespace()
+	run := ns.FindInternedVar(
+		lang.NewSymbol("benchmark-interpreter-constant-branch-run"),
+	).Get().(lang.IFn)
+	if got := run.Invoke(); got != int64(10000000) {
+		b.Fatalf("run = %v, want 10000000", got)
+	}
+
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		benchmarkResult = run.Invoke()
+	}
+}

pkg/compiler/analyze.go

@@ -690,6 +690,12 @@ func (a *Analyzer) parseIf(form interface{}, env Env) (*ast.Node, error) {
 	if err != nil {
 		return nil, err
 	}
+	if testExpr.Op == ast.OpConst {
+		if IsTruthy(testExpr.Sub.(*ast.ConstNode).Value) {
+			return withRawForm(thenExpr, form), nil
+		}
+		return withRawForm(elseExpr, form), nil
+	}
 	n := ast.MakeNode(ast.OpIf, form)
 	n.Env = env
 	n.Sub = &ast.IfNode{

pkg/compiler/analyze_test.go

@@ -86,6 +86,39 @@ func TestFoldLiteralNumberCallLeavesTrapAtRuntime(t *testing.T) {
 	}
 }
 
+func TestFoldLiteralIf(t *testing.T) {
+	analyzer := &Analyzer{}
+	tests := []struct {
+		name string
+		test interface{}
+		want int64
+	}{
+		{name: "truthy", test: int64(0), want: 1},
+		{name: "false", test: false, want: 2},
+		{name: "nil", test: nil, want: 2},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			form := lang.NewList(
+				lang.NewSymbol("if"),
+				test.test,
+				int64(1),
+				int64(2),
+			)
+			node, err := analyzer.parseIf(form, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if node.Op != ast.OpConst {
+				t.Fatalf("folded if op = %v, want OpConst", node.Op)
+			}
+			if got := node.Sub.(*ast.ConstNode).Value; got != test.want {
+				t.Fatalf("folded if = %v, want %v", got, test.want)
+			}
+		})
+	}
+}
+
 func TestContainsResidualUnquote(t *testing.T) {
 	form := lang.NewList(
 		lang.NewSymbol("."),