Custom memory_resource implementation with an atomic monotonic buffer allocator supporting aligned, lock-free allocations on a preallocated memory region.

This article describes a custom C++ memory resource implementation called `monotonic_atomic_buffer`, which provides lock-free, aligned memory allocations from a preallocated buffer using atomic operations. The allocator uses a monotonic bump-pointer strategy with atomic compare-and-exchange to safely manage concurrent allocations without mutexes, and it never deallocates individual allocations. The implementation is designed for high-performance scenarios requiring thread-safe allocation from a fixed-size memory region.

monotonic atomic buffer.hpp This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters. Learn more about bidirectional Unicode characters Show hidden characters // Copyright c May 2026 Félix-Olivier Dumas. All rights reserved. // Licensed under the terms described in the LICENSE file pragma once include <cstddef include <atomic include <stdexcept namespace exotic::memory { class memory resource { public: virtual ~memory resource = default; public: nodiscard void allocate std::size t bytes, std::size t alignment noexcept { if alignment == 0 || alignment & alignment - 1 = 0 unlikely throw std::invalid argument "alignment must be a power of two" ; return do allocate bytes, alignment ; } void deallocate void p, std::size t bytes, std::size t alignment noexcept { if alignment == 0 || alignment & alignment - 1 = 0 unlikely throw std::invalid argument "alignment must be a power of two" ; do deallocate p, bytes, alignment ; } bool is equal const memory resource& other const noexcept { return do is equal other ; } protected: virtual void do allocate std::size t bytes, std::size t alignment = 0; virtual void do deallocate void ptr, std::size t bytes, std::size t alignment = 0; virtual bool do is equal const memory resource& other const noexcept = 0; }; struct monotonic atomic buffer : public memory resource { public: explicit monotonic atomic buffer std::size t p capacity : capacity p capacity , offset 0 , buffer new std::byte p capacity {} monotonic atomic buffer const monotonic atomic buffer& = delete; monotonic atomic buffer& operator= const monotonic atomic buffer& = delete; ~monotonic atomic buffer noexcept override { delete buffer ; } protected: void do allocate std::size t bytes, std::size t alignment override { std::size t current = offset .load std::memory order relaxed ; while true { std::size t aligned = current + alignment - 1 & ~ alignment - 1 ; std::size t next = aligned + bytes; if next capacity return nullptr; if offset .compare exchange weak current, next, std::memory order relaxed { return buffer + aligned; } } } void do deallocate void , std::size t, std::size t override {} bool do is equal const memory resource& other const noexcept override { return this == &other; } public: nodiscard constexpr std::size t capacity const noexcept { return capacity ; } nodiscard std::size t size const noexcept { return offset .load std::memory order relaxed ; } private: std::byte buffer ; std::atomic<std::size t offset ; std::size t capacity ; }; }