Async, Swoole සහ Parallel භාවිතයෙන් Tarantool සඳහා PHP සම්බන්ධක වේගවත් කිරීම

PHP පරිසර පද්ධතිය තුළ දැනට Tarantool සේවාදායකය සමඟ වැඩ කිරීම සඳහා සම්බන්ධක දෙකක් ඇත - මෙය නිල PECL දිගුවයි tarantool/tarantool-php, C වලින් ලියා ඇත, සහ tarantool-php/Client, PHP වලින් ලියා ඇත. මම දෙවැන්නෙහි කතුවරයා වෙමි.

මෙම ලිපියෙන්, පුස්තකාල දෙකෙහිම කාර්ය සාධන පරීක්‍ෂණයේ ප්‍රතිඵල බෙදා ගැනීමට සහ කේතයේ අවම වෙනස්කම් සහිතව, ඔබට 3-5 කාර්ය සාධන වැඩි වීමක් ලබා ගත හැකි ආකාරය පෙන්වීමට මම කැමතියි (කෘතිම පරීක්ෂණ මත!).

අපි පරීක්ෂා කරන්නේ කුමක්ද?

අපි ඉහත සඳහන් කළ ඒවා පරීක්ෂා කරන්නෙමු සමමුහුර්ත අසමමුහුර්තව, සමාන්තරව සහ අසමමුහුර්තව-සමාන්තර ලෙස ක්රියාත්මක වන සම්බන්ධක. 🙂 අපට සම්බන්ධකවල කේතය ස්පර්ශ කිරීමටද අවශ්‍ය නැත. ඔබට අවශ්‍ය දේ ලබා ගැනීමට දැනට දිගු කිහිපයක් තිබේ:

• ස්වුල් PHP සඳහා ඉහළ කාර්යසාධනයක් සහිත අසමමුහුර්ත රාමුවකි. Alibaba සහ Baidu වැනි අන්තර්ජාල දැවැන්තයින් විසින් භාවිතා කරනු ලැබේ. 4.1.0 අනුවාදයේ සිට මැජික් ක්රමයක් දර්ශනය වී ඇත SwooleRuntime::enableCoroutine(), "සමමුහුර්ත PHP ජාල පුස්තකාල එක් කේත පේළියක් සමඟ අසමමුහුර්ත ඒවා බවට පරිවර්තනය කිරීමට" ඔබට ඉඩ සලසයි.
• Async මෑතක් වන තුරුම PHP හි අසමමුහුර්ත වැඩ සඳහා ඉතා හොඳ දිගුවක් විය. මෑතක් වන තුරුම ඇයි? අවාසනාවකට, මා නොදන්නා හේතුවක් නිසා, කතුවරයා ගබඩාව මකා දැමූ අතර ව්‍යාපෘතියේ අනාගත ඉරණම අපැහැදිලි ය. මට ඒක පාවිච්චි කරන්න වෙනවා එකක් ගෑරුප්පු වලින්. Swoole මෙන්, මෙම දිගුව TCP සහ TLS ප්‍රවාහවල සම්මත ක්‍රියාත්මක කිරීම ඒවායේ අසමමුහුර්ත අනුවාද සමඟ ප්‍රතිස්ථාපනය කිරීමෙන් අසමමුහුර්තතාව සක්‍රීය කිරීම සඳහා මැණික් කටුවකින් ඔබේ කලිසම් පහසුවෙන් ක්‍රියාත්මක කිරීමට ඔබට ඉඩ සලසයි. මෙය සිදු කරනු ලබන්නේ විකල්පය හරහා ය.async.tcp = 1«.
• සමාන්තරයි phpdbg, apcu, pthreads, pcov, uopz වැනි පුස්තකාලවල කතුවරයා වන සුප්‍රසිද්ධ ජෝ වොට්කින්ස් වෙතින් තරමක් නව දිගුවක්. දිගුව PHP හි බහු නූල් කිරීම සඳහා API සපයන අතර pthreads සඳහා ආදේශකයක් ලෙස ස්ථානගත කර ඇත. පුස්තකාලයේ සැලකිය යුතු සීමාවක් වන්නේ එය PHP හි ZTS (Zend Thread Safe) අනුවාදය සමඟ පමණක් ක්‍රියා කිරීමයි.

අපි පරීක්ෂා කරන්නේ කෙසේද?

ලිවීමට පෙර ලොග් කිරීම අක්‍රිය කර ඇති ටැරන්ටූල් අවස්ථාවක් දියත් කරමු (wal_mode = කිසිවක් නැත) සහ වැඩි කළ ජාල බෆරය (readahead = 1 * 1024 * 1024) පළමු විකල්පය තැටිය සමඟ වැඩ කිරීම ඉවත් කරනු ඇත, දෙවැන්න මෙහෙයුම් පද්ධති බෆරයෙන් වැඩි ඉල්ලීම් කියවීමට හැකි වන අතර එමඟින් පද්ධති ඇමතුම් ගණන අවම කරයි.

දත්ත සමඟ ක්‍රියා කරන මිණුම් සලකුණු සඳහා (ඇතුළත් කිරීම, මකාදැමීම, කියවීම, ආදිය), මිණුම් ලකුණ ආරම්භ කිරීමට පෙර, memtx අවකාශයක් (නැවත) සාදනු ලැබේ, එහි ප්‍රාථමික දර්ශක අගයන් ඇණවුම් කරන ලද පූර්ණ සංඛ්‍යා අගයන් උත්පාදකයක් මඟින් නිර්මාණය කරනු ලැබේ. (අනුපිළිවෙල).
අභ්‍යවකාශ ඩීඩීඑල් මේ වගේ ය:

space = box.schema.space.create(config.space_name, {id = config.space_id, temporary = true})
space:create_index('primary', {type = 'tree', parts = {1, 'unsigned'}, sequence = true})
space:format({{name = 'id', type = 'unsigned'}, {name = 'name', type = 'string', is_nullable = false}})

අවශ්‍ය නම්, මිණුම් ලකුණ ධාවනය කිරීමට පෙර, පෝරමයේ ටියුපල් 10,000 කින් අවකාශය පුරවනු ලැබේ.

{id, "tuplе_<id>"}

සසම්භාවී යතුරු අගයක් භාවිතයෙන් Tuples වෙත ප්‍රවේශ වේ.

මිණුම් ලකුණ යනු සේවාදායකයට තනි ඉල්ලීමක් වන අතර එය 10,000 වාරයක් ක්‍රියාත්මක වේ (විප්ලව), එය අනෙක් අතට පුනරාවර්තනයෙන් ක්‍රියාත්මක වේ. පුනරාවර්තන 5ක් අතර සියලුම කාල අපගමනයන් 3%*ක පිළිගත හැකි දෝෂයක් තුළ වන තෙක් පුනරාවර්තනය පුනරාවර්තනය වේ. මෙයින් පසු, සාමාන්ය ප්රතිඵලය ගනු ලැබේ. ප්‍රොසෙසරය තෙරපීම වැළැක්වීම සඳහා පුනරාවර්තන අතර තත්පර 1ක විරාමයක් ඇත. ලුවාගේ කසළ එකතු කරන්නා එක් එක් පුනරාවර්තනයට පෙර අක්‍රිය කර ඇති අතර එය සම්පූර්ණ වූ පසු ආරම්භ කිරීමට බල කෙරේ. PHP ක්‍රියාවලිය දියත් කරනු ලබන්නේ මිණුම් ලකුණ සඳහා අවශ්‍ය දිගු සමඟ පමණි, ප්‍රතිදාන බෆරින් සක්‍රීය කර කසළ එකතු කරන්නා අක්‍රීය කර ඇත.

* මිණුම් සලකුණු සැකසුම් තුළ විප්ලව ගණන, පුනරාවර්තන සහ දෝෂ සීමාව වෙනස් කළ හැකිය.

පරීක්ෂණ පරිසරය

පහත ප්‍රකාශනය කරන ලද ප්‍රතිඵල MacBookPro (2015) මත සාදන ලදී, මෙහෙයුම් පද්ධතිය - Fedora 30 (kernel අනුවාදය 5.3.8-200.fc30.x86_64). ටැරන්ටූල් ඩොකර් හි පරාමිතිය සමඟ දියත් කරන ලදී "--network host".

පැකේජ අනුවාද:

Tarantool: 2.3.0-115-g5ba5ed37e
Docker: 19.03.3, build a872fc2f86
PHP: 7.3.11 (cli) (ඉදි කළේ: 22 ඔක්තෝබර් 2019 08:11:04)
tarantool/සේවාලාභියා: 0.6.0
rybakit/msgpack: 0.6.1
ext-tarantool: 0.3.2 (+ පැච් 7.3 සඳහා)*
ext-msgpack: 2.0.3
ext-Async: 0.3.0-8c1da46
ext-swoole: 4.4.12
ext-සමාන්තර: 1.1.3

* අවාසනාවකට, නිල සම්බන්ධකය PHP අනුවාදය > 7.2 සමඟ ක්‍රියා නොකරයි. PHP 7.3 මත දිගුව සම්පාදනය කර ධාවනය කිරීමට, මට භාවිතා කිරීමට සිදු විය පැච්.

ප්රතිඵල

සමමුහුර්ත මාදිලිය

Tarantool ප්‍රොටෝකෝලය ද්විමය ආකෘතියක් භාවිතා කරයි MessagePack පණිවිඩ අනුක්‍රමික කිරීමට. PECL සම්බන්ධකය තුළ, අනුක්‍රමිකකරණය පුස්තකාලයේ ගැඹුරේ සැඟවී ඇති අතර පරිශීලක ඉඩම් කේතයෙන් කේතන ක්‍රියාවලියට බලපායි. නොහැකි බව පෙනේ. පිරිසිදු PHP සම්බන්ධකයක්, ඊට ප්‍රතිවිරුද්ධව, සම්මත කේතකය දිගු කිරීමෙන් හෝ ඔබේම ක්‍රියාත්මක කිරීම භාවිතා කිරීමෙන් කේතීකරණ ක්‍රියාවලිය අභිරුචිකරණය කිරීමේ හැකියාව සපයයි. කොටුවෙන් පිටත කේතක දෙකක් තිබේ, එකක් පදනම් වේ msgpack/msgpack-php (නිල MessagePack PECL දිගුව), අනෙක ක්‍රියාත්මකයි rybakit/msgpack (පිරිසිදු PHP වලින්).

සම්බන්ධක සංසන්දනය කිරීමට පෙර, අපි PHP සම්බන්ධකය සඳහා MessagePack කේතකවල ක්‍රියාකාරීත්වය මනිනු ඇති අතර වැඩිදුර පරීක්ෂණ වලදී අපි හොඳම ප්‍රතිඵලය පෙන්වන එක භාවිතා කරන්නෙමු:

PHP අනුවාදය (පිරිසිදු) වේගයෙන් PECL දිගුවට වඩා පහත් වුවද, සැබෑ ව්‍යාපෘති වලදී මම එය භාවිතා කිරීමට නිර්දේශ කරමි. rybakit/msgpack, නිල MessagePack දිගුව තුළ ආකෘති පිරිවිතරයන් අර්ධ වශයෙන් පමණක් ක්‍රියාත්මක කර ඇති නිසා (උදාහරණයක් ලෙස, අභිරුචි දත්ත වර්ග සඳහා සහායක් නොමැත, එය නොමැතිව ඔබට දශමයක් භාවිතා කිරීමට නොහැකි වනු ඇත - Tarantool 2.3 හි හඳුන්වා දී ඇති නව දත්ත වර්ගයකි) සහ ඇත අනෙකුත් සංඛ්යාව ගැටලු (PHP 7.4 සමඟ අනුකූලතා ගැටළු ඇතුළුව). හොඳයි, පොදුවේ ගත් කල, ව්‍යාපෘතිය අතහැර දමා ඇති බව පෙනේ.

එබැවින්, සමමුහුර්ත ආකාරයෙන් සම්බන්ධකවල කාර්ය සාධනය මැන බලමු:

ප්‍රස්ථාරයෙන් දැකිය හැකි පරිදි, PHP සම්බන්ධකය (Client) හා සසඳන විට PECL සම්බන්ධකය (Tarantool) වඩා හොඳ කාර්ය සාධනයක් පෙන්නුම් කරයි. නමුත් මෙය පුදුමයක් නොවේ, දෙවැන්න මන්දගාමී භාෂාවකින් ක්‍රියාත්මක කිරීමට අමතරව, ඇත්ත වශයෙන්ම වැඩි කාර්යයක් කරයි: එක් එක් ඇමතුම සමඟ නව වස්තුවක් නිර්මාණය වේ. ඉල්ලීම и ප්රතිචාර (තෝරන්න - ද නිර්ණායක, සහ යාවත්කාලීන/උසස් කිරීමේදී - මෙහෙයුම්), වෙනම ආයතන සම්බන්ධතාවය, පැකර් и හැන්ඩ්ලර් ඔවුන් උඩිස් වැඩ ද එකතු කරයි. පැහැදිලිවම, නම්‍යශීලී බව මිලකට පැමිණේ. කෙසේ වෙතත්, සාමාන්‍යයෙන්, PHP පරිවර්තකය හොඳ කාර්ය සාධනයක් පෙන්නුම් කරයි, වෙනසක් ඇතත්, එය නොවැදගත් වන අතර, PHP 7.4 හි පෙර පැටවීම භාවිතා කරන විට ඊටත් වඩා අඩු වනු ඇත, PHP 8 හි JIT ගැන සඳහන් නොකරන්න.

අපි ඉදිරියට යමු. Tarantool 2.0 SQL සඳහා සහය එක් කළේය. SQL ප්‍රොටෝකෝලය භාවිතයෙන් තේරීම්, ඇතුළු කිරීම, යාවත්කාලීන කිරීම සහ මකා දැමීමේ මෙහෙයුම් සිදු කිරීමට උත්සාහ කරමු සහ ප්‍රතිඵල noSQL (ද්විමය) සමානතා සමඟ සංසන්දනය කරමු:

SQL ප්‍රතිඵල එතරම් ආකර්ෂණීය නොවේ (අපි තවමත් සමමුහුර්ත මාදිලිය පරීක්‍ෂා කරමින් සිටින බව මම ඔබට මතක් කරමි). කෙසේ වෙතත්, මම මේ ගැන කලින් කලකිරීමට පත් නොවනු ඇත; SQL සහාය තවමත් සක්‍රිය සංවර්ධනය වෙමින් පවතී (සාපේක්ෂ වශයෙන් මෑතදී, උදාහරණයක් ලෙස, සහාය එකතු කරන ලදී සකස් කළ ප්රකාශ) සහ, ලැයිස්තුව අනුව විනිශ්චය කිරීම ගැටලු, SQL එන්ජිම අනාගතයේ දී ප්‍රශස්තකරණයන් ගණනාවකට ලක් වනු ඇත.

අසින්ක්

හොඳයි, දැන් අපි බලමු Async දිගුව අපට ඉහත ප්‍රතිඵල වැඩිදියුණු කිරීමට උදවු කරන්නේ කෙසේදැයි බලමු. අසමමුහුර්ත වැඩසටහන් ලිවීමට, දිගුව මගින් coroutines මත පදනම් වූ API එකක් සපයයි, එය අප භාවිතා කරනු ඇත. අපගේ පරිසරය සඳහා ප්‍රශස්ත කොරූටින් සංඛ්‍යාව 25 ක් බව අපි ආනුභවිකව සොයා ගනිමු:

coroutines 10,000ක් හරහා මෙහෙයුම් 25ක් "පතුරුවා" සහ සිදුවන්නේ කුමක්දැයි බලන්න:

තත්පරයකට මෙහෙයුම් ගණන 3 ගුණයකට වඩා වැඩි විය tarantool-php/Client!

කනගාටුදායක ලෙස, PECL සම්බන්ධකය ext-async සමඟ ආරම්භ නොවීය.

SQL ගැන කුමක් කිව හැකිද?

ඔබට පෙනෙන පරිදි, අසමමුහුර්ත මාදිලියේදී ද්විමය ප්‍රොටෝකෝලය සහ SQL අතර වෙනස දෝෂයේ මායිම තුළ බවට පත් විය.

ස්වුල්

නැවතත් අපි coroutines ප්‍රශස්ත සංඛ්‍යාව සොයා ගනිමු, මෙවර Swoole සඳහා:

අපි 25 ට නවතිමු. Async දිගුවේදී මෙන් එකම උපක්‍රමය නැවත නැවතත් කරමු - coroutines 10,000ක් අතර මෙහෙයුම් 25ක් බෙදාහරින්න. ඊට අමතරව, අපි තවත් පරීක්ෂණයක් එකතු කරන්නෙමු, එහිදී අපි සියලු කාර්යයන් ක්‍රියාවලි 2 කට බෙදන්නෙමු (එනම්, සෑම ක්‍රියාවලියක්ම coroutine 5,000 කින් මෙහෙයුම් 25 ක් සිදු කරනු ඇත). භාවිතයෙන් ක්‍රියාවලි නිර්මාණය කරනු ලැබේ SwooleProcess.

ප්රතිඵල:

Swole එක ක්‍රියාවලියක ධාවනය කරන විට Async හා සසඳන විට තරමක් අඩු ප්‍රතිඵලයක් පෙන්නුම් කරයි, නමුත් ක්‍රියාවලි 2ක් සමඟ පින්තූරය නාටකාකාර ලෙස වෙනස් වේ (අංක 2 අහම්බෙන් තෝරාගෙන නැත; මගේ යන්ත්‍රයේ, එය හොඳම ප්‍රතිඵලය පෙන්නුම් කළේ ක්‍රියාවලි 2කි).

මාර්ගය වන විට, Async දිගුවේ ක්‍රියාවලි සමඟ වැඩ කිරීම සඳහා API ද ඇත, නමුත් එහිදී මම ක්‍රියාවලි එකක හෝ කිහිපයක මිණුම් සලකුණු ධාවනය කිරීමේ වෙනසක් දුටුවේ නැත (මම කොහේ හරි අවුල් වී ඇති බව පෙනේ).

SQL එදිරිව ද්විමය ප්‍රොටෝකෝලය:

Async සමඟ මෙන්, ද්විමය සහ SQL මෙහෙයුම් අතර වෙනස අසමමුහුර්ත ආකාරයෙන් ඉවත් කරනු ලැබේ.

සමාන්තරයි

සමාන්තර දිගුව යනු coroutines ගැන නොව නූල් ගැන බැවින්, අපි සමාන්තර නූල්වල ප්‍රශස්ත සංඛ්‍යාව මැන බලමු:

එය මගේ යන්ත්‍රයේ 16 ට සමාන වේ. සමාන්තර නූල් 16ක් මත සම්බන්ධක මිණුම් සලකුණු ධාවනය කරමු:

ඔබට පෙනෙන පරිදි, ප්රතිඵලය අසමමුහුර්ත දිගු සමඟ වඩා හොඳයි (ක්රියාවලි 2 ක් මත ක්රියාත්මක වන Swoole ගණන් නොගනී). PECL සම්බන්ධකය සඳහා, යාවත්කාලීන සහ Upsert මෙහෙයුම් හිස් බව සලකන්න. මෙයට හේතුව මෙම මෙහෙයුම් දෝෂයක් සමඟ අසාර්ථක වීමයි - එය ext-parallel, ext-tarantool හෝ දෙකෙහිම වරදක් දැයි මම නොදනිමි.

දැන් අපි SQL කාර්ය සාධනය සංසන්දනය කරමු:

සමමුහුර්තව ක්‍රියාත්මක වන සම්බන්ධක සඳහා ප්‍රස්ථාරය සමඟ ඇති සමානකම සැලකිල්ලට ගන්නද?

එක්ව

අවසාන වශයෙන්, පරීක්ෂා කරන ලද දිගු සඳහා සමස්ත පින්තූරය බැලීමට එක් ප්‍රස්ථාරයකින් සියලුම ප්‍රතිඵල සාරාංශ කරමු. අපි තවමත් ප්‍රස්ථාරයට එක් නව පරීක්ෂණයක් එකතු කරමු, එය අප තවමත් සිදු කර නැත - අපි සමාන්තර* භාවිතයෙන් Async coroutines සමාන්තරව ධාවනය කරමු. ඉහත දිගුවන් ඒකාබද්ධ කිරීමේ අදහස දැනටමත් ඇත සාකච්ඡා කරන ලදී කතුවරුන්, නමුත් එකඟතාවයකට පැමිණ නැත, ඔබට එය ඔබම කිරීමට සිදුවනු ඇත.

* සමාන්තරව Swoole coroutines දියත් කිරීමට නොහැකි විය; මෙම දිගු නොගැලපෙන බව පෙනේ.

ඉතින්, අවසාන ප්රතිඵල:

ඒ වෙනුවට අවසාන කාල පරිච්ඡේදය

මගේ මතය අනුව, ප්රතිඵල ඉතා වටිනා බවට පත් වූ අතර, යම් හේතුවක් නිසා මෙය සීමාව නොවන බව මට විශ්වාසයි! ඔබට මෙය සැබෑ ව්‍යාපෘතියක් තුළ පමණක් තීරණය කිරීමට අවශ්‍ය වුවද, මම පවසන්නේ මට එය සිත්ගන්නාසුලු අත්හදා බැලීමක් වූ අතර එය සමමුහුර්ත TCP සම්බන්ධකයකින් ඔබට අවම උත්සාහයකින් කොපමණ ප්‍රමාණයක් “මිරිකා” ගත හැකිද යන්න තක්සේරු කිරීමට ඉඩ සලසයි. මිණුම් සලකුණු වැඩි දියුණු කිරීම සඳහා ඔබට අදහස් තිබේ නම්, ඔබගේ ඇද ගැනීමේ ඉල්ලීම සලකා බැලීමට මම සතුටු වෙමි. දියත් කිරීමේ උපදෙස් සහ ප්‍රතිඵල සහිත සියලුම කේතයන් වෙනම ප්‍රකාශයට පත් කෙරේ ගබඩා.

මූලාශ්රය: www.habr.com