Revert "cache: use malloc instead of calloc"

This reverts commit dd58b84.

The pebble ycsb benchmarks show a regression around the time this commit was
merged. A comparison of the CPU profiles before and after show ~5.32% time in
_Cfunc_calloc before and ~12.10% time in _cgo_cmalloc after.

Author: jbowens

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.NewUninitialized(manual.BlockCacheData, uintptr(n))
+		b := manual.New(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,10 +77,7 @@ 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.NewUninitialized(manual.BlockCacheData, ValueMetadataSize+uintptr(n))
-	// We must clear the slice because Value contains pointers. See
-	// manual.NewUninitialized.
-	clear(b.Slice()[:ValueMetadataSize])
+	b := manual.New(manual.BlockCacheData, ValueMetadataSize+uintptr(n))
 	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,8 +67,6 @@ 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
@@ -79,36 +77,6 @@ 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,9 +15,7 @@ import (
 // Provides versions of New and Free when cgo is not available (e.g. cross
 // compilation).
 
-// 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.
 func New(purpose Purpose, n uintptr) Buf {
 	if n == 0 {
 		return Buf{}
@@ -30,17 +28,6 @@ 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) {