Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

std::pmr::monotonic_buffer_resource — allocazione con rilascio collettivo

std::pmr::monotonic_buffer_resource fornisce memoria per allocazioni successive ignorando le singole deallocazioni. release() restituisce i blocchi alla risorsa a monte e ripristina la risorsa per riutilizzarla.

Versione: C++23; repository compiler flag, production runtime not attested

Sintassi

#include <cstddef>
#include <memory_resource>

void use_resource(void* buffer, std::size_t buffer_size,
                  std::pmr::memory_resource* upstream) {
    {
        std::pmr::monotonic_buffer_resource resource;
    }
    {
        std::pmr::monotonic_buffer_resource resource(buffer, buffer_size);
    }
    {
        std::pmr::monotonic_buffer_resource resource(buffer, buffer_size, upstream);
        resource.release();
    }
}

std::pmr::monotonic_buffer_resource, dichiarata in <memory_resource>, è una risorsa di memoria utile quando gli oggetti vengono creati gradualmente e la memoria può essere recuperata tutta insieme. I contenitori PMR, come std::pmr::vector<int>, possono usarla tramite un allocatore. Le singole chiamate di deallocazione non recuperano spazio; la crescita di un contenitore può quindi lasciare occupati i blocchi precedenti.

È possibile fornire un buffer iniziale. Quando lo spazio rimanente non soddisfa la dimensione e l’allineamento richiesti, la risorsa ottiene un altro blocco dalla risorsa a monte; le dimensioni dei blocchi dipendono dall’implementazione. Se non viene specificato l’argomento upstream, viene usata la risorsa di memoria predefinita. Il buffer iniziale, quindi, non è un limite rigido al consumo di memoria.

std::pmr::monotonic_buffer_resource::release() restituisce tutti i blocchi ottenuti alla risorsa a monte e ripristina lo stato iniziale delle allocazioni, consentendo di riutilizzare il buffer fornito. Non libera il buffer stesso, che appartiene al chiamante, né invoca i distruttori degli oggetti memorizzati. Distruggi prima gli oggetti e i contenitori che usano tali allocazioni; chiamare soltanto clear() su un contenitore non basta, perché può conservarne la capacità. Anche il distruttore della risorsa chiama release(). Il buffer e la risorsa a monte devono rimanere disponibili mentre la risorsa li usa.

L’esempio distrugge il primo vettore prima di release() e poi ne crea un secondo usando la stessa risorsa. Ambito della voce: C++23; l’opzione del compilatore del repository non certifica l’ambiente di esecuzione di produzione. Il documento collegato è una bozza di lavoro in evoluzione, non una pubblicazione C++23 definitiva.

Esempi

#include <cstddef>
#include <iostream>
#include <memory_resource>
#include <vector>

int main() {
    alignas(std::max_align_t) std::byte buffer[256];
    std::pmr::monotonic_buffer_resource resource(buffer, sizeof buffer);

    {
        std::pmr::vector<int> values(&resource);
        values.reserve(3);
        values.push_back(1);
        values.push_back(2);
        values.push_back(3);
        std::cout << values[0] + values[1] + values[2] << '\n';
    }

    resource.release();

    {
        std::pmr::vector<int> values(&resource);
        values.push_back(4);
        std::cout << values.front() << '\n';
    }
}

Risultato

6
4

Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.

Fonti