feature: reuse common

Author: zhuliquan

bench_test.go

@@ -407,30 +407,34 @@ func Benchmark_realWorldInsane(b *testing.B) {
 		b.Fatal(err)
 	}
 
-	b.Run("no_cse", func(b *testing.B) {
-		var out interface{}
-		out, err = vm.Run(program, env)
-		if err != nil {
-			b.Fatal(err)
-		}
-		if !out.(bool) {
-			b.Fail()
+	b.Run("no_common_reused", func(b *testing.B) {
+		for i := 0; i < b.N; i++ {
+			var out interface{}
+			out, err = vm.Run(program, env)
+			if err != nil {
+				b.Fatal(err)
+			}
+			if !out.(bool) {
+				b.Fail()
+			}
 		}
 	})
 
-	program, err = expr.Compile(expression, expr.Env(env), expr.AllowCommonSubExprElimination(true))
+	program, err = expr.Compile(expression, expr.Env(env), expr.AllowReuseCommon(true))
 	if err != nil {
 		b.Fatal(err)
 	}
 
-	b.Run("allow_cse", func(b *testing.B) {
-		var out interface{}
-		out, err = vm.Run(program, env)
-		if err != nil {
-			b.Fatal(err)
-		}
-		if !out.(bool) {
-			b.Fail()
+	b.Run("allow_common_reused", func(b *testing.B) {
+		for i := 0; i < b.N; i++ {
+			var out interface{}
+			out, err = vm.Run(program, env)
+			if err != nil {
+				b.Fatal(err)
+			}
+			if !out.(bool) {
+				b.Fail()
+			}
 		}
 	})
 }

compiler/check_sub_expr.go renamed to compiler/check_common.go

@@ -1,7 +1,7 @@
 package compiler
 
 import (
-	"crypto/md5"
+	"crypto/sha1"
 	"fmt"
 	"sort"
 	"strconv"
@@ -11,78 +11,78 @@ import (
 	"github.com/antonmedv/expr/file"
 )
 
-func (c *compiler) checkCommonSubExpr(node ast.Node) {
+func (c *compiler) countCommonExpr(node ast.Node) {
 	switch n := node.(type) {
 	case *ast.NilNode:
-		c.checkNilNode(n)
+		c.commonCommonNilNode(n)
 	case *ast.IdentifierNode:
-		c.checkIdentifierNode(n)
+		c.countCommonIdentifierNode(n)
 	case *ast.IntegerNode:
-		c.checkIntegerNode(n)
+		c.countCommonIntegerNode(n)
 	case *ast.FloatNode:
-		c.checkFloatNode(n)
+		c.countCommonFloatNode(n)
 	case *ast.BoolNode:
-		c.checkBoolNode(n)
+		c.countCommonBoolNode(n)
 	case *ast.StringNode:
-		c.checkStringNode(n)
+		c.countCommonStringNode(n)
 	case *ast.ConstantNode:
-		c.checkConstantNode(n)
+		c.countCommonConstantNode(n)
 	case *ast.UnaryNode:
-		c.checkUnaryNode(n)
+		c.countCommonUnaryNode(n)
 	case *ast.BinaryNode:
-		c.checkBinaryNode(n)
+		c.countCommonBinaryNode(n)
 	case *ast.ChainNode:
-		c.checkChainNode(n)
+		c.countCommonChainNode(n)
 	case *ast.MemberNode:
-		c.checkMemberNode(n)
+		c.countCommonMemberNode(n)
 	case *ast.SliceNode:
-		c.checkSliceNode(n)
+		c.countCommonSliceNode(n)
 	case *ast.CallNode:
 		c.checkCallNode(n)
 	case *ast.BuiltinNode:
-		c.checkBuiltinNode(n)
+		c.countCommonBuiltinNode(n)
 	case *ast.ClosureNode:
-		c.checkClosureNode(n)
+		c.countCommonClosureNode(n)
 	case *ast.PointerNode:
-		c.checkPointerNode(n)
+		c.countCommonPointerNode(n)
 	case *ast.ConditionalNode:
-		c.checkConditionalNode(n)
+		c.countCommonConditionalNode(n)
 	case *ast.ArrayNode:
-		c.checkArrayNode(n)
+		c.countCommonArrayNode(n)
 	case *ast.MapNode:
-		c.checkMapNode(n)
+		c.countCommonMapNode(n)
 	case *ast.PairNode:
-		c.checkPairNode(n)
+		c.countCommonPairNode(n)
 	default:
 		panic(fmt.Sprintf("undefined node type (%T)", node))
 	}
 }
 
-func (c *compiler) checkNilNode(n *ast.NilNode) {
+func (c *compiler) commonCommonNilNode(n *ast.NilNode) {
 	n.SetSubExpr("nil")
 }
 
-func (c *compiler) checkIdentifierNode(n *ast.IdentifierNode) {
+func (c *compiler) countCommonIdentifierNode(n *ast.IdentifierNode) {
 	n.SetSubExpr(n.Value)
 }
 
-func (c *compiler) checkIntegerNode(n *ast.IntegerNode) {
+func (c *compiler) countCommonIntegerNode(n *ast.IntegerNode) {
 	n.SetSubExpr(strconv.FormatInt(int64(n.Value), 10))
 }
 
-func (c *compiler) checkFloatNode(n *ast.FloatNode) {
+func (c *compiler) countCommonFloatNode(n *ast.FloatNode) {
 	n.SetSubExpr(strconv.FormatFloat(n.Value, 'f', 10, 64))
 }
 
-func (c *compiler) checkBoolNode(n *ast.BoolNode) {
+func (c *compiler) countCommonBoolNode(n *ast.BoolNode) {
 	n.SetSubExpr(strconv.FormatBool(n.Value))
 }
 
-func (c *compiler) checkStringNode(n *ast.StringNode) {
+func (c *compiler) countCommonStringNode(n *ast.StringNode) {
 	n.SetSubExpr(strconv.Quote(n.Value))
 }
 
-func (c *compiler) checkConstantNode(n *ast.ConstantNode) {
+func (c *compiler) countCommonConstantNode(n *ast.ConstantNode) {
 	switch n.Value.(type) {
 	case string:
 		n.SetSubExpr(strconv.Quote(n.Value.(string)))
@@ -115,8 +115,8 @@ func (c *compiler) checkConstantNode(n *ast.ConstantNode) {
 	}
 }
 
-func (c *compiler) checkUnaryNode(n *ast.UnaryNode) {
-	c.checkCommonSubExpr(n.Node)
+func (c *compiler) countCommonUnaryNode(n *ast.UnaryNode) {
+	c.countCommonExpr(n.Node)
 	switch n.Operator {
 	case "+":
 		n.SetSubExpr(n.Node.SubExpr())
@@ -127,23 +127,27 @@ func (c *compiler) checkUnaryNode(n *ast.UnaryNode) {
 	}
 }
 
-func (c *compiler) checkBinaryNode(n *ast.BinaryNode) {
-	c.checkCommonSubExpr(n.Left)
-	c.checkCommonSubExpr(n.Right)
+func (c *compiler) countCommonBinaryNode(n *ast.BinaryNode) {
+	c.countCommonExpr(n.Left)
+	c.countCommonExpr(n.Right)
 	switch n.Operator {
 	case "==", "!=", "and", "or", "+", "*", "||", "&&": // right / left can be swap
 		ls := n.Left.SubExpr()
 		rs := n.Right.SubExpr()
 		if rs <= ls {
 			ls, rs = rs, ls
 		}
-		if n.Operator == "and" {
-			n.SetSubExpr(fmt.Sprintf("%s && %s", ls, rs))
-		} else if n.Operator == "or" {
-			n.SetSubExpr(fmt.Sprintf("%s || %s", ls, rs))
+		if n.Operator == "&&" {
+			n.SetSubExpr(fmt.Sprintf("%s and %s", ls, rs))
+		} else if n.Operator == "||" {
+			n.SetSubExpr(fmt.Sprintf("%s or %s", ls, rs))
 		} else {
 			n.SetSubExpr(fmt.Sprintf("%s %s %s", ls, n.Operator, rs))
 		}
+	case ">=":
+		n.SetSubExpr(fmt.Sprintf("%s < %s", n.Right.SubExpr(), n.Left.SubExpr()))
+	case "<=":
+		n.SetSubExpr(fmt.Sprintf("%s > %s", n.Right.SubExpr(), n.Left.SubExpr()))
 	case "**", "^":
 		n.SetSubExpr(fmt.Sprintf("%s ** %s", n.Left.SubExpr(), n.Right.SubExpr()))
 	default:
@@ -157,75 +161,75 @@ func (c *compiler) checkBinaryNode(n *ast.BinaryNode) {
 	}
 }
 
-func (c *compiler) checkChainNode(n *ast.ChainNode) {
-	c.checkCommonSubExpr(n.Node)
+func (c *compiler) countCommonChainNode(n *ast.ChainNode) {
+	c.countCommonExpr(n.Node)
 }
 
-func (c *compiler) checkMemberNode(n *ast.MemberNode) {
-	c.checkCommonSubExpr(n.Node)
-	c.checkCommonSubExpr(n.Property)
+func (c *compiler) countCommonMemberNode(n *ast.MemberNode) {
+	c.countCommonExpr(n.Node)
+	c.countCommonExpr(n.Property)
 	optional := ""
 	if n.Optional {
 		optional = "?"
 	}
 	n.SetSubExpr(fmt.Sprintf("%s%s.%s", n.Node.SubExpr(), optional, n.Property.SubExpr()))
 }
 
-func (c *compiler) checkSliceNode(n *ast.SliceNode) {
-	c.checkCommonSubExpr(n.Node)
-	c.checkCommonSubExpr(n.To)
-	c.checkCommonSubExpr(n.From)
+func (c *compiler) countCommonSliceNode(n *ast.SliceNode) {
+	c.countCommonExpr(n.Node)
+	c.countCommonExpr(n.To)
+	c.countCommonExpr(n.From)
 	n.SetSubExpr(fmt.Sprintf("%s[%s:%s]", n.Node.SubExpr(), n.From.SubExpr(), n.To.SubExpr()))
 }
 
 func (c *compiler) checkCallNode(n *ast.CallNode) {
 	s := make([]string, 0)
 	for _, arg := range n.Arguments {
-		c.checkCommonSubExpr(arg)
+		c.countCommonExpr(arg)
 		s = append(s, arg.SubExpr())
 	}
-	c.checkCommonSubExpr(n.Callee)
+	c.countCommonExpr(n.Callee)
 	n.SetSubExpr(fmt.Sprintf("%s(%s)", n.Callee.SubExpr(), strings.Join(s, ",")))
 }
 
-func (c *compiler) checkBuiltinNode(n *ast.BuiltinNode) {
+func (c *compiler) countCommonBuiltinNode(n *ast.BuiltinNode) {
 	s := make([]string, 0)
 	for _, arg := range n.Arguments {
-		c.checkCommonSubExpr(arg)
+		c.countCommonExpr(arg)
 		s = append(s, arg.SubExpr())
 	}
 	n.SetSubExpr(fmt.Sprintf("%s(%s)", n.Name, strings.Join(s, ",")))
 }
 
-func (c *compiler) checkClosureNode(n *ast.ClosureNode) {
-	c.checkCommonSubExpr(n.Node)
+func (c *compiler) countCommonClosureNode(n *ast.ClosureNode) {
+	c.countCommonExpr(n.Node)
 }
 
-func (c *compiler) checkPointerNode(n *ast.PointerNode) {
+func (c *compiler) countCommonPointerNode(n *ast.PointerNode) {
 	// do nothing
 }
 
-func (c *compiler) checkConditionalNode(n *ast.ConditionalNode) {
-	c.checkCommonSubExpr(n.Cond)
-	c.checkCommonSubExpr(n.Exp1)
-	c.checkCommonSubExpr(n.Exp2)
+func (c *compiler) countCommonConditionalNode(n *ast.ConditionalNode) {
+	c.countCommonExpr(n.Cond)
+	c.countCommonExpr(n.Exp1)
+	c.countCommonExpr(n.Exp2)
 	n.SetSubExpr(fmt.Sprintf("%s ? %s : %s", n.Cond.SubExpr(), n.Exp1.SubExpr(), n.Exp2.SubExpr()))
 }
 
-func (c *compiler) checkArrayNode(n *ast.ArrayNode) {
+func (c *compiler) countCommonArrayNode(n *ast.ArrayNode) {
 	s := make([]string, 0)
 	for _, node := range n.Nodes {
-		c.checkCommonSubExpr(node)
+		c.countCommonExpr(node)
 		s = append(s, node.SubExpr())
 	}
 	n.SetSubExpr(fmt.Sprintf("[%s]", strings.Join(s, ",")))
 }
 
-func (c *compiler) checkMapNode(n *ast.MapNode) {
+func (c *compiler) countCommonMapNode(n *ast.MapNode) {
 	pairs := make([]*ast.PairNode, 0)
 	for _, p := range n.Pairs {
 		pair := p.(*ast.PairNode)
-		c.checkPairNode(pair)
+		c.countCommonPairNode(pair)
 		pairs = append(pairs, pair)
 	}
 	sort.Slice(pairs, func(i, j int) bool {
@@ -238,38 +242,38 @@ func (c *compiler) checkMapNode(n *ast.MapNode) {
 	n.SetSubExpr(fmt.Sprintf("{%s}", strings.Join(s, ",")))
 }
 
-func (c *compiler) checkPairNode(n *ast.PairNode) {
-	c.checkCommonSubExpr(n.Key)
-	c.checkCommonSubExpr(n.Value)
+func (c *compiler) countCommonPairNode(n *ast.PairNode) {
+	c.countCommonExpr(n.Key)
+	c.countCommonExpr(n.Value)
 	n.SetSubExpr(fmt.Sprintf("%s:%s", n.Key.SubExpr(), n.Value.SubExpr()))
 }
 
 func (c *compiler) emitSubExpr(subExpr string, loc file.Location) {
-	if subExpr == "" {
+	if c.exprRecords == nil || subExpr == "" {
 		return
 	}
-	hash := fmt.Sprintf("%x", md5.Sum([]byte(subExpr)))
-	if cs, ok := c.subExprCache[hash]; !ok {
-		c.subExprCache[hash] = &SubExprRecord{
-			cnt: 1,
-		}
+	hash := fmt.Sprintf("%x", sha1.Sum([]byte(subExpr)))
+	if cs, ok := c.exprRecords[hash]; !ok {
+		c.exprRecords[hash] = &exprRecord{cnt: 1}
 	} else {
 		if cs.cnt == 1 {
-			c.subExprUniqId += 1
-			cs.id = c.subExprUniqId
+			cs.id = c.commonExprInc
+			c.commonExpr[cs.id] = subExpr
+			c.commonExprInc += 1
 		}
 		cs.cnt = cs.cnt + 1
 	}
 }
 
-func (c *compiler) checkNeedCSE(n ast.Node) (bool, int) {
-	needCSE := false
-	cseUniqId := 0
-	hash := fmt.Sprintf("%x", md5.Sum([]byte(n.SubExpr())))
-	cs, ok := c.subExprCache[hash]
-	if ok && cs.cnt > 1 {
-		needCSE = true
-		cseUniqId = cs.id
+func (c *compiler) needCacheCommon(n ast.Node) (bool, int) {
+	needCacheCommon, exprUniqId := false, -1
+	if c.exprRecords != nil {
+		hash := fmt.Sprintf("%x", sha1.Sum([]byte(n.SubExpr())))
+		cs, ok := c.exprRecords[hash]
+		if ok && cs.cnt > 1 {
+			needCacheCommon = true
+			exprUniqId = cs.id
+		}
 	}
-	return needCSE, cseUniqId
+	return needCacheCommon, exprUniqId
 }