Ответ 1

Это...

vector<vector<vector<double> > > charge(mx, vector<vector<double> >(my, vector<double>(mz)));

... создает временный vector<double>(mz) со всеми значениями 0.0 и копирует его my раз (или, возможно, перемещает, то копирует my-1 раз с компилятором С++ 11, но мало отличается...) для создания временного vector<vector<double>>(my, ...), который затем копируется mx times (... как указано выше...) для инициализации всех данных. Вы все равно читаете данные по этим элементам - нет необходимости тратить время на его инициализацию. Вместо этого создайте пустой charge и используйте вложенные циклы в reserve() достаточно памяти для элементов, не заполняя их.

Затем проверьте, что вы компилируете с оптимизацией. Если вы находитесь, и вы все еще медленнее, чем FORTRAN, в заполняющих данные вложенных циклах попробуйте создать ссылку на вектор, о котором вы находитесь о .emplace_back, на:

for (int i = 0; i < mx; ++i)
    for (int j = 0; j < my; ++j)
    {
        std::vector<double>& v = charge[i][j];
        for (int k = 0; k < mz; ++k)
        {
            double d;
            InFile >> d;
            v.emplace_pack(d);
        }
    }

Это не поможет, если ваш оптимизатор проделал хорошую работу, но стоит попробовать как проверку работоспособности.

Если вы все еще медленнее - или просто хотите попробовать еще быстрее - вы можете попытаться оптимизировать парсинг чисел: вы говорите, что ваши данные все отформатированы ala 0.23080516813E+04 - с фиксированными размерами, которые вы можете легко подсчитать, сколько байты для чтения в буфер, чтобы дать вам приличное количество значений из памяти, затем для каждого из них вы можете запустить atol после ., чтобы извлечь 23080516813, а затем умножить его на 10 на мощность минус (11 (ваш номер цифр) минус 04): для скорости держите таблицу этих степеней десяти и индексируйте в нее с использованием извлеченного показателя (т.е. 4). (Примечание умножения, например, 1E-7, может быть быстрее, чем деление на 1E7 на большом количестве общего оборудования.)

И если вы хотите, чтобы это произошло, переключитесь на использование доступа к файлам с памятью. Стоит рассмотреть boost::mapped_file_source, поскольку он проще в использовании, чем даже POSIX API (не говоря уже о Windows) и переносится, но программирование непосредственно против OS API тоже не должно быть большой проблемой.

UPDATE - ответ на первый и второй комментарии

Пример использования форматирования памяти памяти:

#include <boost/iostreams/device/mapped_file.hpp>

boost::mapped_file_params params("dbldat.in");
boost::mapped_file_source file(params);
file.open();
ASSERT(file.is_open());
const char* p = file.data();
const char* nl = strchr(p, '\n');
std::istringstream iss(std::string(p, nl - p));
size_t x, y, z;
ASSERT(iss >> x >> y >> z);

Вышеприведенный файл отображает файл в память по адресу p, затем анализирует размеры из первой строки. Продолжайте синтаксический анализ фактических double представлений от ++nl и далее. Я упоминаю подход к этому выше, и вы обеспокоены изменением формата данных: вы можете добавить номер версии в файл, поэтому вы можете использовать оптимизированный синтаксический анализ до тех пор, пока номер версии не изменится, а затем вернется к чему-то универсальному для "неизвестного", файлов. Поскольку что-то общее, для представления в памяти с использованием int chars_to_skip; double my_double; ASSERT(sscanf(ptr, "%f%n", &my_double, &chars_to_skip) == 1); является разумным: см. sscanf docs here - вы можете указатель через данные chars_to_skip.

Затем вы предлагаете объединить решение reserve() с решением создания ссылки?

Да.

И (помилуй мое невежество), почему использование ссылки на charge[i][j] и v.emplace_back() будет лучше, чем charge[i][j].emplace_back()?

Это предположение состояло в том, чтобы убедиться в том, что компилятор не неоднократно оценивал charge[i][j] для каждого элемента, который был установлен: надеюсь, что он не изменит производительность, и вы можете вернуться к charge[i][j].emplace(), но IMHO стоит быстро проверить.

Наконец, я скептически отношусь к использованию пустого вектора и резервирования() в вершинах каждого цикла. У меня есть еще одна программа, которая пришла к остановке, используя этот метод, и заменив резерв() s на предварительно выделенный многомерный вектор, ускорило его.

Это возможно, но не обязательно верно вообще или применимо здесь - многое зависит от компилятора/оптимизатора (особенно для разворачивания цикла) и т.д. С неоптимизированным emplace_back вам нужно проверить вектор size() на capacity() неоднократно, но если оптимизатор выполняет хорошую работу, которая должна быть уменьшена до незначительности. Как и при большой настройке производительности, вы часто не можете рассуждать о совершенстве и делать то, что будет самым быстрым, и вам придется попробовать альтернативы и измерить их с помощью вашего фактического компилятора, данных программы и т.д.