Refactoring

Author: buger

Makefile

@@ -1,7 +1,7 @@
 SOURCE = parser.go
 CONTAINER = jsonparser
 SOURCE_PATH = /go/src/github.com/buger/jsonparser
-BENCHMARK = JsonParser
+BENCHMARK = JsonParserSmall
 BENCHTIME = 5s
 TEST = .
 
@@ -14,6 +14,9 @@ race:
 bench:
 	docker run -v `pwd`:$(SOURCE_PATH) -i -t $(CONTAINER) go test $(LDFLAGS) -test.benchmem -bench $(BENCHMARK) ./benchmark/ $(ARGS) -benchtime $(BENCHTIME) -v
 
+bench_local:
+	docker run -v `pwd`:$(SOURCE_PATH) -i -t $(CONTAINER) go test $(LDFLAGS) -test.benchmem -bench . $(ARGS) -benchtime $(BENCHTIME) -v
+
 profile:
 	docker run -v `pwd`:$(SOURCE_PATH) -i -t $(CONTAINER) go test $(LDFLAGS) -test.benchmem -bench $(BENCHMARK) ./benchmark/ $(ARGS) -memprofile mem.mprof -v
 	docker run -v `pwd`:$(SOURCE_PATH) -i -t $(CONTAINER) go test $(LDFLAGS) -test.benchmem -bench $(BENCHMARK) ./benchmark/ $(ARGS) -cpuprofile cpu.out -v

fastbytes.go renamed to bytes.go

@@ -1,6 +1,7 @@
 package jsonparser
 
-func BytesParseInt(bytes []byte) (v int64, ok bool) {
+// About 3x faster then strconv.ParseInt because does not check for range error and support only base 10, which is enough for JSON
+func parseInt(bytes []byte) (v int64, ok bool) {
 	if len(bytes) == 0 {
 		return 0, false
 	}

bytes_safe.go

@@ -0,0 +1,21 @@
+// +build appengine appenginevm
+
+package jsonparser
+
+import (
+	"strconv"
+)
+
+// See fastbytes_unsafe.go for explanation on why *[]byte is used (signatures must be consistent with those in that file)
+
+func equalStr(b *[]byte, s string) bool {
+	return string(*b) == s
+}
+
+func parseFloat(b *[]byte) (float64, error) {
+	return strconv.ParseFloat(string(*b), 64)
+}
+
+func bytesToString(b *[]byte) string {
+  return string(*b)
+}

fastbytes_test.go renamed to bytes_test.go

@@ -70,7 +70,7 @@ var parseIntTests = []ParseIntTest{
 
 func TestBytesParseInt(t *testing.T) {
 	for _, test := range parseIntTests {
-		out, ok := BytesParseInt([]byte(test.in))
+		out, ok := parseInt([]byte(test.in))
 		if ok != !test.isErr {
 			t.Errorf("Test '%s' error return did not match expectation (obtained %t, expected %t)", test.in, !ok, test.isErr)
 		} else if ok && out != test.out {
@@ -82,7 +82,7 @@ func TestBytesParseInt(t *testing.T) {
 func BenchmarkParseInt(b *testing.B) {
 	bytes := []byte("123")
 	for i := 0; i < b.N; i++ {
-		BytesParseInt(bytes)
+		parseInt(bytes)
 	}
 }
 

fastbytesunsafe.go renamed to bytes_unsafe.go

@@ -14,11 +14,18 @@ import (
 // inlined, whereas the pointer []byte version is equally fast to the manually inlined
 // version. Instruction count in assembly taken from "go tool compile" confirms this difference.
 //
-
-func BytesEqualStr(abytesptr *[]byte, bstr string) bool {
-	return *(*string)(unsafe.Pointer(abytesptr)) == bstr
+// TODO: Remove hack after Go 1.7 release
+//
+func equalStr(b *[]byte, s string) bool {
+	return *(*string)(unsafe.Pointer(b)) == s
 }
 
-func BytesParseFloat(bytesptr *[]byte, bitSize int) (float64, error) {
-	return strconv.ParseFloat(*(*string)(unsafe.Pointer(bytesptr)), bitSize)
+func parseFloat(b *[]byte) (float64, error) {
+	return strconv.ParseFloat(*(*string)(unsafe.Pointer(b)), 64)
 }
+
+// A hack until issue golang/go#2632 is fixed.
+// See: https://github.com/golang/go/issues/2632
+func bytesToString(b *[]byte) string {
+  return *(*string)(unsafe.Pointer(b))
+}

fastbytesunsafe_test.go renamed to bytes_unsafe_test.go

@@ -27,8 +27,8 @@ func bytesEqualStrUnsafeSlower(abytes *[]byte, bstr string) bool {
 }
 
 func TestEqual(t *testing.T) {
-	if !BytesEqualStr(&[]byte{}, "") {
-		t.Errorf(`BytesEqualStr("", ""): expected true, obtained false`)
+	if !equalStr(&[]byte{}, "") {
+		t.Errorf(`equalStr("", ""): expected true, obtained false`)
 		return
 	}
 
@@ -37,20 +37,20 @@ func TestEqual(t *testing.T) {
 		s1, s2 := longstr[:i]+"1", longstr[:i]+"2"
 		b1 := []byte(s1)
 
-		if !BytesEqualStr(&b1, s1) {
-			t.Errorf(`BytesEqualStr("a"*%d + "1", "a"*%d + "1"): expected true, obtained false`, i, i)
+		if !equalStr(&b1, s1) {
+			t.Errorf(`equalStr("a"*%d + "1", "a"*%d + "1"): expected true, obtained false`, i, i)
 			break
 		}
-		if BytesEqualStr(&b1, s2) {
-			t.Errorf(`BytesEqualStr("a"*%d + "1", "a"*%d + "2"): expected false, obtained true`, i, i)
+		if equalStr(&b1, s2) {
+			t.Errorf(`equalStr("a"*%d + "1", "a"*%d + "2"): expected false, obtained true`, i, i)
 			break
 		}
 	}
 }
 
-func BenchmarkBytesEqualStr(b *testing.B) {
+func BenchmarkEqualStr(b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		BytesEqualStr(&benchmarkBytes, benchmarkString)
+		equalStr(&benchmarkBytes, benchmarkString)
 	}
 }
 

fastbytessafe.go

@@ -125,10 +125,10 @@ func searchKeys(data []byte, keys ...string) int {
 
 			// if string is a Key, and key level match
 			if data[i] == ':' {
-				candidateKey := data[keyBegin:keyEnd]
+				key := data[keyBegin:keyEnd]
 
 				if keyLevel == level-1 && // If key nesting level match current object nested level
-					BytesEqualStr(&candidateKey, keys[level-1]) {
+					equalStr(&key, keys[level-1]) {
 					keyLevel++
 					// If we found all keys in path
 					if keyLevel == lk {
@@ -341,6 +341,17 @@ func ArrayEach(data []byte, cb func(value []byte, dataType ValueType, offset int
 	return nil
 }
 
+// GetUnsafeString returns the value retrieved by `Get`, use creates string without memory allocation by mapping string to slice memory. It does not handle escape symbols.
+func GetUnsafeString(data []byte, keys ...string) (val string, err error) {
+	v, _, _, e := Get(data, keys...)
+
+	if e != nil {
+		return "", e
+	}
+
+	return bytesToString(&v), nil
+}
+
 // GetString returns the value retrieved by `Get`, cast to a string if possible, trying to properly handle escape and utf8 symbols
 // If key data type do not match, it will return an error.
 func GetString(data []byte, keys ...string) (val string, err error) {
@@ -378,7 +389,7 @@ func GetFloat(data []byte, keys ...string) (val float64, err error) {
 		return 0, fmt.Errorf("Value is not a number: %s", string(v))
 	}
 
-	val, err = BytesParseFloat(&v, 64)
+	val, err = parseFloat(&v)
 	return
 }
 
@@ -395,7 +406,7 @@ func GetInt(data []byte, keys ...string) (val int64, err error) {
 		return 0, fmt.Errorf("Value is not a number: %s", string(v))
 	}
 
-	if val, ok := BytesParseInt(v); !ok {
+	if val, ok := parseInt(v); !ok {
 		return 0, MalformedValueError
 	} else {
 		return val, nil