web-dev-qa-db-ja.com

std :: vectorからテキストファイルにデータを書き込む高速な方法

現在、ベクターから次のようなテキストファイルに一連のdoubleを書き込みます。

std::ofstream fout;
fout.open("vector.txt");

for (l = 0; l < vector.size(); l++)
    fout << std::setprecision(10) << vector.at(l) << std::endl;

fout.close();

しかし、これを完了するには多くの時間がかかります。これを行うためのより高速またはより効率的な方法はありますか？私はそれを見て、学びたいです。

c++stdofstream
54
Diego Fernando Pava

アルゴリズムには2つの部分があります。

  1. 二重数値を文字列または文字バッファーにシリアル化します。

  2. 結果をファイルに書き込みます。

最初の項目は、sprintfまたは fmt を使用して改善（> 20％）できます。 2番目の項目は、結果をバッファーにキャッシュするか、出力ファイルに結果を書き込む前に出力ファイルストリームのバッファーサイズを拡張することで高速化できます。 "\ n"を使用するよりもはるかに遅い なので、std :: endlを使用しないでください。それでも高速にしたい場合は、バイナリ形式でデータを書き込みます。以下は、提案されたソリューションとEdgar Rokyanからのソリューションを含む、完全なコードサンプルです。また、テストコードにBen VoigtとMatthieu Mの提案を含めました。

#include <algorithm>
#include <cstdlib>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <vector>

// https://github.com/fmtlib/fmt
#include "fmt/format.h"

// http://uscilab.github.io/cereal/
#include "cereal/archives/binary.hpp"
#include "cereal/archives/json.hpp"
#include "cereal/archives/portable_binary.hpp"
#include "cereal/archives/xml.hpp"
#include "cereal/types/string.hpp"
#include "cereal/types/vector.hpp"

// https://github.com/DigitalInBlue/Celero
#include "celero/Celero.h"

template <typename T> const char* getFormattedString();
template<> const char* getFormattedString<double>(){return "%g\n";}
template<> const char* getFormattedString<float>(){return "%g\n";}
template<> const char* getFormattedString<int>(){return "%d\n";}
template<> const char* getFormattedString<size_t>(){return "%lu\n";}


namespace {
    constexpr size_t LEN = 32;

    template <typename T> std::vector<T> create_test_data(const size_t N) {
        std::vector<T> data(N);
        for (size_t idx = 0; idx < N; ++idx) {
            data[idx] = idx;
        }
        return data;
    }

    template <typename Iterator> auto toVectorOfChar(Iterator begin, Iterator end) {
        char aLine[LEN];
        std::vector<char> buffer;
        buffer.reserve(std::distance(begin, end) * LEN);
        const char* fmtStr = getFormattedString<typename std::iterator_traits<Iterator>::value_type>();
        std::for_each(begin, end, [&buffer, &aLine, &fmtStr](const auto value) {
            sprintf(aLine, fmtStr, value);
            for (size_t idx = 0; aLine[idx] != 0; ++idx) {
                buffer.Push_back(aLine[idx]);
            }
        });
        return buffer;
    }

    template <typename Iterator>
    auto toStringStream(Iterator begin, Iterator end, std::stringstream &buffer) {
        char aLine[LEN];
        const char* fmtStr = getFormattedString<typename std::iterator_traits<Iterator>::value_type>();
        std::for_each(begin, end, [&buffer, &aLine, &fmtStr](const auto value) {            
            sprintf(aLine, fmtStr, value);
            buffer << aLine;
        });
    }

    template <typename Iterator> auto toMemoryWriter(Iterator begin, Iterator end) {
        fmt::MemoryWriter writer;
        std::for_each(begin, end, [&writer](const auto value) { writer << value << "\n"; });
        return writer;
    }

    // A modified version of the original approach.
    template <typename Container>
    void original_approach(const Container &data, const std::string &fileName) {
        std::ofstream fout(fileName);
        for (size_t l = 0; l < data.size(); l++) {
            fout << data[l] << std::endl;
        }
        fout.close();
    }

    // Replace std::endl by "\n"
    template <typename Iterator>
    void improved_original_approach(Iterator begin, Iterator end, const std::string &fileName) {
        std::ofstream fout(fileName);
        const size_t len = std::distance(begin, end) * LEN;
        std::vector<char> buffer(len);
        fout.rdbuf()->pubsetbuf(buffer.data(), len);
        for (Iterator it = begin; it != end; ++it) {
            fout << *it << "\n";
        }
        fout.close();
    }

    //
    template <typename Iterator>
    void edgar_rokyan_solution(Iterator begin, Iterator end, const std::string &fileName) {
        std::ofstream fout(fileName);
        std::copy(begin, end, std::ostream_iterator<double>(fout, "\n"));
    }

    // Cache to a string stream before writing to the output file
    template <typename Iterator>
    void stringstream_approach(Iterator begin, Iterator end, const std::string &fileName) {
        std::stringstream buffer;
        for (Iterator it = begin; it != end; ++it) {
            buffer << *it << "\n";
        }

        // Now write to the output file.
        std::ofstream fout(fileName);
        fout << buffer.str();
        fout.close();
    }

    // Use sprintf
    template <typename Iterator>
    void sprintf_approach(Iterator begin, Iterator end, const std::string &fileName) {
        std::stringstream buffer;
        toStringStream(begin, end, buffer);
        std::ofstream fout(fileName);
        fout << buffer.str();
        fout.close();
    }

    // Use fmt::MemoryWriter (https://github.com/fmtlib/fmt)
    template <typename Iterator>
    void fmt_approach(Iterator begin, Iterator end, const std::string &fileName) {
        auto writer = toMemoryWriter(begin, end);
        std::ofstream fout(fileName);
        fout << writer.str();
        fout.close();
    }

    // Use std::vector<char>
    template <typename Iterator>
    void vector_of_char_approach(Iterator begin, Iterator end, const std::string &fileName) {
        std::vector<char> buffer = toVectorOfChar(begin, end);
        std::ofstream fout(fileName);
        fout << buffer.data();
        fout.close();
    }

    // Use cereal (http://uscilab.github.io/cereal/).
    template <typename Container, typename OArchive = cereal::BinaryOutputArchive>
    void use_cereal(Container &&data, const std::string &fileName) {
        std::stringstream buffer;
        {
            OArchive oar(buffer);
            oar(data);
        }

        std::ofstream fout(fileName);
        fout << buffer.str();
        fout.close();
    }
}

// Performance test input data.
constexpr int NumberOfSamples = 5;
constexpr int NumberOfIterations = 2;
constexpr int N = 3000000;
const auto double_data = create_test_data<double>(N);
const auto float_data = create_test_data<float>(N);
const auto int_data = create_test_data<int>(N);
const auto size_t_data = create_test_data<size_t>(N);

CELERO_MAIN

BASELINE(DoubleVector, original_approach, NumberOfSamples, NumberOfIterations) {
    const std::string fileName("origsol.txt");
    original_approach(double_data, fileName);
}

BENCHMARK(DoubleVector, improved_original_approach, NumberOfSamples, NumberOfIterations) {
    const std::string fileName("improvedsol.txt");
    improved_original_approach(double_data.cbegin(), double_data.cend(), fileName);
}

BENCHMARK(DoubleVector, edgar_rokyan_solution, NumberOfSamples, NumberOfIterations) {
    const std::string fileName("edgar_rokyan_solution.txt");
    edgar_rokyan_solution(double_data.cbegin(), double_data.end(), fileName);
}

BENCHMARK(DoubleVector, stringstream_approach, NumberOfSamples, NumberOfIterations) {
    const std::string fileName("stringstream.txt");
    stringstream_approach(double_data.cbegin(), double_data.cend(), fileName);
}

BENCHMARK(DoubleVector, sprintf_approach, NumberOfSamples, NumberOfIterations) {
    const std::string fileName("sprintf.txt");
    sprintf_approach(double_data.cbegin(), double_data.cend(), fileName);
}

BENCHMARK(DoubleVector, fmt_approach, NumberOfSamples, NumberOfIterations) {
    const std::string fileName("fmt.txt");
    fmt_approach(double_data.cbegin(), double_data.cend(), fileName);
}

BENCHMARK(DoubleVector, vector_of_char_approach, NumberOfSamples, NumberOfIterations) {
    const std::string fileName("vector_of_char.txt");
    vector_of_char_approach(double_data.cbegin(), double_data.cend(), fileName);
}

BENCHMARK(DoubleVector, use_cereal, NumberOfSamples, NumberOfIterations) {
    const std::string fileName("cereal.bin");
    use_cereal(double_data, fileName);
}

// Benchmark double vector
BASELINE(DoubleVectorConversion, toStringStream, NumberOfSamples, NumberOfIterations) {
    std::stringstream output;
    toStringStream(double_data.cbegin(), double_data.cend(), output);
}

BENCHMARK(DoubleVectorConversion, toMemoryWriter, NumberOfSamples, NumberOfIterations) {
    celero::DoNotOptimizeAway(toMemoryWriter(double_data.cbegin(), double_data.cend()));
}

BENCHMARK(DoubleVectorConversion, toVectorOfChar, NumberOfSamples, NumberOfIterations) {
    celero::DoNotOptimizeAway(toVectorOfChar(double_data.cbegin(), double_data.cend()));
}

// Benchmark float vector
BASELINE(FloatVectorConversion, toStringStream, NumberOfSamples, NumberOfIterations) {
    std::stringstream output;
    toStringStream(float_data.cbegin(), float_data.cend(), output);
}

BENCHMARK(FloatVectorConversion, toMemoryWriter, NumberOfSamples, NumberOfIterations) {
    celero::DoNotOptimizeAway(toMemoryWriter(float_data.cbegin(), float_data.cend()));
}

BENCHMARK(FloatVectorConversion, toVectorOfChar, NumberOfSamples, NumberOfIterations) {
    celero::DoNotOptimizeAway(toVectorOfChar(float_data.cbegin(), float_data.cend()));
}

// Benchmark int vector
BASELINE(int_conversion, toStringStream, NumberOfSamples, NumberOfIterations) {
    std::stringstream output;
    toStringStream(int_data.cbegin(), int_data.cend(), output);
}

BENCHMARK(int_conversion, toMemoryWriter, NumberOfSamples, NumberOfIterations) {
    celero::DoNotOptimizeAway(toMemoryWriter(int_data.cbegin(), int_data.cend()));
}

BENCHMARK(int_conversion, toVectorOfChar, NumberOfSamples, NumberOfIterations) {
    celero::DoNotOptimizeAway(toVectorOfChar(int_data.cbegin(), int_data.cend()));
}

// Benchmark size_t vector
BASELINE(size_t_conversion, toStringStream, NumberOfSamples, NumberOfIterations) {
    std::stringstream output;
    toStringStream(size_t_data.cbegin(), size_t_data.cend(), output);
}

BENCHMARK(size_t_conversion, toMemoryWriter, NumberOfSamples, NumberOfIterations) {
    celero::DoNotOptimizeAway(toMemoryWriter(size_t_data.cbegin(), size_t_data.cend()));
}

BENCHMARK(size_t_conversion, toVectorOfChar, NumberOfSamples, NumberOfIterations) {
    celero::DoNotOptimizeAway(toVectorOfChar(size_t_data.cbegin(), size_t_data.cend()));
}

以下は、clang-3.9.1および-O3フラグを使用してLinuxボックスで得られたパフォーマンス結果です。 Celero を使用して、すべてのパフォーマンス結果を収集します。

Timer resolution: 0.001000 us
-----------------------------------------------------------------------------------------------------------------------------------------------
     Group      |   Experiment    |   Prob. Space   |     Samples     |   Iterations    |    Baseline     |  us/Iteration   | Iterations/sec  | 
-----------------------------------------------------------------------------------------------------------------------------------------------
DoubleVector    | original_approa | Null            |              10 |               4 |         1.00000 |   3650309.00000 |            0.27 | 
DoubleVector    | improved_Origin | Null            |              10 |               4 |         0.47828 |   1745855.00000 |            0.57 | 
DoubleVector    | edgar_rokyan_so | Null            |              10 |               4 |         0.45804 |   1672005.00000 |            0.60 | 
DoubleVector    | stringstream_ap | Null            |              10 |               4 |         0.41514 |   1515377.00000 |            0.66 | 
DoubleVector    | sprintf_approac | Null            |              10 |               4 |         0.35436 |   1293521.50000 |            0.77 | 
DoubleVector    | fmt_approach    | Null            |              10 |               4 |         0.34916 |   1274552.75000 |            0.78 | 
DoubleVector    | vector_of_char_ | Null            |              10 |               4 |         0.34366 |   1254462.00000 |            0.80 | 
DoubleVector    | use_cereal      | Null            |              10 |               4 |         0.04172 |    152291.25000 |            6.57 | 
Complete.

また、数値から文字列への変換アルゴリズムのベンチマークを行い、std :: stringstream、fmt :: MemoryWriter、およびstd :: vectorのパフォーマンスを比較します。

Timer resolution: 0.001000 us
-----------------------------------------------------------------------------------------------------------------------------------------------
     Group      |   Experiment    |   Prob. Space   |     Samples     |   Iterations    |    Baseline     |  us/Iteration   | Iterations/sec  | 
-----------------------------------------------------------------------------------------------------------------------------------------------
DoubleVectorCon | toStringStream  | Null            |              10 |               4 |         1.00000 |   1272667.00000 |            0.79 | 
FloatVectorConv | toStringStream  | Null            |              10 |               4 |         1.00000 |   1272573.75000 |            0.79 | 
int_conversion  | toStringStream  | Null            |              10 |               4 |         1.00000 |    248709.00000 |            4.02 | 
size_t_conversi | toStringStream  | Null            |              10 |               4 |         1.00000 |    252063.00000 |            3.97 | 
DoubleVectorCon | toMemoryWriter  | Null            |              10 |               4 |         0.98468 |   1253165.50000 |            0.80 | 
DoubleVectorCon | toVectorOfChar  | Null            |              10 |               4 |         0.97146 |   1236340.50000 |            0.81 | 
FloatVectorConv | toMemoryWriter  | Null            |              10 |               4 |         0.98419 |   1252454.25000 |            0.80 | 
FloatVectorConv | toVectorOfChar  | Null            |              10 |               4 |         0.97369 |   1239093.25000 |            0.81 | 
int_conversion  | toMemoryWriter  | Null            |              10 |               4 |         0.11741 |     29200.50000 |           34.25 | 
int_conversion  | toVectorOfChar  | Null            |              10 |               4 |         0.87105 |    216637.00000 |            4.62 | 
size_t_conversi | toMemoryWriter  | Null            |              10 |               4 |         0.13746 |     34649.50000 |           28.86 | 
size_t_conversi | toVectorOfChar  | Null            |              10 |               4 |         0.85345 |    215123.00000 |            4.65 | 
Complete.

上記の表から次のことがわかります。

  1. Edgar Rokyanのソリューションは、stringstreamのソリューションよりも10％遅くなります。 fmt ライブラリを使用するソリューションは、double、int、size_tの3つの調査済みデータタイプに最適です。 sprintf + std :: vectorソリューションは、doubleデータ型の fmt ソリューションよりも1％高速です。ただし、生産コードにsprintfを使用するソリューションは、エレガントではなく（まだCスタイルで記述されている）、intやsize_tなどのさまざまなデータ型に対してすぐに動作しないため、お勧めしません。

  2. ベンチマークの結果は、 fmt が他のアプローチよりも少なくとも7倍高速であるため、優れた積分データ型のシリアル化であることも示しています。

  3. バイナリ形式を使用すると、このアルゴリズムを10倍高速化できます。このアプローチは、メモリから出力への生のコピーのみを行うため、フォーマットされたテキストファイルへの書き込みよりもはるかに高速です。より柔軟で移植性のあるソリューションが必要な場合は、 cereal または boost :: serialization または protocol-buffer を試してください。 このパフォーマンス調査 によると、シリアルは最速のようです。

34
hungptit
_std::ofstream fout("vector.txt");
fout << std::setprecision(10);

for(auto const& x : vector)
    fout << x << '\n';
_

私が変更したものはすべて、コードのバージョンで理論的にパフォーマンスが低下していましたが、 _std::endl_が本当のキラーでした 。 _std::vector::at_ （境界チェックでは必要ありません）が2番目になり、イテレーターを使用しなかったという事実になります。

一度に_std::ofstream_をデフォルトで構築してから、openを呼び出すのはなぜですか？ RAII（デストラクタ）が面倒を見るのにcloseを呼び出すのはなぜですか？また呼び出すことができます

_fout << std::setprecision(10)
_

ループの前に一度だけ。

以下のコメントに記載されているように、ベクトルが基本型の要素である場合、for(auto x : vector)を使用するとパフォーマンスが向上する場合があります。実行時間を測定し、アセンブリ出力を検査します。

私の目を引いた別のことを指摘するために、これ：

_for(l = 0; l < vector.size(); l++)
_

このlとは何ですか？ループ外で宣言するのはなぜですか？外側のスコープでは必要ないようですので、必要ありません。また、 ポストインクリメント 。

結果：

_for(size_t l = 0; l < vector.size(); ++l)
_

この投稿からコードをレビューして申し訳ありません。

72
LogicStuff

イテレータとvector関数の助けを借りて、copyの内容をファイルに出力するというかなりきちんとした形式を使用することもできます。

std::ofstream fout("vector.txt");
fout.precision(10);

std::copy(numbers.begin(), numbers.end(),
    std::ostream_iterator<double>(fout, "\n"));

このソリューションは、実行時間の点でLogicStuffのソリューションと実質的に同じです。しかし、単一のcopy関数を使用してコンテンツを印刷する方法も示しています。

21
Edgar Rokjān

魚を与えようとする3つの解決策があるのは残念ですが、釣り方を教えようとする解決策はありません。

パフォーマンスに問題がある場合、解決策はプロファイラーを使用し、プロファイラーが示す問題を修正することです。

ダブルからストリングを300,000倍に変換するには、過去10年間に出荷されたコンピューターで3分かかりません。

ディスクに3 MBのデータを書き込む（平均サイズが300,000倍）ことは、過去10年間に出荷されたコンピューターでは3分かかりません。

これをプロファイルすると、foutが300,000回フラッシュされ、I/Oがブロックまたはセミブロックされる可能性があるため、フラッシュが遅いことがわかります。したがって、ブロッキングI/Oを回避する必要があります。そのための一般的な方法は、すべてのI/Oを単一のバッファーに準備し（文字列ストリームを作成して書き込み）、そのバッファーを物理ファイルに一度に書き込むことです。これは、ハングプティットが説明するソリューションですが、欠落しているのは、そのソリューションが良いソリューションである理由を説明していると思うことを除きます。

または、別の言い方をすれば、プロファイラーは、write（）（Linux）またはWriteFile（）（Windows）の呼び出しは、ユーザーであるため、メモリバッファーに数バイトをコピーするよりもはるかに遅いということです/ kernelレベルの移行。 std :: endlが原因でこれが各doubleで発生する場合、悪い（遅い）時間になります。ユーザー空間にとどまり、データをRAMに置くものに置き換えてください！

それでも十分に高速でない場合は、文字列のoperator <<（）の特定精度バージョンが遅いか、不要なオーバーヘッドが含まれている可能性があります。その場合、sprintf（）またはその他の潜在的に高速な関数を使用してメモリ内バッファーにデータを生成し、最終的にバッファー全体を一度にファイルに書き込むことで、コードをさらに高速化できる場合があります。

11
Jon Watte

プログラムには、テキストの出力と書式設定という2つの主なボトルネックがあります。

パフォーマンスを向上させるには、呼び出しごとのデータ出力量を増やします。たとえば、500文字の1回の出力転送は、1文字の500回の転送よりも高速です。

私の推奨事項は、データを大きなバッファにフォーマットしてから、バッファにブロック書き込みすることです。

以下に例を示します。

char buffer[1024 * 1024];
unsigned int buffer_index = 0;
const unsigned int size = my_vector.size();
for (unsigned int i = 0; i < size; ++i)
{
  signed int characters_formatted = snprintf(&buffer[buffer_index],
                                             (1024 * 1024) - buffer_index,
                                             "%.10f", my_vector[i]);
  if (characters_formatted > 0)
  {
      buffer_index += (unsigned int) characters_formatted;
  }
}
cout.write(&buffer[0], buffer_index);

コードをいじる前に、まずコンパイラの最適化設定を変更してみてください。

5
Thomas Matthews

少し異なる解決策があります：ダブルをバイナリ形式で保存します。

int fd = ::open("/path/to/the/file", O_WRONLY /* whatever permission */);
::write(fd, &vector[0], vector.size() * sizeof(vector[0]));

300kダブル、つまり300k * 8バイト= 2.4Mに等しいと述べたので、それらすべてを0.1秒未満のでローカルディスクファイルに保存できます。この方法の唯一の欠点は、保存されたファイルが文字列表現ほど読みにくいことですが、HexEditorはその問題を解決できます。

より堅牢な方法を希望する場合は、オンラインで利用可能なシリアル化ライブラリ/ツールがたくさんあります。これらは、言語に依存しない、マシンに依存しない、柔軟な圧縮アルゴリズムなど、より多くの利点を提供します。これらは私が通常使用する2つです。

2
Jason L.