ការសរសេរម៉ូឌុលដែលផុតកំណត់របស់យើងសម្រាប់ tarantool

មួយរយៈមុនយើងប្រឈមមុខនឹងបញ្ហានៃការសម្អាត tuples នៅក្នុងលំហ tarantool. ការសម្អាតត្រូវតែចាប់ផ្តើមមិនមែននៅពេលដែល tarantool អស់អង្គចងចាំនោះទេ ប៉ុន្តែជាមុន និងនៅប្រេកង់ជាក់លាក់មួយ។ សម្រាប់កិច្ចការនេះ tarantool មានម៉ូឌុលសរសេរជា Lua ហៅថា ការផុតកំណត់. បន្ទាប់ពីប្រើម៉ូឌុលនេះក្នុងរយៈពេលខ្លី យើងបានដឹងថាវាមិនស័ក្តិសមសម្រាប់យើងទេ៖ ដោយសារតែការសម្អាតជាប្រចាំនៃទិន្នន័យជាច្រើន Lua បានព្យួរនៅក្នុង GC ។ ដូច្នេះហើយ យើងបានគិតអំពីការបង្កើតម៉ូឌុលដែលផុតកំណត់ដែលកំណត់ដោយខ្លួនយើង ដោយសង្ឃឹមថាកូដដែលសរសេរជាភាសាសរសេរកម្មវិធីដើមនឹងដោះស្រាយបញ្ហារបស់យើងតាមវិធីល្អបំផុត។

ឧទាហរណ៍ដ៏ល្អមួយសម្រាប់ពួកយើងគឺម៉ូឌុល tarantool ហៅថា memcached. វិធីសាស្រ្តដែលបានប្រើនៅក្នុងវាគឺផ្អែកលើការពិតដែលថាវាលដាច់ដោយឡែកមួយត្រូវបានបង្កើតឡើងនៅក្នុងលំហដែលបង្ហាញពីអាយុកាលរបស់ tuple និយាយម្យ៉ាងទៀត ttl ។ ម៉ូឌុលនៅក្នុងផ្ទៃខាងក្រោយស្កេនចន្លោះ ប្រៀបធៀប TTL ជាមួយពេលវេលាបច្ចុប្បន្ន ហើយសម្រេចចិត្តថាតើត្រូវលុប tuple ឬអត់។ កូដម៉ូឌុល memcached គឺសាមញ្ញ និងឆើតឆាយ ប៉ុន្តែមានលក្ខណៈទូទៅពេក។ ជាដំបូង វាមិនគិតពីប្រភេទនៃលិបិក្រមដែលកំពុងត្រូវបានវារ និងលុបនោះទេ។ ទីពីរនៅលើច្រកនីមួយៗ tuple ទាំងអស់ត្រូវបានស្កេនចំនួនដែលអាចមានទំហំធំណាស់។ ហើយប្រសិនបើនៅក្នុងម៉ូឌុលដែលផុតកំណត់បញ្ហាទីមួយត្រូវបានដោះស្រាយ (សន្ទស្សន៍ដើមឈើត្រូវបានបំបែកទៅជាថ្នាក់ដាច់ដោយឡែក) បន្ទាប់មកទីពីរនៅតែមិនទទួលបានការយកចិត្តទុកដាក់។ ចំណុចទាំងបីនេះកំណត់ទុកជាមុននូវជម្រើសក្នុងការពេញចិត្តក្នុងការសរសេរកូដផ្ទាល់ខ្លួនរបស់ខ្ញុំ។

បរិយាយ

ឯកសារសម្រាប់ tarantool គឺល្អណាស់ ការបង្រៀន អំពីរបៀបសរសេរនីតិវិធីដែលបានរក្សាទុករបស់អ្នកនៅក្នុង C. ជាដំបូងខ្ញុំស្នើឱ្យអ្នកស្គាល់ខ្លួនអ្នកជាមួយវា ដើម្បីយល់ពីការបញ្ចូលទាំងនោះជាមួយនឹងពាក្យបញ្ជា និងកូដដែលនឹងបង្ហាញខាងក្រោម។ វាក៏គួរអោយយកចិត្តទុកដាក់ផងដែរ។ ឯកសារយោង ទៅវត្ថុដែលមាននៅពេលសរសេរម៉ូឌុលដែលបិទភ្ជាប់ផ្ទាល់ខ្លួនរបស់អ្នក ពោលគឺ ប្រអប់, ជាតិសរសៃ, សន្ទស្សន៍ и txn.

ចូរចាប់ផ្តើមពីចម្ងាយ ហើយមើលថាតើម៉ូឌុលផុតកំណត់ដែលបិទជិតមើលទៅដូចអ្វីពីខាងក្រៅ៖

fiber = require('fiber')
net_box = require('net.box')
box.cfg{listen = 3300}
box.schema.func.create('libcapped-expirationd.start', {language = 'C'})
box.schema.user.grant('guest', 'execute', 'function', 'libcapped-expirationd.start')
box.schema.func.create('libcapped-expirationd.kill', {language = 'C'})
box.schema.user.grant('guest', 'execute', 'function', 'libcapped-expirationd.kill')
box.schema.space.create('tester')
box.space.tester:create_index('primary', {unique = true, parts = {1, 'unsigned'}})
capped_connection = net_box:new(3300)

សម្រាប់ភាពសាមញ្ញ យើងបើកដំណើរការ tarantool នៅក្នុងថតដែលបណ្ណាល័យ libcapped-expirationd.so របស់យើងស្ថិតនៅ។ មុខងារពីរត្រូវបាននាំចេញពីបណ្ណាល័យ៖ ចាប់ផ្តើម និងសម្លាប់។ ជំហានដំបូងគឺធ្វើឱ្យមុខងារទាំងនេះមានពី Lua ដោយប្រើ box.schema.func.create និង box.schema.user.grant ។ បន្ទាប់មកបង្កើតចន្លោះដែល tuples នឹងមានវាលតែបីប៉ុណ្ណោះ៖ ទីមួយគឺជាឧបករណ៍កំណត់អត្តសញ្ញាណតែមួយគត់ ទីពីរគឺអ៊ីមែល ហើយទីបីគឺជាអាយុកាលរបស់ tuple ។ យើងបង្កើតលិបិក្រមមែកធាងនៅផ្នែកខាងលើនៃវាលទីមួយ ហើយហៅវាថាបឋម។ បន្ទាប់យើងទទួលបានវត្ថុតភ្ជាប់ទៅបណ្ណាល័យដើមរបស់យើង។

បន្ទាប់ពីការងាររៀបចំ ដំណើរការមុខងារចាប់ផ្តើម៖

capped_connection:call('libcapped-expirationd.start', {'non-indexed', box.space.tester.id, box.space.tester.index.primary, box.space.tester.index.primary, 3, 1024, 3600})

ឧទាហរណ៍នេះនឹងដំណើរការក្នុងអំឡុងពេលស្កេនដូចគ្នាទៅនឹងម៉ូឌុលផុតកំណត់ដែលត្រូវបានសរសេរជា Lua ។ អាគុយម៉ង់ទីមួយចំពោះមុខងារចាប់ផ្តើមគឺជាឈ្មោះតែមួយគត់នៃកិច្ចការ។ ទីពីរគឺឧបករណ៍សម្គាល់លំហ។ ទីបីគឺជាសន្ទស្សន៍តែមួយគត់ដែល tuples នឹងត្រូវបានលុប។ ទីបួនគឺជាសន្ទស្សន៍ដែល tuples នឹងត្រូវបានឆ្លងកាត់។ ទីប្រាំគឺជាលេខនៃវាល tuple ជាមួយនឹងអាយុកាល (លេខចាប់ផ្តើមពីលេខ 1 មិនមែន 0!)។ ទីប្រាំមួយ និងទីប្រាំពីរ គឺជាការកំណត់ស្កេន។ 1024 គឺជាចំនួនអតិបរមានៃ tuples ដែលអាចមើលបានក្នុងប្រតិបត្តិការតែមួយ។ 3600 - ពេលវេលាស្កេនពេញក្នុងមួយវិនាទី។

ចំណាំថាឧទាហរណ៍ប្រើលិបិក្រមដូចគ្នាសម្រាប់ការរុករក និងលុប។ ប្រសិនបើនេះជាសន្ទស្សន៍មែកធាង នោះការឆ្លងកាត់ត្រូវបានអនុវត្តពីគន្លឹះតូចជាងទៅធំជាង។ ប្រសិនបើមានមួយចំនួនផ្សេងទៀត ឧទាហរណ៍ សន្ទស្សន៍ hash នោះ ការឆ្លងកាត់ត្រូវបានអនុវត្ត ជាក្បួនតាមលំដាប់ចៃដន្យ។ ដុំពកលំហរទាំងអស់ត្រូវបានស្កេនក្នុងស្កេនតែមួយ។

ចូរយើងបញ្ចូល tuples ជាច្រើនទៅក្នុងលំហដែលមានអាយុកាល 60 វិនាទី៖

box.space.tester:insert{0, '[email protected]', math.floor(fiber.time()) + 60}
box.space.tester:insert{1, '[email protected]', math.floor(fiber.time()) + 60}
box.space.tester:insert{2, '[email protected]', math.floor(fiber.time()) + 60}

សូមពិនិត្យមើលថាការបញ្ចូលបានជោគជ័យ៖

tarantool> box.space.tester.index.primary:select()
---
- - [0, '[email protected]', 1576418976]
  - [1, '[email protected]', 1576418976]
  - [2, '[email protected]', 1576418976]
...

ចូរយើងជ្រើសរើសម្តងទៀតបន្ទាប់ពី 60+ វិនាទី (រាប់ចាប់ពីការចាប់ផ្តើមនៃការបញ្ចូល tuple ដំបូង) ហើយឃើញថាម៉ូឌុលដែលផុតកំណត់ដែលបានកំណត់បានដំណើរការរួចហើយ៖

tarantool> box.space.tester.index.primary:select()
---
  - []
...

តោះបញ្ឈប់កិច្ចការ៖

capped_connection:call('libcapped-expirationd.kill', {'non-indexed'})

សូមក្រឡេកមើលឧទាហរណ៍ទីពីរដែលលិបិក្រមដាច់ដោយឡែកត្រូវបានប្រើសម្រាប់ការរុករក៖

fiber = require('fiber')
net_box = require('net.box')
box.cfg{listen = 3300}
box.schema.func.create('libcapped-expirationd.start', {language = 'C'})
box.schema.user.grant('guest', 'execute', 'function', 'libcapped-expirationd.start')
box.schema.func.create('libcapped-expirationd.kill', {language = 'C'})
box.schema.user.grant('guest', 'execute', 'function', 'libcapped-expirationd.kill')
box.schema.space.create('tester')
box.space.tester:create_index('primary', {unique = true, parts = {1, 'unsigned'}})
box.space.tester:create_index('exp', {unique = false, parts = {3, 'unsigned'}})
capped_connection = net_box:new(3300)

អ្វីគ្រប់យ៉ាងនៅទីនេះគឺដូចគ្នាទៅនឹងឧទាហរណ៍ទីមួយ ដោយមានករណីលើកលែងមួយចំនួន។ យើងបង្កើតសន្ទស្សន៍មែកធាងមួយនៅលើកំពូលនៃវាលទីបីហើយហៅវាថា exp ។ លិបិក្រម​នេះ​មិន​ចាំបាច់​មាន​តែ​មួយ​ទេ មិន​ដូច​លិបិក្រម​ដែល​ហៅ​ថា​បឋម។ ការឆ្លងកាត់នឹងត្រូវបានអនុវត្តដោយសន្ទស្សន៍ exp និងការលុបដោយបឋម។ យើងចងចាំថាពីមុនទាំងពីរត្រូវបានធ្វើតែដោយប្រើសន្ទស្សន៍បឋមប៉ុណ្ណោះ។

បន្ទាប់ពីការងាររៀបចំ យើងដំណើរការមុខងារចាប់ផ្តើមជាមួយនឹងអាគុយម៉ង់ថ្មី៖

capped_connection:call('libcapped-expirationd.start', {'indexed', box.space.tester.id, box.space.tester.index.primary, box.space.tester.index.exp, 3, 1024, 3600})

ចូរយើងបញ្ចូល tuples ជាច្រើនចូលទៅក្នុងលំហម្តងទៀតជាមួយនឹងអាយុកាល 60 វិនាទី៖

box.space.tester:insert{0, '[email protected]', math.floor(fiber.time()) + 60}
box.space.tester:insert{1, '[email protected]', math.floor(fiber.time()) + 60}
box.space.tester:insert{2, '[email protected]', math.floor(fiber.time()) + 60}

បន្ទាប់ពី 30 វិនាទីដោយការប្រៀបធៀបយើងនឹងបន្ថែម tuples ពីរបីបន្ថែមទៀត:

box.space.tester:insert{3, '[email protected]', math.floor(fiber.time()) + 60}
box.space.tester:insert{4, '[email protected]', math.floor(fiber.time()) + 60}
box.space.tester:insert{5, '[email protected]', math.floor(fiber.time()) + 60}

សូមពិនិត្យមើលថាការបញ្ចូលបានជោគជ័យ៖

tarantool> box.space.tester.index.primary:select()
---
- - [0, '[email protected]', 1576421257]
  - [1, '[email protected]', 1576421257]
  - [2, '[email protected]', 1576421257]
  - [3, '[email protected]', 1576421287]
  - [4, '[email protected]', 1576421287]
  - [5, '[email protected]', 1576421287]
...

ចូរយើងជ្រើសរើសម្តងទៀតបន្ទាប់ពី 60+ វិនាទី (រាប់ចាប់ពីការចាប់ផ្តើមនៃការបញ្ចូល tuple ដំបូង) ហើយឃើញថាម៉ូឌុលដែលផុតកំណត់ដែលបានកំណត់បានដំណើរការរួចហើយ៖

tarantool> box.space.tester.index.primary:select()
---
- - [3, '[email protected]', 1576421287]
  - [4, '[email protected]', 1576421287]
  - [5, '[email protected]', 1576421287]
...

នៅមាន tuples មួយចំនួនដែលនៅសល់ក្នុងលំហ ដែលនឹងមានពេលប្រហែល 30 វិនាទីទៀតដើម្បីរស់នៅ។ លើសពីនេះទៅទៀត ការស្កេនបានឈប់នៅពេលផ្លាស់ប្តូរពី tuple ដែលមានលេខសម្គាល់ 2 និងអាយុកាល 1576421257 ទៅ tuple ដែលមានលេខសម្គាល់ 3 និងពេញមួយជីវិតនៃ 1576421287 ។ Tuples ដែលមានអាយុកាល 1576421287 ឬច្រើនជាងនេះមិនត្រូវបានស្កេនទេ ដោយសារការបញ្ជាទិញរបស់ គ្រាប់ចុចសន្ទស្សន៍ exp ។ នេះជាការសន្សំដែលយើងចង់សម្រេចតាំងពីដំបូង។

តោះបញ្ឈប់កិច្ចការ៖

capped_connection:call('libcapped-expirationd.kill', {'indexed'})

Реализация

មធ្យោបាយដ៏ល្អបំផុតដើម្បីប្រាប់អំពីលក្ខណៈពិសេសទាំងអស់នៃគម្រោងគឺជាប្រភពដើមរបស់វា។ កូដ! ជាផ្នែកមួយនៃការបោះពុម្ភ យើងនឹងផ្តោតតែលើចំណុចសំខាន់បំផុតប៉ុណ្ណោះ ពោលគឺ ក្បួនដោះស្រាយលំហឆ្លងកាត់។

អាគុយម៉ង់ដែលយើងឆ្លងទៅវិធីសាស្ត្រចាប់ផ្តើមត្រូវបានរក្សាទុកក្នុងរចនាសម្ព័ន្ធហៅថា expirationd_task៖

struct expirationd_task
{
  char name[256];
  uint32_t space_id;
  uint32_t rm_index_id;
  uint32_t it_index_id;
  uint32_t it_index_type; 
  uint32_t field_no;
  uint32_t scan_size;
  uint32_t scan_time;
};

គុណលក្ខណៈឈ្មោះគឺជាឈ្មោះនៃកិច្ចការ។ គុណលក្ខណៈ space_id គឺជាឧបករណ៍សម្គាល់លំហ។ គុណលក្ខណៈ rm_index_id គឺជាការកំណត់អត្តសញ្ញាណនៃសន្ទស្សន៍តែមួយគត់ដែល tuples នឹងត្រូវបានលុប។ គុណលក្ខណៈ it_index_id គឺជាការកំណត់អត្តសញ្ញាណនៃសន្ទស្សន៍ដែល tuples នឹងត្រូវបានឆ្លងកាត់។ គុណលក្ខណៈ it_index_type គឺជាប្រភេទនៃលិបិក្រមដែល tuples នឹងត្រូវបានឆ្លងកាត់។ គុណលក្ខណៈ filed_no គឺជាចំនួននៃវាល tuple ជាមួយនឹងអាយុកាល។ គុណលក្ខណៈ scan_size គឺជាចំនួនអតិបរមានៃ tuples ដែលត្រូវបានស្កេនក្នុងប្រតិបត្តិការមួយ។ គុណលក្ខណៈ scan_time គឺជាពេលវេលាស្កេនពេញលេញគិតជាវិនាទី។

យើងនឹងមិនពិចារណាលើការញែកអំណះអំណាងទេ។ នេះ​ជា​ការងារ​ដ៏​លំបាក ប៉ុន្តែ​សាមញ្ញ​ដែល​បណ្ណាល័យ​នឹង​ជួយ​អ្នក​បាន។ msgpuck. ភាពលំបាកអាចកើតឡើងបានតែជាមួយលិបិក្រមដែលត្រូវបានឆ្លងកាត់ពី Lua ជារចនាសម្ព័ន្ធទិន្នន័យស្មុគ្រស្មាញជាមួយនឹងប្រភេទ mp_map និងមិនប្រើប្រភេទសាមញ្ញ mp_bool, mp_double, mp_int, mp_uint និង mp_array ។ ប៉ុន្តែមិនចាំបាច់ញែកលិបិក្រមទាំងមូលទេ។ អ្នកគ្រាន់តែត្រូវពិនិត្យមើលភាពប្លែករបស់វា គណនាប្រភេទ និងស្រង់ចេញនូវអត្តសញ្ញាណ។

យើងរាយបញ្ជីគំរូនៃមុខងារទាំងអស់ដែលប្រើសម្រាប់ញែក៖

bool expirationd_parse_name(struct expirationd_task *task, const char **pos);
bool expirationd_parse_space_id(struct expirationd_task *task, const char **pos);
bool expirationd_parse_rm_index_id(struct expirationd_task *task, const char **pos);
bool expirationd_parse_rm_index_unique(struct expirationd_task *task, const char **pos);
bool expirationd_parse_rm_index(struct expirationd_task *task, const char **pos);
bool expirationd_parse_it_index_id(struct expirationd_task *task, const char **pos);
bool expirationd_parse_it_index_type(struct expirationd_task *task, const char **pos);
bool expirationd_parse_it_index(struct expirationd_task *task, const char **pos);
bool expirationd_parse_field_no(struct expirationd_task *task, const char **pos);
bool expirationd_parse_scan_size(struct expirationd_task *task, const char **pos);
bool expirationd_parse_scan_time(struct expirationd_task *task, const char **pos);

ឥឡូវនេះចូរយើងបន្តទៅអ្វីដែលសំខាន់បំផុត - តក្កវិជ្ជានៃការឆ្លងកាត់ចន្លោះនិងការលុប tuples ។ ប្លុកនីមួយៗនៃ tuples មិនធំជាង scan_size ត្រូវបានស្កេន និងកែប្រែក្រោមប្រតិបត្តិការតែមួយ។ ប្រសិនបើជោគជ័យ ប្រតិបត្តិការនេះត្រូវបានប្រព្រឹត្ត ប្រសិនបើកំហុសកើតឡើង វាត្រូវបានបង្វិលមកវិញ។ អាគុយម៉ង់ចុងក្រោយចំពោះអនុគមន៍ expirationd_iterate គឺជាទ្រនិចទៅអ្នកធ្វើឡើងវិញដែលការស្កេនចាប់ផ្តើម ឬបន្ត។ iterator នេះ​ត្រូវ​បាន​បង្កើន​នៅ​ខាង​ក្នុង​រហូត​ដល់​មាន​កំហុស​កើត​ឡើង ចន្លោះ​អស់ ឬ​វា​មិន​អាច​បញ្ឈប់​ដំណើរការ​ជា​មុន​បាន​ទេ។ មុខងារ expirationd_expired ពិនិត្យអាយុកាលរបស់ tuple, expirationd_delete លុប tuple, expirationd_breakable checks ថាតើយើងត្រូវការបន្តឬអត់។

កូដ​មុខងារ​ផុតកំណត់_iterate៖

static bool
expirationd_iterate(struct expirationd_task *task, box_iterator_t **iterp)
{
  box_iterator_t *iter = *iterp;
  box_txn_begin();
  for (uint32_t i = 0; i < task->scan_size; ++i) {
    box_tuple_t *tuple = NULL;
    if (box_iterator_next(iter, &tuple) < 0) {
      box_iterator_free(iter);
      *iterp = NULL;
      box_txn_rollback();
      return false;
    }
    if (!tuple) {
      box_iterator_free(iter);
      *iterp = NULL;
      box_txn_commit();
      return true;
    }
    if (expirationd_expired(task, tuple))
      expirationd_delete(task, tuple);
    else if (expirationd_breakable(task))
      break;
  }
  box_txn_commit();
  return true;
}

លេខកូដមុខងារផុតកំណត់_ផុតកំណត់៖

static bool
expirationd_expired(struct expirationd_task *task, box_tuple_t *tuple)
{
  const char *buf = box_tuple_field(tuple, task->field_no - 1);
  if (!buf || mp_typeof(*buf) != MP_UINT)
    return false;
  uint64_t val = mp_decode_uint(&buf);
  if (val > fiber_time64() / 1000000)
    return false;
  return true;
}

កូដមុខងារផុតកំណត់ _លុប៖

static void
expirationd_delete(struct expirationd_task *task, box_tuple_t *tuple)
{
  uint32_t len;
  const char *str = box_tuple_extract_key(tuple, task->space_id, task->rm_index_id, &len);
  box_delete(task->space_id, task->rm_index_id, str, str + len, NULL);
}

កូដមុខងារផុតកំណត់_បំបែកបាន៖

static bool
expirationd_breakable(struct expirationd_task *task)
{
  return task->it_index_id != task->rm_index_id && task->it_index_type == ITER_GT;
}

កម្មវិធី

អ្នកអាចមើលកូដប្រភពនៅ នៅទីនេះ!

ប្រភព: www.habr.com