Preallocazione della memoria con C++ in ambiente realtime

Question

Ho una funzione che ottiene un buffer di input di n byte e richiede un buffer ausiliario di n byte per elaborare il buffer di input specificato.

(lo so vettore è l'allocazione della memoria in fase di esecuzione, diciamo che sto usando un vettore che utilizza una memoria preallocato statica. Immaginate questo NON è un vettore STL.)

L'approccio comune è

void processData(vector<T> &vec) { 
    vector<T> &aux = new vector<T>(vec.size()); //dynamically allocate memory 
    // process data 
} 
//usage: 
processData(v) 

Dal momento che sto lavorando in un ambiente in tempo reale, desidero preallocare tutta la memoria che avrò mai bisogno in anticipo.

Il buffer viene assegnato una sola volta all'avvio. Voglio che quando alloco un vettore, allocherò automaticamente il buffer ausiliario per la mia funzione processData.

che posso fare qualcosa di simile con una funzione template

static void _processData(vector<T> &vec,vector<T> &aux) { 
    // process data 
} 
template<size_t sz> 
void processData(vector<T> &vec) { 
    static aux_buffer[sz]; 
    vector aux(vec.size(),aux_buffer); // use aux_buffer for the vector 
    _processData(vec,aux); 
} 
// usage: 
processData<V_MAX_SIZE>(v); 

Tuttavia lavorando molto con i modelli non è molto divertente (ora diamo ricompilare tutto da quando ho cambiato un commento!), E mi costringe a fare un po 'di contabilità ogni volta che uso questa funzione.

Esistono progetti più interessanti in merito a questo problema?

Answer 1

Non vedo come si possa ottenere esattamente ciò che si descrive. Qualcosa di simile potrebbe essere un buon compromesso per te.

void processData(vector<T>& vec) 
{ 
    static vector<T> aux(vec.size()); 
    if (vec.size() > aux.size()) { 
     aux.resize(vec.size()); 
    } 
    ... 
} 

Answer 2

È possibile creare una piccola struttura contenente il vettore e un buffer di dimensioni uguali? Allora avresti il ​​tuo vettore che trasporta il suo buffer di elaborazione con esso ovunque vada. Se lo passi per riferimento o puntatore, devi evitare il sovraccarico di copia. Pseudocodice segue qui sotto:

struct Container 
{ 
    vector<T> vec; 
    vector<T> buf; 

    Container(int size) 
    { 
     vec.reserve(size); 
     buf.reserve(size); 
    } 
}; 

Qualsiasi funzione che attualmente prende il vostro argomento vettore avrebbe poi prendere un Container.

Answer 3

vector aux(vec.size(),aux_buffer); // use aux_buffer for the vector

è che i nuovi in ​​STL? O un'estensione personalizzata?

La soluzione tipica sarebbe l'utilizzo di un allocatore personalizzato. Tuttavia, questo non è necessariamente "più carino" nel codice.

Some intro slides (Attenzione: powerpoint)
Wikipedia
Google

Answer 4

Anche se si riesce a fare questo, non può ottenere quello che vuoi. A seconda del sistema operativo in uso e del modo in cui implementa la memoria virtuale, è possibile che si ottenga lazy allocation, in cui solo parte dell'allocazione di memoria viene effettivamente allocata e mappata inizialmente e altre pagine vengono mappate in seguito a causa di errori di pagina. Se il tuo sistema operativo ha mlock o equivalente, potresti riuscire a ovviare a questo problema.

Answer 5

Penso che si potrebbe pre-allocare e mlock() un numero sufficientemente ampio pool di memoria all'avvio, e quindi utilizzare contenitori STL regolari con ripartitori pool di memoria (Boost del FSBA o il proprio).

L'ho cercato per il nostro software in tempo reale, ma i test hanno dimostrato che l'allocazione della memoria è abbastanza veloce sul nostro hardware per i nostri scopi.

Answer 6

Probabilmente è possibile ignorare gli operatori nuovi ed eliminare, ma di quello che si dovrà gestire tutta la memoria da soli. È possibile allocare la quantità di memoria che si desidera all'inizio:

void* operator new (std::size_t size) throw (std::bad_alloc); 
void* operator new[] (std::size_t size) throw (std::bad_alloc); 
void operator delete (void* ptr) throw(); 
void operator delete[] (void* ptr) throw(); 

Answer 7

diciamo che sto usando un vettore che utilizza la memoria preallocato statica

Poi si dovrebbe essere in grado di ottenere dimensione (o dimensione massima) della memoria preallocata in fase di compilazione. Se un vettore di questo tipo aveva le sue dimensioni come argomento modello, allora lavorare con la funzione processData sarebbe più semplice.

template<class T, size_t sz> 
class vector 
{ 
enum { size = sz } //either max size 
... 
} 

template<class Vector> 
static void _processData(Vector &vec,Vector &aux) 
{ 
    // process data 
} 
template<class Vector> 
void processData(Vector &vec) { 
    static aux_buffer[Vector::size]; 
    //no need to pass size into constructor, as Vector type knows it already 
    Vector aux(aux_buffer); // use aux_buffer for the vector 
    _processData(vec,aux); 
} 
// usage: 
vector<int, 30> v1; 
vector<float, 40> v2; 
//no need to specify template parameter explicitly 
//every call uses its own function instance and its own buffer of different size 
processData(v1); 
processData(v2); 

Answer 8

Non è la vector è necessario preoccuparsi, è l'allocatore di memoria.

Si può creare perfettamente un allocatore di memoria che prealloca la sua memoria e poi lo passa al vettore quando lo si genera, ecco a cosa serve il parametro del modello Alloc!

E per assicurarsi che la memoria non sia allocata "virtualmente", toccarla quando la si assegna.

scoped_array<byte> buffer = new byte[SIZE]; 
memset(buffer.get(), 0, SIZE); 

Ora, è "solo" sono tenuti ad attuare un allocatore personalizzato, che si riferisce a questo pool di memoria e passarlo alla realizzazione vettore :)