Async, Swoole અને Parallel નો ઉપયોગ કરીને Tarantool માટે PHP કનેક્ટર્સને ઝડપી બનાવવું

PHP ઇકોસિસ્ટમમાં હાલમાં ટેરેન્ટૂલ સર્વર સાથે કામ કરવા માટે બે કનેક્ટર્સ છે - આ સત્તાવાર PECL એક્સ્ટેંશન છે tarantool/tarantool-php, C માં લખાયેલ છે, અને tarantool-php/client, PHP માં લખાયેલ. હું પછીનો લેખક છું.

આ લેખમાં, હું બંને લાઇબ્રેરીઓના પ્રદર્શન પરીક્ષણના પરિણામો શેર કરવા માંગુ છું અને બતાવવા માંગુ છું કે કોડમાં ન્યૂનતમ ફેરફારો સાથે, તમે 3-5 પ્રદર્શન વધારો કેવી રીતે પ્રાપ્ત કરી શકો છો (કૃત્રિમ પરીક્ષણો પર!).

આપણે શું પરીક્ષણ કરીશું?

અમે ઉપર જણાવેલા પરીક્ષણો કરીશું સિંક્રનસ કનેક્ટર્સ અસુમેળ રીતે, સમાંતરમાં અને અસુમેળ-સમાંતર રીતે ચાલે છે. 🙂 અમે કનેક્ટર્સના કોડને પણ સ્પર્શ કરવા માંગતા નથી. તમને જે જોઈએ છે તે પ્રાપ્ત કરવા માટે હાલમાં ઘણા એક્સટેન્શન્સ ઉપલબ્ધ છે:

• સ્વૂલે - PHP માટે ઉચ્ચ-પ્રદર્શન અસુમેળ માળખું. અલીબાબા અને બાયડુ જેવા ઈન્ટરનેટ જાયન્ટ્સ દ્વારા ઉપયોગમાં લેવાય છે. આવૃત્તિ 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 થ્રેડ સેફ) સંસ્કરણ સાથે કામ કરે છે.

અમે કેવી રીતે પરીક્ષણ કરીશું?

ચાલો લખવા-આગળ લૉગિંગ અક્ષમ સાથે ટેરેન્ટૂલ દાખલો શરૂ કરીએ (wal_mode = કોઈ નહીં) અને વધેલા નેટવર્ક બફર (રીડહેડ = 1 * 1024 * 1024). પ્રથમ વિકલ્પ ડિસ્ક સાથેના કાર્યને દૂર કરશે, બીજો ઑપરેટિંગ સિસ્ટમ બફરની વધુ વિનંતીઓ વાંચવાનું શક્ય બનાવશે અને ત્યાંથી સિસ્ટમ કૉલ્સની સંખ્યા ઘટાડશે.

બેન્ચમાર્ક માટે કે જે ડેટા સાથે કામ કરે છે (નિવેશ, કાઢી નાખવું, વાંચન, વગેરે), બેન્ચમાર્ક શરૂ કરતા પહેલા, એક memtx જગ્યા (ફરીથી) બનાવવામાં આવશે, જેમાં પ્રાથમિક અનુક્રમણિકા મૂલ્યો ઓર્ડર કરેલ પૂર્ણાંક મૂલ્યોના જનરેટર દ્વારા બનાવવામાં આવે છે. (ક્રમ).
જગ્યા DDL આના જેવો દેખાય છે:

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>"}

રેન્ડમ કી મૂલ્યનો ઉપયોગ કરીને ટ્યુપલ્સને ઍક્સેસ કરવામાં આવે છે.

બેન્ચમાર્ક પોતે સર્વરને એક જ વિનંતી છે, જે 10,000 વખત એક્ઝિક્યુટ કરવામાં આવે છે (રિવોલ્યુશન્સ), જે બદલામાં, પુનરાવૃત્તિઓમાં ચલાવવામાં આવે છે. જ્યાં સુધી 5 પુનરાવર્તનો વચ્ચેના તમામ સમયના વિચલનો 3%* ની સ્વીકાર્ય ભૂલની અંદર ન હોય ત્યાં સુધી પુનરાવર્તનોનું પુનરાવર્તન થાય છે. આ પછી, સરેરાશ પરિણામ લેવામાં આવે છે. પ્રોસેસરને થ્રોટલિંગથી રોકવા માટે પુનરાવર્તનો વચ્ચે 1 સેકન્ડનો વિરામ છે. લુઆના ગાર્બેજ કલેક્ટરને દરેક પુનરાવૃત્તિ પહેલાં અક્ષમ કરવામાં આવે છે અને તે પૂર્ણ થયા પછી તેને શરૂ કરવાની ફરજ પાડવામાં આવે છે. PHP પ્રક્રિયા ફક્ત બેન્ચમાર્ક માટે જરૂરી એક્સ્ટેંશન સાથે જ શરૂ કરવામાં આવે છે, જેમાં આઉટપુટ બફરિંગ સક્ષમ હોય છે અને કચરો એકત્ર કરનાર અક્ષમ હોય છે.

* ક્રાંતિની સંખ્યા, પુનરાવર્તનો અને ભૂલ થ્રેશોલ્ડ બેન્ચમાર્ક સેટિંગ્સમાં બદલી શકાય છે.

પરીક્ષણ વાતાવરણ

નીચે પ્રકાશિત પરિણામો MacBookPro (2015), ઓપરેટિંગ સિસ્ટમ - Fedora 30 (kernel version 5.3.8-200.fc30.x86_64) પર બનાવવામાં આવ્યા હતા. ટેરન્ટૂલ પેરામીટર સાથે ડોકરમાં લોન્ચ કરવામાં આવ્યું હતું.--network host".

પેકેજ સંસ્કરણો:

Tarantool: 2.3.0-115-g5ba5ed37e
ડોકર: 19.03.3, બિલ્ડ a872fc2f86
PHP: 7.3.11 (cli) (બિલ્ટ: 22 ઑક્ટો 2019 08:11:04)
tarantool/client: 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 પર એક્સ્ટેંશન કમ્પાઇલ કરવા અને ચલાવવા માટે, મારે ઉપયોગ કરવો પડ્યો પેચ.

રિઝલ્ટ

સિંક્રનસ મોડ

ટેરેન્ટૂલ પ્રોટોકોલ બાઈનરી ફોર્મેટનો ઉપયોગ કરે છે મેસેજપેક સંદેશાઓને શ્રેણીબદ્ધ કરવા માટે. PECL કનેક્ટરમાં, સીરીયલાઇઝેશન પુસ્તકાલયની ઊંડાઈમાં છુપાયેલું છે અને યુઝરલેન્ડ કોડમાંથી એન્કોડિંગ પ્રક્રિયાને અસર કરે છે. શક્ય જણાતું નથી. એક શુદ્ધ PHP કનેક્ટર, તેનાથી વિપરીત, પ્રમાણભૂત એન્કોડરને વિસ્તૃત કરીને અથવા તમારા પોતાના અમલીકરણનો ઉપયોગ કરીને એન્કોડિંગ પ્રક્રિયાને કસ્ટમાઇઝ કરવાની ક્ષમતા પ્રદાન કરે છે. બૉક્સની બહાર બે એન્કોડર્સ ઉપલબ્ધ છે, એક તેના પર આધારિત છે msgpack/msgpack-php (સત્તાવાર MessagePack PECL એક્સ્ટેંશન), બીજું ચાલુ છે rybakit/msgpack (શુદ્ધ PHP માં).

કનેક્ટર્સની સરખામણી કરતા પહેલા, અમે PHP કનેક્ટર માટે MessagePack એન્કોડર્સની કામગીરીને માપીશું અને આગળના પરીક્ષણોમાં અમે શ્રેષ્ઠ પરિણામ બતાવે છે તેનો ઉપયોગ કરીશું:

જોકે PHP વર્ઝન (શુદ્ધ) ઝડપમાં PECL એક્સ્ટેંશન કરતાં હલકી ગુણવત્તાવાળા છે, વાસ્તવિક પ્રોજેક્ટ્સમાં હું હજી પણ તેનો ઉપયોગ કરવાની ભલામણ કરીશ rybakit/msgpack, કારણ કે અધિકૃત MessagePack એક્સ્ટેંશનમાં ફોર્મેટ સ્પષ્ટીકરણ માત્ર આંશિક રીતે લાગુ કરવામાં આવ્યું છે (ઉદાહરણ તરીકે, કસ્ટમ ડેટા પ્રકારો માટે કોઈ સમર્થન નથી, જેના વિના તમે ડેસિમલનો ઉપયોગ કરી શકશો નહીં - ટેરેન્ટૂલ 2.3 માં રજૂ કરાયેલ નવો ડેટા પ્રકાર) અને અન્યની સંખ્યા સમસ્યાઓ (PHP 7.4 સાથે સુસંગતતા મુદ્દાઓ સહિત). ઠીક છે, સામાન્ય રીતે, પ્રોજેક્ટ ત્યજી દેવામાં આવે છે.

તેથી, ચાલો સિંક્રનસ મોડમાં કનેક્ટર્સનું પ્રદર્શન માપીએ:

ગ્રાફ પરથી જોઈ શકાય છે તેમ, PECL કનેક્ટર (Tarantool) PHP કનેક્ટર (ક્લાયન્ટ) ની સરખામણીમાં વધુ સારું પ્રદર્શન દર્શાવે છે. પરંતુ આ આશ્ચર્યજનક નથી, જો કે બાદમાં, ધીમી ભાષામાં અમલમાં મૂકવા ઉપરાંત, વાસ્તવમાં વધુ કાર્ય કરે છે: દરેક કૉલ સાથે એક નવો ઑબ્જેક્ટ બનાવવામાં આવે છે. વિનંતી и પ્રતિભાવ (પસંદ કરવાના કિસ્સામાં - પણ માપદંડ, અને અપડેટ/અપ્સર્ટના કિસ્સામાં - ઓપરેશન્સ), અલગ સંસ્થાઓ કનેક્શન, પેકર и હેન્ડલર તેઓ ઓવરહેડ પણ ઉમેરે છે. દેખીતી રીતે, લવચીકતા કિંમતે આવે છે. જો કે, સામાન્ય રીતે, PHP દુભાષિયા સારું પ્રદર્શન બતાવે છે, જો કે તેમાં તફાવત છે, તે નજીવો છે અને, કદાચ, PHP 7.4 માં પ્રીલોડિંગનો ઉપયોગ કરતી વખતે પણ ઓછો હશે, PHP 8 માં JIT નો ઉલ્લેખ ન કરવો.

ચલો આગળ વધીએ. Tarantool 2.0 એ SQL સપોર્ટ રજૂ કર્યો. ચાલો SQL પ્રોટોકોલનો ઉપયોગ કરીને સિલેક્ટ, ઇન્સર્ટ, અપડેટ અને ડિલીટ ઓપરેશન્સ કરવાનો પ્રયાસ કરીએ અને noSQL (બાઈનરી) સમકક્ષ સાથે પરિણામોની તુલના કરીએ:

SQL પરિણામો ખૂબ પ્રભાવશાળી નથી (હું તમને યાદ અપાવી દઉં કે અમે હજુ પણ સિંક્રનસ મોડનું પરીક્ષણ કરી રહ્યા છીએ). જો કે, હું અગાઉથી આ વિશે નારાજ થઈશ નહીં SQL સપોર્ટ હજી પણ સક્રિય વિકાસ હેઠળ છે (પ્રમાણમાં તાજેતરમાં, ઉદાહરણ તરીકે, સપોર્ટ ઉમેરવામાં આવ્યો હતો; તૈયાર નિવેદનો) અને, યાદી દ્વારા અભિપ્રાય મુદ્દાઓ, SQL એન્જિન ભવિષ્યમાં સંખ્યાબંધ ઑપ્ટિમાઇઝેશનમાંથી પસાર થશે.

અસિંક

સારું, હવે ચાલો જોઈએ કે Async એક્સ્ટેંશન અમને ઉપરના પરિણામોને સુધારવામાં કેવી રીતે મદદ કરી શકે છે. અસુમેળ પ્રોગ્રામ્સ લખવા માટે, એક્સ્ટેંશન કોરોટીન્સ પર આધારિત API પ્રદાન કરે છે, જેનો અમે ઉપયોગ કરીશું. અમે પ્રાયોગિક રીતે શોધી કાઢીએ છીએ કે આપણા પર્યાવરણ માટે કોરોટીનની શ્રેષ્ઠ સંખ્યા 25 છે:

10,000 કોરોટિન્સમાં 25 ઑપરેશન્સ “ફેલાવો” અને જુઓ શું થાય છે:

માટે પ્રતિ સેકન્ડ કામગીરીની સંખ્યા 3 ગણાથી વધુ વધી છે tarantool-php/client!

દુર્ભાગ્યે, PECL કનેક્ટર ext-async સાથે શરૂ થયું નથી.

SQL વિશે શું?

જેમ તમે જોઈ શકો છો, અસુમેળ મોડમાં બાઈનરી પ્રોટોકોલ અને એસક્યુએલ વચ્ચેનો તફાવત ભૂલના માર્જિનમાં બની ગયો છે.

સ્વૂલે

ફરીથી અમે કોરોટીનની શ્રેષ્ઠ સંખ્યા શોધીએ છીએ, આ વખતે સ્વૂલ માટે:

ચાલો 25 પર અટકીએ. ચાલો Async એક્સ્ટેંશનની જેમ જ યુક્તિનું પુનરાવર્તન કરીએ - 10,000 કોરોટીન વચ્ચે 25 ઓપરેશન્સનું વિતરણ કરો. વધુમાં, અમે અન્ય ટેસ્ટ ઉમેરીશું જેમાં અમે તમામ કાર્યને 2 બે પ્રક્રિયાઓમાં વિભાજીત કરીશું (એટલે ​​કે, દરેક પ્રક્રિયા 5,000 કોરોટીનમાં 25 કામગીરી કરશે). નો ઉપયોગ કરીને પ્રક્રિયાઓ બનાવવામાં આવશે SwooleProcess.

પરિણામો:

Swole જ્યારે એક પ્રક્રિયામાં ચાલે ત્યારે Async ની તુલનામાં થોડું ઓછું પરિણામ દર્શાવે છે, પરંતુ 2 પ્રક્રિયાઓ સાથે ચિત્ર નાટકીય રીતે બદલાય છે (નંબર 2 તક દ્વારા પસંદ કરવામાં આવ્યો ન હતો; મારા મશીન પર, તે 2 પ્રક્રિયાઓ હતી જેણે શ્રેષ્ઠ પરિણામ દર્શાવ્યું હતું).

માર્ગ દ્વારા, Async એક્સ્ટેંશન પાસે પ્રક્રિયાઓ સાથે કામ કરવા માટે API પણ છે, પરંતુ ત્યાં મને એક અથવા વધુ પ્રક્રિયાઓમાં બેન્ચમાર્ક ચલાવવાથી કોઈ તફાવત જોવા મળ્યો નથી (એ શક્ય છે કે મેં ક્યાંક ગડબડ કરી હોય).

એસક્યુએલ વિ બાઈનરી પ્રોટોકોલ:

Async ની જેમ, બાઈનરી અને SQL ઑપરેશન્સ વચ્ચેનો તફાવત અસુમેળ મોડમાં દૂર કરવામાં આવે છે.

સમાંતર

કારણ કે સમાંતર એક્સ્ટેંશન કોરોટીન વિશે નથી, પરંતુ થ્રેડો વિશે છે, ચાલો સમાંતર થ્રેડોની શ્રેષ્ઠ સંખ્યાને માપીએ:

તે મારા મશીન પર 16 છે. ચાલો 16 સમાંતર થ્રેડો પર કનેક્ટર બેન્ચમાર્ક ચલાવીએ:

જેમ તમે જોઈ શકો છો, પરિણામ અસુમેળ એક્સ્ટેંશન કરતાં પણ વધુ સારું છે (2 પ્રક્રિયાઓ પર ચાલતા Swooleની ગણતરી કરતા નથી). નોંધ કરો કે PECL કનેક્ટર માટે, અપડેટ અને અપસર્ટ ઓપરેશન્સ ખાલી છે. આ એ હકીકતને કારણે છે કે આ ઑપરેશન્સ ભૂલ સાથે નિષ્ફળ થયા હતા - મને ખબર નથી કે તે ext-સમાંતર, ext-tarantool અથવા બંનેનો દોષ હતો.

હવે ચાલો SQL પ્રદર્શનની તુલના કરીએ:

સિંક્રનસ રીતે ચાલતા કનેક્ટર્સ માટેના ગ્રાફ સાથે સમાનતા પર ધ્યાન આપો?

એકસાથે

અને અંતે, ચાલો એક ગ્રાફમાં બધા પરિણામોનો સારાંશ આપીએ અને પરીક્ષણ કરેલ એક્સ્ટેંશન માટે એકંદર ચિત્ર જોવા માટે. ચાલો ચાર્ટમાં માત્ર એક નવી કસોટી ઉમેરીએ, જે આપણે હજુ સુધી કર્યું નથી - ચાલો Async કોરોટીન્સને સમાંતર* નો ઉપયોગ કરીને સમાંતર ચલાવીએ. ઉપરોક્ત એક્સ્ટેંશનને એકીકૃત કરવાનો વિચાર પહેલેથી જ છે ચર્ચા કરવામાં આવી હતી લેખકો, પરંતુ કોઈ સર્વસંમતિ પહોંચી ન હતી, તમારે તે જાતે કરવું પડશે.

* સમાંતર સાથે Swoole coroutines લોન્ચ કરવાનું શક્ય ન હતું એવું લાગે છે કે આ એક્સ્ટેન્શન્સ અસંગત છે.

તેથી, અંતિમ પરિણામો:

તેના બદલે એક નિષ્કર્ષ

મારા મતે, પરિણામો તદ્દન યોગ્ય હોવાનું બહાર આવ્યું છે, અને કેટલાક કારણોસર મને ખાતરી છે કે આ મર્યાદા નથી! તમારે ફક્ત તમારા માટે વાસ્તવિક પ્રોજેક્ટમાં આ નક્કી કરવાની જરૂર છે કે કેમ, હું ફક્ત એટલું જ કહીશ કે મારા માટે તે એક રસપ્રદ પ્રયોગ હતો જે તમને મૂલ્યાંકન કરવાની મંજૂરી આપે છે કે તમે ઓછામાં ઓછા પ્રયત્નો સાથે સિંક્રનસ TCP કનેક્ટરમાંથી કેટલું "સ્ક્વિઝ" કરી શકો છો. જો તમારી પાસે બેન્ચમાર્ક સુધારવા માટેના વિચારો હોય, તો તમારી પુલ વિનંતી પર વિચાર કરવામાં મને આનંદ થશે. લોંચ સૂચનાઓ અને પરિણામો સાથેનો તમામ કોડ અલગમાં પ્રકાશિત કરવામાં આવ્યો છે ભંડાર.

સોર્સ: www.habr.com