Reduce runtime of Go Encode() by another 25% (#649)

* Improve performance of Go Encode() implementation further

Unroll loops to improve performance.

Rewrite lat/lng rounding logic to avoid divides.

Signed-off-by: Will Beason <willbeason@gmail.com>

* Improve comments and function names in Go Encode()

Also merge logic for lat/lng iterations as they are identical.

Signed-off-by: Will Beason <willbeason@gmail.com>

---------

Signed-off-by: Will Beason <willbeason@gmail.com>
Co-authored-by: Doug Rinckes <drinckes@google.com>

go/encode.go

@@ -44,15 +44,7 @@ const (
 // codes represent smaller areas, but lengths > 14 are sub-centimetre and so
 // 11 or 12 are probably the limit of useful codes.
 func Encode(lat, lng float64, codeLen int) string {
-	if codeLen <= 0 {
-		codeLen = pairCodeLen
-	} else if codeLen < 2 {
-		codeLen = 2
-	} else if codeLen < pairCodeLen && codeLen%2 == 1 {
-		codeLen++
-	} else if codeLen > maxCodeLen {
-		codeLen = maxCodeLen
-	}
+	codeLen = clipCodeLen(codeLen)
 	// Clip the latitude. Normalise the longitude.
 	lat, lng = clipLatitude(lat), normalizeLng(lng)
 	// Latitude 90 needs to be adjusted to be just less, so the returned code
@@ -62,57 +54,48 @@ func Encode(lat, lng float64, codeLen int) string {
 	}
 	// Use a char array so we can build it up from the end digits, without having
 	// to keep reallocating strings.
-	var code [16]byte
-	// Avoid the need for string concatenation by filling in the Separator manually.
-	code[sepPos] = Separator
+	var code [maxCodeLen + 1]byte
 
 	// Compute the code.
 	// This approach converts each value to an integer after multiplying it by
 	// the final precision. This allows us to use only integer operations, so
 	// avoiding any accumulation of floating point representation errors.
-
-	// Multiply values by their precision and convert to positive.
-	// Note: Go requires rounding before truncating to ensure precision!
-	var latVal int64 = int64(math.Round((lat+latMax)*finalLatPrecision*1e6) / 1e6)
-	var lngVal int64 = int64(math.Round((lng+lngMax)*finalLngPrecision*1e6) / 1e6)
+	latVal, lngVal := roundLatLngToInts(lat, lng)
 
 	// Compute the grid part of the code if necessary.
-	pos := maxCodeLen
 	if codeLen > pairCodeLen {
-		for i := 0; i < gridCodeLen; i++ {
-			latDigit := latVal % int64(gridRows)
-			lngDigit := lngVal % int64(gridCols)
-			ndx := latDigit*gridCols + lngDigit
-			code[pos] = Alphabet[ndx]
-			pos -= 1
-			latVal /= int64(gridRows)
-			lngVal /= int64(gridCols)
-		}
+		code[sepPos+7], latVal, lngVal = latLngGridStep(latVal, lngVal)
+		code[sepPos+6], latVal, lngVal = latLngGridStep(latVal, lngVal)
+		code[sepPos+5], latVal, lngVal = latLngGridStep(latVal, lngVal)
+		code[sepPos+4], latVal, lngVal = latLngGridStep(latVal, lngVal)
+		code[sepPos+3], latVal, lngVal = latLngGridStep(latVal, lngVal)
 	} else {
 		latVal /= gridLatFullValue
 		lngVal /= gridLngFullValue
 	}
 
-	// Compute the pair after the Separator as a special case rather than
-	// introduce an if statement to the loop which will only be executed once.
-	// This also allows us to remove two unnecessary divides at the end of the loop.
+	// Add the pair after the separator.
 	latNdx := latVal % int64(encBase)
 	lngNdx := lngVal % int64(encBase)
 	code[sepPos+2] = Alphabet[lngNdx]
 	code[sepPos+1] = Alphabet[latNdx]
 
+	// Avoid the need for string concatenation by filling in the Separator manually.
+	code[sepPos] = Separator
+
 	// Compute the pair section of the code.
-	pos = sepPos - 1
-	for i := 0; i < sepPos/2; i++ {
-		latVal /= int64(encBase)
-		lngVal /= int64(encBase)
-		latNdx = latVal % int64(encBase)
-		lngNdx = lngVal % int64(encBase)
-		code[pos] = Alphabet[lngNdx]
-		pos -= 1
-		code[pos] = Alphabet[latNdx]
-		pos -= 1
-	}
+	// Even indices contain latitude and odd contain longitude.
+	code[7], lngVal = pairIndexStep(lngVal)
+	code[6], latVal = pairIndexStep(latVal)
+
+	code[5], lngVal = pairIndexStep(lngVal)
+	code[4], latVal = pairIndexStep(latVal)
+
+	code[3], lngVal = pairIndexStep(lngVal)
+	code[2], latVal = pairIndexStep(latVal)
+
+	code[1], lngVal = pairIndexStep(lngVal)
+	code[0], latVal = pairIndexStep(latVal)
 
 	// If we don't need to pad the code, return the requested section.
 	if codeLen >= sepPos {
@@ -122,6 +105,57 @@ func Encode(lat, lng float64, codeLen int) string {
 	return string(code[:codeLen]) + strings.Repeat(string(Padding), sepPos-codeLen) + string(Separator)
 }
 
+// roundLatLngToInts rounds the passed latitude and longitude to integral values
+// representing a location within 1 centimetre of the passed coordinates.
+func roundLatLngToInts(lat, lng float64) (int64, int64) {
+	// To round, we:
+	// 1) Offset latitude and longitude so that all values are positive.
+	// 2) Multiply by the final precision before conversion to integer to preserve precision.
+	// 3) Multiply by desired rounding precision and add 1.
+	// 4) Bit shift to undo the multiply used for rounding.
+
+	// Precision of rounding is equal to 2^roundPrecision.
+	// A value of 20 corresponds to sub-centimetre precision.
+	const roundPrecision = 20
+	latVal := int64((lat+latMax)*finalLatPrecision*(1<<roundPrecision)+1) >> roundPrecision
+	lngVal := int64((lng+lngMax)*finalLngPrecision*(1<<roundPrecision)+1) >> roundPrecision
+	return latVal, lngVal
+}
+
+// clipCodeLen returns the smallest valid code length greater than or equal to
+// the desired code length.
+func clipCodeLen(codeLen int) int {
+	if codeLen <= 0 {
+		// Default to a full pair code if codeLen is the default or negative
+		// value.
+		return pairCodeLen
+	} else if codeLen < pairCodeLen && codeLen%2 == 1 {
+		// Codes only consisting of pairs must have an even length.
+		return codeLen + 1
+	} else if codeLen > maxCodeLen {
+		return maxCodeLen
+	}
+	return codeLen
+}
+
+// latLngGridStep computes the next smallest grid code in sequence,
+// followed by the remaining latitude and longitude values not yet converted
+// to a grid code.
+func latLngGridStep(latVal, lngVal int64) (byte, int64, int64) {
+	latDigit := latVal % int64(gridRows)
+	lngDigit := lngVal % int64(gridCols)
+	ndx := latDigit*gridCols + lngDigit
+	return Alphabet[ndx], latVal / int64(gridRows), lngVal / int64(gridCols)
+}
+
+// pairIndexStep computes the next smallest pair code in sequence,
+// followed by the remaining integer not yet converted to a pair code.
+func pairIndexStep(coordinate int64) (byte, int64) {
+	coordinate /= int64(encBase)
+	latNdx := coordinate % int64(encBase)
+	return Alphabet[latNdx], coordinate
+}
+
 // computeLatPrec computes the precision value for a given code length.
 // Lengths <= 10 have the same precision for latitude and longitude,
 // but lengths > 10 have different precisions due to the grid method