unroll loops when parsing base58

Author: jaredLunde

README.md

@@ -90,7 +90,8 @@ This package is a fork of [github.com/gofrs/uuid](https://github.com/gofrs/uuid)
 This library includes additional performance optimizations beyond the original fork:
 
 - **Zero allocations** for all parsing operations
-- **Optimized hex encoding/decoding** with lookup tables
+- **Optimized hex encoding/decoding** with lookup tables and unrolled loops
+- **Optimized base58 decoding** with stack allocation and loop unrolling (~29% faster)
 
 ## Benchmarks
 
@@ -112,7 +113,7 @@ BenchmarkFromBytes             504783348	        2.380 ns/op	       0 B/op
 
 BenchmarkFromString/canonical  153610305	         7.834 ns/op	     0 B/op	       0 allocs/op
 BenchmarkFromString/hash       158399199	         7.480 ns/op	     0 B/op	       0 allocs/op
-BenchmarkFromString/base58      16845720	         71.05 ns/op	     0 B/op	       0 allocs/op
+BenchmarkFromString/base58      24494169	        48.91 ns/op	     0 B/op	       0 allocs/op
 ```
 
 ## Contributing

base58/base58.go

@@ -69,7 +69,7 @@ func UnmarshalString(dst []byte, str string) error {
 	return UnmarshalBytes(dst, []byte(str))
 }
 
-func UnmarshalBytes(dst, src []byte) error {
+func UnmarshalBytesOld(dst, src []byte) error {
 	outi := make([]uint32, 4) // (uuidSize + 3) / 4
 
 	for i := 0; i < len(src); i++ {
@@ -96,6 +96,91 @@ func UnmarshalBytes(dst, src []byte) error {
 	return nil
 }
 
+func UnmarshalBytes(dst, src []byte) error {
+	// Use stack allocation for better performance
+	var outi [4]uint32
+	
+	// Optimized for the common case of 22-byte base58 UUID
+	if len(src) == 22 {
+		// Unrolled loop for base58 decoding
+		// Process all 22 characters with partially unrolled loop
+		var c uint64
+		
+		// Unroll by 2 for better performance
+		for i := 0; i < 22; i += 2 {
+			// First character
+			c = decode[src[i]]
+			t3 := uint64(outi[3])*58 + c
+			c = t3 >> 32
+			outi[3] = uint32(t3)
+			
+			t2 := uint64(outi[2])*58 + c
+			c = t2 >> 32
+			outi[2] = uint32(t2)
+			
+			t1 := uint64(outi[1])*58 + c
+			c = t1 >> 32
+			outi[1] = uint32(t1)
+			
+			t0 := uint64(outi[0])*58 + c
+			outi[0] = uint32(t0)
+			
+			// Second character (if exists)
+			if i+1 < 22 {
+				c = decode[src[i+1]]
+				t3 = uint64(outi[3])*58 + c
+				c = t3 >> 32
+				outi[3] = uint32(t3)
+				
+				t2 = uint64(outi[2])*58 + c
+				c = t2 >> 32
+				outi[2] = uint32(t2)
+				
+				t1 = uint64(outi[1])*58 + c
+				c = t1 >> 32
+				outi[1] = uint32(t1)
+				
+				t0 = uint64(outi[0])*58 + c
+				outi[0] = uint32(t0)
+			}
+		}
+	} else {
+		// Fallback for non-standard lengths
+		for i := 0; i < len(src); i++ {
+			c := decode[src[i]]
+			
+			for j := 3; j >= 0; j-- {
+				t := uint64(outi[j])*58 + c
+				c = t >> 32
+				outi[j] = uint32(t)
+			}
+		}
+	}
+	
+	// Unrolled output conversion
+	dst[0] = byte(outi[0] >> 24)
+	dst[1] = byte(outi[0] >> 16)
+	dst[2] = byte(outi[0] >> 8)
+	dst[3] = byte(outi[0])
+	
+	dst[4] = byte(outi[1] >> 24)
+	dst[5] = byte(outi[1] >> 16)
+	dst[6] = byte(outi[1] >> 8)
+	dst[7] = byte(outi[1])
+	
+	dst[8] = byte(outi[2] >> 24)
+	dst[9] = byte(outi[2] >> 16)
+	dst[10] = byte(outi[2] >> 8)
+	dst[11] = byte(outi[2])
+	
+	dst[12] = byte(outi[3] >> 24)
+	dst[13] = byte(outi[3] >> 16)
+	dst[14] = byte(outi[3] >> 8)
+	dst[15] = byte(outi[3])
+
+	return nil
+}
+
 func Encode(bin []byte) string {
 	// A UUID will result in a base58 string of at most 22 characters.
 	// This calculation is specific to 128-bit numbers (UUIDs).

base58/base58_test.go

@@ -58,3 +58,74 @@ func BenchmarkDecode(b *testing.B) {
 		Decode(testPairs[i].enc)
 	}
 }
+
+var testCases = []string{
+	"1C9z3nFjeJ44HMBeuqGNxt",
+	"6ba7b8109dad11d180b400c04f",
+	"Xk7pWZaRRFkqbVa3ma7F5f",
+	"11111111111111111111EJ",
+	"zzzzzzzzzzzzzzzzzzzzzz",
+}
+
+func BenchmarkUnmarshalBytesOld(b *testing.B) {
+	dst := make([]byte, 16)
+	src := []byte(testCases[0])
+	
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_ = UnmarshalBytesOld(dst, src)
+	}
+}
+
+func BenchmarkUnmarshalBytesNew(b *testing.B) {
+	dst := make([]byte, 16)
+	src := []byte(testCases[0])
+	
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_ = UnmarshalBytes(dst, src)
+	}
+}
+
+func BenchmarkUnmarshalBytesOldMultiple(b *testing.B) {
+	dst := make([]byte, 16)
+	
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		for _, tc := range testCases {
+			_ = UnmarshalBytesOld(dst, []byte(tc))
+		}
+	}
+}
+
+func BenchmarkUnmarshalBytesNewMultiple(b *testing.B) {
+	dst := make([]byte, 16)
+	
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		for _, tc := range testCases {
+			_ = UnmarshalBytes(dst, []byte(tc))
+		}
+	}
+}
+
+func TestUnmarshalBytesConsistency(t *testing.T) {
+	for _, tc := range testCases {
+		src := []byte(tc)
+		dst1 := make([]byte, 16)
+		dst2 := make([]byte, 16)
+		
+		err1 := UnmarshalBytesOld(dst1, src)
+		err2 := UnmarshalBytes(dst2, src)
+		
+		if err1 != err2 {
+			t.Fatalf("Error mismatch for %q: old=%v, new=%v", tc, err1, err2)
+		}
+		
+		for i := range dst1 {
+			if dst1[i] != dst2[i] {
+				t.Fatalf("Result mismatch for %q at byte %d: old=%x, new=%x", tc, i, dst1, dst2)
+			}
+		}
+	}
+}