Memoria de preasignación con C++ en entorno de tiempo real

Question

Tengo una función que obtiene un búfer de entrada de n bytes, y necesita un búfer auxiliar de n bytes para procesar el búfer de entrada proporcionado.

(sé vector es la asignación de memoria en tiempo de ejecución, digamos que estoy usando un vector que utiliza memoria preasignada estática. Imagínese esto es NO un vector de STL.)

El enfoque habitual es

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

Dado que estoy trabajando en un entorno de tiempo real, deseo preasignar toda la memoria que necesitaré de antemano.

El búfer se asigna solo una vez al inicio. Quiero que cada vez que asigne un vector, automáticamente asigne el buffer auxiliar para mi función processData.

puedo hacer algo similar con una función de plantilla

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); 

Sin embargo trabajando mucho con las plantillas no es muy divertido (ahora vamos a recompilar todo lo que ya he cambiado un comentario!), Y me obliga a hacer un poco de contabilidad cada vez que uso esta función.

¿Hay diseños más agradables alrededor de este problema?

Answer 1

No veo cómo puede obtener exactamente lo que describe. Algo como esto podría ser un buen compromiso para ti.

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

Answer 2

¿Podría crear una estructura pequeña que contuviera su vector y un búfer del mismo tamaño? Entonces harías que tu vector llevara su búfer de procesamiento junto con él donde quiera que vaya. Si lo pasa por referencia o puntero, debe evitar la sobrecarga de la copia. Pseudocódigo sigue a continuación:

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

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

Cualquier función que actualmente lleva su vector argumento sería luego tomar un Container.

Answer 3

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

es que los nuevos en STL? O una extensión personalizada?

La solución típica sería usar un asignador personalizado. Sin embargo, esto no es necesariamente "más bonito" en el código.

Some intro slides (advertencia: PowerPoint)
Wikipedia
Google

Answer 4

Incluso si usted tiene éxito en hacer esto, no puede lograr lo que quiere. Dependiendo del sistema operativo que esté utilizando y cómo implemente la memoria virtual, puede encontrar que obtiene lazy allocation, donde solo se asigna y asigna inicialmente una parte de la asignación de memoria, y posteriormente se mapean más páginas como resultado de fallas de página. Si su sistema operativo tiene mlock o equivalente, entonces puede evitar esto.

Answer 5

Creo que podría preasignar y mlock() un grupo de memoria suficientemente grande en el inicio y luego usar contenedores STL regulares con asignadores de grupo de memoria (Boost de FSBA o el suyo).

Estaba investigando eso para nuestro software en tiempo real, pero las pruebas mostraron que la asignación de memoria es lo suficientemente rápida en nuestro hardware para nuestros propósitos.

Answer 6

Probablemente puede anular los operadores nuevos y eliminar, pero tendrá que administrar toda su memoria por su cuenta. Se pueden asignar más memoria que desea al principio:

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

digamos que estoy usando un vector que utiliza la memoria preasignada estática

Entonces usted debe ser capaz de obtener tamaño (o tamaño máximo) de la memoria preasignada en tiempo de compilación. Si dicho vector tiene su tamaño como argumento de plantilla, entonces trabajar con la función processData sería más fácil.

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

No es el vector necesita preocuparse, que es el asignador de memoria.

Puede crear perfectamente un asignador de memoria que preasigne su memoria y luego la pase al vector cuando la construya, ¡para eso sirve el parámetro de plantilla Alloc!

Y para asegurarse de que la memoria no está "virtualmente" asignada, tóquela cuando la asigne.

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

Ahora, "sólo" tienen que poner en práctica un asignador de costumbre que se refiere a este bloque de memoria y pasarlo a la puesta en práctica del vector :)