{"id":8337,"date":"2023-10-09T17:09:22","date_gmt":"2023-10-09T17:09:22","guid":{"rendered":"https:\/\/www.modernescpp.com\/?p=8337"},"modified":"2023-10-09T17:09:22","modified_gmt":"2023-10-09T17:09:22","slug":"optimization-with-allocators-in-c17","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/optimization-with-allocators-in-c17\/","title":{"rendered":"Optimization with Allocators in C++17"},"content":{"rendered":"\n

Thanks to polymorphic allocators in C++17, you can optimize your memory allocation. This optimization includes performance and the reuse of memory.<\/p>\n\n\n\n

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

<\/p>\n\n\n\n

Performance<\/h2>\n\n\n\n

The following program is from cppreference.com\/monotonic_buffer_resource<\/a>. I will explain and extend its performance test to Clang and the MSVC compiler.<\/p>\n\n\n\n

\/\/ pmrPerformance.cpp<\/span>\n\/\/ https:\/\/en.cppreference.com\/w\/cpp\/memory\/monotonic_buffer_resource<\/span>\n\n#include <array><\/span>\n#include <chrono><\/span>\n#include <cstddef><\/span>\n#include <iomanip><\/span>\n#include <iostream><\/span>\n#include <list><\/span>\n#include <memory_resource><\/span>\n \ntemplate<\/span><<\/span>typename<\/span> Func><\/span>\nauto<\/span> benchmark(Func test_func, int<\/span> iterations)              \/\/ (1)<\/span>\n{\n    const<\/span> auto<\/span> start =<\/span> std::<\/span>chrono::<\/span>system_clock::<\/span>now();\n    while<\/span> (iterations--<\/span> ><\/span> 0<\/span>)\n        test_func();\n    const<\/span> auto<\/span> stop =<\/span> std::<\/span>chrono::<\/span>system_clock::<\/span>now();\n    const<\/span> auto<\/span> secs =<\/span> std::<\/span>chrono::<\/span>duration<<\/span>double<\/span>><\/span>(stop -<\/span> start);\n    return<\/span> secs.count();\n}\n \nint<\/span> main()\n{\n    constexpr int<\/span> iterations{100<\/span>};\n    constexpr int<\/span> total_nodes{2<\/span>'<\/span>00<\/span>'<\/span>000<\/span>};\n \n    auto<\/span> default_std_alloc =<\/span> [total_nodes]            \/\/ (2)<\/span>\n    {\n        std::<\/span>list<<\/span>int<\/span>><\/span> list;\n        for<\/span> (int<\/span> i{}; i !=<\/span> total_nodes; ++<\/span>i)\n            list.push_back(i);\n    };\n \n    auto<\/span> default_pmr_alloc =<\/span> [total_nodes]            \/\/ (3)<\/span>\n    {\n        std::<\/span>pmr::<\/span>list<<\/span>int<\/span>><\/span> list;\n        for<\/span> (int<\/span> i{}; i !=<\/span> total_nodes; ++<\/span>i)\n            list.push_back(i);\n    };\n \n    auto<\/span> pmr_alloc_no_buf =<\/span> [total_nodes]             \/\/ (4)<\/span>\n    {\n        std::<\/span>pmr::<\/span>monotonic_buffer_resource mbr;\n        std::<\/span>pmr::<\/span>polymorphic_allocator<<\/span>int<\/span>><\/span> pa{&<\/span>mbr};\n        std::<\/span>pmr::<\/span>list<<\/span>int<\/span>><\/span> list{pa};\n        for<\/span> (int<\/span> i{}; i !=<\/span> total_nodes; ++<\/span>i)\n            list.push_back(i);\n    };\n \n    auto<\/span> pmr_alloc_and_buf =<\/span> [total_nodes]            \/\/ (5)<\/span>\n    {\n        std::<\/span>array<<\/span>std::<\/span>byte, total_nodes *<\/span> 32<\/span>><\/span> buffer; \/\/ enough to fit in all nodes<\/span>\n        std::<\/span>pmr::<\/span>monotonic_buffer_resource mbr{buffer.data(), buffer.size()};\n        std::<\/span>pmr::<\/span>polymorphic_allocator<<\/span>int<\/span>><\/span> pa{&<\/span>mbr};\n        std::<\/span>pmr::<\/span>list<<\/span>int<\/span>><\/span> list{pa};\n        for<\/span> (int<\/span> i{}; i !=<\/span> total_nodes; ++<\/span>i)\n            list.push_back(i);\n    };\n \n    const<\/span> double<\/span> t1 =<\/span> benchmark(default_std_alloc, iterations);\n    const<\/span> double<\/span> t2 =<\/span> benchmark(default_pmr_alloc, iterations);\n    const<\/span> double<\/span> t3 =<\/span> benchmark(pmr_alloc_no_buf , iterations);\n    const<\/span> double<\/span> t4 =<\/span> benchmark(pmr_alloc_and_buf, iterations);\n \n    std::<\/span>cout <<<\/span> std::<\/span>fixed <<<\/span> std::<\/span>setprecision(3<\/span>)\n              <<<\/span> "t1 (default std alloc): "<\/span> <<<\/span> t1 <<<\/span> " sec; t1\/t1: "<\/span> <<<\/span> t1\/<\/span>t1 <<<\/span> '\\n'<\/span>\n              <<<\/span> "t2 (default pmr alloc): "<\/span> <<<\/span> t2 <<<\/span> " sec; t1\/t2: "<\/span> <<<\/span> t1\/<\/span>t2 <<<\/span> '\\n'<\/span>\n              <<<\/span> "t3 (pmr alloc  no buf): "<\/span> <<<\/span> t3 <<<\/span> " sec; t1\/t3: "<\/span> <<<\/span> t1\/<\/span>t3 <<<\/span> '\\n'<\/span>\n              <<<\/span> "t4 (pmr alloc and buf): "<\/span> <<<\/span> t4 <<<\/span> " sec; t1\/t4: "<\/span> <<<\/span> t1\/<\/span>t4 <<<\/span> '\\n'<\/span>;\n}\n<\/pre><\/div>\n\n\n\n
This performance test  in line (1) executes the functions in lines 2 – 5 one hundred times (constexpr int iterations{100}<\/code>) . Each call of the functions creates a std::pmr::list<int> <\/code>of two hundred thousand nodes (constexpr int total_nodes{2'00'000<\/code>}). The nodes of each list are allocated in different ways:<\/p>\n\n\n\n
    \n
  • Line 2: std::list<int><\/code> uses the global operator new<\/code><\/li>\n\n\n\n
  • Line 3: std::pmr::list<int><\/code> uses the special memory resource std::pmr::new_delete_resource<\/code><\/li>\n\n\n\n
  • Line 4: std::pmr::list<int><\/code> uses std::pmr::monoton<\/code>ic_buffer <\/code>without a preallocated buffer on the stack<\/li>\n\n\n\n
  • Line 5: std::pmr::list<\/code> uses std::pmr::monotonic_buffer <\/code>with a preallocated buffer on the stack<\/li>\n<\/ul>\n\n\n\n
    The comment to the last function (line 5) states that the stack has enough space to fit all nodes: “enough to fit in all nodes<\/em>“. This was correct on my Linux PC but not on my Windows PC. On Linux, the default for the stack size is 8 MB, but on Windows only 1 MB. Consequentially, my program execution on Windows using the MSVC compiler and the Clang compiler failed silently. I fixed it by changing with the help of editbin.exe <\/code>the stack size of my MSVC and Clang executables:<\/p>\n\n\n\n
    \"\"<\/figure>\n\n\n\n
    Finally, here are the numbers. The reference value is the allocation with std::list<int><\/code> (line 2). Don’t compare the absolute numbers but the relative numbers because I used a virtualized Linux PC and a non-virtual Windows PC. Additionally, I enabled full optimization. This means (\/Ox<\/code>) for the MSVC compiler and (-Ox<\/code>) for the GCC and Clang compilers.<\/p>\n\n\n\n
      \n
    • Clang Compiler<\/li>\n<\/ul>\n\n\n\n
      \"\"<\/figure>\n\n\n\n
        \n
      • GCC Compiler<\/li>\n<\/ul>\n\n\n\n
        \"\"<\/figure>\n\n\n\n
          \n
        • MSVC Compiler<\/li>\n<\/ul>\n\n\n\n
          \"\"<\/figure>\n\n\n\n
          Interestingly, the memory resource std::pmr::new_delete_resource<\/code> was always the slowest memory allocation. On the contrary, std::pmr::monotonic_buffer<\/code> the fastest memory allocation. This holds particularly if you use a preallocated buffer on the stack. On Windows, memory allocation is about 10 times faster.<\/p>\n\n\n\n
          There is another optimization potential of std::pmr::new_delete_resource<\/code>.<\/p>\n\n\n\n
          Memory Reuse<\/h2>\n\n\n\n
          std::pmr::monotonic_buffer<\/code> enables the reuse of memory, and you can, therefor, spare the to free the memory. <\/p>\n\n\n\n
          \/\/ reuseMemory.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>array<<\/span>std::<\/span>byte, 2000<\/span>><\/span> buf;\n\n    for<\/span> (int<\/span> i =<\/span> 0<\/span>; i <<\/span> 100<\/span>; ++<\/span>i) {                                       \/\/ (1)<\/span>\n        std::<\/span>pmr::<\/span>monotonic_buffer_resource pool{buf.data(), buf.size(),  \/\/ (2)<\/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};\n        for<\/span> (int<\/span> j =<\/span> 0<\/span>; j <<\/span> 16<\/span>; ++<\/span>j) {                                    \/\/ (3)<\/span>\n            myVec.emplace_back("A short string"<\/span>);\n        }\n    }\n}\n<\/pre><\/div>\n\n\n\n
          This program allocated a std::array of 2000 bytes : std::array<std::byte, 2000><\/code>. This stack-allocated memory is reused 100 times (line 1). The std::pmr::vector<std::prm::string><\/code> uses the std::pmr::monotonic_buffer_resourc<\/code>e with the upstream memory resource std::pmr::null_memory_resource<\/code> (line 2). Finally, 16 strings are added to the vector.<\/p>\n\n\n\n
          \"\"<\/figure>\n\n\n\n
          What’s Next? <\/h2>\n\n\n\n
          This post ends my min-series about the polymorphic memory resources in C++17. In my next post, I will jump three years further and continue my journey through C++20.<\/p>\n","protected":false},"excerpt":{"rendered":"
          Thanks to polymorphic allocators in C++17, you can optimize your memory allocation. This optimization includes performance and the reuse of memory. Performance The following program is from cppreference.com\/monotonic_buffer_resource. I will explain and extend its performance test to Clang and the MSVC compiler. \/\/ pmrPerformance.cpp \/\/ https:\/\/en.cppreference.com\/w\/cpp\/memory\/monotonic_buffer_resource #include <array> #include <chrono> #include <cstddef> #include <iomanip> #include […]<\/p>\n","protected":false},"author":21,"featured_media":8339,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[370],"tags":[556,498],"class_list":["post-8337","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\/8337","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=8337"}],"version-history":[{"count":29,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/8337\/revisions"}],"predecessor-version":[{"id":8481,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/8337\/revisions\/8481"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/8339"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=8337"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=8337"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=8337"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}