{"id":8311,"date":"2023-10-02T08:35:05","date_gmt":"2023-10-02T08:35:05","guid":{"rendered":"https:\/\/www.modernescpp.com\/?p=8311"},"modified":"2023-10-02T08:35:05","modified_gmt":"2023-10-02T08:35:05","slug":"special-allocators-with-c17","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/special-allocators-with-c17\/","title":{"rendered":"Special Allocators with C++17"},"content":{"rendered":"\n

I introduced in my last post “Polymorphic Allocators with C++17” the theory of polymorphic allocators in C++17. Today, I will apply the theory.<\/p>\n\n\n\n

\"\"<\/figure>\n\n\n\n

Before I go on, here are the essential parts of my last post: “Polymorphic Allocators with C++17<\/a>“. <\/p>\n\n\n\n

A Short Reminder<\/h2>\n\n\n\n

The following program uses polymorphic allocators. <\/p>\n\n\n\n

\/\/ polymorphicAllocator.cpp<\/span>\n\n#include <array><\/span>\n#include <cstddef><\/span>\n#include <memory_resource><\/span>\n#include <vector><\/span>\n\nint<\/span> main<\/span>() {\n\n    std::<\/span>array<<\/span>std::<\/span>byte, 200<\/span>><\/span> buf1;                               \/\/ (1)<\/span>\n    std::<\/span>pmr::<\/span>monotonic_buffer_resource pool1{buf1.data(), buf1.size()};\n    std::<\/span>pmr::<\/span>vector<<\/span>int<\/span>><\/span> myVec1{&<\/span>pool1};                          \/\/ (3)<\/span>\n    for<\/span> (int<\/span> i =<\/span> 0<\/span>; i <<\/span> 5<\/span>; ++<\/span>i) {\n        myVec1.push_back(i);\n    }\n\n    char<\/span> buf2[200<\/span>] =<\/span> {};                                           \/\/ (2)<\/span>\n    std::<\/span>pmr::<\/span>monotonic_buffer_resource pool2{std::<\/span>data(buf2), std::<\/span>size(buf2)};\n    std::<\/span>pmr::<\/span>vector<<\/span>int<\/span>><\/span> myVec2{&<\/span>pool2};\n    for<\/span> (int<\/span> i =<\/span> 0<\/span>; i <<\/span> 200<\/span>; ++<\/span>i) {\n        myVec2.push_back(i);\n    }\n\n}\n<\/pre><\/div>\n\n\n\n
Now, I want to focus on myVec2<\/code>. It pushes 200 int<\/code>s onto the std::pmr::vector<int><\/code>. 200 int<\/code>s do not fit into a char buf[200]<\/code> and, therefore, std::pmr::new_delete_resource()<\/code> as the so-called upstream allocator kicks in and calls the global new <\/code>for the remaining elements. Let me instrumentalize the upstream allocator.<\/p>\n\n\n\n
A Tracking Allocator<\/h2>\n\n\n\n
The following program is based on the previous one, uses a tracking allocator, and makes the dynamic memory allocation and deallocation visible.<\/p>\n\n\n\n
\/\/ trackAllocator.cpp<\/span>\n\n#include <array><\/span>\n#include <cstdlib><\/span>\n#include <format><\/span>\n#include <iostream><\/span>\n#include <memory_resource><\/span>\n#include <vector><\/span>\n\nclass<\/span> TrackAllocator<\/span> :<\/span> public<\/span> std::<\/span>pmr::<\/span>memory_resource {\n    void<\/span>*<\/span> do_allocate(std::<\/span>size_t<\/span> bytes, std::<\/span>size_t<\/span> alignment) override {\n        void<\/span>*<\/span> p =<\/span> std::<\/span>pmr::<\/span>new_delete_resource()-><\/span>allocate(bytes, alignment);\n        std::<\/span>cout <<<\/span> std::<\/span>format("  do_allocate: {:6} bytes at {}<\/span>\\n<\/span>"<\/span>, bytes, p);\n        return<\/span> p;\n    }\n \n    void<\/span> do_deallocate(void<\/span>*<\/span> p, std::<\/span>size_t<\/span> bytes, std::<\/span>size_t<\/span> alignment) override {\n        std::<\/span>cout <<<\/span> std::<\/span>format("  do_deallocate: {:4} bytes at {}<\/span>\\n<\/span>"<\/span>, bytes, p);\n        return<\/span> std::<\/span>pmr::<\/span>new_delete_resource()-><\/span>deallocate(p, bytes, alignment);\n    }\n \n    bool<\/span> do_is_equal(const<\/span> std::<\/span>pmr::<\/span>memory_resource&<\/span> other) const<\/span> noexcept override {\n        return<\/span> std::<\/span>pmr::<\/span>new_delete_resource()-><\/span>is_equal(other);\n    }\n};\n\n\nint<\/span> main<\/span>() {\n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n    TrackAllocator trackAllocator;                         \/\/ (1)<\/span>\n    std::<\/span>pmr::<\/span>set_default_resource(&<\/span>trackAllocator);       \/\/ (2)<\/span>\n\n    std::<\/span>cout <<<\/span> "myVec1<\/span>\\n<\/span>"<\/span>;\n\n    std::<\/span>array<<\/span>std::<\/span>byte, 200<\/span>><\/span> buf1;\n    std::<\/span>pmr::<\/span>monotonic_buffer_resource pool1{buf1.data(), buf1.size()};\n    std::<\/span>pmr::<\/span>vector<<\/span>int<\/span>><\/span> myVec1{&<\/span>pool1};                  \/\/ (3)<\/span>\n    for<\/span> (int<\/span> i =<\/span> 0<\/span>; i <<\/span> 5<\/span>; ++<\/span>i) {\n        myVec1.push_back(i);\n    }\n\n    std::<\/span>cout <<<\/span> "myVec2<\/span>\\n<\/span>"<\/span>;\n\n    char<\/span> buf2[200<\/span>] =<\/span> {}; \n    std::<\/span>pmr::<\/span>monotonic_buffer_resource pool2{std::<\/span>data(buf2), std::<\/span>size(buf2)};\n    std::<\/span>pmr::<\/span>vector<<\/span>int<\/span>><\/span> myVec2{&<\/span>pool2};                  \/\/ (4)<\/span>\n    for<\/span> (int<\/span> i =<\/span> 0<\/span>; i <<\/span> 200<\/span>; ++<\/span>i) {\n        myVec2.push_back(i);\n    }\n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n}\n<\/pre><\/div>\n\n\n\n
TrackAllocator<\/code> is a tracking allocator. It derives from the interface class std::pmr::memory_resource<\/code>, from which all memory resources derive. TrackAllocator <\/code>defines the three required member functions do_allocate<\/code>, do_deallocate<\/code>, and do_is_equal<\/code>.  Each call forwards its call to std::pmr::new_delete_resource<\/code>. std:pmr::new_delete_resource<\/code> is the default memory resource and calls the global new <\/code>and delete<\/code>. The member function’s job do_is_equal<\/code> is to <\/code>check that the two memory resources are equal. The interesting point in the program is the visualization of the allocation and the deallocation in the member functions do_allocate <\/code>and do_deallocate<\/code>.<\/p>\n\n\n\n
By instantiating the TrackAllocator<\/code> (line 1) and make it as the default resource (line 2). myVec1<\/code> (line 3) and myVec2<\/code> (line 4) use them as the upstream allocator. This allocator kicks in if the primary allocator is consumed. This fallback is not necessary for myVec1<\/code>, but necessary for myVec2<\/code>. <\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
This output shows the dynamical allocation and deallocation of myVec2 <\/code>until all int<\/code>s fit into the std::pmr::vector<int><\/code>.<\/p>\n\n\n\n
You can also bind an upstream allocator to a specific container.<\/p>\n\n\n\n
A Non-Allocating Allocator<\/h2>\n\n\n\n
std::pmr::null_resource_allocator<\/code> is a special allocator. Using this memory resource for allocating causes a std::bad_alloc<\/code> exception. This memory resource ensures that you do not arbitrarily allocate memory on the heap. Let’s try it out.<\/p>\n\n\n\n
\/\/ nullMemoryResource.cpp<\/span>\n\n#include <array><\/span>\n#include <cstddef><\/span>\n#include <iostream> <\/span>\n#include <memory_resource><\/span>\n#include <string><\/span>\n#include <vector><\/span>\n\nint<\/span> main<\/span>() {\n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n \n    std::<\/span>array<<\/span>std::<\/span>byte, 2000<\/span>><\/span> buf;\n    std::<\/span>pmr::<\/span>monotonic_buffer_resource pool{buf.data(), buf.size(),  \/\/ (1)<\/span>\n                                           std::<\/span>pmr::<\/span>null_memory_resource()};\n    std::<\/span>pmr::<\/span>vector<<\/span>std::<\/span>pmr::<\/span>string><\/span> myVec{&<\/span>pool};                  \/\/ (2)<\/span>\n    try {\n        for<\/span> (int<\/span> i =<\/span> 0<\/span>; i <<\/span> 100<\/span>; ++<\/span>i) {                               \/\/ (3)<\/span>\n            std::<\/span>cerr <<<\/span> i <<<\/span> " "<\/span>;\n            myVec.emplace_back("A short string"<\/span>);\n        }\n    }\n    catch<\/span> (const<\/span> std::<\/span>bad_alloc&<\/span> e) {                                 \/\/ (4)<\/span>\n        std::<\/span>cerr <<<\/span> '\\n'<\/span> <<<\/span> e.what() <<<\/span> '\\n'<\/span>;\n    }\n    \n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n    \n}\n<\/pre><\/div>\n\n\n\n
First, I allocate memory on the stack and initialize std::pmr::monotonic_buffer_resource<\/code> with it. Then, I use this memory resource and std::pmr::null_memory_resource<\/code> as an upstream allocator (line 1).  In line 2, I create a std::pmr::vector<std::pmr::string><\/code>. Because I use a std::pmr::string, <\/code>the string also uses the memory resource and its upstream allocator. When I use std::pmr::vector<std::string><\/code>, std::string<\/code> allocates using the global new <\/code>and delete<\/code>. Finally, in line (3), I create 100 strings and catch in line (4) a std::bad_alloc <\/code>exception. I got what I deserved. 100 strings will not fit into a std::array<std::byte, 2000><\/code> buffer. After 17 strings, the buffer is consumed.<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
What’s Next?<\/h2>\n\n\n\n
You may have heard it already. The std::pmr::monotonic_buffer <\/code>has outstanding features. It is pretty fast and does not free memory.  I will provide the number in my next post.<\/p>\n","protected":false},"excerpt":{"rendered":"
I introduced in my last post “Polymorphic Allocators with C++17” the theory of polymorphic allocators in C++17. Today, I will apply the theory. Before I go on, here are the essential parts of my last post: “Polymorphic Allocators with C++17“. A Short Reminder The following program uses polymorphic allocators. \/\/ polymorphicAllocator.cpp #include <array> #include <cstddef> […]<\/p>\n","protected":false},"author":21,"featured_media":8313,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[370],"tags":[556,498],"class_list":["post-8311","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-c-17","tag-allocator","tag-memory"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/8311","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/users\/21"}],"replies":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/comments?post=8311"}],"version-history":[{"count":28,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/8311\/revisions"}],"predecessor-version":[{"id":8432,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/8311\/revisions\/8432"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/8313"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=8311"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=8311"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=8311"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}