Urychlenie súborového vstupu-výstupu C/C++, bez prílišného namáhania

Úvod

Na svete existuje taká jednoduchá a veľmi užitočná utilita — BDelta, a skutočne sa zdá, že sa dávno usadila v našich pracovných procesoch (pravda, nebolo možné nainštalovať jej verziu, ale určite nebola najnovšia dostupná). Používame ju na jej zamýšľaný účel — vytváranie binárnych patchov. Ak sa pozriete, čo tam v repozitári je — trošku z toho smúti, pretože súčasne to dávno bolo opustené a veľa z toho je silne zastarané (kedysi tam niekoľko zmien vložil môj bývalý kolega, ale to bolo už dávno). Takže som sa rozhodol to oživiť: forkoval som, vyhodil to, čo neplánujem používať, a presunul projekt na cmake, inline-oval „horúce“ mikrofunkcie, odstránil veľké poli (a polia variable length, z ktorých mi doslova „vybuchuje“ hlava), znova spustil profiler — a zistil, že asi 40% času sa míňa na fwrite…

Čo teda s fwrite?

V tomto kóde sa fwrite (v mojom konkrétnom testovacom prípade: vytváranie patchu medzi blízkymi 300 MB súbormi, vstupné údaje sú úplne v pamäti) volá milióny krát s malou veľkosťou bufferu. Je zjavné, že táto vec bude spomaľovať, a preto by som chcel nejako ovplyvniť tento problém bez akýchkoľvek zmien v zdrojoch dát alebo asynchrónnom vstupe/výstupu. Prvá vec, ktorá mi napadla — zvýšiť veľkosť bufferu

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

ale žiadne podstatné zlepšenie výsledku som nezískal (teraz na fwrite išlo asi 37% času) — to znamená, že problém nie je v častom zapisovaní údajov na disk. Ak sa pozriete „pod kapotu“ fwrite, môžete vidieť, že vnútri sa vykonáva lock/unlock FILE štruktúry približne takto (pseudo-kód, celý analýza bola vykonaná pod Visual Studio 2017):

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

Ak veríte profileru, na _fwrite_nolock pripadá iba 6% času, zvyšok je overhead. V mojom konkrétnom prípade je thread safety jasným nadbytkem, na ktorom ušetrím tým, že nahradím volanie fwrite na _fwrite_nolock — ani s argumentmi netreba manipulovať. Takže: táto jednoduchá manipulácia razantne znížila náklady na zápis výsledku, ktoré v pôvodnej verzii predstavovali takmer polovicu časových nákladov. Mimochodom, v svete POSIX existuje podobná funkcia — fwrite_unlocked. Vlastne to isté platí aj pre fread. Takže pomocou pár #define môžeme získať celkom prenosné riešenie bez zbytočných blokovaní, ak to nie je potrebné (čo sa stáva pomerne často).

fwrite, _fwrite_nolock, setvbuf

Poďme sa abstrahovať od pôvodného projektu a zaoberajme sa testovaním konkrétneho prípadu: zápis veľkého súboru (512 MB) v extrémne malých dávkach — po 1 byte. Testovací systém: AMD Ryzen 7 1700, 16 GB RAM, HDD 7200 rpm a 64 MB cache, Windows 10 1809, binárny súbor bol zostavený ako 32-bitový, optimalizácie sú zapnuté, knižnica staticky pripojená.

Ukážkový súbor na vykonanie experimentu:

#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;
}

Ako premenné budú slúžiť TEST_BUFFER_SIZE, a pre pár prípadov nahradíme fwrite_unlocked za fwrite. Začneme s prípadom fwrite bez zjavného nastavenia veľkosti vyrovnávacej pamäte (zakomentujeme setvbuf a súvisiaci kód): čas 27048906 μs, rýchlosť zápisu — 18.93 MB/s. Teraz nastavíme veľkosť vyrovnávacej pamäte na 64 KB: čas — 25037111 μs, rýchlosť — 20.44 MB/s. Teraz otestujeme prácu _fwrite_nolock bez vyvolania setvbuf: 7262221 μs, rýchlosť — 70.5 MB/s!

Potom experimentujeme s veľkosťou vyrovnávacej pamäte (setvbuf):

Údaje boli získané priemerovaním 5 experimentov, na chyby som sa vykašlal. Podľa mňa, 93 MB/s pri zápise po 1 byte na bežnom HDD — to je veľmi slušný výsledok, stačí si iba vybrať optimálnu veľkosť vyrovnávacej pamäte (v mojom prípade 256 KB — je presne správna) a nahradiť fwrite za _fwrite_nolock/fwrite_unlocked (v prípade, že nie je potrebná bezpečnosť vlákien, samozrejme).
Rovnako aj s fread za podobných podmienok. Keďže nemám po ruke "hardvérový" stroj s Linuxom (jednosúčkové zariadenia neberieme do úvahy), rozhodol som sa vykonať obmedzený experiment na virtuálke (Hyper-V, OpenSUSE 15, GCC 8.3.1) — zákonitosti sú v podstate rovnaké: „holé“ fwrite 20 MB/s, fwrite + vyrovnávacia pamäť na 256 KB dosiahla 23 MB/s, fwrite_unlocked s rovnakou vyrovnávacou pamäťou — 35 MB/s (binárny súbor 64-bitový, zostavoval som g++ -o2 -s -static-libgcc -static-libstdc++ fwrite_test.cpp -o fwrite_test).

Pósledok

Cieľom napísania tohto článku bolo opísať jednoduchú a účinnú metódu, ktorá sa v mnohých prípadoch osvedčila (s funkciami _fwrite_nolock/fwrite_unlocked som sa predtým nestretol, nie sú veľmi populárne — a to je škoda). Nezaoberám sa novelou materiálu, ale dúfam, že článok bude užitočný pre komunitu.

Zdroj: habr.com