Namensräume
Varianten
Aktionen

std::pmr::monotonic_buffer_resource

Von cppreference.com
< cpp‎ | memory
 
C++
 
Speicherverwaltungsbibliothek
(nur Exposition*)
Algorithmen für uninitialisierten Speicher
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++11)
(C++17)
(C++17)
(C++17)
(C++17)
(C++20)
Beschränkte uninitialisierte
Speicher-Algorithmen
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20) 
(C++20)
C-Bibliothek

Allocatoren
(C++11)
(C++23)
(C++11)
(C++11)
(C++20)
(C++20)
(C++20) 
(C++11)
(C++17)
Speicherressourcen
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
pmr::monotonic_buffer_resource
(C++17)
(C++17)
Unterstützung für Garbage Collection
(C++11)(bis C++23)
(C++11)(bis C++23)
(C++11)(bis C++23)
(C++11)(bis C++23)
(C++11)(bis C++23)
(C++11)(bis C++23)
Uninitialisierter Speicher
(bis C++20*)
(bis C++20*)
(bis C++20*)
Explizites Lebenszeitmanagement
(C++23)(C++23)
 
std::pmr::monotonic_buffer_resource
 
Definiert in Header <memory_resource>
Klasse monotonic_buffer_resource : public std::pmr::memory_resource;
 (seit C++17)

Die Klasse std::pmr::monotonic_buffer_resource ist eine speziell für bestimmte Zwecke entwickelte Speicherressourcenklasse, die den allokierten Speicher erst freigibt, wenn die Ressource zerstört wird. Sie ist für sehr schnelle Speicherallokationen in Situationen gedacht, in denen Speicher zum Erstellen einiger Objekte verwendet und dann auf einmal freigegeben wird.

monotonic_buffer_resource kann mit einem anfänglichen Puffer konstruiert werden. Wenn kein anfänglicher Puffer vorhanden ist oder der Puffer erschöpft ist, werden zusätzliche Puffer von einer beim Konstruktor übergebenen vorgelagerten Speicherressource bezogen. Die Größe der bezogenen Puffer folgt einer geometrischen Progression.

monotonic_buffer_resource ist nicht threadsicher.

Inhalt

[bearbeiten] Member Functions

 konstruiert eine monotonic_buffer_resource
(public member function) [bearbeiten]
[virtuell]
 zerstört eine monotonic_buffer_resource und gibt allen allokierten Speicher frei
(virtual public member function) [bearbeiten]
operator=
[gelöscht]
 Der Kopierzuweisungsoperator ist gelöscht. monotonic_buffer_resource ist nicht kopierbar
(public member function) [bearbeiten]
Öffentliche Memberfunktionen
 gibt allen zugewiesenen Speicher frei
(public member function) [bearbeiten]
 gibt einen Zeiger auf die Upstream-Speicherressource zurück
(public member function) [bearbeiten]
Geschützte Memberfunktionen
[virtuell]
 alloziiert Speicher
(virtual protected member function) [bearbeiten]
[virtuell]
 no-op
(virtual protected member function) [bearbeiten]
[virtuell]
 Vergleich auf Gleichheit mit einer anderen std::pmr::memory_resource
(virtual protected member function) [bearbeiten]

[bearbeiten] Beispiel

Das Programm misst die Zeit für die Erstellung riesiger doppelt verketteter Listen unter Verwendung der folgenden Allokatoren

  • Standard-Allokator (Standard),
  • pmr-Allokator (Standard),
  • pmr-Allokator mit einem monotonen Puffer, aber ohne expliziten Speicherpuffer,
  • pmr-Allokator mit einem monotonen Puffer und einem externen Speicherpuffer (auf dem Stack).
Führen Sie diesen Code aus
#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)
{
    const auto start = std::chrono::system_clock::now();
    while (iterations-- > 0)
        test_func();
    const auto stop = std::chrono::system_clock::now();
    const auto secs = std::chrono::duration<double>(stop - start);
    return secs.count();
}
 
int main()
{
    constexpr int iterations{100};
    constexpr int 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);
    };
 
    const double t1 = benchmark(default_std_alloc, iterations);
    const double t2 = benchmark(default_pmr_alloc, iterations);
    const double t3 = benchmark(pmr_alloc_no_buf , iterations);
    const double 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';
}

Mögliche Ausgabe

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