Add fast call opcode for special case functions

Author: antonmedv

ast/node.go

@@ -128,6 +128,7 @@ type FunctionNode struct {
 
 	Name      string
 	Arguments []Node
+	Fast      bool
 }
 
 type BuiltinNode struct {

bench_test.go

@@ -75,19 +75,68 @@ func Benchmark_access(b *testing.B) {
 	}
 }
 
+func Benchmark_accessFast(b *testing.B) {
+	type Price struct {
+		Value int
+	}
+	env := map[string]interface{}{
+		"price": Price{Value: 1},
+	}
+
+	program, err := expr.Compile(`price.Value > 0`, expr.Env(env))
+	if err != nil {
+		b.Fatal(err)
+	}
+
+	for n := 0; n < b.N; n++ {
+		_, err = vm.Run(program, env)
+	}
+
+	if err != nil {
+		b.Fatal(err)
+	}
+}
+
 func Benchmark_call(b *testing.B) {
 	type Env struct {
 		Fn func(string, string, string) bool
 	}
 
-	program, err := expr.Compile(`Fn("", "", "")`, expr.Env(Env{}))
+	program, err := expr.Compile(`Fn("a", "b", "ab")`, expr.Env(Env{}))
 	if err != nil {
 		b.Fatal(err)
 	}
 
-	env := Env{Fn: func(s string, s2 string, s3 string) bool {
-		return s+s2+s3 == ""
-	}}
+	env := Env{
+		Fn: func(s1, s2, s3 string) bool {
+			return s1+s2 == s3
+		},
+	}
+
+	for n := 0; n < b.N; n++ {
+		_, err = vm.Run(program, env)
+	}
+
+	if err != nil {
+		b.Fatal(err)
+	}
+}
+
+func Benchmark_callFast(b *testing.B) {
+	type Env struct {
+		Fn func(...interface{}) interface{}
+	}
+
+	program, err := expr.Compile(`Fn("a", "b", "ab"`, expr.Env(Env{}))
+	if err != nil {
+		b.Fatal(err)
+	}
+
+	env := Env{
+		Fn: func(s ...interface{}) interface{} {
+			return s[0].(string)+s[1].(string) == s[2].(string)
+		},
+	}
 
 	for n := 0; n < b.N; n++ {
 		_, err = vm.Run(program, env)

checker/checker.go

@@ -314,6 +314,14 @@ func (v *visitor) SliceNode(node *ast.SliceNode) reflect.Type {
 func (v *visitor) FunctionNode(node *ast.FunctionNode) reflect.Type {
 	if f, ok := v.types[node.Name]; ok {
 		if fn, ok := isFuncType(f.Type); ok {
+
+			if !isInterface(fn) && fn.IsVariadic() && fn.NumOut() == 1 {
+				rest := fn.In(fn.NumIn() - 1)
+				if rest.Kind() == reflect.Slice && rest.Elem().Kind() == reflect.Interface {
+					node.Fast = true
+				}
+			}
+
 			return v.checkFunc(fn, f.Method, node, node.Name, node.Arguments)
 		}
 	}

compiler/compiler.go

@@ -429,7 +429,11 @@ func (c *compiler) FunctionNode(node *ast.FunctionNode) {
 	for _, arg := range node.Arguments {
 		c.compile(arg)
 	}
-	c.emit(OpCall, c.makeConstant(
+	op := OpCall
+	if node.Fast {
+		op = OpCallFast
+	}
+	c.emit(op, c.makeConstant(
 		Call{
 			Name: node.Name,
 			Size: len(node.Arguments),

go.mod

@@ -3,7 +3,7 @@ module github.com/antonmedv/expr
 go 1.12
 
 require (
-	github.com/antlr/antlr4 v0.0.0-20190518164840-edae2a1c9b4b
+	github.com/antlr/antlr4 v0.0.0-20191011202612-ad2bd05285ca
 	github.com/gdamore/tcell v1.1.2
 	github.com/rivo/tview v0.0.0-20190515161233-bd836ef13b4b
 	github.com/sanity-io/litter v1.1.0

go.sum

@@ -1,6 +1,8 @@
 github.com/DATA-DOG/go-sqlmock v1.3.3/go.mod h1:f/Ixk793poVmq4qj/V1dPUg2JEAKC73Q5eFN3EC/SaM=
 github.com/antlr/antlr4 v0.0.0-20190518164840-edae2a1c9b4b h1:IyTcB1l64U991qSZ0ufqiJv9GVEOUBiSPwsObDm7+cc=
 github.com/antlr/antlr4 v0.0.0-20190518164840-edae2a1c9b4b/go.mod h1:T7PbCXFs94rrTttyxjbyT5+/1V8T2TYDejxUfHJjw1Y=
+github.com/antlr/antlr4 v0.0.0-20191011202612-ad2bd05285ca h1:QHbltbNkVcw97h4zA/L8gA4o3dJiFvBZ0gyZHrYXHbs=
+github.com/antlr/antlr4 v0.0.0-20191011202612-ad2bd05285ca/go.mod h1:T7PbCXFs94rrTttyxjbyT5+/1V8T2TYDejxUfHJjw1Y=
 github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/gdamore/encoding v1.0.0 h1:+7OoQ1Bc6eTm5niUzBa0Ctsh6JbMW6Ra+YNuAtDBdko=

vm/opcodes.go

@@ -39,6 +39,7 @@ const (
 	OpSlice
 	OpProperty
 	OpCall
+	OpCallFast
 	OpMethod
 	OpArray
 	OpMap
@@ -48,5 +49,5 @@ const (
 	OpLoad
 	OpInc
 	OpBegin
-	OpEnd
+	OpEnd // This opcode must be at the end of this list.
 )

vm/program.go

@@ -175,6 +175,9 @@ func (program *Program) Disassemble() string {
 		case OpCall:
 			constant("OpCall")
 
+		case OpCallFast:
+			constant("OpCallFast")
+
 		case OpMethod:
 			constant("OpMethod")
 

vm/program_test.go

@@ -8,7 +8,7 @@ import (
 )
 
 func TestProgram_Disassemble(t *testing.T) {
-	for op := vm.OpPush; op < vm.OpLoad; op++ {
+	for op := vm.OpPush; op < vm.OpEnd; op++ {
 		program := vm.Program{
 			Constants: []interface{}{true},
 			Bytecode:  []byte{op},

vm/vm.go

@@ -67,7 +67,7 @@ func (vm *VM) Run(program *Program, env interface{}) interface{} {
 		switch op {
 
 		case OpPush:
-			vm.push(vm.constants[vm.arg()])
+			vm.push(vm.constant())
 
 		case OpPop:
 			vm.pop()
@@ -79,10 +79,10 @@ func (vm *VM) Run(program *Program, env interface{}) interface{} {
 			vm.push(a)
 
 		case OpFetch:
-			vm.push(fetch(env, vm.constants[vm.arg()]))
+			vm.push(fetch(env, vm.constant()))
 
 		case OpFetchMap:
-			vm.push(env.(map[string]interface{})[vm.constants[vm.arg()].(string)])
+			vm.push(env.(map[string]interface{})[vm.constant().(string)])
 
 		case OpTrue:
 			vm.push(true)
@@ -208,7 +208,7 @@ func (vm *VM) Run(program *Program, env interface{}) interface{} {
 
 		case OpMatchesConst:
 			a := vm.pop()
-			r := vm.constants[vm.arg()].(*regexp.Regexp)
+			r := vm.constant().(*regexp.Regexp)
 			vm.push(r.MatchString(a.(string)))
 
 		case OpContains:
@@ -239,31 +239,34 @@ func (vm *VM) Run(program *Program, env interface{}) interface{} {
 
 		case OpProperty:
 			a := vm.pop()
-			b := vm.constants[vm.arg()]
+			b := vm.constant()
 			vm.push(fetch(a, b))
 
 		case OpCall:
-			call := vm.constants[vm.arg()].(Call)
-
+			call := vm.constant().(Call)
 			in := make([]reflect.Value, call.Size)
 			for i := call.Size - 1; i >= 0; i-- {
 				in[i] = reflect.ValueOf(vm.pop())
 			}
-
 			out := fetchFn(env, call.Name).Call(in)
 			vm.push(out[0].Interface())
 
+		case OpCallFast:
+			call := vm.constant().(Call)
+			in := make([]interface{}, call.Size)
+			for i := call.Size - 1; i >= 0; i-- {
+				in[i] = vm.pop()
+			}
+			fn := fetchFn(env, call.Name).Interface()
+			vm.push(fn.(func(...interface{}) interface{})(in...))
+
 		case OpMethod:
 			call := vm.constants[vm.arg()].(Call)
-
 			in := make([]reflect.Value, call.Size)
 			for i := call.Size - 1; i >= 0; i-- {
 				in[i] = reflect.ValueOf(vm.pop())
 			}
-
-			obj := vm.pop()
-
-			out := fetchFn(obj, call.Name).Call(in)
+			out := fetchFn(vm.pop(), call.Name).Call(in)
 			vm.push(out[0].Interface())
 
 		case OpArray:
@@ -298,18 +301,18 @@ func (vm *VM) Run(program *Program, env interface{}) interface{} {
 
 		case OpStore:
 			scope := vm.Scope()
-			key := vm.constants[vm.arg()].(string)
+			key := vm.constant().(string)
 			value := vm.pop()
 			scope[key] = value
 
 		case OpLoad:
 			scope := vm.Scope()
-			key := vm.constants[vm.arg()].(string)
+			key := vm.constant().(string)
 			vm.push(scope[key])
 
 		case OpInc:
 			scope := vm.Scope()
-			key := vm.constants[vm.arg()].(string)
+			key := vm.constant().(string)
 			i := scope[key].(int)
 			i++
 			scope[key] = i
@@ -362,6 +365,10 @@ func (vm *VM) arg() uint16 {
 	return uint16(b0) | uint16(b1)<<8
 }
 
+func (vm *VM) constant() interface{} {
+	return vm.constants[vm.arg()]
+}
+
 func (vm *VM) Stack() []interface{} {
 	return vm.stack
 }