Предварительное выделение памяти с C++ в среде реального времени

Я думаю, вы могли бы предварительно -allocate и mlock () достаточно большой пул памяти при запуске, а затем использовать обычные контейнеры STL с распределителями пула памяти ( Boost из FSBA или ваши собственные).

Я изучал это для нашего программного обеспечения реального времени, но тесты показали, что распределение памяти на нашем оборудовании достаточно быстрое для наших целей.

Возможно, вы можете переопределить операторы new и delete, но тогда вам придется управлять всей своей памятью самостоятельно. В начале вы можете выделить столько памяти, сколько хотите:

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

vector aux(vec.size(),aux_buffer); // используем aux_buffer для вектора

Это новое в STL? Или пользовательское расширение?

Типичным решением было бы использование пользовательского аллокатора. Однако это не обязательно "красивее" в коде.

Некоторые вводные слайды (предупреждение: powerpoint!)
Wikipedia
Google

допустим, я использую вектор. который использует статическую предварительно выделенную память

Тогда вы должны быть в состоянии получить размер (или максимальный размер) предварительно выделенной памяти во время компиляции. Если бы такой вектор имел свой размер как аргумент шаблона, то работа с функцией processData была бы проще.

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

Не могли бы вы создать небольшую структуру, содержащую ваш вектор и буфер такого же размера? Тогда ваш вектор будет нести свой буфер обработки вместе с собой, куда бы он ни направлялся. Если вы передадите его по ссылке или указателю, вам следует избежать накладных расходов на копирование. Псевдокод следует ниже:

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

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

Любая функция, которая в настоящее время принимает ваш аргумент вектора, затем примет Контейнер .

Даже если вам это удастся, это может не достичь того, чего вы хотите. В зависимости от того, какую ОС вы используете и как она реализует виртуальную память, вы можете обнаружить, что вы получаете ленивое выделение , при котором только часть вашего распределения памяти фактически выделяется и отображается изначально, а дальнейшие страницы отображаются позже. в результате ошибок страниц. Если в вашей ОС есть mlock или аналогичный, вы можете обойти это.

Вам нужно беспокоиться не о векторе , а о распределителе памяти.

Вы могли бы идеально создать распределитель памяти, который предварительно выделяет ее память, а затем передает ее вектору при его построении, для этого и нужен параметр шаблона Alloc !

И чтобы убедиться, что память не выделена «виртуально», прикоснитесь к ней при выделении.

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

Теперь вам «просто» нужно реализовать собственный распределитель, который ссылается на этот пул памяти и передать его векторной реализации :)