ਪਸੀਨਾ ਵਹਾਏ ਬਿਨਾਂ C/C++ ਫਾਈਲ I/O ਨੂੰ ਤੇਜ਼ ਕਰੋ

ਮੁਖਬੰਧ

ਦੁਨੀਆ ਵਿੱਚ ਇੱਕ ਅਜਿਹੀ ਸਧਾਰਨ ਅਤੇ ਬਹੁਤ ਉਪਯੋਗੀ ਉਪਯੋਗਤਾ ਹੈ - ਬੀਡੈਲਟਾ, ਅਤੇ ਇਹ ਇਸ ਤਰ੍ਹਾਂ ਹੋਇਆ ਕਿ ਇਹ ਬਹੁਤ ਲੰਬੇ ਸਮੇਂ ਤੋਂ ਸਾਡੀ ਉਤਪਾਦਨ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਸ਼ਾਮਲ ਸੀ (ਹਾਲਾਂਕਿ ਇਸਦਾ ਸੰਸਕਰਣ ਸਥਾਪਤ ਕਰਨਾ ਸੰਭਵ ਨਹੀਂ ਸੀ, ਪਰ ਇਹ ਯਕੀਨੀ ਤੌਰ 'ਤੇ ਆਖਰੀ ਉਪਲਬਧ ਨਹੀਂ ਸੀ)। ਅਸੀਂ ਇਸਨੂੰ ਇਸਦੇ ਉਦੇਸ਼ ਉਦੇਸ਼ ਲਈ ਵਰਤਦੇ ਹਾਂ - ਬਾਈਨਰੀ ਪੈਚ ਬਣਾਉਣਾ। ਜੇ ਤੁਸੀਂ ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਕੀ ਹੈ ਉਸ ਨੂੰ ਦੇਖਦੇ ਹੋ, ਤਾਂ ਇਹ ਥੋੜਾ ਉਦਾਸ ਹੋ ਜਾਂਦਾ ਹੈ: ਅਸਲ ਵਿੱਚ, ਇਸਨੂੰ ਬਹੁਤ ਸਮਾਂ ਪਹਿਲਾਂ ਛੱਡ ਦਿੱਤਾ ਗਿਆ ਸੀ ਅਤੇ ਇਸਦਾ ਬਹੁਤ ਸਾਰਾ ਹਿੱਸਾ ਬਹੁਤ ਪੁਰਾਣਾ ਹੈ (ਮੇਰੇ ਸਾਬਕਾ ਸਹਿਯੋਗੀ ਨੇ ਇੱਕ ਵਾਰ ਉੱਥੇ ਕਈ ਸੰਪਾਦਨ ਕੀਤੇ ਸਨ, ਪਰ ਇਹ ਬਹੁਤ ਸਮਾਂ ਪਹਿਲਾਂ ਸੀ) . ਆਮ ਤੌਰ 'ਤੇ, ਮੈਂ ਇਸ ਮਾਮਲੇ ਨੂੰ ਮੁੜ ਜ਼ਿੰਦਾ ਕਰਨ ਦਾ ਫੈਸਲਾ ਕੀਤਾ: ਮੈਂ ਫੋਰਕ ਕੀਤਾ, ਉਹ ਚੀਜ਼ ਬਾਹਰ ਸੁੱਟ ਦਿੱਤੀ ਜੋ ਮੈਂ ਵਰਤਣ ਦੀ ਯੋਜਨਾ ਨਹੀਂ ਸੀ, ਪ੍ਰੋਜੈਕਟ ਨੂੰ cmake, ਇਨਲਾਈਨਡ "ਹੌਟ" ਮਾਈਕ੍ਰੋਫੰਕਸ਼ਨ, ਸਟੈਕ ਤੋਂ ਵੱਡੇ ਐਰੇ ਹਟਾਏ (ਅਤੇ ਵੇਰੀਏਬਲ ਲੰਬਾਈ ਦੇ ਐਰੇ, ਜੋ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ ਮੈਨੂੰ "ਬੰਬ" ਬਣਾਉਂਦੇ ਹਨ), ਪ੍ਰੋਫਾਈਲਰ ਨੂੰ ਇੱਕ ਵਾਰ ਫਿਰ ਚਲਾਇਆ - ਅਤੇ ਪਤਾ ਲੱਗਾ ਕਿ ਲਗਭਗ 40% ਸਮਾਂ ਇਸ 'ਤੇ ਖਰਚ ਕੀਤਾ ਗਿਆ ਹੈ ਲਿਖੋ...

ਤਾਂ fwrite ਨਾਲ ਕੀ ਹੋ ਰਿਹਾ ਹੈ?

ਇਸ ਕੋਡ ਵਿੱਚ, fwrite (ਮੇਰੇ ਖਾਸ ਟੈਸਟ ਕੇਸ ਵਿੱਚ: ਕਰੀਬ 300 MB ਫਾਈਲਾਂ ਦੇ ਵਿਚਕਾਰ ਇੱਕ ਪੈਚ ਬਣਾਉਣਾ, ਇਨਪੁਟ ਡੇਟਾ ਪੂਰੀ ਤਰ੍ਹਾਂ ਮੈਮੋਰੀ ਵਿੱਚ ਹੈ) ਨੂੰ ਇੱਕ ਛੋਟੇ ਬਫਰ ਆਕਾਰ ਨਾਲ ਲੱਖਾਂ ਵਾਰ ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ, ਇਹ ਚੀਜ਼ ਹੌਲੀ ਹੋ ਜਾਵੇਗੀ, ਅਤੇ ਇਸ ਲਈ ਮੈਂ ਕਿਸੇ ਤਰ੍ਹਾਂ ਇਸ ਬੇਇੱਜ਼ਤੀ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰਨਾ ਚਾਹਾਂਗਾ. ਕਈ ਤਰ੍ਹਾਂ ਦੇ ਡੇਟਾ ਸਰੋਤਾਂ, ਅਸਿੰਕਰੋਨਸ ਇਨਪੁਟ-ਆਉਟਪੁੱਟ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦੀ ਅਜੇ ਤੱਕ ਕੋਈ ਇੱਛਾ ਨਹੀਂ ਹੈ, ਮੈਂ ਇੱਕ ਸਰਲ ਹੱਲ ਲੱਭਣਾ ਚਾਹੁੰਦਾ ਸੀ. ਪਹਿਲੀ ਗੱਲ ਜੋ ਮਨ ਵਿੱਚ ਆਈ ਉਹ ਸੀ ਬਫਰ ਦਾ ਆਕਾਰ ਵਧਾਉਣਾ

setvbuf(file, nullptr, _IOFBF, 64* 1024)

ਪਰ ਮੈਨੂੰ ਨਤੀਜੇ ਵਿੱਚ ਕੋਈ ਮਹੱਤਵਪੂਰਨ ਸੁਧਾਰ ਨਹੀਂ ਮਿਲਿਆ (ਹੁਣ fwrite ਸਮੇਂ ਦੇ ਲਗਭਗ 37% ਲਈ ਖਾਤਾ ਹੈ) - ਜਿਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਇਹ ਅਜੇ ਵੀ ਡਿਸਕ 'ਤੇ ਅਕਸਰ ਡੇਟਾ ਲਿਖਣ ਦੀ ਗੱਲ ਨਹੀਂ ਹੈ। fwrite ਦੇ "ਹੁੱਡ ਦੇ ਹੇਠਾਂ" ਦੇਖਦੇ ਹੋਏ, ਤੁਸੀਂ ਦੇਖ ਸਕਦੇ ਹੋ ਕਿ ਇੱਕ ਲਾਕ/ਅਨਲਾਕ FILE ਢਾਂਚਾ ਕੁਝ ਇਸ ਤਰ੍ਹਾਂ ਦੇ ਅੰਦਰ ਹੋ ਰਿਹਾ ਹੈ (ਸੂਡੋ-ਕੋਡ, ਸਾਰਾ ਵਿਸ਼ਲੇਸ਼ਣ ਵਿਜ਼ੂਅਲ ਸਟੂਡੀਓ 2017 ਦੇ ਅਧੀਨ ਕੀਤਾ ਗਿਆ ਸੀ):

size_t fwrite (const void *buffer, size_t size, size_t count, FILE *stream)
{
   size_t retval = 0;
   _lock_str(stream);   /* lock stream */
   __try
   {
      retval = _fwrite_nolock(buffer, size, count, stream);
   }
   __finally 
   {
       _unlock_str(stream);   /* unlock stream */
   }
   return retval;
}

ਪ੍ਰੋਫਾਈਲਰ ਦੇ ਅਨੁਸਾਰ, _fwrite_nolock ਸਿਰਫ 6% ਸਮੇਂ ਲਈ ਖਾਤਾ ਹੈ, ਬਾਕੀ ਓਵਰਹੈੱਡ ਹੈ। ਮੇਰੇ ਖਾਸ ਕੇਸ ਵਿੱਚ, ਥਰਿੱਡ ਸੁਰੱਖਿਆ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ ਓਵਰਕਿਲ ਹੈ, ਇਸ ਲਈ ਮੈਂ fwrite ਕਾਲ ਨੂੰ ਇਸ ਨਾਲ ਬਦਲ ਕੇ ਕੁਰਬਾਨ ਕਰਾਂਗਾ _fwrite_nolock - ਤੁਹਾਨੂੰ ਦਲੀਲਾਂ ਨਾਲ ਹੁਸ਼ਿਆਰ ਹੋਣ ਦੀ ਵੀ ਲੋੜ ਨਹੀਂ ਹੈ। ਕੁੱਲ: ਇਸ ਸਧਾਰਣ ਹੇਰਾਫੇਰੀ ਨੇ ਨਤੀਜਾ ਰਿਕਾਰਡ ਕਰਨ ਦੀ ਲਾਗਤ ਨੂੰ ਮਹੱਤਵਪੂਰਣ ਰੂਪ ਵਿੱਚ ਘਟਾ ਦਿੱਤਾ, ਜੋ ਕਿ ਅਸਲ ਸੰਸਕਰਣ ਵਿੱਚ ਖਰਚੇ ਗਏ ਸਮੇਂ ਦੇ ਲਗਭਗ ਅੱਧੇ ਦੇ ਬਰਾਬਰ ਸੀ। ਤਰੀਕੇ ਨਾਲ, ਪੋਸਿਕਸ ਸੰਸਾਰ ਵਿੱਚ ਇੱਕ ਸਮਾਨ ਫੰਕਸ਼ਨ ਹੈ - fwrite_unlocked. ਆਮ ਤੌਰ 'ਤੇ, ਇਹੀ ਫਰੈੱਡ 'ਤੇ ਲਾਗੂ ਹੁੰਦਾ ਹੈ. ਇਸ ਤਰ੍ਹਾਂ, # ਪਰਿਭਾਸ਼ਾਵਾਂ ਦੀ ਇੱਕ ਜੋੜੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਤੁਸੀਂ ਬੇਲੋੜੇ ਤਾਲੇ ਦੇ ਬਿਨਾਂ ਇੱਕ ਪੂਰੀ ਤਰ੍ਹਾਂ ਕਰਾਸ-ਪਲੇਟਫਾਰਮ ਹੱਲ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹੋ ਜੇਕਰ ਉਹ ਜ਼ਰੂਰੀ ਨਹੀਂ ਹਨ (ਅਤੇ ਅਜਿਹਾ ਅਕਸਰ ਹੁੰਦਾ ਹੈ)।

fwrite, _fwrite_nolock, setvbuf

ਆਓ ਮੂਲ ਪ੍ਰੋਜੈਕਟ ਤੋਂ ਦੂਰ ਚਲੇ ਜਾਈਏ ਅਤੇ ਇੱਕ ਖਾਸ ਕੇਸ ਦੀ ਜਾਂਚ ਕਰਨ 'ਤੇ ਧਿਆਨ ਕੇਂਦਰਿਤ ਕਰੀਏ: ਇੱਕ ਵੱਡੀ ਫਾਈਲ (512 MB) ਨੂੰ ਬਹੁਤ ਛੋਟੇ ਹਿੱਸਿਆਂ ਵਿੱਚ ਲਿਖਣਾ—ਹਰੇਕ ਵਿੱਚ ਇੱਕ ਬਾਈਟ। ਟੈਸਟ ਸਿਸਟਮ: AMD Ryzen 7 1700, 16 GB RAM, 7200 rpm HDD, 64 MB ਕੈਸ਼। Windows 10 1809 ਵਿੱਚ, ਬਾਈਨਰੀ ਨੂੰ 32-ਬਿੱਟ ਦੇ ਰੂਪ ਵਿੱਚ ਬਣਾਇਆ ਗਿਆ ਸੀ, ਅਨੁਕੂਲਤਾ ਸਮਰੱਥ ਹੈ, ਲਾਇਬ੍ਰੇਰੀ ਸਥਿਰ ਤੌਰ 'ਤੇ ਲਿੰਕ ਕੀਤੀ ਗਈ ਹੈ।

ਪ੍ਰਯੋਗ ਲਈ ਨਮੂਨਾ:

#include <chrono>
#include <cstdio>
#include <inttypes.h>
#include <memory>

#ifdef _MSC_VER
#define fwrite_unlocked _fwrite_nolock
#endif

using namespace std::chrono;

int main()
{
    std::unique_ptr<FILE, int(*)(FILE*)> file(fopen("test.bin", "wb"), fclose);
    if (!file)
        return 1;

    constexpr size_t TEST_BUFFER_SIZE = 256 * 1024;
    if (setvbuf(file.get(), nullptr, _IOFBF, TEST_BUFFER_SIZE) != 0)
        return 2;

    auto start = steady_clock::now();
    const uint8_t b = 77;
    constexpr size_t TEST_FILE_SIZE = 512 * 1024 * 1024;
    for (size_t i = 0; i < TEST_FILE_SIZE; ++i)
        fwrite_unlocked(&b, 1, sizeof(b), file.get());

    auto end = steady_clock::now();
    auto interval = duration_cast<microseconds>(end - start);
    printf("Time: %lldn", interval.count());

    return 0;
}

ਵੇਰੀਏਬਲ TEST_BUFFER_SIZE ਹੋਣਗੇ, ਅਤੇ ਕੁਝ ਮਾਮਲਿਆਂ ਲਈ ਅਸੀਂ fwrite_unlocked ਨੂੰ fwrite ਨਾਲ ਬਦਲ ਦੇਵਾਂਗੇ। ਆਉ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਬਫਰ ਸਾਈਜ਼ ਨੂੰ ਸੈੱਟ ਕੀਤੇ ਬਿਨਾਂ fwrite ਕੇਸ ਨਾਲ ਸ਼ੁਰੂ ਕਰੀਏ (setvbuf ਅਤੇ ਸੰਬੰਧਿਤ ਕੋਡ ਨੂੰ ਟਿੱਪਣੀ ਕਰੋ): ਸਮਾਂ 27048906 µs, ਲਿਖਣ ਦੀ ਗਤੀ - 18.93 MB/s। ਹੁਣ ਬਫਰ ਦਾ ਆਕਾਰ 64 KB 'ਤੇ ਸੈੱਟ ਕਰੀਏ: ਸਮਾਂ - 25037111 μs, ਸਪੀਡ - 20.44 Mb/s। ਆਉ ਹੁਣ setvbuf ਨੂੰ ਕਾਲ ਕੀਤੇ ਬਿਨਾਂ _fwrite_nolock ਦੇ ਸੰਚਾਲਨ ਦੀ ਜਾਂਚ ਕਰੀਏ: 7262221 µs, ਸਪੀਡ - 70.5 Mb/s!

ਅੱਗੇ, ਆਓ ਬਫਰ ਆਕਾਰ (setvbuf) ਨਾਲ ਪ੍ਰਯੋਗ ਕਰੀਏ:

ਡਾਟਾ ਔਸਤਨ 5 ਪ੍ਰਯੋਗਾਂ ਦੁਆਰਾ ਪ੍ਰਾਪਤ ਕੀਤਾ ਗਿਆ ਸੀ; ਮੈਂ ਗਲਤੀਆਂ ਦੀ ਗਣਨਾ ਕਰਨ ਲਈ ਬਹੁਤ ਆਲਸੀ ਸੀ। ਮੇਰੇ ਲਈ, 93 MB/s ਜਦੋਂ ਇੱਕ ਨਿਯਮਤ HDD ਵਿੱਚ 1 ਬਾਈਟ ਲਿਖਣਾ ਇੱਕ ਬਹੁਤ ਵਧੀਆ ਨਤੀਜਾ ਹੈ, ਤੁਹਾਨੂੰ ਸਿਰਫ਼ ਅਨੁਕੂਲ ਬਫ਼ਰ ਆਕਾਰ (ਮੇਰੇ ਕੇਸ ਵਿੱਚ, 256 KB ਬਿਲਕੁਲ ਸਹੀ ਹੈ) ਦੀ ਚੋਣ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਅਤੇ fwrite ਨੂੰ _fwrite_nolock/fwrite_unlocked ਨਾਲ ਬਦਲੋ ( ਜੇ ਧਾਗੇ ਦੀ ਸੁਰੱਖਿਆ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ, ਬੇਸ਼ਕ).
ਇਸੇ ਤਰ੍ਹਾਂ ਦੀਆਂ ਸਥਿਤੀਆਂ ਵਿੱਚ ਫਰੈੱਡ ਦੇ ਨਾਲ. ਕਿਉਂਕਿ ਮੇਰੇ ਕੋਲ ਲੀਨਕਸ ਵਾਲੀ ਹਾਰਡਵੇਅਰ ਮਸ਼ੀਨ ਨਹੀਂ ਹੈ (ਸਿੰਗਲ-ਬੋਰਡ ਕੰਪਿਊਟਰਾਂ ਦੀ ਗਿਣਤੀ ਨਹੀਂ ਹੈ), ਮੈਂ ਇੱਕ ਵਰਚੁਅਲ ਮਸ਼ੀਨ (ਹਾਈਪਰ-ਵੀ, ਓਪਨਸੂਸੇ 15, ਜੀਸੀਸੀ 8.3.1) 'ਤੇ ਇੱਕ ਸੀਮਤ ਪ੍ਰਯੋਗ ਕਰਨ ਦਾ ਫੈਸਲਾ ਕੀਤਾ ਹੈ - ਪੈਟਰਨ, ਸਿਧਾਂਤ ਵਿੱਚ, ਉਹੀ ਹੈ: “ਨੰਗੇ” fwrite 20 Mb/s, fwrite + 256 KB ਬਫਰ ਨੇ 23 Mb/s, fwrite_unlocked ਉਸੇ ਬਫਰ ਨਾਲ - 35 Mb/s (64-ਬਿੱਟ ਬਾਈਨਰੀ, ਅਸੈਂਬਲਡ g++ -o2 - s -static-libgcc -static-libstdc++ fwrite_test. cpp -o fwrite_test)।

ਬਾਅਦ

ਇਸ ਲੇਖ ਨੂੰ ਲਿਖਣ ਦਾ ਉਦੇਸ਼ ਬਹੁਤ ਸਾਰੇ ਮਾਮਲਿਆਂ ਵਿੱਚ ਇੱਕ ਸਧਾਰਨ ਅਤੇ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਤਕਨੀਕ ਦਾ ਵਰਣਨ ਕਰਨਾ ਸੀ (ਮੈਂ ਪਹਿਲਾਂ ਕਦੇ ਵੀ _fwrite_nolock/fwrite_unlocked ਫੰਕਸ਼ਨਾਂ ਵਿੱਚ ਨਹੀਂ ਆਇਆ, ਉਹ ਬਹੁਤ ਮਸ਼ਹੂਰ ਨਹੀਂ ਹਨ - ਪਰ ਵਿਅਰਥ)। ਮੈਂ ਇਹ ਦਿਖਾਵਾ ਨਹੀਂ ਕਰਦਾ ਕਿ ਸਮੱਗਰੀ ਨਵੀਂ ਹੈ, ਪਰ ਮੈਨੂੰ ਉਮੀਦ ਹੈ ਕਿ ਲੇਖ ਭਾਈਚਾਰੇ ਲਈ ਲਾਭਦਾਇਕ ਹੋਵੇਗਾ।

ਸਰੋਤ: www.habr.com