perf: now 30% faster than before

utahta · May 11, 2019 · ae5cfbd · ae5cfbd
1 parent a5520fc
commit ae5cfbd
Show file tree

Hide file tree

Showing 8 changed files with 147 additions and 73 deletions.
diff --git a/.circleci/config.yml b/.circleci/config.yml
@@ -15,6 +15,16 @@ jobs:
     docker:
       - image: circleci/golang:1.11
     working_directory: /go/src/github.com/utahta/go-validator
+    steps:
+      - checkout
+      - run:
+          name: Run test
+          command: make test
+
+  "go-1.12":
+    docker:
+      - image: circleci/golang:1.12
+    working_directory: /go/src/github.com/utahta/go-validator
     steps:
       - checkout
       - run:
@@ -29,3 +39,4 @@ workflows:
     jobs:
       - "go-1.10"
       - "go-1.11"
+      - "go-1.12"
diff --git a/README.md b/README.md
@@ -13,3 +13,19 @@ go-validator is a data validation library for Go.
 ```sh
 go get -u github.com/utahta/go-validator
 ```
+
+# Benchmarks
+
+3.2 GHz Intel Core i7, 64 GB 2667 MHz DDR4
+```go
+goos: darwin
+goarch: amd64
+pkg: github.com/utahta/go-validator
+BenchmarkValidateVarSuccess-12                          20000000                57.5 ns/op             0 B/op          0 allocs/op
+BenchmarkValidateVarParallelSuccess-12                  100000000               12.8 ns/op             0 B/op          0 allocs/op
+BenchmarkValidateStructSuccess-12                       10000000               184 ns/op               0 B/op          0 allocs/op
+BenchmarkValidateStructParallelSuccess-12               50000000                34.2 ns/op             0 B/op          0 allocs/op
+BenchmarkValidateStructComplexSuccess-12                 1000000              1072 ns/op              32 B/op          3 allocs/op
+BenchmarkValidateStructComplexParallelSuccess-12        10000000               216 ns/op              32 B/op          3 allocs/op
+BenchmarkValidateVarFailure-12                          10000000               173 ns/op             208 B/op          2 allocs/op
+```
diff --git a/benchmark_test.go b/benchmark_test.go
@@ -49,7 +49,9 @@ func BenchmarkValidateVarSuccess(b *testing.B) {
 
 	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
-		v.ValidateVar(&s, "len(1)")
+		if err := v.ValidateVar(&s, "len(1)"); err != nil {
+			b.Fatal(err)
+		}
 	}
 }
 
@@ -61,7 +63,9 @@ func BenchmarkValidateVarParallelSuccess(b *testing.B) {
 	b.ResetTimer()
 	b.RunParallel(func(pb *testing.PB) {
 		for pb.Next() {
-			v.ValidateVar(&s, "len(1)")
+			if err := v.ValidateVar(&s, "len(1)"); err != nil {
+				b.Fatal(err)
+			}
 		}
 	})
 }
@@ -78,7 +82,9 @@ func BenchmarkValidateStructSuccess(b *testing.B) {
 
 	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
-		v.ValidateStruct(s)
+		if err := v.ValidateStruct(s); err != nil {
+			b.Fatal(err)
+		}
 	}
 }
 
@@ -95,7 +101,9 @@ func BenchmarkValidateStructParallelSuccess(b *testing.B) {
 	b.ResetTimer()
 	b.RunParallel(func(pb *testing.PB) {
 		for pb.Next() {
-			v.ValidateStruct(s)
+			if err := v.ValidateStruct(s); err != nil {
+				b.Fatal(err)
+			}
 		}
 	})
 }
@@ -104,15 +112,15 @@ func BenchmarkValidateStructComplexSuccess(b *testing.B) {
 	v := New()
 
 	s := &TestString{
-		Required:  "Required",
-		Len:       "length==10",
-		Min:       "min=1",
+		Required:  "12345",
+		Len:       "1234567890",
+		Min:       "1",
 		Max:       "1234567890",
 		MinMax:    "12345",
-		Lt:        "012345678",
-		Lte:       "0123456789",
-		Gt:        "01234567890",
-		Gte:       "0123456789",
+		Lt:        "123456789",
+		Lte:       "1234567890",
+		Gt:        "12345678901",
+		Gte:       "1234567890",
 		OmitEmpty: "",
 		Sub: &SubTest{
 			Test: "1",
@@ -132,23 +140,25 @@ func BenchmarkValidateStructComplexSuccess(b *testing.B) {
 
 	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
-		v.ValidateStruct(s)
+		if err := v.ValidateStruct(s); err != nil {
+			b.Fatal(err)
+		}
 	}
 }
 
 func BenchmarkValidateStructComplexParallelSuccess(b *testing.B) {
 	v := New()
 
 	s := &TestString{
-		Required:  "Required",
-		Len:       "length==10",
-		Min:       "min=1",
+		Required:  "12345",
+		Len:       "1234567890",
+		Min:       "1",
 		Max:       "1234567890",
 		MinMax:    "12345",
-		Lt:        "012345678",
-		Lte:       "0123456789",
-		Gt:        "01234567890",
-		Gte:       "0123456789",
+		Lt:        "123456789",
+		Lte:       "1234567890",
+		Gt:        "12345678901",
+		Gte:       "1234567890",
 		OmitEmpty: "",
 		Sub: &SubTest{
 			Test: "1",
@@ -169,7 +179,22 @@ func BenchmarkValidateStructComplexParallelSuccess(b *testing.B) {
 	b.ResetTimer()
 	b.RunParallel(func(pb *testing.PB) {
 		for pb.Next() {
-			v.ValidateStruct(s)
+			if err := v.ValidateStruct(s); err != nil {
+				b.Fatal(err)
+			}
 		}
 	})
 }
+
+func BenchmarkValidateVarFailure(b *testing.B) {
+	v := New()
+
+	s := "12"
+
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		if err := v.ValidateVar(&s, "len(1)"); err == nil {
+			b.Fatal("want invalid argument error, but got nil")
+		}
+	}
+}
diff --git a/field_cache.go b/field_cache.go
@@ -2,8 +2,10 @@ package validator
 
 type (
 	fieldCache struct {
+		index     int
 		isPrivate bool
 		name      string
 		tagValue  string
+		tagChunk  *tagChunk
 	}
 )
diff --git a/func.go b/func.go
@@ -32,8 +32,8 @@ var (
 	defaultFuncMap = FuncMap{
 		"required":        hasValue,
 		"req":             hasValue,
-		"empty":           zeroValue,
-		"zero":            zeroValue,
+		"empty":           isZeroValue,
+		"zero":            isZeroValue,
 		"alpha":           isAlpha,
 		"alphanum":        isAlphaNum,
 		"alphaunicode":    isAlphaUnicode,
@@ -124,7 +124,7 @@ func hasValue(_ context.Context, f Field, _ FuncOption) (bool, error) {
 	return !isEmpty(f), nil
 }
 
-func zeroValue(_ context.Context, f Field, _ FuncOption) (bool, error) {
+func isZeroValue(_ context.Context, f Field, _ FuncOption) (bool, error) {
 	return isEmpty(f), nil
 }
 
@@ -293,11 +293,11 @@ func minLength(_ context.Context, f Field, opt FuncOption) (bool, error) {
 	v := f.current
 	switch v.Kind() {
 	case reflect.String, reflect.Array, reflect.Map, reflect.Slice:
-		min, err := strconv.Atoi(minStr)
+		min, err := strconv.ParseInt(minStr, 10, 64)
 		if err != nil {
 			return false, err
 		}
-		return min <= v.Len(), nil
+		return min <= int64(v.Len()), nil
 
 	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
 		min, err := strconv.ParseInt(minStr, 10, 64)
@@ -334,11 +334,11 @@ func maxLength(_ context.Context, f Field, opt FuncOption) (bool, error) {
 	v := f.current
 	switch v.Kind() {
 	case reflect.String, reflect.Array, reflect.Map, reflect.Slice:
-		max, err := strconv.Atoi(maxStr)
+		max, err := strconv.ParseInt(maxStr, 10, 64)
 		if err != nil {
 			return false, err
 		}
-		return v.Len() <= max, nil
+		return int64(v.Len()) <= max, nil
 
 	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
 		max, err := strconv.ParseInt(maxStr, 10, 64)
@@ -373,11 +373,11 @@ func eqLength(_ context.Context, f Field, opt FuncOption) (bool, error) {
 	v := f.current
 	switch v.Kind() {
 	case reflect.String, reflect.Array, reflect.Map, reflect.Slice:
-		i, err := strconv.Atoi(str)
+		i, err := strconv.ParseInt(str, 10, 64)
 		if err != nil {
 			return false, err
 		}
-		return v.Len() == i, nil
+		return int64(v.Len()) == i, nil
 
 	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
 		i, err := strconv.ParseInt(str, 10, 64)

diff --git a/tag_parser.go b/tag_parser.go
@@ -5,19 +5,19 @@ import (
 	"strings"
 )
 
-func (v *Validator) tagParse(rawTag string) (*tagChunk, error) {
+func (v *Validator) parseTag(rawTag string) (*tagChunk, error) {
 	if tags, ok := v.tagCache.Load(rawTag); ok {
 		return tags, nil
 	}
 
 	var (
-		rootTagChunk tagChunk
-		chunk        *tagChunk
-		orParsing    = false
+		rootChunk tagChunk
+		chunk     *tagChunk
+		orParsing = false
 	)
 	const optionalTagName = "optional"
 
-	chunk = &rootTagChunk
+	chunk = &rootChunk
 
 	s := newTagScanner(rawTag)
 loop:
@@ -37,7 +37,8 @@ loop:
 			}
 
 			if orParsing {
-				chunk.Tags[len(chunk.Tags)-1].Params = append(chunk.Tags[len(chunk.Tags)-1].Params, lit)
+				idx := len(chunk.Tags) - 1
+				chunk.Tags[idx].Params = append(chunk.Tags[idx].Params, lit)
 			} else {
 				tag, err := v.newTag(lit)
 				if err != nil {
@@ -56,7 +57,8 @@ loop:
 			}
 
 			if orParsing {
-				chunk.Tags[len(chunk.Tags)-1].Params = append(chunk.Tags[len(chunk.Tags)-1].Params, lit)
+				idx := len(chunk.Tags) - 1
+				chunk.Tags[idx].Params = append(chunk.Tags[idx].Params, lit)
 			} else {
 				tag, err := v.newTag(lit)
 				if err != nil {
@@ -75,7 +77,8 @@ loop:
 			}
 
 			if orParsing {
-				chunk.Tags[len(chunk.Tags)-1].Params = append(chunk.Tags[len(chunk.Tags)-1].Params, lit)
+				idx := len(chunk.Tags) - 1
+				chunk.Tags[idx].Params = append(chunk.Tags[idx].Params, lit)
 			} else {
 				chunk.Tags = append(chunk.Tags, Tag{Name: "or", Params: []string{lit}, validateFn: v.FuncMap["or"]})
 			}
@@ -84,7 +87,8 @@ loop:
 		case nextSeparator:
 			if lit != "" && lit != optionalTagName {
 				if orParsing {
-					chunk.Tags[len(chunk.Tags)-1].Params = append(chunk.Tags[len(chunk.Tags)-1].Params, lit)
+					idx := len(chunk.Tags) - 1
+					chunk.Tags[idx].Params = append(chunk.Tags[idx].Params, lit)
 				} else {
 					tag, err := v.newTag(lit)
 					if err != nil {
@@ -99,9 +103,9 @@ loop:
 		}
 	}
 
-	v.tagCache.Store(rawTag, &rootTagChunk)
+	v.tagCache.Store(rawTag, &rootChunk)
 
-	return &rootTagChunk, nil
+	return &rootChunk, nil
 }
 
 // newTag returns Tag.

diff --git a/tag_parser_test.go b/tag_parser_test.go
@@ -308,7 +308,7 @@ func Test_tagParse(t *testing.T) {
 
 	for _, tc := range testcases {
 		t.Run(tc.rawTag, func(t *testing.T) {
-			chunk, err := New().tagParse(tc.rawTag)
+			chunk, err := New().parseTag(tc.rawTag)
 			if err != nil {
 				t.Fatal(err)
 			}
@@ -390,7 +390,7 @@ func Test_tagParseInvalid(t *testing.T) {
 	}
 
 	for _, tc := range testcases {
-		_, err := New().tagParse(tc.rawTag)
+		_, err := New().parseTag(tc.rawTag)
 		if err.Error() != tc.wantError {
 			t.Errorf("want `%v`, got `%v`", tc.wantError, err.Error())
 		}
@@ -400,7 +400,7 @@ func Test_tagParseInvalid(t *testing.T) {
 func Test_tagCache(t *testing.T) {
 	const rawTag = "required,min(1),max(10)"
 	v := New()
-	want, err := v.tagParse(rawTag)
+	want, err := v.parseTag(rawTag)
 	if err != nil {
 		t.Fatal(err)
 	}