How Go’s New Arena Package Boosts Performance by Up to 15%

Proposal Overview

The Go language community is discussing a new proposal called arena , which allocates a set of objects from a contiguous memory region. This approach is typically more efficient than general allocation, and all objects in an arena can be released at once with minimal memory‑management or garbage‑collection overhead.

Because explicit freeing is unsafe in garbage‑collected languages, arenas are rarely implemented there. The proposal mitigates this by adding dynamic safety checks; if an unsafe arena operation is detected, the program terminates before any incorrect behavior occurs.

Internal use of arena at Google has shown up to a 15% reduction in CPU and memory usage for large applications, mainly due to lower garbage‑collection CPU time and reduced heap usage.

Proposal API

package arena

type Arena struct {
    // contains filtered or unexported fields
}

// New allocates a new arena.
func New() *Arena

// Free frees the arena (and all objects allocated from the arena) so that
// memory backing the arena can be reused fairly quickly without garbage
// collection overhead. Applications must not call any method on this
// arena after it has been freed.
func (a *Arena) Free()

// New allocates an object from arena a. If the concrete type of objPtr is
// a pointer to a pointer to type T (**T), New allocates an object of type T
// and stores a pointer to the object in *objPtr. The object must not be
// accessed after arena a is freed.
func (a *Arena) New(objPtr interface{})

// NewSlice allocates a slice from arena a. If the concrete type of slicePtr
// is *[]T, NewSlice creates a slice of element type T with the specified
// capacity whose backing store is from the arena a and stores it in *slicePtr.
// The length of the slice is set to the capacity. The slice must not be
// accessed after arena a is freed.
func (a *Arena) NewSlice(slicePtr interface{}, cap int)

Usage example:

import (
    "arena"
    …
)

type T struct {
    val int
}

func main() {
    a := arena.New()
    var ptrT *T
    a.New(&ptrT)
    ptrT.val = 1

    var sliceT []T
    a.NewSlice(&sliceT, 100)
    sliceT[99].val = 4

    a.Free()
}