├── .github
    ├── LICENSE
    └── README.md
├── mem
└── mem.cppm


/.github/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2025 Kris Jusiak <kris@jusiak.net>
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/.github/README.md:
--------------------------------------------------------------------------------
1 | ../mem


--------------------------------------------------------------------------------
/mem:
--------------------------------------------------------------------------------
  1 | // <!--
  2 | // The MIT License (MIT)
  3 | //
  4 | // Copyright (c) 2024-2025 Kris Jusiak <kris@jusiak.net>
  5 | //
  6 | // Permission is hereby granted, free of charge, to any person obtaining a copy
  7 | // of this software and associated documentation files (the "Software"), to deal
  8 | // in the Software without restriction, including without limitation the rights
  9 | // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 10 | // copies of the Software, and to permit persons to whom the Software is
 11 | // furnished to do so, subject to the following conditions:
 12 | //
 13 | // The above copyright notice and this permission notice shall be included in all
 14 | // copies or substantial portions of the Software.
 15 | //
 16 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 17 | // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 18 | // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 19 | // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 20 | // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 21 | // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 22 | // SOFTWARE.
 23 | //
 24 | #if 0
 25 | // -->
 26 | [Overview](#Overview) / [API](#API) / [FAQ](#FAQ) / [Resources](#Resources)
 27 | 
 28 | ## `mem`: Memory Allocator library
 29 | 
 30 | [![MIT Licence](http://img.shields.io/badge/license-MIT-blue.svg)](https://opensource.org/license/mit)
 31 | [![Version](https://img.shields.io/github/v/release/qlibs/mem)](https://github.com/qlibs/mem/releases)
 32 | [![Build](https://img.shields.io/badge/build-green.svg)](https://godbolt.org/z/Yh6r9h9Pf)
 33 | [![Try it online](https://img.shields.io/badge/try%20it-online-blue.svg)](https://godbolt.org/z/WdaTrqrxK)
 34 | 
 35 |   > [https://en.wikipedia.org/wiki/Allocator_C++](https://en.wikipedia.org/wiki/Allocator_(C%2B%2B))
 36 | 
 37 | ### Features
 38 | 
 39 | - Single header (https://raw.githubusercontent.com/qlibs/mem/main/mem) / C++20 module (https://raw.githubusercontent.com/qlibs/mem/main/mem.cppm)
 40 | - [C++23](https://eel.is/c++draft/allocator.requirements) standard compliant [API](#api)
 41 | - Verifies itself upon `include/import` (can be disabled with `-DNTEST` - see [FAQ](#faq))
 42 | 
 43 | ### Requirements
 44 | 
 45 | - C++20+ ([clang++12+, g++11+](https://en.cppreference.com/w/cpp/compiler_support)) / [`Linux`](https://en.wikipedia.org/wiki/Linux)\* / [`numactl`](https://github.com/numactl/numactl)\*
 46 | 
 47 | ### Overview
 48 | 
 49 | ```cpp
 50 | import mem;
 51 | 
 52 | int main() {
 53 |   static_assert(mem::allocator_like<std::allocator<int>>);
 54 |   static_assert(mem::allocator_like<mem::allocator::aligned<int, std::align_val_t(64u)>>);
 55 |   static_assert(mem::allocator_like<mem::allocator::stack<int, 1024u>>);
 56 |   static_assert(mem::allocator_like<mem::allocator::transparent_huge_pages<int>>);
 57 |   static_assert(mem::allocator_like<mem::allocator::huge_pages<int>>);
 58 |   static_assert(mem::allocator_like<mem::allocator::numa<int>>);
 59 | 
 60 |   {
 61 |     std::vector<int, mem::allocator::aligned<int, std::align_val_t(64u)>> v{};
 62 |     std::vector<int, mem::allocator::stack<int, 1024u>> v{};
 63 |     // echo 20 > /proc/sys/vm/nr_hugepages
 64 |     std::vector<int, mem::allocator::huge_pages<int>> v{};
 65 |     // echo always > /sys/kernel/mm/transparent_hugepage/hugepages-2048kB/enabled
 66 |     std::vector<int, mem::allocator::transparent_huge_pages<int>> v{};
 67 |     // -lnuma # requires libnuma-dev
 68 |     std::vector<int, mem::allocator::numa<int>> v{};
 69 |   }
 70 | }
 71 | ```
 72 | 
 73 | ### API
 74 | 
 75 | > - https://github.com/qlibs/mem/blob/main/mem.cppm
 76 | 
 77 | ### FAQ
 78 | 
 79 | > - How to disable running tests at compile-time? <br />
 80 | >   When `-DNTEST` is defined static_asserts tests wont be executed upon inclusion.
 81 | >   Note: Use with caution as disabling tests means that there are no gurantees upon inclusion that given compiler/env combination works as expected.
 82 | >
 83 | > - Similar projects? <br />
 84 | >   [std::pmr](https://en.cppreference.com/w/cpp/header/memory)
 85 | 
 86 | ### Resources
 87 | 
 88 | > `std::allocator`
 89 | > - https://eel.is/c++draft/allocator.requirements
 90 | > - https://en.cppreference.com/w/cpp/memory/allocator
 91 | 
 92 | > **Transparent Huge Pages**
 93 | > - https://www.kernel.org/doc/html/latest/admin-guide/mm/transhuge.html
 94 | > - https://man7.org/linux/man-pages/man2/madvise.2.html
 95 | > - https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/6/html/performance_tuning_guide/s-memory-transhuge
 96 | 
 97 | > **Huge Pages**
 98 | > - https://www.kernel.org/doc/html/latest/admin-guide/mm/hugetlbpage.html
 99 | > - https://www.man7.org/linux/man-pages/man2/mmap.2.html
100 | > - https://www.intel.com/content/www/us/en/docs/programmable/683840/1-2-1/enabling-hugepages.html
101 | > - https://github.com/libhugetlbfs/libhugetlbfs
102 | > - https://wiki.debian.org/Hugepages
103 | 
104 | > **Non Uniform Memory Access**
105 | > - https://en.wikipedia.org/wiki/Non-uniform_memory_access
106 | > - https://man7.org/linux/man-pages/man3/numa.3.html
107 | > - https://www.intel.com/content/www/us/en/developer/articles/technical/use-intel-quickassist-technology-efficiently-with-numa-awareness.html
108 | 
109 | ### License
110 | 
111 | > - [MIT](LICENSE)
112 | 
113 | <!--
114 | #endif
115 | 
116 | #pragma once
117 | 
118 | #include <cstdint>
119 | #include <cstddef>
120 | #include <cassert>
121 | 
122 | #include <bitset>
123 | #include <bit>
124 | #include <numeric>
125 | #include <memory>
126 | #include <array>
127 | 
128 | #if __has_include(<sys/mman.h>)
129 | #include <sys/mman.h>
130 | #endif
131 | 
132 | #if  __has_include(<cstdlib>)
133 | #include <cstdlib>
134 | #endif
135 | 
136 | #if __has_include(<numa.h>)
137 | #include <numa.h>
138 | #endif
139 | 
140 | namespace mem::inline v1_1_0 {
141 | template<class TAllocator>
142 | concept allocator_like = requires(TAllocator alloc, typename TAllocator::value_type* ptr, std::size_t n) {
143 |   typename TAllocator::value_type;
144 |   { alloc.allocate(n) } -> std::same_as<decltype(ptr)>;
145 |   { alloc.deallocate(ptr, n) } -> std::same_as<void>;
146 |   #if __cpp_lib_allocate_at_least >= 202302L
147 |   { allocate_at_least(n) } -> std::same_as<std::allocation_result<T*, std::size_t>>;
148 |   #endif
149 | };
150 | 
151 | inline namespace allocator {
152 |   namespace utility {
153 |     inline constexpr auto align = [](const std::size_t n, const std::align_val_t alignment) {
154 |       return (n + (std::size_t(alignment) - 1u)) & ~(std::size_t(alignment) - 1u);
155 |     };
156 | 
157 |     inline constexpr auto round = [](const std::size_t n, const std::size_t size) {
158 |       assert(n > 1u and size > 0u);
159 |       return (((n - 1u) / size) + 1u) * size;
160 |     };
161 |   } // namespace utility
162 | 
163 |   template<class T, std::align_val_t alignment = std::align_val_t(64u), auto on_error = [] { return nullptr; }>
164 |     requires (std::has_single_bit(std::size_t(alignment)))
165 |   struct aligned {
166 |     using value_type = T;
167 |     template<class U> struct rebind {
168 |       using other = aligned<T, alignment, on_error>;
169 |     };
170 | 
171 |     constexpr aligned() noexcept = default;
172 |     constexpr ~aligned() noexcept = default;
173 | 
174 |     [[nodiscard]] constexpr auto allocate(std::size_t n) noexcept(noexcept(on_error())) -> T* {
175 |       return reinterpret_cast<T*>(::operator new[](n * sizeof(T), alignment));
176 |     }
177 | 
178 |     #if __cpp_lib_allocate_at_least >= 202302L
179 |     [[nodiscard]] constexpr auto allocate_at_least(std::size_t n) noexcept(noexcept(allocate(n)) {
180 |       return std::allocation_result<T*, std::size_t>{
181 |         allocate(n), utility::align(n * sizeof(T), alignment) / sizeof(T)
182 |       };
183 |     }
184 |     #endif
185 | 
186 |     constexpr void deallocate(T* ptr, [[maybe_unused]] std::size_t n) noexcept {
187 |       ::operator delete[](ptr, alignment);
188 |     }
189 |   };
190 | 
191 |   template<class T, std::size_t N, std::align_val_t alignment = std::align_val_t(alignof(T)), auto on_error = [] { return nullptr; }>
192 |     requires
193 |       (std::has_single_bit(std::size_t(alignment))) and
194 |       (std::size_t(alignment) <= alignof(std::max_align_t)) and
195 |       (not (N % std::size_t(alignment)))
196 |   struct stack {
197 |     using value_type = T;
198 |     template<class U> struct rebind {
199 |       using other = stack<U, N, alignment, on_error>;
200 |     };
201 | 
202 |     constexpr stack() noexcept = default;
203 |     constexpr ~stack() noexcept = default;
204 | 
205 |     [[nodiscard]] constexpr auto allocate(std::size_t n) noexcept(noexcept(on_error())) -> T* {
206 |       const auto aligned = utility::align(n * sizeof(T), alignment);
207 |       if (std::size_t(data_.data() + N - sp_) < utility::align(n * sizeof(T), alignment)) [[unlikely]] {
208 |         return on_error();
209 |       }
210 |       auto ptr = reinterpret_cast<T*>(sp_);
211 |       sp_ += aligned;
212 |       return ptr;
213 |     }
214 | 
215 |     #if __cpp_lib_allocate_at_least >= 202302L
216 |     [[nodiscard]] constexpr auto allocate_at_least(std::size_t n) noexcept(noexcept(allocate(n)) {
217 |       return std::allocation_result<T*, std::size_t>{
218 |         allocate(n),
219 |         utility::align(n * sizeof(T), alignment) / sizeof(T)
220 |       };
221 |     }
222 |     #endif
223 | 
224 |     constexpr void deallocate(T* ptr, std::size_t n) noexcept {
225 |       const auto aligned = utility::align(n * sizeof(T), alignment);
226 |       auto p = reinterpret_cast<std::byte*>(ptr);
227 |       if (p + aligned != sp_) [[unlikely]] {
228 |         return;
229 |       }
230 |       sp_ = p;
231 |     }
232 | 
233 |    private:
234 |     alignas([] { return std::size_t(alignment); }()) std::array<std::byte, N> data_{};
235 |     std::byte* sp_{data_.data()};
236 |   };
237 | 
238 |   #if __has_include(<sys/mman.h>) and __has_include(<cstdlib>)
239 |   /**
240 |    * `echo always > /sys/kernel/mm/transparent_hugepage/hugepages-2048kB/enabled`
241 |    * https://www.kernel.org/doc/html/latest/admin-guide/mm/transhuge.html
242 |    * https://man7.org/linux/man-pages/man2/madvise.2.html
243 |    * https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/6/html/performance_tuning_guide/s-memory-transhuge
244 |    */
245 |   template<class T, std::size_t N = (1u << 21u), auto on_error = [] { return nullptr; }>
246 |   struct transparent_huge_pages {
247 |     using value_type = T;
248 |     template<class U> struct rebind {
249 |       using other = transparent_huge_pages<U, N, on_error>;
250 |     };
251 |     static constexpr auto size = N;
252 | 
253 |     constexpr transparent_huge_pages() noexcept = default;
254 |     constexpr ~transparent_huge_pages() noexcept = default;
255 | 
256 |     [[nodiscard]] constexpr auto allocate(std::size_t n) noexcept(noexcept(on_error())) -> T* {
257 |       if (n > std::numeric_limits<std::size_t>::max() / sizeof(T)) [[unlikely]] {
258 |         return on_error();
259 |       }
260 |       void *ptr{};
261 |       posix_memalign(&ptr, N, n * sizeof(T));
262 |       madvise(ptr, n * sizeof(T), MADV_HUGEPAGE);
263 |       if (not ptr) [[unlikely]] {
264 |         return on_error();
265 |       }
266 |       return static_cast<T*>(ptr);
267 |     }
268 | 
269 |     #if __cpp_lib_allocate_at_least >= 202302L
270 |     [[nodiscard]] constexpr auto allocate_at_least(std::size_t n) noexcept(noexcept(allocate(n)) {
271 |       return std::allocation_result<T*, std::size_t>{
272 |         allocate(n),
273 |         utility::round(n * sizeof(T), size) / sizeof(T)
274 |       };
275 |     }
276 |     #endif
277 | 
278 |     constexpr void deallocate(T *ptr, [[maybe_unused]] std::size_t n) noexcept {
279 |       std::free(ptr);
280 |     }
281 |   };
282 |   #endif
283 | 
284 |   #if __has_include(<sys/mman.h>)
285 |   /**
286 |    * `echo 20 > /proc/sys/vm/nr_hugepages`
287 |    * https://www.kernel.org/doc/html/latest/admin-guide/mm/hugetlbpage.html
288 |    * https://www.man7.org/linux/man-pages/man2/mmap.2.html
289 |    * https://www.intel.com/content/www/us/en/docs/programmable/683840/1-2-1/enabling-hugepages.html
290 |    * https://github.com/libhugetlbfs/libhugetlbfs
291 |    * https://wiki.debian.org/Hugepages
292 |    */
293 |   template <class T, std::size_t N = (1u << 21u), auto on_error = [] { return nullptr; }>
294 |   struct huge_pages {
295 |     using value_type = T;
296 |     template<class U> struct rebind {
297 |       using other = huge_pages<U, N, on_error>;
298 |     };
299 |     static constexpr auto size = N;
300 | 
301 |     constexpr huge_pages() noexcept = default;
302 |     constexpr ~huge_pages() noexcept = default;
303 | 
304 |     [[nodiscard]] constexpr auto allocate(std::size_t n) noexcept(noexcept(on_error())) -> T* {
305 |       constexpr auto prot = PROT_READ | PROT_WRITE;
306 |       constexpr auto flags = MAP_PRIVATE | MAP_ANONYMOUS | MAP_POPULATE | MAP_HUGETLB;
307 | 
308 |       if (n > std::numeric_limits<std::size_t>::max() / sizeof(T)) [[unlikely]] {
309 |         return on_error();
310 |       }
311 |       auto ptr = reinterpret_cast<T*>(mmap(nullptr, utility::round(n * sizeof(T), size), prot, flags, -1, 0));
312 |       if (ptr == MAP_FAILED) [[unlikely]] {
313 |         return on_error();
314 |       }
315 |       return ptr;
316 |     }
317 | 
318 |     #if __cpp_lib_allocate_at_least >= 202302L
319 |     [[nodiscard]] constexpr auto allocate_at_least(std::size_t n) noexcept(noexcept(allocate(n)) {
320 |       return std::allocation_result<T*, std::size_t>{
321 |         allocate(n),
322 |         utility::round(n * sizeof(T), size) / sizeof(T)
323 |       };
324 |     }
325 |     #endif
326 | 
327 |     constexpr void deallocate(T *ptr, std::size_t n) noexcept {
328 |       munmap(ptr, utility::round(n, size));
329 |     }
330 |   };
331 |   #endif
332 | 
333 |   #if __has_include(<numa.h>)
334 |   /**
335 |    * `-lnuma`
336 |    * https://en.wikipedia.org/wiki/Non-uniform_memory_access
337 |    * https://man7.org/linux/man-pages/man3/numa.3.html
338 |    * https://www.intel.com/content/www/us/en/developer/articles/technical/use-intel-quickassist-technology-efficiently-with-numa-awareness.html
339 |    */
340 |   template<class T, auto on_error = [] { return nullptr; }>
341 |   struct numa {
342 |     using value_type = T;
343 |     template<class U> struct rebind {
344 |       using other = numa<U, on_error>;
345 |     };
346 | 
347 |     constexpr explicit numa(int node = {}) noexcept : node_{node} { }
348 |     constexpr ~numa() noexcept = default;
349 | 
350 |     /**
351 |      * The size argument (n) will be rounded up to a multiple of the system page size.
352 |      */
353 |     [[nodiscard]] constexpr auto allocate(std::size_t n) noexcept(noexcept(on_error())) -> T* {
354 |       auto ptr = numa_alloc_onnode(n * sizeof(T), node_);
355 |       if (not ptr) [[unlikely]] {
356 |         return on_error();
357 |       }
358 |       return reinterpret_cast<T*>(ptr);
359 |     }
360 | 
361 |     #if __cpp_lib_allocate_at_least >= 202302L
362 |     [[nodiscard]] constexpr auto allocate_at_least(std::size_t n) noexcept(noexcept(allocate(n)) {
363 |       return std::allocation_result<T*, std::size_t>{
364 |         allocate(n),
365 |         n
366 |       };
367 |     }
368 |     #endif
369 | 
370 |     /**
371 |      * The size argument (n) will be rounded up to a multiple of the system page size.
372 |      */
373 |     constexpr void deallocate(T* ptr, std::size_t n) noexcept {
374 |       numa_free(ptr, n * sizeof(T));
375 |     }
376 | 
377 |    private:
378 |     int node_{};
379 |   };
380 |   #endif
381 | } // namespace allocator
382 | } // namespace mem
383 | 
384 | #ifndef NTEST
385 | static_assert(([] {
386 |   struct empty { };
387 | 
388 |   // mem::utility::align
389 |   {
390 |     static_assert(mem::utility::align(0u, std::align_val_t{8u}) == 0u);
391 |     static_assert(mem::utility::align(1u, std::align_val_t{8u}) == 8u);
392 |     static_assert(mem::utility::align(8u, std::align_val_t{8u}) == 8u);
393 |     static_assert(mem::utility::align(9u, std::align_val_t{8u}) == 16u);
394 |     static_assert(mem::utility::align(15u, std::align_val_t{8u}) == 16u);
395 |     static_assert(mem::utility::align(16u, std::align_val_t{8u}) == 16u);
396 |     static_assert(mem::utility::align(17u, std::align_val_t{8u}) == 24u);
397 |     static_assert(mem::utility::align(5u, std::align_val_t{1u}) == 5u);
398 |     static_assert(mem::utility::align(123u, std::align_val_t{64u}) == 128u);
399 |     static_assert(mem::utility::align(256u, std::align_val_t{256u}) == 256u);
400 |     static_assert(mem::utility::align(511u, std::align_val_t{256u}) == 512u);
401 |   }
402 | 
403 |   // mem::utility::round
404 |   {
405 |     static_assert(mem::utility::round(2u, 2u) == 2u);
406 |     static_assert(mem::utility::round(3u, 2u) == 4u);
407 |     static_assert(mem::utility::round(5u, 4u) == 8u);
408 |     static_assert(mem::utility::round(8u, 4u) == 8u);
409 |     static_assert(mem::utility::round(9u, 4u) == 12u);
410 |     static_assert(mem::utility::round(15u, 16u) == 16u);
411 |     static_assert(mem::utility::round(16u, 16u) == 16u);
412 |     static_assert(mem::utility::round(17u, 16u) == 32u);
413 |   }
414 | 
415 |   // mem::allocator_like
416 |   {
417 |     static_assert(not mem::allocator_like<void>);
418 |     static_assert(not mem::allocator_like<int>);
419 |     static_assert(mem::allocator_like<std::allocator<int>>);
420 |     static_assert(mem::allocator_like<mem::stack<int, 1024u>>);
421 |     #if __has_include(<sys/mman.h>)
422 |     static_assert(mem::allocator_like<mem::huge_pages<int>>);
423 |     #endif
424 |     #if __has_include(<numa.h>)
425 |     static_assert(mem::allocator_like<mem::numa<int>>);
426 |     #endif
427 |   }
428 | 
429 |   // mem::allocator::aligned
430 |   {
431 |     static_assert([]<class T, auto... Vs> { return requires { mem::allocator::aligned<T, Vs...>{}; }; }.template operator()<int>());
432 |     static_assert([]<class T, auto... Vs> { return requires { mem::allocator::aligned<T, Vs...>{}; }; }.template operator()<int, std::align_val_t(64u)>());
433 |   }
434 | 
435 |   // mem::allocator::stack
436 |   {
437 |     static_assert(not []<class T, auto... Vs> { return requires { mem::allocator::stack<T, Vs...>{}; }; }.template operator()<int, 1u>());
438 |     static_assert(not []<class T, auto... Vs> { return requires { mem::allocator::stack<T, Vs...>{}; }; }.template operator()<int, 2u>());
439 |     static_assert(not []<class T, auto... Vs> { return requires { mem::allocator::stack<T, Vs...>{}; }; }.template operator()<int, sizeof(int), 1u + alignof(std::max_align_t)>());
440 |     static_assert([]<class T, auto... Vs> { return requires { mem::allocator::stack<T, Vs...>{}; }; }.template operator()<int, sizeof(int) * 8u>());
441 |     static_assert([]<class T, auto... Vs> { return requires { mem::allocator::stack<T, Vs...>{}; }; }.template operator()<int, alignof(int)>());
442 |     static_assert(sizeof(mem::allocator::stack<int, 16u>) >= sizeof(std::array<std::byte, 16u>));
443 |   }
444 | 
445 |   #if __has_include(<sys/mman.h>)
446 |   // mem::allocator::huge_pages
447 |   {
448 |     static_assert([]<class T, auto... Vs> { return requires { mem::allocator::huge_pages<T, Vs...>{}; }; }.template operator()<int>());
449 |     static_assert([]<class T, auto... Vs> { return requires { mem::allocator::huge_pages<T, Vs...>{}; }; }.template operator()<int, 32u>());
450 |     static_assert(sizeof(empty) == sizeof(mem::allocator::huge_pages<int>));
451 |     mem::allocator::huge_pages<int> allocator{};
452 |     static_assert(1u << 21u == allocator.size);
453 |   }
454 |   #endif
455 | 
456 |   #if __has_include(<sys/mman.h>) and __has_include(<cstdlib>)
457 |   // mem::allocator::transparent_huge_pages
458 |   {
459 |     static_assert([]<class T, auto... Vs> { return requires { mem::allocator::transparent_huge_pages<T, Vs...>{}; }; }.template operator()<int>());
460 |     static_assert([]<class T, auto... Vs> { return requires { mem::allocator::transparent_huge_pages<T, Vs...>{}; }; }.template operator()<int, 32u>());
461 |     static_assert(sizeof(empty) == sizeof(mem::allocator::huge_pages<int>));
462 |     mem::allocator::transparent_huge_pages<int> allocator{};
463 |     static_assert(1u << 21u == allocator.size);
464 |   }
465 |   #endif
466 | 
467 |   #if __has_include(<numa.h>)
468 |   // mem::allocator::numa
469 |   {
470 |     static_assert([]<class T, auto... Vs> { return requires { mem::allocator::numa<T, Vs...>{}; }; }.template operator()<int>());
471 |     static_assert([]<class T, auto... Vs> { return requires { mem::allocator::numa<T, Vs...>{}; }; }.template operator()<int, 32u>());
472 |   }
473 |   #endif
474 | }(), true));
475 | #endif // NTEST
476 | 


--------------------------------------------------------------------------------
/mem.cppm:
--------------------------------------------------------------------------------
  1 | // <!--
  2 | // The MIT License (MIT)
  3 | //
  4 | // Copyright (c) 2024 Kris Jusiak <kris@jusiak.net>
  5 | //
  6 | // Permission is hereby granted, free of charge, to any person obtaining a copy
  7 | // of this software and associated documentation files (the "Software"), to deal
  8 | // in the Software without restriction, including without limitation the rights
  9 | // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 10 | // copies of the Software, and to permit persons to whom the Software is
 11 | // furnished to do so, subject to the following conditions:
 12 | //
 13 | // The above copyright notice and this permission notice shall be included in all
 14 | // copies or substantial portions of the Software.
 15 | //
 16 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 17 | // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 18 | // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 19 | // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 20 | // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 21 | // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 22 | // SOFTWARE.
 23 | //
 24 | module;
 25 | #include "mem"
 26 | export module mem;
 27 | 
 28 | export namespace mem {
 29 |   /**
 30 |    * template<class TAllocator> concept allocator_like =
 31 |    *   requires(TAllocator alloc, typename TAllocator::value_type* ptr, std::size_t n) {
 32 |    *     typename TAllocator::value_type;
 33 |    *     { alloc.allocate(n) } -> std::same_as<decltype(ptr)>;
 34 |    *     { alloc.deallocate(ptr, n) } -> std::same_as<void>;
 35 |    *     #if __cpp_lib_allocate_at_least >= 202302L
 36 |    *     { allocate_at_least(n) } -> std::same_as<std::allocation_result<T*, std::size_t>>;
 37 |    *     #endif
 38 |    *   };
 39 |    */
 40 |   using mem::allocator_like;
 41 | 
 42 |   inline namespace allocator {
 43 |     /**
 44 |      * template<
 45 |      *   class T,
 46 |      *   std::align_val_t alignment = 64u,
 47 |      *   auto on_error = [] { return nullptr; }
 48 |      * > requires (std::has_single_bit(std::size_t(alignment)))
 49 |      * struct aligned {
 50 |      *   using value_type = T;
 51 |      *
 52 |      *   constexpr aligned() noexcept = default;
 53 |      *   constexpr ~aligned() noexcept = default;
 54 |      *
 55 |      *   [[nodiscard]]
 56 |      *   constexpr auto allocate(std::size_t n) noexcept(noexcept(on_error())) -> T*;
 57 |      *
 58 |      *   #if __cpp_lib_allocate_at_least >= 202302L
 59 |      *   [[nodiscard]]
 60 |      *   constexpr auto allocate_at_least(std::size_t n) noexcept(noexcept(allocate(n));
 61 |      *   #endif
 62 |      *
 63 |      *   constexpr void deallocate(T* ptr, std::size_t n) noexcept;
 64 |      * };
 65 |      */
 66 |     using mem::allocator::aligned;
 67 | 
 68 |     /**
 69 |      * template<
 70 |      *   class T,
 71 |      *   std::size_t N,
 72 |      *   std::align_val_t alignment = alignof(T),
 73 |      *   auto on_error = [] { return nullptr; }
 74 |      * > requires
 75 |      *     (std::has_single_bit(std::size_t(alignment))) and
 76 |      *     (std::size_t(alignment) <= alignof(std::max_align_t)) and
 77 |      *     (not (N % std::size_t(alignment)))
 78 |      * struct stack {
 79 |      *   using value_type = T;
 80 |      *
 81 |      *   constexpr stack() noexcept = default;
 82 |      *   constexpr ~stack() noexcept = default;
 83 |      *
 84 |      *   [[nodiscard]]
 85 |      *   constexpr auto allocate(std::size_t n) noexcept(noexcept(on_error())) -> T*;
 86 |      *
 87 |      *   #if __cpp_lib_allocate_at_least >= 202302L
 88 |      *   [[nodiscard]]
 89 |      *   constexpr auto allocate_at_least(std::size_t n) noexcept(noexcept(allocate(n));
 90 |      *   #endif
 91 |      *
 92 |      *   constexpr void deallocate(T* ptr, std::size_t n) noexcept;
 93 |      * };
 94 |      */
 95 |     using mem::allocator::stack;
 96 | 
 97 |     /**
 98 |      * template<class T,
 99 |      *   std::size_t N = (1u << 21u),
100 |      *   auto on_error = [] { return nullptr; }
101 |      * > struct transparent_huge_pages {
102 |      *   using value_type = T;
103 |      *
104 |      *   constexpr transparent_huge_pages() noexcept = default;
105 |      *   constexpr ~transparent_huge_pages() noexcept = default;
106 |      *
107 |      *   [[nodiscard]]
108 |      *   constexpr auto allocate(std::size_t n) noexcept(noexcept(on_error())) -> T*;
109 |      *
110 |      *   #if __cpp_lib_allocate_at_least >= 202302L
111 |      *   [[nodiscard]]
112 |      *   constexpr auto allocate_at_least(std::size_t n) noexcept(noexcept(allocate(n));
113 |      *   #endif
114 |      *
115 |      *   constexpr void deallocate(T *ptr, std::size_t n) noexcept;
116 |      * };
117 |      */
118 |     using mem::allocator::transparent_huge_pages;
119 | 
120 |     /**
121 |      * template <
122 |      *   class T,
123 |      *   std::size_t N = (1u << 21u),
124 |      *   auto on_error = [] { return nullptr; }
125 |      * > struct huge_pages {
126 |      *   using value_type = T;
127 |      *
128 |      *   constexpr huge_pages() noexcept = default;
129 |      *   constexpr ~huge_pages() noexcept = default;
130 |      *
131 |      *   [[nodiscard]]
132 |      *   constexpr auto allocate(std::size_t n) noexcept(noexcept(on_error())) -> T*;
133 |      *
134 |      *   #if __cpp_lib_allocate_at_least >= 202302L
135 |      *   [[nodiscard]]
136 |      *   constexpr auto allocate_at_least(std::size_t n) noexcept(noexcept(allocate(n));
137 |      *   #endif
138 |      *
139 |      *   constexpr void deallocate(T *ptr, std::size_t n) noexcept;
140 |      * };
141 |      */
142 |     using mem::allocator::huge_pages;
143 | 
144 |     /**
145 |      * template<class T, auto on_error = [] { return nullptr; }>
146 |      * struct numa {
147 |      *   using value_type = T;
148 |      *
149 |      *   constexpr explicit numa(auto node = {}) noexcept;
150 |      *   constexpr ~numa() noexcept = default;
151 |      *
152 |      *   [[nodiscard]]
153 |      *   constexpr auto allocate(std::size_t n) noexcept(noexcept(on_error())) -> T*;
154 |      *
155 |      *   #if __cpp_lib_allocate_at_least >= 202302L
156 |      *   [[nodiscard]]
157 |      *   constexpr auto allocate_at_least(std::size_t n) noexcept(noexcept(allocate(n));
158 |      *   #endif
159 |      *
160 |      *   constexpr void deallocate(T* ptr, std::size_t n) noexcept;
161 |      * };
162 |      */
163 |     using mem::allocator::numa;
164 |   } // namespace allocator
165 | } // namespace mem
166 | 
167 | // -*- mode: c++; -*-
168 | // vim: set filetype=cpp:
169 | 


--------------------------------------------------------------------------------