Почему std:: fstreams так медленно?

Ответ 1

Казалось бы, в Linux для этого большого набора данных реализация fwrite намного эффективнее, поскольку она использует write, а не writev.

Я не уверен, ПОЧЕМУ writev работает гораздо медленнее, чем write, но, похоже, это разница. И я не вижу абсолютно никакой причины, почему в этом случае fstream должна использовать эту конструкцию.

Это легко увидеть с помощью strace ./a.out (где a.out - это программа, проверяющая это).

Вывод:

Fstream:

clock_gettime(CLOCK_REALTIME, {1411978373, 114560081}) = 0
open("test", O_WRONLY|O_CREAT|O_TRUNC, 0666) = 3
writev(3, [{NULL, 0}, {"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"..., 1073741824}], 2) = 1073741824
close(3)                                = 0
clock_gettime(CLOCK_REALTIME, {1411978386, 376353883}) = 0
write(1, "fstream write 13261.8 ms\n", 25fstream write 13261.8 ms) = 25

ФАЙЛ *:

clock_gettime(CLOCK_REALTIME, {1411978386, 930326134}) = 0
open("test", O_WRONLY|O_CREAT|O_TRUNC, 0666) = 3
write(3, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"..., 1073741824) = 1073741824
clock_gettime(CLOCK_REALTIME, {1411978388, 584197782}) = 0
write(1, "FILE* write 1653.87 ms\n", 23FILE* write 1653.87 ms) = 23

У меня нет им причудливых дисков SSD, поэтому моя машина будет немного медленнее - или что-то еще медленнее в моем случае.

Как отметил Ян Худек, я неверно истолковываю результаты. Я просто написал это:

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/uio.h>
#include <unistd.h>
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <chrono>

void measure(const std::string& test, std::function<void()> function)
{
    auto start_time = std::chrono::high_resolution_clock::now();

    function();

    auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now() - start_time);
    std::cout<<test<<" "<<static_cast<double>(duration.count()) * 0.000001<<" ms"<<std::endl;
}

#define BUFFER_SIZE (1024 * 1024 * 1024)


int main()
{
    auto buffer = new char[BUFFER_SIZE];
    memset(buffer, 0, BUFFER_SIZE);

    measure("writev", [buffer]()
    {
        int fd = open("test", O_CREAT|O_WRONLY);
        struct iovec vec[] = 
        {
            { NULL, 0 },
            { (void *)buffer, BUFFER_SIZE }
        };
        writev(fd, vec, sizeof(vec)/sizeof(vec[0]));
        close(fd);
    });

    measure("write", [buffer]()
    {
        int fd = open("test", O_CREAT|O_WRONLY);
        write(fd, buffer, BUFFER_SIZE);
        close(fd);
    });
}

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

И результат почти идентичен для обоих случаев и быстрее, чем варианты fstream и FILE* в вопросе.

Edit:

Казалось бы, на моей машине, прямо сейчас, если вы добавите fclose(file) после записи, для моей системы fstream и FILE* - примерно столько же времени для моей системы, примерно за 13 секунд написать 1 ГБ - с дисковыми накопителями старого стиля, а не с SSD.

Я могу быстрее писать MUCH с помощью этого кода:

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/uio.h>
#include <unistd.h>
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <chrono>

void measure(const std::string& test, std::function<void()> function)
{
    auto start_time = std::chrono::high_resolution_clock::now();

    function();

    auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now() - start_time);
    std::cout<<test<<" "<<static_cast<double>(duration.count()) * 0.000001<<" ms"<<std::endl;
}

#define BUFFER_SIZE (1024 * 1024 * 1024)


int main()
{
    auto buffer = new char[BUFFER_SIZE];
    memset(buffer, 0, BUFFER_SIZE);

    measure("writev", [buffer]()
    {
        int fd = open("test", O_CREAT|O_WRONLY, 0660);
        struct iovec vec[] = 
        {
            { NULL, 0 },
            { (void *)buffer, BUFFER_SIZE }
        };
        writev(fd, vec, sizeof(vec)/sizeof(vec[0]));
        close(fd);
    });

    measure("write", [buffer]()
    {
        int fd = open("test", O_CREAT|O_WRONLY, 0660);
        write(fd, buffer, BUFFER_SIZE);
        close(fd);
    });
}

дает время около 650-900 мс.

Я также могу отредактировать исходную программу, чтобы дать время около 1000 мс для fwrite - просто удалите fclose.

Я также добавил этот метод:

measure("fstream write (new)", [buffer]()
{
    std::ofstream* stream = new std::ofstream("test", std::ios::binary);
    stream->write(buffer, BUFFER_SIZE);
    // Intentionally no delete.
});

а затем здесь требуется около 1000 мс.

Итак, мой вывод состоит в том, что, как-то иногда, закрытие файла делает его flush на диск. В других случаях это не так. Я до сих пор не понимаю, почему...

Ответ 2

Поток каким-то образом разбит на MAC, старая реализация или настройка.

Старая настройка может привести к тому, что ФАЙЛ будет записан в каталоге exe и потоке в каталоге пользователя, это не должно иметь никакого значения, если вы не получили 2 диска или другие разные настройки.

На моей паршивой Vista я получаю Обычный буфер + Uncached:
С++ 201103
ФАЙЛ * написать 4756 мс
FILE * прочитано 5007 мс
fstream написать 5526 мс
fstream читать 5728 мс

Обычный буфер + Кэширование:
С++ 201103
FILE * написать 4747 мс
FILE * читать 454 мс
fstream написать письмо 5490 мс
fstream читать 396 мс

Большой буфер + кеширование:
С++ 201103
5-й запуск:
FILE * write 4760 ms
ФАЙЛ * читать 446 мс
fstream написать письмо 5278 мс
fstream читать 369 мс

Это показывает, что запись FILE быстрее, чем fstream, но медленнее в чтении, чем fstream... но все числа находятся в пределах ~ 10% друг от друга.

Попробуйте добавить еще несколько буферов в поток, чтобы узнать, помогает ли это.

const int MySize = 1024*1024;
char MrBuf[MySize];
stream.rdbuf()->pubsetbuf(MrBuf, MySize);

Эквивалент для FILE -

const int MySize = 1024*1024;
if (!setvbuf ( file , NULL , _IOFBF , MySize )) 
    DieInDisgrace();

Ответ 3

В отличие от других ответов большая проблема с большими файловыми чтениями возникает из-за буферизации со стандартной библиотекой C. Попробуйте использовать низкоуровневые вызовы read/write в больших кусках (1024 КБ) и увидеть скачок производительности.

Буферизация файлов с помощью библиотеки C полезна для чтения или записи небольших фрагментов данных (меньше размера блока диска).

В Windows я получил почти 3-кратное повышение производительности при буферизации файлов при чтении и записи необработанных видеопотоков.

Я также открыл файл, используя собственные вызовы API (win32) API, и сказал ОС не кэшировать файл, так как это включает в себя еще одну копию.

Ответ 4

TL; DR: Попробуйте добавить это в свой код перед записью:

const size_t bufsize = 256*1024;
char buf[bufsize];
mystream.rdbuf()->pubsetbuf(buf, bufsize);

При работе с большими файлами с fstream убедитесь, что использует буфер потока.

В отличие от этого, отключение буферизации потоков значительно снижает производительность. По крайней мере, реализация MSVC копирует 1 char за раз до filebuf, когда буфер не был установлен (см. streambuf::xsputn()), что может сделать ваше приложение привязанным к процессору, что приведет к снижению скорости ввода-вывода.

NB: вы можете найти полное примерное приложение здесь.