Создание быстродействующего распределителя памяти, для std::vector или замена глобальных операций выделения памяти Опции

[AD]

Раньше был обычный массив (динамический), который содержал значения определенных параметров, прочитанных из лог-файла (широта, долгота, скорость и пр.). Сейчас сделал в виде вектора. Вместо оператора new теперь использую resize. Но так как эти операции чересчур затратные (а цикл может содержать и 100000 итераций (где каждый раз происходит выделение)), то стало необходимо сделать алгоритм немного по-другому.
Выделять память блоками. Т.е. вместо след. операций:
code1

t.params = new PARAMVALUE[rec_descr.size()];
t.words = new uint[rec_descr.size()];
memset(t.params, 0, sizeof(PARAMVALUE) * rec_descr.size());
memset(t.words, 0, sizeof(uint) * rec_descr.size());

Делать следующее:
code2

/// 0 <= num_block <= 1000
char *buff, *buff1;
if(num_block > 1000)
{
buff = new char[rec_descr.size() * BLOCKSIZE];
buff1 = new char[rec_descr.size() * BLOCKSIZE];
flag = false;
num_block = 0;
}
++num_block;
t.params = buff + rec_descr.size() * num_block;
t.words = buff1 + rec_descr.size() * num_block;

При замене на QVector code1 перешел в следующий:
code3

t.params.resize(rec_descr.size());
t.words.resize(rec_descr.size());

Как переписать code2 для использования в векторе QVector? Заранее благодарен за помощь....

Сообщение отредактировал AD - 30.6.2009, 15:08

[Tonal]

Может всё же так:

...
    struct Chunk
    {
        Chunk* next;
        char memory[chunk_size * sizeof(T)];
    };
...

Тогда размер Chunk::memory будет всегда кратен количеству элементов - не будут пропадать попусту невлезшие кусочки.
Ну и размер chunk_size я бы поставил как среднее rec_descr.size() * 100, например.

Да, ты ведь профилируешь релизную сборку, я надеюсь?

[AD]

Да, ты ведь профилируешь релизную сборку, я надеюсь?

На счет профилировки хотел посоветоваться! Не помню как мне один раз удалось спрофилировать программу, но больше не удавалось. Причина следующая: файлы, которые генерирует MOC типа ui_tlv.h я создаю еще cpp, переношу туда setupUi, retranslateUi! Делаю это потому что кое-что изменяю в этих функциях! Так проблема в том, что при включенном профайлере компилятор каждый пересобирает проект, соответственно h-файлы все время пересоздаются и выдается куча ошибок. При попытке просто скомпилировать, он снова пересобирает проект. Есть способ победить эту штуку?

Вот видоизменил распределитель.
Пока не видны изменения в скорости:

allocator

#ifndef SPECIFIC_ALLOCATOR_INL
#define SPECIFIC_ALLOCATOR_INL

#include <memory>
#include <cassert>

#define CHUNK_SIZE 2048

/// Собственный распределитель памяти
template <typename T> class pool_alloc: public std::allocator<T>
{
private:
    static const difference_type chunk_size = CHUNK_SIZE;
    struct Link { Link* next; };
    struct Chunk
    {
        Chunk* next;
        char memory[chunk_size * ((sizeof(T) <= 0) ? 1 : sizeof(T))];
    };
    Link* head;
    Chunk* chunks;
    static const size_type elem_size = (sizeof(T) < sizeof(Link*)) ? sizeof(Link*) : sizeof(T);
    static const size_type num_elem = chunk_size / elem_size;

private:
    void grow(bool special = false)            ///< увеличиваем пулл
    {
        Chunk* n = new Chunk;
        n -> next = chunks;
        chunks = n;

        char* start = n -> memory;
        char* last = &n -> memory[(num_elem - 1) * elem_size];
        for(char* p=start; p<last; p+=elem_size)
            reinterpret_cast<Link*> (p) -> next = reinterpret_cast<Link*> (p + elem_size);
        reinterpret_cast<Link*> (last) -> next = (special) ? head : 0;
        head = reinterpret_cast<Link*> (start);
    }

public:
    pool_alloc() throw(): head(0), chunks(0) {}
    pointer allocate(size_type n)            ///< выделяем память под n элементов типа T
    {
        if(n * elem_size > chunk_size) throw std::bad_alloc();
        if(!head) grow();
        else if(n != 1) grow(true);
        Link* p = head;
        while(n--) head = head -> next;
        return reinterpret_cast<pointer> (p);
    }
    void deallocate(pointer p, size_type n) ///< возвращаем память в пулл
    {
        char* end = (char*)(p) + n;
        for(char* q=(char*)p; q<end; q+=elem_size)
            reinterpret_cast<Link*> (q) -> next = reinterpret_cast<Link*> (q + elem_size);
        reinterpret_cast<Link*> (end - elem_size) -> next = head;
        head = reinterpret_cast<Link*> (p);
    }
    ~pool_alloc() throw()
    {
        Chunk* n = chunks;
        while(n)
        {
            Chunk* p = n;
            n = n -> next;
            delete p;
        }
    }
    template <typename Other> struct rebind
    { typedef pool_alloc<Other> other; };
    template <typename Other> pool_alloc(const pool_alloc<Other>& p) throw() { head = 0, chunks = 0; }
    template <typename Other> pool_alloc<T>& operator=(const pool_alloc<Other>&)
    { head = 0; chunks = 0; return *this; }
    pool_alloc(const pool_alloc<T>& p) throw() { head = 0, chunks = 0; }
};

#endif // SPECIFIC_ALLOCATOR_INL

Сообщение отредактировал AD - 2.7.2009, 10:50

[AD]

Так.... совсем интересно. При загрузке большого количества логов программа терпит молный крах.

Пока попробую тогда реализовать вариант с массивами, описанный в code 2!