cache: use malloc instead of calloc

Many profiles have a percentage or two in `manual.Alloc`. Switch to
using `malloc` instead of `calloc`, which should speed up the
allocations. We clear only the part that we cast to `*cache.Value`. We
already clear the part that we use for block metadata (via
`block.CastMetadataZero`).

Author: RaduBerinde

internal/cache/value.go

@@ -59,7 +59,7 @@ func Alloc(n int) *Value {
 
 	if valueEntryCanBeGoAllocated && valueEntryGoAllocated {
 		// Note: if cgo is not enabled, manual.New will do a regular Go allocation.
-		b := manual.New(manual.BlockCacheData, uintptr(n))
+		b := manual.NewUninitialized(manual.BlockCacheData, uintptr(n))
 		v := &Value{buf: b.Slice()}
 		v.ref.init(1)
 		// Note: this is a no-op if invariants and tracing are disabled or race is
@@ -77,7 +77,10 @@ func Alloc(n int) *Value {
 	// When we're not performing leak detection, the lifetime of the returned
 	// Value is exactly the lifetime of the backing buffer and we can manually
 	// allocate both.
-	b := manual.New(manual.BlockCacheData, ValueMetadataSize+uintptr(n))
+	b := manual.NewUninitialized(manual.BlockCacheData, ValueMetadataSize+uintptr(n))
+	// We must clear the slice because Value contains pointers. See
+	// manual.NewUninitialized.
+	clear(b.Slice()[:ValueMetadataSize])
 	v := (*Value)(b.Data())
 	v.buf = b.Slice()[ValueMetadataSize:]
 	v.ref.init(1)

internal/manual/manual_cgo.go

@@ -39,9 +39,9 @@ var useGoAllocation = invariants.RaceEnabled && rand.Uint32()%2 == 0
 // runtime page allocator and allocate large chunks of memory using mmap or
 // similar.
 
-// New allocates a slice of size n. The returned slice is from manually
-// managed memory and MUST be released by calling Free. Failure to do so will
-// result in a memory leak.
+// New allocates a slice of size n. The returned slice is from manually managed
+// memory and MUST be released by calling Free. Failure to do so will result in
+// a memory leak.
 func New(purpose Purpose, n uintptr) Buf {
 	if n == 0 {
 		return Buf{}
@@ -67,6 +67,8 @@ func New(purpose Purpose, n uintptr) Buf {
 	//   passing uninitialized C memory to Go code if the Go code is going to
 	//   store pointer values in it. Zero out the memory in C before passing it
 	//   to Go.
+	//
+	// See https://github.com/golang/go/issues/19928
 	ptr := C.calloc(C.size_t(n), 1)
 	if ptr == nil {
 		// NB: throw is like panic, except it guarantees the process will be
@@ -77,6 +79,36 @@ func New(purpose Purpose, n uintptr) Buf {
 	return Buf{data: ptr, n: n}
 }
 
+// NewUninitialized allocates a slice of size n without zeroing it out. The
+// returned slice is from manually managed memory and MUST be released by
+// calling Free. Failure to do so will result in a memory leak (see
+// https://github.com/golang/go/issues/19928).
+//
+// If the caller does an unsafe cast from the slice to any type containing
+// pointers, the relevant part of the slice *must* be zeroed out.
+func NewUninitialized(purpose Purpose, n uintptr) Buf {
+	if n == 0 {
+		return Buf{}
+	}
+	recordAlloc(purpose, n)
+
+	// In race-enabled builds, we sometimes make allocations using Go to allow
+	// the race detector to observe concurrent memory access to memory allocated
+	// by this package. See the definition of useGoAllocation for more details.
+	if invariants.RaceEnabled && useGoAllocation {
+		b := make([]byte, n)
+		return Buf{data: unsafe.Pointer(&b[0]), n: n}
+	}
+	ptr := C.malloc(C.size_t(n))
+	if ptr == nil {
+		// NB: throw is like panic, except it guarantees the process will be
+		// terminated. The call below is exactly what the Go runtime invokes when
+		// it cannot allocate memory.
+		throw("out of memory")
+	}
+	return Buf{data: ptr, n: n}
+}
+
 // Free frees the specified slice. It has to be exactly the slice that was
 // returned by New.
 func Free(purpose Purpose, b Buf) {

internal/manual/manual_nocgo.go

@@ -15,7 +15,9 @@ import (
 // Provides versions of New and Free when cgo is not available (e.g. cross
 // compilation).
 
-// New allocates a slice of size n.
+// New allocates a slice of size n. The returned slice is from manually managed
+// memory and MUST be released by calling Free. Failure to do so will result in
+// a memory leak.
 func New(purpose Purpose, n uintptr) Buf {
 	if n == 0 {
 		return Buf{}
@@ -28,6 +30,17 @@ func New(purpose Purpose, n uintptr) Buf {
 	}
 }
 
+// NewUninitialized allocates a slice of size n without zeroing it out. The
+// returned slice is from manually managed memory and MUST be released by
+// calling Free. Failure to do so will result in a memory leak (see
+// https://github.com/golang/go/issues/19928).
+//
+// If the caller does an unsafe cast from the slice to any type containing
+// pointers, the relevant part of the slice *must* be zeroed out.
+func NewUninitialized(purpose Purpose, n uintptr) Buf {
+	return New(purpose, n)
+}
+
 // Free frees the specified slice. It has to be exactly the slice that was
 // returned by New.
 func Free(purpose Purpose, b Buf) {