předmluva
Na světě je takový jednoduchý a velmi užitečný nástroj - , a tak se stalo, že byl v našem výrobním procesu zakořeněný na velmi dlouhou dobu (jeho verzi sice nebylo možné nainstalovat, ale rozhodně nebyla poslední dostupná). Používáme jej k zamýšlenému účelu - vytváření binárních záplat. Když se podíváte na to, co je v úložišti, je to trochu smutné: ve skutečnosti to bylo opuštěné už dávno a hodně z toho je velmi zastaralé (můj bývalý kolega tam kdysi provedl několik úprav, ale to už je dávno) . Obecně jsem se rozhodl tuto záležitost vzkřísit: rozvětvil jsem, vyhodil to, co jsem neplánoval použít, přesunul jsem projekt do , vložil „horké“ mikrofunkce, odstranil ze zásobníku velká pole (a pole s proměnlivou délkou, která ze mě upřímně dělá „bombu“), znovu spustil profiler – a zjistil, že asi 40 % času strávím ...
Jak je to tedy s fwrite?
V tomto kódu je fwrite (v mém konkrétním testovacím případě: vytvoření opravy mezi blízkými 300 MB soubory, vstupní data jsou celá v paměti) volán milionkrát s malou velikostí vyrovnávací paměti. Evidentně se tato věc zpomalí, a proto bych chtěl tento nešvar nějak ovlivnit. Není zatím chuť implementovat různé typy datových zdrojů, asynchronní vstup-výstup, chtěl jsem najít jednodušší řešení. První, co mě napadlo, bylo zvětšit velikost vyrovnávací paměti
setvbuf(file, nullptr, _IOFBF, 64* 1024)ale nedosáhl jsem výrazného zlepšení výsledku (nyní fwrite představoval asi 37 % času) – což znamená, že stále nejde o časté zapisování dat na disk. Když se podíváte „pod pokličku“ fwrite, můžete vidět, že struktura lock/unlock FILE se děje uvnitř něčeho takového (pseudokód, veškerá analýza byla provedena 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); /* lock stream */
__try
{
retval = _fwrite_nolock(buffer, size, count, stream);
}
__finally
{
_unlock_str(stream); /* unlock stream */
}
return retval;
}
Podle profilovače tvoří _fwrite_nolock pouze 6 % času, zbytek je režijní. V mém konkrétním případě je bezpečnost vláken jasně přehnaná, takže ji obětuji nahrazením volání fwrite za - ani nemusíte být chytrý s argumenty. Celkem: tato jednoduchá manipulace výrazně snížila náklady na záznam výsledku, který v původní verzi činil téměř polovinu vynaloženého času. Mimochodem, ve světě POSIX existuje podobná funkce - . Obecně řečeno, totéž platí pro fread. Pomocí dvojice #defines tedy můžete získat zcela multiplatformní řešení bez zbytečných zámků, pokud nejsou nutné (a to se stává poměrně často).
fwrite, _fwrite_nolock, setvbuf
Abstrahujme od původního projektu a začněme testovat konkrétní případ: zápis velkého souboru (512 MB) v extrémně malých částech – 1 byte. Testovací systém: AMD Ryzen 7 1700, 16 GB RAM, HDD 7200 ot./min 64 MB cache, Windows 10 1809, binárka byla sestavena jako 32bitová, optimalizace povoleny, knihovna je staticky propojena.
Ukázka pro experiment:
#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;
}
Proměnné budou TEST_BUFFER_SIZE a v několika případech nahradíme fwrite_unlocked fwrite. Začněme případem fwrite bez explicitního nastavení velikosti vyrovnávací paměti (komentujte setvbuf a související kód): čas 27048906 µs, rychlost zápisu - 18.93 MB/s. Nyní nastavíme velikost vyrovnávací paměti na 64 KB: čas - 25037111 μs, rychlost - 20.44 Mb/s. Nyní vyzkoušíme fungování _fwrite_nolock bez volání setvbuf: 7262221 µs, rychlost - 70.5 Mb/s!
Dále experimentujme s velikostí vyrovnávací paměti (setvbuf):
Data byla získána zprůměrováním 5 experimentů Byl jsem příliš líný vypočítat chyby. Pokud jde o mě, 93 MB/s při zápisu 1 bajtu na běžný HDD je velmi dobrý výsledek, stačí vybrat optimální velikost vyrovnávací paměti (v mém případě je 256 KB tak akorát) a nahradit fwrite _fwrite_nolock/fwrite_unlocked ( v případě, že bezpečnost závitu není potřeba, samozřejmě).
Stejně tak s freadem za podobných podmínek. Protože nemám po ruce hardwarový stroj s Linuxem (jednotné desky se nepočítají), rozhodl jsem se provést omezený experiment na virtuálním stroji (Hyper-V, OpenSUSE 15, GCC 8.3.1) - vzor je v zásadě totéž: „naked“ fwrite 20 Mb/s, fwrite + 256 KB buffer produkoval 23 Mb/s, fwrite_unlocked se stejnou vyrovnávací pamětí - 35 Mb/s (64bitový binární, sestavený g++ -o2 -s -static-libgcc -static-libstdc++ fwrite_test cpp -o fwrite_test).
Doslov
Účelem psaní tohoto článku bylo popsat v mnoha případech jednoduchou a účinnou techniku (s funkcemi _fwrite_nolock/fwrite_unlocked jsem se ještě nesetkal, nejsou moc oblíbené - ale marně). Nepředstírám, že je materiál nový, ale doufám, že článek bude pro komunitu užitečný.
Zdroj: www.habr.com
