Speicher mit C++ in Echtzeit vormerken

Question

Ich habe eine Funktion, die einen Eingabepuffer von n Bytes erhält und einen Hilfspuffer von n Bytes benötigt, um den angegebenen Eingabepuffer zu verarbeiten.

(ich weiß Vektor Speicher zur Laufzeit Zuweisung von, sagen wir mal, dass ich einen Vektor bin mit der statischen vorreservierten Speicher verwendet. Stellen Sie sich dieses ist NICHT ein STL-Vektor.)

Der übliche Ansatz ist

Da ich in einer Echtzeitumgebung arbeite, möchte ich den gesamten Speicher im Voraus reservieren, den ich jemals brauche.

Der Puffer wird nur einmal beim Start zugewiesen. Ich möchte, dass, wenn ich einen Vektor zuzuteilen, ich automatisch Auxiliary-Puffer für meine processData-Funktion zuweisen werde.

ich etwas ähnliches mit einer Template-Funktion mit Vorlagen nicht viel Spaß

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

Allerdings arbeiten viel tun kann, ist (jetzt wollen wir alles neu kompilieren, da ich einen Kommentar geändert!), Und es zwingt mich eine Buchhaltung zu tun wann immer ich diese Funktion nutze.

Gibt es schönere Designs für dieses Problem?

Answer 1

Ich sehe nicht, wie Sie genau das bekommen können, was Sie beschreiben. So etwas könnte ein guter Kompromiss für Sie sein.

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

Answer 2

Konnten Sie eine kleine Struktur schaffen, die Ihren Vektor und einen gleich großen Puffer enthielt? Dann würde Ihr Vektor seinen Verarbeitungspuffer mit sich führen, wo immer er hingehört. Wenn Sie es durch Referenz oder Zeiger übergeben, sollten Sie den Kopieraufwand vermeiden. Pseudo-Code folgt unten:

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

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

Jede Funktion, die derzeit Ihre Vektor-Argument würde dann eine Container nehmen.

Answer 3

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

Ist das neu in STL? Oder eine benutzerdefinierte Erweiterung?

Die typische Lösung wäre die Verwendung eines benutzerdefinierten Zuordners. Dies ist jedoch nicht unbedingt "schöner" Code.

Some intro slides (Warnung: Powerpoint)
Wikipedia
Google

Answer 4

Auch wenn Sie dies gelingen, kann es nicht erreichen, was Sie wollen. Je nachdem, welches Betriebssystem Sie verwenden und wie virtueller Speicher implementiert wird, erhalten Sie möglicherweise lazy allocation, wobei nur ein Teil Ihrer Speicherzuweisung zugewiesen und initialisiert wird und weitere Seiten aufgrund von Seitenfehlern später zugeordnet werden. Wenn Ihr Betriebssystem mlock oder gleichwertig ist, können Sie dies möglicherweise umgehen.

Answer 5

Ich denke, Sie könnten beim Start einen ausreichend großen Speicherpool vormieten und mlock() verwenden und dann normale STL-Container mit Speicherpoolzuweisern (Boost von oder Ihre eigenen) verwenden.

Ich habe das für unsere Echtzeit-Software untersucht, aber Tests haben gezeigt, dass die Speicherzuweisung auf unserer Hardware für unsere Zwecke schnell genug ist.

Answer 6

Wahrscheinlich können Sie die neuen und löschenden Operatoren überschreiben, aber dann müssen Sie Ihren gesamten Speicher auf eigene Faust verwalten. Sie können so viel Speicher zuweisen, wie Sie am Anfang wollen:

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

lassen Sie uns sagen, dass ich einen Vektor bin mit der

statisch vorab zugeordneten Speicher verwendet Dann sollten Sie in der Lage zu bekommen Größe (oder maximale Größe) von vorab zugewiesenem Speicher zur Kompilierungszeit. Wenn ein solcher Vektor seine Größe als Template-Argument hatte, wäre es einfacher, mit der processData-Funktion zu arbeiten.

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

Es ist nicht das vector Sie sich kümmern müssen, es ist die Speicherzuordner.

Sie könnten perfekt einen Speicherzuordner erstellen, der seinen Speicher vorlistet und ihn dann an den Vektor weitergibt, wenn Sie ihn erstellen, das ist der Vorlagenparameter Alloc!

Und um sicherzustellen, dass der Speicher nicht "virtuell" zugewiesen ist, berühren Sie es, wenn Sie es zuweisen.

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

Jetzt Sie „nur“ eine benutzerdefinierte allocator implementieren, die auf diesen Speicherpool bezeichnet und an die Vektor-Implementierung passieren :)