Caching bytes array to increase access speed

Author: cmaglie

benchmark_test.go

@@ -68,7 +68,9 @@ func BenchmarkVersionParser(b *testing.B) {
 	res := &Version{}
 	for i := 0; i < b.N; i++ {
 		for _, v := range list {
-			parseInto([]byte(v), res)
+			res.raw = v
+			res.bytes = []byte(v)
+			parse(res)
 		}
 	}
 
@@ -82,7 +84,7 @@ func BenchmarkVersionParser(b *testing.B) {
 	// BenchmarkVersionParser-12    	  188611	      7715 ns/op	    8557 B/op	      51 allocs/op
 
 	// Results for v0.12.0:  \o/
-	// BenchmarkVersionParser-12    	 1298325	       912.9 ns/op	       0 B/op	       0 allocs/op
+	// BenchmarkVersionParser-12    	  479626	      3719 ns/op	     616 B/op	      51 allocs/op
 }
 
 func BenchmarkVersionComparator(b *testing.B) {
@@ -112,6 +114,6 @@ func BenchmarkVersionComparator(b *testing.B) {
 	// Results for v0.11.0:
 	// BenchmarkVersionComparator-12    	   74793	     17347 ns/op	       0 B/op	       0 allocs/op
 
-	// Results for v0.12.0:  :-|
-	// BenchmarkVersionComparator-12    	   74320	     16223 ns/op	       0 B/op	       0 allocs/op
+	// Results for v0.12.0:  :-)
+	// BenchmarkVersionComparator-12    	   80622	     14659 ns/op	       0 B/op	       0 allocs/op
 }

parser.go

@@ -22,16 +22,18 @@ func MustParse(inVersion string) *Version {
 // Parse parse a version string
 func Parse(inVersion string) (*Version, error) {
 	result := &Version{
-		raw: inVersion,
+		raw:   inVersion,
+		bytes: []byte(inVersion),
 	}
-	if err := parseInto([]byte(inVersion), result); err != nil {
+	if err := parse(result); err != nil {
 		return nil, err
 	}
 	return result, nil
 }
 
-func parseInto(in []byte, result *Version) error {
+func parse(result *Version) error {
 	// Setup parsing harness
+	in := result.bytes
 	inLen := len(in)
 	currIdx := -1
 	var curr byte

version.go

@@ -9,6 +9,7 @@ package semver
 // Version contains the results of parsed version string
 type Version struct {
 	raw        string
+	bytes      []byte
 	major      int
 	minor      int
 	patch      int
@@ -70,7 +71,7 @@ func (v *Version) Normalize() {
 	}
 }
 
-func compareNumber(a, b string) int {
+func compareNumber(a, b []byte) int {
 	la := len(a)
 	lb := len(b)
 	if la == lb {
@@ -101,7 +102,7 @@ func compareAlpha(a, b []byte) int {
 	return 0
 }
 
-var zero = "0"
+var zero = []byte("0")
 
 // CompareTo compares the Version with the one passed as parameter.
 // Returns -1, 0 or 1 if the version is respectively less than, equal
@@ -114,23 +115,25 @@ func (v *Version) CompareTo(u *Version) int {
 	// comparing each of these identifiers from left to right as follows: Major, minor,
 	// and patch versions are always compared numerically.
 	// Example: 1.0.0 < 2.0.0 < 2.1.0 < 2.1.1.
-	vMajor := zero[:]
-	if v.major > 0 {
-		vMajor = v.raw[:v.major]
+	vMajorValue := zero[:]
+	vMajor := v.major
+	if vMajor > 0 {
+		vMajorValue = v.bytes[:vMajor]
 	}
-	uMajor := zero[:]
-	if u.major > 0 {
-		uMajor = u.raw[:u.major]
+	uMajorValue := zero[:]
+	uMajor := u.major
+	if uMajor > 0 {
+		uMajorValue = u.bytes[:uMajor]
 	}
 	{
-		la := len(vMajor)
-		lb := len(uMajor)
+		la := len(vMajorValue)
+		lb := len(uMajorValue)
 		if la == lb {
-			for i := range vMajor {
-				if vMajor[i] == uMajor[i] {
+			for i := range vMajorValue {
+				if vMajorValue[i] == uMajorValue[i] {
 					continue
 				}
-				if vMajor[i] > uMajor[i] {
+				if vMajorValue[i] > uMajorValue[i] {
 					return 1
 				}
 				return -1
@@ -141,26 +144,25 @@ func (v *Version) CompareTo(u *Version) int {
 			return -1
 		}
 	}
-	vMinor := zero[:]
-	if v.minor > v.major {
-		vMinor = v.raw[v.major+1 : v.minor]
+	vMinorValue := zero[:]
+	vMinor := v.minor
+	if vMinor > vMajor {
+		vMinorValue = v.bytes[vMajor+1 : vMinor]
 	}
-	uMinor := zero[:]
-	if u.minor > u.major {
-		uMinor = u.raw[u.major+1 : u.minor]
+	uMinorValue := zero[:]
+	uMinor := u.minor
+	if uMinor > uMajor {
+		uMinorValue = u.bytes[uMajor+1 : uMinor]
 	}
-	// if cmp := compareNumber(vMinor, uMinor); cmp != 0 {
-	// 	return cmp
-	// }
 	{
-		la := len(vMinor)
-		lb := len(uMinor)
+		la := len(vMinorValue)
+		lb := len(uMinorValue)
 		if la == lb {
-			for i := range vMinor {
-				if vMinor[i] == uMinor[i] {
+			for i := range vMinorValue {
+				if vMinorValue[i] == uMinorValue[i] {
 					continue
 				}
-				if vMinor[i] > uMinor[i] {
+				if vMinorValue[i] > uMinorValue[i] {
 					return 1
 				}
 				return -1
@@ -171,26 +173,25 @@ func (v *Version) CompareTo(u *Version) int {
 			return -1
 		}
 	}
-	vPatch := zero[:]
-	if v.patch > v.minor {
-		vPatch = v.raw[v.minor+1 : v.patch]
+	vPatchValue := zero[:]
+	vPatch := v.patch
+	if vPatch > vMinor {
+		vPatchValue = v.bytes[vMinor+1 : vPatch]
 	}
-	uPatch := zero[:]
-	if u.patch > u.minor {
-		uPatch = u.raw[u.minor+1 : u.patch]
+	uPatchValue := zero[:]
+	uPatch := u.patch
+	if uPatch > uMinor {
+		uPatchValue = u.bytes[uMinor+1 : uPatch]
 	}
-	// if cmp := compareNumber(vPatch, uPatch); cmp != 0 {
-	// 	return cmp
-	// }
 	{
-		la := len(vPatch)
-		lb := len(uPatch)
+		la := len(vPatchValue)
+		lb := len(uPatchValue)
 		if la == lb {
-			for i := range vPatch {
-				if vPatch[i] == uPatch[i] {
+			for i := range vPatchValue {
+				if vPatchValue[i] == uPatchValue[i] {
 					continue
 				}
-				if vPatch[i] > uPatch[i] {
+				if vPatchValue[i] > uPatchValue[i] {
 					return 1
 				}
 				return -1
@@ -203,7 +204,7 @@ func (v *Version) CompareTo(u *Version) int {
 	}
 
 	// if both versions have no pre-release, they are equal
-	if v.prerelease == v.patch && u.prerelease == u.patch {
+	if v.prerelease == vPatch && u.prerelease == uPatch {
 		return 0
 	}
 
@@ -212,11 +213,11 @@ func (v *Version) CompareTo(u *Version) int {
 	// Example: 1.0.0-alpha < 1.0.0.
 
 	// if v has no pre-release, it's greater than u
-	if v.prerelease == v.patch {
+	if v.prerelease == vPatch {
 		return 1
 	}
 	// if u has no pre-release, it's greater than v
-	if u.prerelease == u.patch {
+	if u.prerelease == uPatch {
 		return -1
 	}
 
@@ -369,26 +370,26 @@ func (v *Version) CompatibleWith(u *Version) bool {
 	}
 	vMajor := zero[:]
 	if v.major > 0 {
-		vMajor = v.raw[:v.major]
+		vMajor = v.bytes[:v.major]
 	}
 	uMajor := zero[:]
 	if u.major > 0 {
-		uMajor = u.raw[:u.major]
+		uMajor = u.bytes[:u.major]
 	}
 	majorEquals := compareNumber(vMajor, uMajor) == 0
-	if v.major > 0 && v.raw[0] != '0' {
+	if v.major > 0 && v.bytes[0] != '0' {
 		return majorEquals
 	}
 	if !majorEquals {
 		return false
 	}
 	vMinor := zero[:]
 	if v.minor > v.major {
-		vMinor = v.raw[v.major+1 : v.minor]
+		vMinor = v.bytes[v.major+1 : v.minor]
 	}
 	uMinor := zero[:]
 	if u.minor > u.major {
-		uMinor = u.raw[u.major+1 : u.minor]
+		uMinor = u.bytes[u.major+1 : u.minor]
 	}
 	minorEquals := compareNumber(vMinor, uMinor) == 0
 	if vMinor[0] != '0' {
@@ -399,11 +400,11 @@ func (v *Version) CompatibleWith(u *Version) bool {
 	}
 	vPatch := zero[:]
 	if v.patch > v.minor {
-		vPatch = v.raw[v.minor+1 : v.patch]
+		vPatch = v.bytes[v.minor+1 : v.patch]
 	}
 	uPatch := zero[:]
 	if u.patch > u.minor {
-		uPatch = u.raw[u.minor+1 : u.patch]
+		uPatch = u.bytes[u.minor+1 : u.patch]
 	}
 	return compareNumber(vPatch, uPatch) == 0
 }

version_test.go

@@ -221,14 +221,14 @@ func TestNilVersionString(t *testing.T) {
 
 func TestCompareNumbers(t *testing.T) {
 	// ==
-	require.Zero(t, compareNumber("0", "0"))
-	require.Zero(t, compareNumber("5", "5"))
-	require.Zero(t, compareNumber("15", "15"))
+	require.Zero(t, compareNumber([]byte("0"), []byte("0")))
+	require.Zero(t, compareNumber([]byte("5"), []byte("5")))
+	require.Zero(t, compareNumber([]byte("15"), []byte("15")))
 
 	// >
 	testGreater := func(a, b string) {
-		require.Positive(t, compareNumber(a, b), `compareNumber("%s","%s") is not positive`, a, b)
-		require.Negative(t, compareNumber(b, a), `compareNumber("%s","%s") is not negative`, b, a)
+		require.Positive(t, compareNumber([]byte(a), []byte(b)), `compareNumber("%s","%s") is not positive`, a, b)
+		require.Negative(t, compareNumber([]byte(b), []byte(a)), `compareNumber("%s","%s") is not negative`, b, a)
 	}
 	testGreater("1", "")
 	testGreater("1", "0")