Improve builtin performance

Author: antonmedv

builtin/builtin.go

@@ -3,8 +3,6 @@ package builtin
 import (
 	"fmt"
 	"reflect"
-
-	"github.com/antonmedv/expr/vm/runtime"
 )
 
 var (
@@ -13,16 +11,22 @@ var (
 )
 
 type Function struct {
-	Name     string
-	Func     func(args ...interface{}) (interface{}, error)
-	Types    []reflect.Type
-	Validate func(args []reflect.Type) (reflect.Type, error)
+	Name      string
+	Func      func(args ...interface{}) (interface{}, error)
+	Types     []reflect.Type
+	Validate  func(args []reflect.Type) (reflect.Type, error)
+	BuiltinId int
 }
 
+const (
+	Len = iota + 1
+	Abs
+)
+
 var Builtins = []*Function{
 	{
-		Name: "len",
-		Func: runtime.Len,
+		Name:      "len",
+		BuiltinId: Len,
 		Validate: func(args []reflect.Type) (reflect.Type, error) {
 			if len(args) != 1 {
 				return anyType, fmt.Errorf("invalid number of arguments for len (expected 1, got %d)", len(args))
@@ -35,61 +39,8 @@ var Builtins = []*Function{
 		},
 	},
 	{
-		Name: "abs",
-		Func: func(args ...interface{}) (interface{}, error) {
-			x := args[0]
-			switch x.(type) {
-			case float32:
-				if x.(float32) < 0 {
-					return -x.(float32), nil
-				}
-			case float64:
-				if x.(float64) < 0 {
-					return -x.(float64), nil
-				}
-			case int:
-				if x.(int) < 0 {
-					return -x.(int), nil
-				}
-			case int8:
-				if x.(int8) < 0 {
-					return -x.(int8), nil
-				}
-			case int16:
-				if x.(int16) < 0 {
-					return -x.(int16), nil
-				}
-			case int32:
-				if x.(int32) < 0 {
-					return -x.(int32), nil
-				}
-			case int64:
-				if x.(int64) < 0 {
-					return -x.(int64), nil
-				}
-			case uint:
-				if x.(uint) < 0 {
-					return -x.(uint), nil
-				}
-			case uint8:
-				if x.(uint8) < 0 {
-					return -x.(uint8), nil
-				}
-			case uint16:
-				if x.(uint16) < 0 {
-					return -x.(uint16), nil
-				}
-			case uint32:
-				if x.(uint32) < 0 {
-					return -x.(uint32), nil
-				}
-			case uint64:
-				if x.(uint64) < 0 {
-					return -x.(uint64), nil
-				}
-			}
-			return nil, fmt.Errorf("invalid argument for abs (type %T)", x)
-		},
+		Name:      "abs",
+		BuiltinId: Abs,
 		Validate: func(args []reflect.Type) (reflect.Type, error) {
 			if len(args) != 1 {
 				return anyType, fmt.Errorf("invalid number of arguments for abs (expected 1, got %d)", len(args))

compiler/compiler.go

@@ -527,6 +527,10 @@ func (c *compiler) CallNode(node *ast.CallNode) {
 		c.compile(arg)
 	}
 	if node.Func != nil {
+		if node.Func.BuiltinId > 0 {
+			c.emit(OpCallBuiltin, node.Func.BuiltinId)
+			return
+		}
 		switch len(node.Arguments) {
 		case 0:
 			c.emit(OpCall0, c.addFunction(node))

vm/opcodes.go

@@ -6,7 +6,6 @@ const (
 	OpPush Opcode = iota
 	OpPushInt
 	OpPop
-	OpRot
 	OpLoadConst
 	OpLoadField
 	OpLoadFast
@@ -55,6 +54,7 @@ const (
 	OpCallN
 	OpCallFast
 	OpCallTyped
+	OpCallBuiltin
 	OpArray
 	OpMap
 	OpLen

vm/program.go

@@ -70,9 +70,6 @@ func (program *Program) Disassemble() string {
 		case OpPop:
 			code("OpPop")
 
-		case OpRot:
-			code("OpRot")
-
 		case OpLoadConst:
 			constant("OpLoadConst")
 
@@ -217,6 +214,9 @@ func (program *Program) Disassemble() string {
 		case OpCallTyped:
 			argument("OpCallTyped")
 
+		case OpCallBuiltin:
+			argument("OpCallBuiltin")
+
 		case OpArray:
 			code("OpArray")
 

vm/runtime/runtime.go

@@ -242,13 +242,13 @@ func In(needle interface{}, array interface{}) bool {
 	panic(fmt.Sprintf(`operator "in"" not defined on %T`, array))
 }
 
-func Len(args ...interface{}) (interface{}, error) {
-	v := reflect.ValueOf(args[0])
+func Len(a interface{}) interface{} {
+	v := reflect.ValueOf(a)
 	switch v.Kind() {
 	case reflect.Array, reflect.Slice, reflect.Map, reflect.String:
-		return v.Len(), nil
+		return v.Len()
 	default:
-		return 0, fmt.Errorf("invalid argument for len (type %T)", args[0])
+		panic(fmt.Sprintf("invalid argument for len (type %T)", a))
 	}
 }
 
@@ -404,3 +404,57 @@ func IsNil(v interface{}) bool {
 		return false
 	}
 }
+
+func Abs(x interface{}) interface{} {
+	switch x.(type) {
+	case float32:
+		if x.(float32) < 0 {
+			return -x.(float32)
+		}
+	case float64:
+		if x.(float64) < 0 {
+			return -x.(float64)
+		}
+	case int:
+		if x.(int) < 0 {
+			return -x.(int)
+		}
+	case int8:
+		if x.(int8) < 0 {
+			return -x.(int8)
+		}
+	case int16:
+		if x.(int16) < 0 {
+			return -x.(int16)
+		}
+	case int32:
+		if x.(int32) < 0 {
+			return -x.(int32)
+		}
+	case int64:
+		if x.(int64) < 0 {
+			return -x.(int64)
+		}
+	case uint:
+		if x.(uint) < 0 {
+			return -x.(uint)
+		}
+	case uint8:
+		if x.(uint8) < 0 {
+			return -x.(uint8)
+		}
+	case uint16:
+		if x.(uint16) < 0 {
+			return -x.(uint16)
+		}
+	case uint32:
+		if x.(uint32) < 0 {
+			return -x.(uint32)
+		}
+	case uint64:
+		if x.(uint64) < 0 {
+			return -x.(uint64)
+		}
+	}
+	panic(fmt.Sprintf("invalid argument for abs (type %T)", x))
+}

vm/vm.go

@@ -8,6 +8,7 @@ import (
 	"regexp"
 	"strings"
 
+	"github.com/antonmedv/expr/builtin"
 	"github.com/antonmedv/expr/file"
 	"github.com/antonmedv/expr/vm/runtime"
 )
@@ -95,12 +96,6 @@ func (vm *VM) Run(program *Program, env interface{}) (_ interface{}, err error)
 		case OpPop:
 			vm.pop()
 
-		case OpRot:
-			b := vm.pop()
-			a := vm.pop()
-			vm.push(b)
-			vm.push(a)
-
 		case OpLoadConst:
 			vm.push(runtime.Fetch(env, program.Constants[arg]))
 
@@ -372,6 +367,14 @@ func (vm *VM) Run(program *Program, env interface{}) (_ interface{}, err error)
 			out := vm.call(fn, arg)
 			vm.push(out)
 
+		case OpCallBuiltin:
+			switch arg {
+			case builtin.Len:
+				vm.push(runtime.Len(vm.pop()))
+			case builtin.Abs:
+				vm.push(runtime.Abs(vm.pop()))
+			}
+
 		case OpArray:
 			size := vm.pop().(int)
 			array := make([]interface{}, size)
@@ -399,11 +402,7 @@ func (vm *VM) Run(program *Program, env interface{}) (_ interface{}, err error)
 			}
 
 		case OpLen:
-			l, err := runtime.Len(vm.current())
-			if err != nil {
-				panic(err)
-			}
-			vm.push(l)
+			vm.push(runtime.Len(vm.current()))
 
 		case OpCast:
 			t := arg