បង្កើនល្បឿនឯកសារ C/C++ I/O ដោយមិនបែកញើស

បុព្វកថា

មានឧបករណ៍ប្រើប្រាស់ដ៏សាមញ្ញ និងមានប្រយោជន៍ខ្លាំងណាស់នៅលើពិភពលោក - ប៊ីឌីលតាហើយវាបានកើតឡើងដូច្នេះវាត្រូវបានបញ្ចូលក្នុងដំណើរការផលិតរបស់យើងអស់រយៈពេលជាយូរណាស់មកហើយ (ទោះបីជាវាមិនអាចដំឡើងកំណែរបស់វាបានក៏ដោយ ប៉ុន្តែវាពិតជាមិនមែនជាកំណែចុងក្រោយដែលអាចប្រើបានទេ)។ យើងប្រើវាសម្រាប់គោលបំណងដែលបានគ្រោងទុក - ការកសាងបំណះប្រព័ន្ធគោលពីរ។ ប្រសិនបើអ្នកក្រឡេកមើលអ្វីដែលមាននៅក្នុងឃ្លាំង វាពិតជាគួរឲ្យសោកស្តាយបន្តិច៖ តាមពិត វាត្រូវបានបោះបង់ចោលតាំងពីយូរយារណាស់មកហើយ ហើយភាគច្រើនវាហួសសម័យណាស់ (អតីតមិត្តរួមការងាររបស់ខ្ញុំធ្លាប់បានធ្វើការកែសម្រួលជាច្រើននៅទីនោះ ប៉ុន្តែវាយូរណាស់មកហើយ) . ជាទូទៅ ខ្ញុំបានសម្រេចចិត្តធ្វើឱ្យបញ្ហានេះរស់ឡើងវិញ៖ ខ្ញុំបានបំបែក បោះចោលនូវអ្វីដែលខ្ញុំមិនមានគម្រោងប្រើ ផ្លាស់ប្តូរគម្រោងទៅ ស៊ីខេមីក្រូមុខងារ "ក្តៅ" ដែលដាក់បញ្ចូល បានដកអារេធំៗចេញពីជង់ (និងអារេនៃប្រវែងអថេរ ដែលធ្វើអោយខ្ញុំ "បំផ្ទុះ" ដោយស្មោះត្រង់) រត់ profiler ម្តងទៀត ហើយបានរកឃើញថាប្រហែល 40% នៃពេលវេលាត្រូវបានចំណាយលើ សរសេរ...

ចុះfwrite មានអ្វីប្លែក?

នៅក្នុងកូដនេះ fwrite (ក្នុងករណីសាកល្បងជាក់លាក់របស់ខ្ញុំ៖ ការបង្កើតបំណះរវាងឯកសារជិត 300 MB ទិន្នន័យបញ្ចូលគឺនៅក្នុងសតិទាំងស្រុង) ត្រូវបានគេហៅថារាប់លានដងជាមួយនឹងទំហំផ្ទុកតូចមួយ។ ជាក់ស្តែង រឿងនេះនឹងថយចុះ ហើយដូច្នេះខ្ញុំចង់មានឥទ្ធិពលលើភាពអាម៉ាស់នេះ។ មិនទាន់មានបំណងប្រាថ្នាដើម្បីអនុវត្តប្រភេទផ្សេងៗនៃប្រភពទិន្នន័យ អសមកាល I/O ទេ ខ្ញុំចង់ស្វែងរកដំណោះស្រាយដ៏សាមញ្ញជាងនេះ។ រឿងដំបូងដែលគិតគឺការបង្កើនទំហំសតិបណ្ដោះអាសន្ន

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

ប៉ុន្តែខ្ញុំមិនបានទទួលការកែលម្អគួរឱ្យកត់សម្គាល់នៅក្នុងលទ្ធផលទេ (ឥឡូវនេះ fwrite មានចំនួនប្រហែល 37% នៃពេលវេលា) - ដែលមានន័យថាវានៅតែមិនមែនជាបញ្ហានៃការសរសេរទិន្នន័យជាញឹកញាប់ទៅថាសនោះទេ។ រកមើល "នៅក្រោមក្រណាត់" នៃ fwrite អ្នកអាចមើលឃើញថារចនាសម្ព័ន្ធចាក់សោ / ដោះសោឯកសារកំពុងកើតឡើងនៅខាងក្នុងអ្វីមួយដូចនេះ (កូដក្លែងក្លាយ ការវិភាគទាំងអស់ត្រូវបានអនុវត្តនៅក្រោម 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;
}

យោងតាម ​​Profiler គណនី _fwrite_nolock សម្រាប់តែ 6% នៃពេលវេលាដែលនៅសល់គឺលើស។ ក្នុងករណីពិសេសរបស់ខ្ញុំ សុវត្ថិភាពខ្សែស្រឡាយគឺច្បាស់ណាស់ហួសហេតុ ដូច្នេះខ្ញុំនឹងលះបង់វាដោយជំនួសការហៅ fwrite ជាមួយ _fwrite_nolock - អ្នកមិនចាំបាច់ឆ្លាតជាមួយនឹងការប្រកែកទេ។ សរុប៖ ឧបាយកលដ៏សាមញ្ញនេះបានកាត់បន្ថយការចំណាយលើការកត់ត្រាលទ្ធផលយ៉ាងច្រើន ដែលនៅក្នុងកំណែដើមមានចំនួនជិតពាក់កណ្តាលនៃពេលវេលាដែលបានចំណាយ។ ដោយវិធីនេះនៅក្នុងពិភព POSIX មានមុខងារស្រដៀងគ្នា - fwrite_ដោះសោ. និយាយជាទូទៅ ដូចគ្នានេះដែរអនុវត្តចំពោះ fread ។ ដូច្នេះដោយប្រើ #defines មួយគូ អ្នកអាចទទួលបានដំណោះស្រាយឆ្លងវេទិកាទាំងស្រុងដោយមិនចាំបាច់ចាក់សោរ ប្រសិនបើមិនចាំបាច់ (ហើយវាកើតឡើងជាញឹកញាប់)។

fwrite, _fwrite_nolock, setvbuf

ចូរយើងងាកចេញពីគម្រោងដើម ហើយផ្តោតលើការសាកល្បងករណីជាក់លាក់មួយ៖ ការសរសេរឯកសារធំមួយ (512 MB) ជាបំណែកតូចៗបំផុត - មួយបៃក្នុងមួយបៃ។ ប្រព័ន្ធសាកល្បង៖ AMD Ryzen 7 1700, RAM 16 GB, HDD 7200 rpm, ឃ្លាំងសម្ងាត់ 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 ។ ឥឡូវនេះសូមសាកល្បងប្រតិបត្តិការរបស់ _fwrite_nolock ដោយមិនចាំបាច់ហៅ setvbuf: 7262221 µs ល្បឿន - 70.5 Mb/s!

បន្ទាប់​មក យើង​សាកល្បង​ទំហំ​សតិបណ្ដោះ​អាសន្ន (setvbuf)៖

ទិន្នន័យនេះត្រូវបានទទួលដោយការពិសោធន៍ជាមធ្យមចំនួន 5 ខ្ញុំខ្ជិលក្នុងការគណនាកំហុស។ សម្រាប់ខ្ញុំ 93 MB/s នៅពេលសរសេរ 1 បៃទៅ HDD ធម្មតាគឺជាលទ្ធផលល្អណាស់ អ្នកគ្រាន់តែត្រូវជ្រើសរើសទំហំផ្ទុកល្អបំផុត (ក្នុងករណីរបស់ខ្ញុំ 256 KB គឺត្រឹមត្រូវ) ហើយជំនួស fwrite ជាមួយ _fwrite_nolock/fwrite_unlocked ( ក្នុងករណីប្រសិនបើសុវត្ថិភាពខ្សែស្រឡាយមិនត្រូវការ ជាការពិត)។
ដូចគ្នានេះដែរជាមួយនឹង fread នៅក្នុងលក្ខខណ្ឌស្រដៀងគ្នា។ ដោយសារខ្ញុំមិនមានម៉ាស៊ីនផ្នែករឹងជាមួយលីនុចនៅនឹងដៃ (កុំព្យូទ័របន្ទះតែមួយមិនរាប់បញ្ចូលទេ) ខ្ញុំបានសម្រេចចិត្តធ្វើការពិសោធន៍មានកំណត់លើម៉ាស៊ីននិម្មិត (Hyper-V, OpenSUSE 15, GCC 8.3.1) - the ជាគោលការណ៍ លំនាំគឺដូចគ្នា៖ "អាក្រាត" fwrite 20 Mb/s, fwrite + 256 KB buffer ផលិត 23 Mb/s, fwrite_unlocked with the same buffer - 35 Mb/s (64-bit binary, assembled g++ -o2 - s -static-libgcc -static-libstdc++ fwrite_test. cpp -o fwrite_test)។

Afterword

គោលបំណងនៃការសរសេរអត្ថបទនេះគឺដើម្បីពិពណ៌នាអំពីបច្ចេកទេសដ៏សាមញ្ញ និងមានប្រសិទ្ធភាពក្នុងករណីជាច្រើន (ខ្ញុំមិនដែលឆ្លងកាត់មុខងារ _fwrite_nolock/fwrite_unlocked ពីមុនមកទេ ពួកគេមិនមានប្រជាប្រិយភាពខ្លាំងទេ - ប៉ុន្តែឥតប្រយោជន៍)។ ខ្ញុំ​មិន​ធ្វើ​ពុត​ជា​ថា​សម្ភារៈ​នោះ​ថ្មី​ទេ ប៉ុន្តែ​ខ្ញុំ​សង្ឃឹម​ថា​អត្ថបទ​នឹង​មាន​ប្រយោជន៍​សម្រាប់​សហគមន៍។

ប្រភព: www.habr.com