Bump Allocator in Go

A bump allocator is a simple memory allocation strategy often used in embedded systems or game development where predictable allocation and deallocation are less critical than speed and minimal overhead. This challenge asks you to implement a basic bump allocator in Go, allowing you to understand memory management techniques and their trade-offs. It's a useful exercise for grasping how memory can be managed without relying on the standard Go garbage collector for certain scenarios.

Problem Description

You are tasked with creating a BumpAllocator struct in Go that manages a fixed-size memory buffer. The allocator should provide the following functionalities:

• Initialization: The allocator should be initialized with a buffer size.
• Allocate: The Allocate(size int) method should allocate a contiguous block of size bytes from the buffer. It should return a pointer to the allocated memory block if successful, and nil if there's insufficient space. The allocation should be "bumped" – meaning the allocation pointer is advanced by the allocated size.
• Reset: The Reset() method should reset the allocator, effectively freeing all allocated memory and returning the allocation pointer to the beginning of the buffer.
• Used: The Used() method should return the number of bytes currently allocated.
• Capacity: The Capacity() method should return the total capacity of the buffer.

The allocator should not support deallocation of individual blocks. All allocated memory is freed only when Reset() is called.

Key Requirements:

• The allocator must manage a single, contiguous memory buffer.
• Allocation must be contiguous and "bumped" – no fragmentation is supported.
• Error handling: Return nil when allocation fails due to insufficient space.
• The Reset() method must return the allocation pointer to the beginning of the buffer.

Expected Behavior:

The allocator should efficiently allocate memory blocks from the buffer until the buffer is exhausted. Subsequent allocation attempts should return nil until Reset() is called.

Edge Cases to Consider:

• Allocation size is zero.
• Allocation size is larger than the remaining buffer space.
• Multiple consecutive allocations.
• Calling Reset() after all memory has been used.
• Calling Allocate() after Reset().

Examples

Example 1:

Input:
allocator := BumpAllocator{Capacity: 100}
ptr1 := allocator.Allocate(20)
ptr2 := allocator.Allocate(30)
fmt.Println(ptr1, ptr2, allocator.Used(), allocator.Capacity())

Output:
0x... 0x... 50 100
Explanation:
The first allocation of 20 bytes starts at address 0x... and advances the allocation pointer. The second allocation of 30 bytes starts immediately after the first, at address 0x... . The `Used()` method returns 50 (20 + 30), and `Capacity()` returns 100.

Example 2:

Input:
allocator := BumpAllocator{Capacity: 50}
ptr1 := allocator.Allocate(20)
ptr2 := allocator.Allocate(30)
ptr3 := allocator.Allocate(10)
fmt.Println(ptr1, ptr2, ptr3, allocator.Used(), allocator.Capacity())

Output:
0x... 0x... 0x... 50 50
Explanation:
The first two allocations succeed. The third allocation of 30 bytes fails because only 30 bytes remain, and the allocator returns nil. `Used()` returns 50, and `Capacity()` returns 50.

Example 3: (Edge Case)

Input:
allocator := BumpAllocator{Capacity: 100}
allocator.Reset()
ptr1 := allocator.Allocate(50)
ptr2 := allocator.Allocate(50)
fmt.Println(ptr1, ptr2, allocator.Used(), allocator.Capacity())

Output:
0x... 0x... 100 100
Explanation:
After `Reset()`, the allocation pointer is reset to the beginning of the buffer. Two allocations of 50 bytes each succeed, using the entire buffer.

Constraints

• Capacity must be a positive integer.
• size in Allocate must be a non-negative integer.
• The allocator should be reasonably efficient (avoid unnecessary copying or complex data structures).
• The Allocate method should return a pointer to a valid memory location within the buffer if successful, and nil otherwise.
• The Reset method should not panic or cause any unexpected behavior.

Notes

• Consider using a uintptr to represent the allocation pointer. This allows you to treat the pointer as an integer for calculations.
• Think about how to handle the case where the requested allocation size is larger than the remaining buffer space.
• This is a simplified bump allocator. Real-world allocators often include features like deallocation, fragmentation management, and alignment. This challenge focuses on the core "bump" allocation concept.
• Error handling is important. Return nil when allocation fails, and avoid panics.