ការបែងចែកនៅលើជង់

ហេតុអ្វីបានជាការបែងចែកជង់នៅតែជាបញ្ហានៅក្នុងវិស្វកម្មកម្មវិធីទំនើប

រាល់ពេលដែលកម្មវិធីរបស់អ្នកដំណើរការសំណើ បង្កើតអថេរ ឬហៅមុខងារ ការសម្រេចចិត្តស្ងាត់មួយកំពុងត្រូវបានធ្វើឡើងនៅពីក្រោយឆាក៖ តើទិន្នន័យនេះគួររស់នៅក្នុងអង្គចងចាំនៅឯណា? អស់ជាច្រើនទសវត្សរ៍មកហើយ ការបែងចែកជង់គឺជាយុទ្ធសាស្ត្រចងចាំដ៏លឿនបំផុតមួយដែលអាចទស្សន៍ទាយបានបំផុតដែលមានសម្រាប់អ្នកសរសេរកម្មវិធី ប៉ុន្តែវានៅតែមានការយល់ច្រឡំយ៉ាងទូលំទូលាយ។ នៅក្នុងយុគសម័យនៃដំណើរការគ្រប់គ្រង អ្នកប្រមូលសំរាម និងស្ថាបត្យកម្មដើមកំណើតពពក ការយល់ដឹងពីរបៀប និងពេលណាដែលត្រូវបែងចែកនៅលើជង់អាចមានន័យថាភាពខុសគ្នារវាងកម្មវិធីដែលគ្រប់គ្រងអ្នកប្រើប្រាស់ស្របគ្នា 10,000 នាក់ និងកម្មវិធីមួយដែលដាក់ក្រោម 500 នាក់។ នៅ Mewayz ជាកន្លែងដែលវេទិការបស់យើងបម្រើអាជីវកម្មជាង 138,000 អាជីវកម្មជាមួយ 207 ការគ្រប់គ្រងខ្នាតតូច។Stack ទល់នឹង Heap៖ ការដោះដូរជាមូលដ្ឋាន

អង្គចងចាំនៅក្នុងបរិស្ថានកម្មវិធីភាគច្រើនត្រូវបានបែងចែកទៅជាតំបន់ចម្បងពីរ៖ ជង់ និងហ៊ាប។ ជង់ដំណើរការជារចនាសម្ព័ន្ធទិន្នន័យចុងក្រោយចូលដំបូង (LIFO) ។ នៅពេលមុខងារត្រូវបានហៅ "ស៊ុម" ថ្មីត្រូវបានរុញទៅលើជង់ដែលមានអថេរមូលដ្ឋាន អាសយដ្ឋានត្រឡប់ និងប៉ារ៉ាម៉ែត្រមុខងារ។ នៅពេលដែលមុខងារនោះត្រឡប់មកវិញ ស៊ុមទាំងមូលត្រូវបានបិទភ្លាមៗ។ មិន​មាន​ការ​ស្វែង​រក គ្មាន​ការ​រក្សា​ទុក​ក្នុង​បញ្ជី គ្មាន​ការ​បែក​បាក់ — គ្រាន់​តែ​ការ​កែ​សម្រួល​ទ្រនិច​មួយ​ប៉ុណ្ណោះ។

ផ្ទុយទៅវិញ ហ៊ាប គឺជាបណ្តុំនៃការចងចាំដ៏ធំមួយ ដែលការបែងចែក និងការបែងចែកអាចកើតឡើងតាមលំដាប់លំដោយ។ ភាពបត់បែននេះកើតឡើងក្នុងតម្លៃមួយ៖ អ្នកបែងចែកត្រូវតែតាមដានថាតើប្លុកណាដែលមិនគិតថ្លៃ ដោះស្រាយការបែកខ្ញែក និងជាភាសាជាច្រើន ពឹងផ្អែកលើអ្នកប្រមូលសំរាមដើម្បីយកមកវិញនូវអង្គចងចាំដែលមិនប្រើ។ ការបែងចែក heap នៅក្នុងកម្មវិធី C ធម្មតាចំណាយពេលប្រហែល 10 ទៅ 20 ដងយូរជាងការបែងចែកជង់។ នៅក្នុងភាសាដែលប្រមូលសំរាមដូចជា Java ឬ C# ការចំណាយលើសអាចខ្ពស់ជាងនៅពេលដែលការផ្អាកការប្រមូលត្រូវបានរាប់បញ្ចូល។

ការយល់ដឹងអំពីការដោះដូរនេះមិនមែនគ្រាន់តែជាការសិក្សាទេ។ នៅពេលដែលអ្នកកំពុងបង្កើតកម្មវិធីដែលដំណើរការប្រតិបត្តិការរាប់ពាន់ក្នុងមួយវិនាទី — ថាតើនោះជាម៉ាស៊ីនចេញវិក្កយបត្រ ផ្ទាំងគ្រប់គ្រងការវិភាគពេលវេលាពិត ឬ CRM គ្រប់គ្រងការនាំចូលទំនាក់ទំនងច្រើន — ការជ្រើសរើសយុទ្ធសាស្ត្របែងចែកត្រឹមត្រូវសម្រាប់ផ្លូវក្តៅប៉ះពាល់ដោយផ្ទាល់ទៅលើពេលវេលាឆ្លើយតប និងតម្លៃហេដ្ឋារចនាសម្ព័ន្ធ។

របៀបដែលការបែងចែកជង់ពិតជាដំណើរការ

នៅកម្រិតផ្នែករឹង ស្ថាបត្យកម្មដំណើរការភាគច្រើនកំណត់ការចុះឈ្មោះ (ទ្រនិចជង់) ដើម្បីតាមដានកំពូលបច្ចុប្បន្ននៃជង់។ ការបែងចែកអង្គចងចាំនៅលើជង់គឺសាមញ្ញដូចជាការបន្ថយទ្រនិចនេះដោយចំនួនបៃដែលត្រូវការ។ ការបែងចែកគឺបញ្ច្រាស៖ បង្កើនទ្រនិច។ គ្មាន​បឋមកថា​ទិន្នន័យ​មេតា គ្មាន​បញ្ជី​ឥតគិតថ្លៃ គ្មាន​ការ​រួម​បញ្ចូល​គ្នា​នៃ​ប្លុក​ដែល​នៅ​ជាប់​គ្នា។ នេះ​ជា​មូលហេតុ​ដែល​ការ​បែងចែក​ជង់​ត្រូវ​បាន​ពណ៌នា​ជា​ញឹក​ញាប់​ថា​មាន O(1) ដំណើរការ​ថេរ​ដោយ​មាន​ការ​ធ្វេសប្រហែស។

ពិចារណាមុខងារដែលគណនាចំនួនសរុបសម្រាប់ធាតុបន្ទាត់វិក្កយបត្រ។ វាអាចប្រកាសពីអថេរក្នុងស្រុកមួយចំនួន៖ ចំនួនគត់បរិមាណ តម្លៃឯកតាអណ្តែត អត្រាពន្ធអណ្តែត និងអណ្តែតលើលទ្ធផល។ តម្លៃទាំងបួនត្រូវបានរុញលើជង់ នៅពេលដែលមុខងារត្រូវបានបញ្ចូល និងទាមទារមកវិញដោយស្វ័យប្រវត្តិនៅពេលវាចេញ។ វដ្តជីវិតទាំងមូលត្រូវបានកំណត់ និងទាមទារឱ្យមានអន្តរាគមន៍ពីអ្នកសរសេរកម្មវិធី ឬអ្នកប្រមូលសំរាម។

ការយល់ដឹងសំខាន់ៗ៖ ការបែងចែកជង់មិនគ្រាន់តែលឿនប៉ុណ្ណោះទេ វាអាចព្យាករណ៍បាន។ នៅក្នុងប្រព័ន្ធសំខាន់ៗ ការព្យាករណ៍ច្រើនតែសំខាន់ជាងល្បឿនឆៅ។ មុខងារដែលបំពេញជាប់លាប់ក្នុងរយៈពេល 2 មីក្រូវិនាទីគឺមានតម្លៃជាងមួយដែលជាមធ្យម 1 មីក្រូវិនាទី ប៉ុន្តែម្តងម្កាលកើនឡើងដល់ 50 មីក្រូវិនាទី ដោយសារការផ្អាកការប្រមូលសំរាម។

ពេលណាដែលត្រូវអនុគ្រោះដល់ការបែងចែកជង់

មិនមែនរាល់ទិន្នន័យទាំងអស់សុទ្ធតែមាននៅលើជង់នោះទេ។ អង្គចងចាំជង់ត្រូវបានកំណត់ (ជាធម្មតាចន្លោះពី 1 MB និង 8 MB ក្នុងមួយខ្សែ អាស្រ័យលើប្រព័ន្ធប្រតិបត្តិការ) ហើយទិន្នន័យដែលបានបម្រុងទុកនៅលើជង់មិនអាចលើសពីមុខងារដែលបានបង្កើតវាទេ។ ទោះយ៉ាងណាក៏ដោយ មានសេណារីយ៉ូច្បាស់លាស់ដែលការបែងចែកជង់គឺជាជម្រើសដ៏ប្រសើរ។

• អថេរមូលដ្ឋានរយៈពេលខ្លី៖ បញ្ជរ ឧបករណ៍ផ្ទុក បណ្តុំបណ្តោះអាសន្នក្រោមពីរបីគីឡូបៃ និងសន្ទស្សន៍រង្វិលជុំគឺសមនឹងធម្មជាតិសម្រាប់ជង់។ ពួកវាត្រូវបានបង្កើត ប្រើប្រាស់ និងបោះចោលក្នុងវិសាលភាពមុខងារតែមួយ។
• រចនាសម្ព័ន្ធទិន្នន័យទំហំថេរ៖ អារេដែលមានទំហំពេលវេលាចងក្រងដែលគេស្គាល់ រចនាសម្ព័ន្ធតូច និងប្រភេទតម្លៃអាចត្រូវបានដាក់នៅលើជង់ដោយគ្មានហានិភ័យនៃការហៀរចេញ។ អង្គចងចាំទំហំ 256 បៃសម្រាប់ធ្វើទ្រង់ទ្រាយខ្សែអក្សរកាលបរិច្ឆេទគឺជាបេក្ខជនដ៏ល្អឥតខ្ចោះ។
• Performance-critical loops ខាងក្នុង៖ នៅពេលដែលមុខងារមួយត្រូវបានគេហៅថារាប់លានដងក្នុងមួយវិនាទី — ដូចជាម៉ាស៊ីនគណនាតម្លៃដែលធ្វើម្តងទៀតលើកាតាឡុកផលិតផល — ការលុបបំបាត់ការបែងចែក heap នៅក្នុងតួរង្វិលជុំអាចផ្តល់លទ្ធផលប្រសើរឡើង 3x ទៅ 10x ។
• ផ្លូវ​ដែល​មាន​ភាព​តានតឹង​ក្នុង​ពេល​ពិត ឬ​ពេល​វេលា៖ ដំណើរការ​ទូទាត់ ការ​ធ្វើ​បច្ចុប្បន្នភាព​ផ្ទាំងគ្រប់គ្រង​ផ្ទាល់ និង​ការ​ជូន​ដំណឹង​បញ្ជូន​អត្ថប្រយោជន៍​ទាំងអស់​ពី​ការ​ជៀសវាង​ការ​ផ្អាក​ការ​ប្រមូល​សំរាម​ដែល​មិន​កំណត់។
• ក្បួនដោះស្រាយបង្កើតឡើងវិញជាមួយនឹងជម្រៅកំណត់៖ ប្រសិនបើអ្នកអាចធានាថាជម្រៅនៃការហៅឡើងវិញស្ថិតនៅក្នុងដែនកំណត់សុវត្ថិភាព ស៊ុមដែលបានបែងចែកជាជង់នឹងរក្សាមុខងារដដែលៗបានលឿន និងសាមញ្ញ។

នៅក្នុងការអនុវត្តជាក់ស្តែង អ្នកចងក្រងទំនើបគឺល្អគួរឱ្យកត់សម្គាល់ក្នុងការបង្កើនប្រសិទ្ធភាពការប្រើប្រាស់ជង់។ បច្ចេកទេសដូចជាការវិភាគគេចចេញពី Go និងកម្មវិធីចងក្រង JIT របស់ Java អាចផ្លាស់ទីការបែងចែក heap ដោយស្វ័យប្រវត្តិទៅជង់ នៅពេលដែលកម្មវិធីចងក្រងបង្ហាញថាទិន្នន័យមិនគេចផុតពីវិសាលភាពមុខងារ។ ការយល់ដឹងពីការបង្កើនប្រសិទ្ធភាពទាំងនេះអនុញ្ញាតឱ្យអ្នកសរសេរកូដស្អាតជាងមុន ខណៈពេលដែលនៅតែទទួលបានអត្ថប្រយោជន៍ពីដំណើរការជង់។

បញ្ហាទូទៅ និងវិធីជៀសវាងពួកវា

កំហុសដែលទាក់ទងនឹងជង់ដ៏ល្បីបំផុតគឺការផ្ទុកលើសចំណុះ — បែងចែកទិន្នន័យច្រើនជាងជង់ដែលអាចផ្ទុកបាន ជាធម្មតាតាមរយៈការបង្កើតឡើងវិញដែលគ្មានដែនកំណត់ ឬអារេក្នុងស្រុកធំពេក។ នៅក្នុងបរិយាកាសផលិតកម្ម ការហូរលើសជង់ជាធម្មតាធ្វើឱ្យខូចខ្សែស្រឡាយ ឬដំណើរការទាំងមូលដោយមិនមានផ្លូវស្ដារឡើងវិញ។ នេះ​ជា​មូលហេតុ​ដែល​ក្របខ័ណ្ឌ និង​ប្រព័ន្ធ​ប្រតិបត្តិការ​កំណត់​ទំហំ​ជង់។

បញ្ហា​ដ៏​ងាយ​ស្រួល​មួយ​ទៀត​កំពុង​ត្រឡប់​ចំណុច​ចង្អុល ឬ​សេចក្ដី​យោង​ទៅ​កាន់​ទិន្នន័យ​ដែល​បាន​បែងចែក​ជា​ជង់។ ដោយសារតែអង្គចងចាំជង់ត្រូវបានទាមទារមកវិញ នៅពេលដែលមុខងារមួយត្រលប់មកវិញ ទ្រនិចណាមួយទៅកាន់អង្គចងចាំនោះនឹងក្លាយជាឯកសារយោងដែលជាប់គាំង។ នៅក្នុង C និង C ++ នេះនាំទៅរកអាកប្បកិរិយាដែលមិនបានកំណត់ដែលអាចហាក់ដូចជាដំណើរការក្នុងការធ្វើតេស្ត ប៉ុន្តែបរាជ័យយ៉ាងមហន្តរាយនៅក្នុងការផលិត។ កម្មវិធីត្រួតពិនិត្យការខ្ចីប្រាក់របស់ Rust ចាប់បាននូវចំណាត់ថ្នាក់នៃកំហុសនេះនៅពេលចងក្រង ដែលជាហេតុផលមួយដែលភាសាបានទទួលការទាក់ទាញសម្រាប់ការសរសេរកម្មវិធីប្រព័ន្ធ។

បញ្ហាទីបីទាក់ទងនឹងសុវត្ថិភាពខ្សែស្រឡាយ។ ខ្សែស្រលាយនីមួយៗទទួលបានជង់ផ្ទាល់ខ្លួនរបស់វា ដែលមានន័យថាទិន្នន័យដែលបានបែងចែកជាជង់គឺស្ថិតនៅក្នុងមូលដ្ឋាន។ នេះពិតជាអត្ថប្រយោជន៍មួយនៅក្នុងករណីជាច្រើន — មិនចាំបាច់ចាក់សោរដើម្បីចូលប្រើអថេរក្នុងស្រុកទេ។ ទោះជាយ៉ាងណាក៏ដោយ ពេលខ្លះអ្នកអភិវឌ្ឍន៍មានកំហុសក្នុងការព្យាយាមចែករំលែកទិន្នន័យដែលបានបែងចែកជាជង់រវាងខ្សែស្រលាយ ដែលនាំឱ្យមានលក្ខខណ្ឌប្រណាំង ឬកំហុសក្នុងការប្រើប្រាស់បន្ទាប់ពីគ្មានកំហុស។ នៅពេលដែលទិន្នន័យត្រូវចែករំលែកនៅទូទាំងខ្សែស្រឡាយ ឬបន្តលើសពីការហៅមុខងារ ហេបគឺជាជម្រើសដ៏សមស្រប។

ការ​បែងចែក​ជង់​ទូទាំង​ភាសា និង​ក្របខ័ណ្ឌ

ភាសាសរសេរកម្មវិធីផ្សេងៗគ្នាគ្រប់គ្រងការបែងចែកជង់ជាមួយនឹងកម្រិតតម្លាភាពខុសៗគ្នា។ នៅក្នុង C និង C ++ អ្នកសរសេរកម្មវិធីមានការគ្រប់គ្រងច្បាស់លាស់៖ អថេរមូលដ្ឋានដំណើរការលើជង់ ហើយ malloc ឬ new ដាក់ទិន្នន័យនៅលើ heap ។ នៅក្នុង Go កម្មវិធីចងក្រងធ្វើការវិភាគរត់គេចខ្លួនដើម្បីសម្រេចចិត្តដោយស្វ័យប្រវត្តិ ហើយកម្មវិធីកំណត់គោលដៅចាប់ផ្តើមជាមួយនឹងបណ្តុំតូចៗ 2 KB ដែលរីកចម្រើនយ៉ាងស្វាហាប់ ដែលជាដំណោះស្រាយដ៏ប្រណិតដែលធ្វើអោយមានតុល្យភាពសុវត្ថិភាពជាមួយនឹងដំណើរការ។ PHP ដែលជាក្របខ័ណ្ឌពង្រឹងភាសាដូចជា Laravel បែងចែកតម្លៃភាគច្រើនតាមរយៈកម្មវិធីគ្រប់គ្រងអង្គចងចាំ Zend Engine ខាងក្នុងរបស់វា ប៉ុន្តែការយល់ដឹងពីគោលការណ៍ជាមូលដ្ឋានជួយឱ្យអ្នកអភិវឌ្ឍន៍សរសេរកូដកាន់តែមានប្រសិទ្ធភាពសូម្បីតែនៅកម្រិតកម្មវិធី។

សម្រាប់ក្រុមដែលបង្កើតវេទិកាស្មុគស្មាញ — ដូចជាក្រុមវិស្វករនៅ Mewayz ដែលសំណើតែមួយអាចឆ្លងកាត់តក្កវិជ្ជា CRM ការគណនាវិក្កយបត្រ ការគណនាពន្ធលើប្រាក់បៀវត្សរ៍ និងការបូកសរុបការវិភាគ — សមាសធាតុនៃការសម្រេចចិត្តកម្រិតទាបទាំងនេះ។ នៅពេលដែលម៉ូឌុល 207 ចែករំលែកពេលវេលាដំណើរការ ការកាត់បន្ថយការបែងចែកអង្គចងចាំតាមសំណើសូម្បីតែ 15% អាចបកប្រែទៅជាការកាត់បន្ថយដ៏មានអត្ថន័យនៃការចំណាយលើម៉ាស៊ីនមេ និងការកែលម្អដែលអាចវាស់វែងបាននៅក្នុងពេលវេលាឆ្លើយតបសម្រាប់អ្នកប្រើប្រាស់ចុងក្រោយដែលគ្រប់គ្រងអាជីវកម្មរបស់ពួកគេនៅលើវេទិកា។

JavaScript និង TypeScript ដែលផ្តល់ថាមពលដល់ផ្នែកខាងមុខទំនើបបំផុត និងផ្នែកខាងក្រោយ Node.js ពឹងផ្អែកទាំងស្រុងលើឧបករណ៍ប្រមូលសំរាមរបស់ម៉ាស៊ីន V8 សម្រាប់ការគ្រប់គ្រងអង្គចងចាំ។ អ្នកអភិវឌ្ឍន៍មិនអាចបែងចែកដោយផ្ទាល់នៅលើជង់បានទេ ប៉ុន្តែកម្មវិធីចងក្រងបង្កើនប្រសិទ្ធភាពរបស់ V8 (TurboFan) អនុវត្តការបែងចែកជង់នៅខាងក្នុងសម្រាប់តម្លៃដែលវាអាចបង្ហាញថាមានរយៈពេលខ្លី។ ការ​សរសេរ​មុខងារ​តូច និង​សុទ្ធ​ជាមួយ​អថេរ​មូលដ្ឋាន​ផ្តល់​ឱ្យ​ម៉ាស៊ីន​នូវ​ឱកាស​ដ៏​ល្អ​បំផុត​ក្នុង​ការ​អនុវត្ត​ការ​បង្កើន​ប្រសិទ្ធភាព​ទាំងនេះ។

យុទ្ធសាស្ត្រជាក់ស្តែងសម្រាប់កាត់បន្ថយសម្ពាធខ្លាំង

ទោះបីជាអ្នកធ្វើការជាភាសាកម្រិតខ្ពស់ដែលអ្នកមិនអាចគ្រប់គ្រងដោយផ្ទាល់ទល់នឹងការបែងចែក heap ក៏ដោយ អ្នកអាចទទួលយកគំរូដែលកាត់បន្ថយសម្ពាធ heap ដែលមិនចាំបាច់ និងអនុញ្ញាតឱ្យពេលវេលាដំណើរការដំណើរការកាន់តែខ្លាំងក្លា។

1. ចូលចិត្តប្រភេទតម្លៃជាងប្រភេទឯកសារយោង ដែលភាសាគាំទ្រពួកគេ។ នៅក្នុង C# ការប្រើ struct ជំនួសឱ្យ class សម្រាប់វត្ថុតូចៗដែលបង្កើតជាញឹកញាប់រក្សាពួកវានៅលើជង់។ នៅក្នុង Go ការឆ្លងកាត់រចនាសម្ព័ន្ធតូចៗតាមតម្លៃជាជាងដោយទ្រនិច ទទួលបានប្រសិទ្ធភាពដូចគ្នា។
2. ជៀសវាង​ការ​បែង​ចែក​នៅ​ក្នុង​រង្វង់​តឹង។ កំណត់​ទុក​ជា​មុន ហើយ​ប្រើ​វា​ឡើង​វិញ​តាម​ការ​ធ្វើ​ម្តង​ទៀត។ ប្រសិនបើអ្នកត្រូវការចំណិតបណ្ដោះអាសន្ន ឬអារេនៅខាងក្នុងរង្វិលជុំដែលដំណើរការ 100,000 ដង បែងចែកវាម្តងមុនពេលរង្វិលជុំ ហើយកំណត់វាឡើងវិញនៅលើការធ្វើម្តងទៀតនីមួយៗ។
3. ប្រើការរួមបញ្ចូលវត្ថុសម្រាប់វត្ថុដែលបានបង្កើត និងបំផ្លាញជាញឹកញាប់។ បណ្តុំនៃការតភ្ជាប់មូលដ្ឋានទិន្នន័យគឺជាឧទាហរណ៍បុរាណ ប៉ុន្តែគំរូនេះអនុវត្តស្មើៗគ្នាចំពោះវត្ថុសំណើ HTTP សតិបណ្ដោះអាសន្ន និងរចនាសម្ព័ន្ធបរិបទគណនា។
4. កម្រងព័ត៌មាន មុនពេលធ្វើឱ្យប្រសើរ។ ឧបករណ៍ដូចជា pprof របស់ Go, async-profiler របស់ Java, ឬ Blackfire របស់ PHP អាចកំណត់ច្បាស់ពីកន្លែងដែលការបែងចែកកើតឡើង។ ការធ្វើឱ្យ​ប្រសើរ​ឡើង​ដោយ​គ្មាន​ការ​កំណត់​ទិន្នន័យ​ប្រថុយប្រថាន​នឹង​ការ​ចំណាយ​លើ​ផ្លូវ​ត្រជាក់​ដែល​កម្រ​នឹង​អនុវត្ត។
5. Leverage arena allocators forbatch operations