runtime: Grow small slices more aggressively, larger more mildly

Align the capacity on the next power of two for small slices, but tries
a milder (1.5x) over-allocation for slices with capacity over the
threshold.

This behavior is similar to (but not the same as) Big Go.

Signed-off-by: L. Pereira <[email protected]>

Author: lpereira

src/runtime/slice.go

@@ -7,6 +7,8 @@ import (
 	"unsafe"
 )
 
+const DoubleCapThreshold = 64
+
 // Builtin append(src, elements...) function: append elements to src and return
 // the modified (possibly expanded) slice.
 func sliceAppend(srcBuf, elemsBuf unsafe.Pointer, srcLen, srcCap, elemsLen, elemSize uintptr) (unsafe.Pointer, uintptr, uintptr) {
@@ -41,10 +43,13 @@ func sliceGrow(oldBuf unsafe.Pointer, oldLen, oldCap, newCap, elemSize uintptr)
 		return oldBuf, oldLen, oldCap
 	}
 
-	// This can be made more memory-efficient by multiplying by some other constant, such as 1.5,
-	// which seems to be allowed by the Go language specification (but this can be observed by
-	// programs).
-	newCap = 1 << bits.Len32(uint32(newCap))
+	// Align the capacity on the next power of two for small slices, but tries a
+	// milder (1.5x) over-allocation for slices with capacity over the threshold.
+	if newCap < DoubleCapThreshold {
+		newCap = 1 << bits.Len(uint(newCap))
+	} else {
+		newCap = (newCap / 2) * 3
+	}
 
 	buf := alloc(newCap*elemSize, nil)
 	if oldLen > 0 {