Chapter 41: Performance Optimization with Memory Arenas // Sanko Robinson

Frequent calls to malloc() and free() (or Perl's new and garbage collection) can become a significant bottleneck in performance-critical code. Each allocation is a request to the operating system or the memory manager, which involves searching for a free block, updating metadata, and potentially triggering a syscall.

A Memory Arena (also known as a Region or Zone allocator) is a technique where you allocate one large block of memory upfront and then "carve" out smaller pieces as needed. When you are done, you free the entire block at once.

The Recipe

We will build a simple Arena allocator in Perl using Affix's memory utilities. This allows us to create millions of small C-compatible structs with near-zero allocation overhead.

use v5.40;
use Affix qw[:all];

# Define a Struct for our data
typedef Point => Struct [ x => Int, y => Int ];
my $point_size = sizeof Point();

# Setup the arena
# We allocate 1MB upfront (enough for ~131,000 Points)
my $ARENA_SIZE     = 1024 * 1024;
my $arena_ptr      = malloc $ARENA_SIZE;
my $current_offset = 0;

# Allocation Helper
# Carves a block of memory from the arena
sub arena_alloc($size) {
    die 'Arena exhausted' if $current_offset + $size > $ARENA_SIZE;

    # Get the address of the current slot
    my $ptr = ptr_add( $arena_ptr, $current_offset );

    # Advance the pointer and return
    $current_offset += $size;
    return $ptr;
}

# Use the Arena
say 'Allocating 100,000 points...';
my $start_time = time();
my @points;
for ( 1 .. 100_000 ) {

    # Grab memory from the arena
    my $raw = arena_alloc($point_size);

    # Cast it to our Struct type (Zero-copy view)
    # We use Pointer[Point] so we get unified access
    my $p = cast $raw, Pointer [ Point() ];

    # Initialize
    $p->{x} = $_;
    $p->{y} = $_ * 2;

    # Store the pin (optional, we could just process and forget)
    push @points, $p;
}
say 'Finished in ' . ( time() - $start_time ) . ' seconds.';
say 'Point 500: x=' . $points[499]{x} . ', y=' . $points[499]{y};

# Cleanup
# Instead of 100,000 free() calls, we just do one!
free $arena_ptr;
undef @points;    # Pins are now invalid, but that's okay.

How It Works

1. Pre-allocation By calling malloc 1024 * 1024, we make a single request to the system. From that point on, every "allocation" we make via arena_alloc is just simple integer addition ($current_offset += $size). This is the fastest possible way to allocate memory.
2. ptr_add and cast
```
my $raw = ptr_add($arena_ptr, $current_offset);
my $p = cast $raw, Pointer[Point()];
```
The ptr_add function returns a new unmanaged pin pointing to an offset within our big block. cast then tells Affix how to interpret the bytes at that address. No memory is copied during these steps.
3. Bulk Deallocation In a standard FFI script, you might rely on own($ptr, 1) to let Perl's GC free each struct individually. With an Arena, you set own($arena_ptr, 1) (which is the default for malloc) and when the arena itself goes out of scope, the entire 1MB block is reclaimed.

Kitchen Reminders

Fragmentation Arenas are perfect for data that has the same lifetime. If you need to free specific items while keeping others, an Arena is the wrong tool (use standard malloc/free).
Alignment In a real-world scenario, you must ensure that each "carved" piece starts on a valid alignment boundary (usually 4 or 8 bytes). You can achieve this with a simple bitwise mask:
```
# Align to 8 bytes
$current_offset = ($current_offset + 7) & ~7;
```
Performance This technique is especially powerful when combined with direct_affix. If you pass your arena-allocated pointers to a JIT-optimized C function, the total overhead is virtually indistinguishable from native C.