Юра, мне непонятна одна конкретная вещь:

вот я выделил память какому-то вектору:

QVector bigVec;
bigVec.resize(1000000);

Как теперь выделенную вектору память распределить между маленькими векторами t.params?

а её зачем распределять?
Ты вектор даными заполняй и всё.

Тогда я не понимаю как! В смысле? У меня идет такая штуковина:

/// Чтение файла загрузки
    bool LogReader::tRead()
    {
        uint var = (uint)1E+6, index = 0;
        QVector<LOGRECORD> log;
        while(_file -> read((char*)&var, sizeof(var)) > 0)
        {
            Suint adr = var % 256;
            /// Определение начала/конца одной записи и записывание ее в вектор
            switch(adr)
            {
            case 0000:
                m_vBlock.clear();
                bBlock = true;
            break;
            case 0001:
                if(bBlock)
                {
                    LOGRECORD t = parseBlock();
                    /// что-то еще...
                    log.append(t);
                    /// что-то еще...
                }
                bBlock = false;
            break;
            default:
                if(bBlock) m_vBlock.append((uint)var);
            }
        }
    }

LOGRECORD LogReader::parseBlock()
{
        LOGRECORD t;
        t.params.resize(rec_descr.size()); ///< это самая длительная операция. Если лог-файлов много - то именно из-за нее довольно долго крутимся в этих циклах!
        t.name_file = strippedName(_file -> fileName()); 
        for(QVector<uint>::iterator iter=m_vBlock.begin(); iter!=m_vBlock.end(); ++iter)
        {
            uint var = *iter;
            Suint adr = var % 256;
            register int i = 0;
            for(paramI jter=rec_descr.begin(); jter!=rec_descr.end(); ++jter, ++i)
            {
                                    /// actions with paramters
                         }
                   }
}

Сообщение отредактировал AD - 29.6.2009, 18:03

AD, прости, а можешь словами рассказать, что нужно получить.
Почитал, но особо не врубился.
При последовательном заполнении (чтении) все равно QList или QVector. Только QList не нужно resize'ить.

code 1, code2 из первого примера - это рабочие коды. Он плохи тем, что при чтении большого количества лог-файлов (или же очень-очень большого лог-файла) на операцию выделения памяти тратится много времени, из-за чего загрузка длится дольше, чем хотелось бы и сжирает процессорное время! Хотелось бы, чтобы загрузка происходила быстрее. Вариант который можно сделать следующий: выделять память более большими блоками, а потом ее распределять между более мелкими массивами - модернизация code 3. Так как я вместо обычных массивов, стал пользоваться QVector, то хотелось бы получить аналогичный алгоритм для векторов!

P.S. Заполнение непоследовательное - вначале могут заполнить 20 элемент, а потом 1-ый!

Сообщение отредактировал AD - 29.6.2009, 22:02

Т.е. у тебя много маленьких векторочков.
В stl у std::vector есть параметр шаблона, который позволяет указать свой менеджер памяти для этого вектора - это именно то, что тебе нужно.
В Qt, QVector не имеет подобного механизма, и сделать тут ничего нельзя.

Выходов может быть несколько:
* Перейти на std::vector и свой аллокатор вместо QVector.
* Запихивать всё в единый QVector, а в LOGRECORD хранить индекс массиве и количество элементов.
* Если все блоки одинаковы по составу (или есть небольшое количество разных составов) то может проще выделить отдельную структуру для этих данных вместо векторов, и включить в состав LOGRECORD (в случае нескольких типов хранить указатель).

Я бы сказал так: их ох...но (ну очень-очень) много! )))


Раньше не писал собственных аллокаторов памяти. Поможешь если что? С чего написание аллокатора памяти начать писать? Заранее спасибо!

P.S. Заменил QVetor на std::vector (для этого практически ничего не пришлось изменять, кроме самого типа)!

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

Как я понял задачу. Есть несколько конфигурационных файлов в которых храниться информация для вектора. Порядок загрузки файлов может быть любым. Нужно сформировать вектор с определенной последовательность данных.
Известно, что неприемлемое время тратиться на resize вектора.
Можно попробовать использовать QList. Т.е. читаем все файлы в отдельные списки, а после этого собрать общий список из маленьких, соблюдая необходимый порядок. Сложение QList операция быстрая, так же как и добавления в список элемента.

Это удобно при большом количестве однотипных векторов, но ведь это не отменяет возможности перевыделять память каждому такому векторку через resize в каком-нибудь цикле.

Если размеры мелких векторов влияют на размер основного вектора, то сначала надо увеличить размер основного вектора скажем на 10000, а потом разделить эту сумму на количество мелких векторов. Если их 1000, то 10000/1000=10. Т.е. +10 к resize'у каждого мелкого

Сообщение отредактировал SABROG - 30.6.2009, 8:54

Есть ини-файл, в котором определено, какие-именно параметры следует выбирать из лог-файлов (бинарные файлы определенного формата, записанные авиа-приборами)! Данные этого ини-файла (описание параметров) считываются в вектор QVector<ParamDescr*>, ParamDescr - абстрактный класс, описывающий вид параметров (в общем виде - название параметра, адрес (в восьмеричной системе счисления), тип параметра). При чтении лог-файлов значения нужных параметров (сравниваются получаемые адреса) записываются по нужному индексу в вектор значений параметров (как раз в params)! Что именно делать с QList, как и что складывать я не совсем понял. Можешь пояснить, пожалуйста? Если что-то в коде запишешь, буду благодарен.