GV

GeezerVison

The World Wide Web, restored to 800 pixels of glory.

Home|About|Gaming cabinet|Archives|How it works|Starter sites

On this site

  • Sign in
  • ActionsCI/CD and automation
  • CodespacesCloud development environments
  • All Features
  • Documentation
  • Training
  • Certifications
  • Build with Copilot
  • Customize Copilot
  • Integrations
  • Trending repos
  • GitHub Sponsors
  • Developer articles
  • Enterprises

This view

  • Original page
  • New address

GeezerVison is showing github.com — GitHub - unrays/unsynchronized-chunk-allocator: A C++ unsynchronized chunk-based memory allocator with monotonic allocation strategy for high-performance workloads.

BranchesTags
Open more actions menu

Latest commit

 

History

19 Commits
19 Commits

Folders and files

NameName
Last commit message
Last commit date
include/exotic/memory
include/exotic/memory
 
 
LICENSE
LICENSE
 
 
README.md
README.md
 
 
SECURITY.md
SECURITY.md
 
 

Repository files navigation

Unsynchronized Chunk Allocator

A C++ unsynchronized chunk-based memory allocator with monotonic allocation strategy for high-performance workloads. This project is part of the EXOTIC::memory library.

Overview

This project started as a technical challenge I set for myself within the scope of a compiler-related work.

It required a solid understanding of allocators, as they form the foundation of precise lifetime management and efficient data structures in low-level systems.

To approach this, I studied the design of std::pmr and related allocator models, taking notes and extracting the core ideas that I found most relevant.

It took me around three weeks to arrive at a functional implementation.

This is not a simple copy of an existing allocator from the internet. While I drew inspiration from established standards and allocator design principles, I implemented the system in a very educational and deliberate way, focusing on clarity and understanding.

I’m genuinely proud of this work, and it will be used as part of a compiler project where it fulfills its original goal.


Example Usage

// In this case, we use a monotonic atomic buffer as the memory backend
exotic::memory::monotonic_atomic_buffer upstream(1 << 20);

exotic::memory::unsynchronized_chunk_allocator<int> allocator(&upstream);

// Allocate raw memory for 10 ints
int* data = allocator.allocate(10);

// Construct objects in-place
allocator.construct(data, 42);

// High-level allocation helper
auto* obj = allocator.new_object<int>(123);

// Destroy (no-op deallocation model)
allocator.destroy(obj);

Notes

This project is intentionally minimal in scope and focused on learning and system-level understanding rather than being a production-ready general-purpose allocator. This project is the result of the skills I have undoubtedly acquired over the past 7 months since I started learning C++. Also, the very library-like aspect with exotic::memory is simply because it looks cooler and more professional :)

License

This project is licensed under the Boost Software License. See the LICENSE file for details.

© Félix-Olivier Dumas 2026

About

A C++ unsynchronized chunk-based memory allocator with monotonic allocation strategy for high-performance workloads.

unrays.github.io/unsynchronized-chunk-allocator/

Topics

allocatorarena-allocatorcache-friendlycompiler-backendcppcpp-librarycustom-allocatordata-structuresexotichigh-performancelow-level-programmingmemory-allocatormemory-managementmemory-poolmonotonic-allocatorpmrquebecsystems-programmingzero-overhead

Resources

Readme
BSL-1.0 license

Code of conduct

Code of conduct

Security policy

Security policy
Activity

Stars

1 star

Watchers

0 watching

Forks

0 forks
Report repository

Releases

Sponsor this project

Packages

Contributors

Languages

You are visitor 01402503 — GeezerVison does not store the pages you look up.
Best viewed with Netscape Navigator 4.7 or Internet Explorer 6 at 800×600. No cookies required.