Movatterモバイル変換


[0]ホーム

URL:


cppreference.com
Namespaces
Variants
    Actions

      std::pmr::monotonic_buffer_resource

      From cppreference.com
      <cpp‎ |memory
       
       
      Memory management library
      (exposition only*)
      Allocators
      Uninitialized memory algorithms
      Constrained uninitialized memory algorithms
      Memory resources
      Uninitialized storage(until C++20)
      (until C++20*)
      (until C++20*)
      Garbage collector support(until C++23)
      (C++11)(until C++23)
      (C++11)(until C++23)
      (C++11)(until C++23)
      (C++11)(until C++23)
      (C++11)(until C++23)
      (C++11)(until C++23)
       
       
      Defined in header<memory_resource>
      class monotonic_buffer_resource:publicstd::pmr::memory_resource;
      (since C++17)

      The classstd::pmr::monotonic_buffer_resource is a special-purpose memory resource class that releases the allocated memory only when the resource is destroyed. It is intended for very fast memory allocations in situations where memory is used to build up a few objects and then is released all at once.

      monotonic_buffer_resource can be constructed with an initial buffer. If there is no initial buffer, or if the buffer is exhausted, additional buffers are obtained from anupstream memory resource supplied at construction. The size of buffers obtained follows a geometric progression.

      monotonic_buffer_resource is not thread-safe.

      Contents

      [edit]Member functions

      constructs amonotonic_buffer_resource
      (public member function)[edit]
      [virtual]
      destroys amonotonic_buffer_resource, releasing all allocated memory
      (virtual public member function)[edit]
      operator=
      [deleted]
      copy assignment operator is deleted.monotonic_buffer_resource is not copy assignable
      (public member function)[edit]
      Public member functions
      release all allocated memory
      (public member function)[edit]
      returns a pointer to the upstream memory resource
      (public member function)[edit]
      Protected member functions
      [virtual]
      allocate memory
      (virtual protected member function)[edit]
      [virtual]
      no-op
      (virtual protected member function)[edit]
      [virtual]
      compare for equality with anotherstd::pmr::memory_resource
      (virtual protected member function)[edit]

      [edit]Example

      The program measures the time of creating huge double-linked lists using the following allocators:

      • default standard allocator,
      • defaultpmr allocator,
      • pmr allocator with monotonic resource but without explicit memory buffer,
      • pmr allocator with monotonic resource and external memory buffer (on stack).
      Run this code
      #include <array>#include <chrono>#include <cstddef>#include <iomanip>#include <iostream>#include <list>#include <memory_resource> template<typename Func>auto benchmark(Func test_func,int iterations){constauto start=std::chrono::system_clock::now();while(iterations-->0)        test_func();constauto stop=std::chrono::system_clock::now();constauto secs=std::chrono::duration<double>(stop- start);return secs.count();} int main(){constexprint iterations{100};constexprint total_nodes{2'00'000}; auto default_std_alloc=[total_nodes]{std::list<int> list;for(int i{}; i!= total_nodes;++i)            list.push_back(i);}; auto default_pmr_alloc=[total_nodes]{std::pmr::list<int> list;for(int i{}; i!= total_nodes;++i)            list.push_back(i);}; auto pmr_alloc_no_buf=[total_nodes]{        std::pmr::monotonic_buffer_resource mbr;std::pmr::polymorphic_allocator<int> pa{&mbr};std::pmr::list<int> list{pa};for(int i{}; i!= total_nodes;++i)            list.push_back(i);}; auto pmr_alloc_and_buf=[total_nodes]{std::array<std::byte, total_nodes*32> buffer;// enough to fit in all nodes        std::pmr::monotonic_buffer_resource mbr{buffer.data(), buffer.size()};std::pmr::polymorphic_allocator<int> pa{&mbr};std::pmr::list<int> list{pa};for(int i{}; i!= total_nodes;++i)            list.push_back(i);}; constdouble t1= benchmark(default_std_alloc, iterations);constdouble t2= benchmark(default_pmr_alloc, iterations);constdouble t3= benchmark(pmr_alloc_no_buf , iterations);constdouble t4= benchmark(pmr_alloc_and_buf, iterations); std::cout<<std::fixed<<std::setprecision(3)<<"t1 (default std alloc): "<< t1<<" sec; t1/t1: "<< t1/t1<<'\n'<<"t2 (default pmr alloc): "<< t2<<" sec; t1/t2: "<< t1/t2<<'\n'<<"t3 (pmr alloc  no buf): "<< t3<<" sec; t1/t3: "<< t1/t3<<'\n'<<"t4 (pmr alloc and buf): "<< t4<<" sec; t1/t4: "<< t1/t4<<'\n';}

      Possible output:

      t1 (default std alloc): 0.720 sec; t1/t1: 1.000t2 (default pmr alloc): 0.915 sec; t1/t2: 0.787t3 (pmr alloc  no buf): 0.370 sec; t1/t3: 1.945t4 (pmr alloc and buf): 0.247 sec; t1/t4: 2.914
      Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/memory/monotonic_buffer_resource&oldid=152966"

      [8]ページ先頭

      ©2009-2025 Movatter.jp