Am PHP-Ökosystem ginn et momentan zwee Connectoren fir mam Tarantool Server ze schaffen - dat ass déi offiziell PECL Extensioun , geschriwwen an C, an , an PHP geschriwwen. Ech sinn den Auteur vun der leschter.
An dësem Artikel wëll ech d'Resultater vun der Leeschtungstestung vu béide Bibliothéiken deelen a weisen wéi Dir mat minimale Ännerunge vum Code eng 3-5 Leeschtungserhéijung erreechen kann (op syntheteschen Tester!).
Wat wäerte mir testen?
Mir testen déi uewen ernimmt synchron Stecker lafen asynchron, parallel an asynchron-parallel. 🙂 Mir wëllen och net de Code vun de Stecker selwer beréieren. Et gi momentan e puer Extensiounen verfügbar fir z'erreechen wat Dir wëllt:
- ― en High-Performance asynchrone Kader fir PHP. Benotzt vun esou Internet Risen wéi Alibaba a Baidu. Zënter Versioun 4.1.0 ass eng magesch Method opgetaucht SwooleRuntime::enableCoroutine(), wat Iech erlaabt "synchron PHP-Netzbibliothéiken op asynchrone mat enger Zeil vum Code ze konvertéieren."
- Async war bis viru kuerzem eng ganz villverspriechend Extensioun fir asynchron Aarbecht am PHP. Firwat bis viru kuerzem? Leider, aus engem fir mech onbekannte Grond, huet den Auteur de Repository geläscht an dat zukünfteg Schicksal vum Projet ass onkloer. Ech muss et benotzen vun Gabel. Wéi Swoole, erlaabt dës Verlängerung Iech Är Hosen einfach mat engem Flick vum Handgelenk ze maachen fir Asynchronie z'erméiglechen andeems Dir d'Standardimplementatioun vun TCP an TLS Streame mat hiren asynchrone Versiounen ersetzt. Dëst gëtt gemaach duerch d'Optioun "async.tcp = 1".
- - eng zimlech nei Extensioun vum bekannte Joe Watkins, Auteur vun esou Bibliothéike wéi phpdbg, apcu, pthreads, pcov, uopz. D'Extensioun bitt eng API fir Multithreading an PHP a gëtt als Ersatz fir pthreads positionéiert. Eng bedeitend Begrenzung vun der Bibliothéik ass datt et nëmme mat der ZTS (Zend Thread Safe) Versioun vu PHP funktionnéiert.
Wéi wäerte mir testen?
Loosst eis eng Tarantool Instanz lancéieren mat Schreiwe-Ahead Logbuch behënnert (wal_mode = keng) an erhéicht Netzwierkbuffer (liesen = 1 * 1024 * 1024). Déi éischt Optioun wäert d'Aarbecht mat der Disk eliminéieren, déi zweet wäert et méiglech maachen méi Ufroe vum Betribssystembuffer ze liesen an doduerch d'Zuel vun de Systemappellen ze minimiséieren.
Fir Benchmarks déi mat Daten funktionnéieren (Insertion, Läschen, Liesen, asw.), ier Dir de Benchmark ufänkt, gëtt e memtx Raum (ne) erstallt, an deem déi primär Indexwäerter vun engem Generator vun bestallten ganzer Wäerter erstallt ginn (Sequenz).
De Raum DDL gesäit esou aus:
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}})Wann néideg, ier Dir de Benchmark leeft, ass de Raum mat 10,000 Tuples vun der Form gefëllt
{id, "tuplе_<id>"}Tuples ginn zougänglech mat engem zoufälleg Schlësselwäert.
De Benchmark selwer ass eng eenzeg Ufro un de Server, déi 10,000 Mol ausgefouert gëtt (Revolutiounen), déi am Tour an Iteratiounen ausgefouert ginn. D'Iteratiounen gi widderholl bis all Zäitabweichungen tëscht 5 Iteratiounen an engem akzeptable Feeler vun 3%* sinn. Duerno gëtt d'Duerchschnëttsresultat geholl. Et gëtt eng 1 Sekonn Paus tëscht Iteratiounen fir ze verhënneren datt de Prozessor dréit. Dem Lua seng Gerempels ass virun all Iteratioun behënnert a gëtt gezwongen ze starten nodeems se fäerdeg ass. De PHP-Prozess gëtt nëmme mat den Extensiounen, déi fir de Benchmark néideg sinn, gestart, mat Ausgangsbufferung aktivéiert an de Gerempels Sammler behënnert.
* D'Zuel vun de Revolutiounen, Iteratiounen a Feelerschwell kënnen an de Benchmark-Astellunge geännert ginn.
Test Ëmfeld
D'Resultater hei ënnen publizéiert goufen op engem MacBookPro (2015), Betribssystem gemaach - Fedora 30 (Kernel Versioun 5.3.8-200.fc30.x86_64). Tarantool gouf am Docker mam Parameter "--network host".
Package Versiounen:
Tarantool: 2.3.0-115-g5ba5ed37e
Docker: 19.03.3, bauen a872fc2f86
PHP: 7.3.11 (cli) (gebaut: 22. Oktober 2019 08:11:04)
tarantool / Client: 0.6.0
rybakit/msgpack: 0.6.1
ext-tarantool: 0.3.2 (+ Patch fir 7.3)*
ext-msgpack: 2.0.3
ext-async: 0.3.0-8c1da46
ext-swolle: 4.4.12
ext-parallel: 1.1.3
* Leider funktionnéiert den offiziellen Connector net mat PHP Versioun> 7.2. Fir d'Extensioun op PHP 7.3 ze kompiléieren an auszeféieren, hunn ech missen benotzen .
Resultater
Synchronmodus
Den Tarantool Protokoll benotzt e binäre Format fir Messagen ze serialiséieren. Am PECL Connector ass d'Serialiséierung déif an den Tiefen vun der Bibliothéik verstoppt an beaflosst de Kodéierungsprozess vum Userland Code . E pure PHP Connector, am Géigendeel, bitt d'Fäegkeet de Kodéierungsprozess unzepassen andeems de Standard Encoder verlängert oder andeems Dir Är eegen Implementatioun benotzt. Et ginn zwee Encoder verfügbar aus der Këscht, een baséiert op (offiziell MessagePack PECL Extensioun), déi aner ass op (a pure PHP).
Ier Dir Connectoren vergläicht, moosse mir d'Performance vu MessagePack Encoder fir de PHP Connector an a weideren Tester benotze mir deen deen dat bescht Resultat weist:
Och wann d'PHP Versioun (Pure) manner wéi d'PECL Extensioun a Geschwindegkeet ass, an echte Projete géif ech nach ëmmer recommandéieren et ze benotzen , well an der offizieller MessagePack Extensioun ass d'Formatspezifikatioun nëmmen deelweis ëmgesat (zum Beispill gëtt et keng Ënnerstëtzung fir personaliséiert Datentypen, ouni déi Dir net fäeg sidd Dezimal ze benotzen - en neien Datetyp, deen an Tarantool 2.3 agefouert gëtt) an huet eng Zuel vun aneren (inklusiv Kompatibilitéitsprobleemer mat PHP 7.4). Gutt, am Allgemengen, gesäit de Projet opginn.
Also loosst eis d'Performance vu Stecker am Synchronmodus moossen:
Wéi kann aus der Grafik gesi ginn, weist de PECL Connector (Tarantool) besser Leeschtung am Verglach zum PHP Connector (Client). Awer dëst ass net iwwerraschend, well dee leschte, nieft dem Ëmsetzung an enger méi lueser Sprooch, tatsächlech méi Aarbecht mécht: en neien Objet gëtt mat all Uruff erstallt Ufro и Äntwert (am Fall vu Select - och Critèrien, an am Fall vun Update / Upsert - Operatiounen), getrennten Entitéiten Connexioun, Packer и Handler si addéieren och Overhead. Natierlech kënnt Flexibilitéit zu engem Präis. Wéi och ëmmer, am Allgemengen weist de PHP Dolmetscher gutt Leeschtung, och wann et en Ënnerscheed ass, ass et onwichteg a wäert vläicht nach manner sinn wann Dir Preloading am PHP 7.4 benotzt, fir net JIT am PHP 8 ze ernimmen.
Loosst eis weidergoen. Tarantool 2.0 huet SQL Support agefouert. Loosst eis probéieren d'Auswiel, d'Insert, d'Aktualiséierung an d'Delete Operatiounen mat dem SQL Protokoll auszeféieren an d'Resultater mat den noSQL (binäre) Äquivalenten ze vergläichen:
D'SQL Resultater sinn net ganz beandrockend (loosst mech drun erënneren datt mir nach ëmmer de Synchronmodus testen). Wéi och ëmmer, ech géif mech net am Viraus opreegen; SQL Support ass nach ëmmer an der aktiver Entwécklung (relativ viru kuerzem, zum Beispill, Ënnerstëtzung gouf bäigefüügt ) an, no der Lëscht beurteelen , de SQL-Motor wäert an der Zukunft eng Rei Optimisatiounen erliewen.
async
Gutt, loosst eis elo kucken wéi d'Async Extensioun eis hëllefe kann d'Resultater hei uewen verbesseren. Fir asynchrone Programmer ze schreiwen, gëtt d'Extensioun eng API baséiert op Coroutines, déi mir benotzen. Mir fannen empiresch eraus datt déi optimal Zuel vu Coroutine fir eis Ëmwelt 25 ass:
"Verbreet" 10,000 Operatiounen iwwer 25 Coroutinen a kuckt wat geschitt:
D'Zuel vun Operatiounen pro Sekonn ëm méi wéi 3 Mol fir !
Leider huet de PECL Connector net mat ext-async ugefaang.
Wat iwwer SQL?
Wéi Dir kënnt gesinn, am asynchrone Modus ass den Ënnerscheed tëscht dem binäre Protokoll an SQL bannent der Feelermarge ginn.
Swolle
Nach eng Kéier fanne mir déi optimal Zuel vu Coroutinen eraus, dës Kéier fir Swoole:
Loosst eis um 25. Loosst eis dee selwechten Trick widderhuelen wéi mat der Async Extensioun - verdeelt 10,000 Operatiounen tëscht 25 Coroutinen. Zousätzlech addéiere mir en aneren Test, an deem mir all d'Aarbecht an 2 zwee Prozesser opdeelen (dat ass, all Prozess wäert 5,000 Operatiounen an 25 Coroutines maachen). Prozesser ginn erstallt mat SwooleProcess.
Resultater:
Swole weist e bësse méi niddereg Resultat am Verglach mat Async wann se an engem Prozess lafen, awer mat 2 Prozesser ännert d'Bild dramatesch (d'Nummer 2 gouf net zoufälleg gewielt; op menger Maschinn war et 2 Prozesser déi dat bescht Resultat gewisen hunn).
Iwwregens huet d'Async Extensioun och eng API fir mat Prozesser ze schaffen, awer do hunn ech keen Ënnerscheed gemierkt vu Benchmarks an engem oder méi Prozesser ze lafen (et ass méiglech datt ech iergendwou vermësst hunn).
SQL vs binäre Protokoll:
Wéi mat Async gëtt den Ënnerscheed tëscht binären a SQL Operatiounen am asynchrone Modus eliminéiert.
Parallel
Zënter der Parallel Extensioun ass net iwwer Coroutines, mee iwwer Threads, loosst eis déi optimal Unzuel vu parallele Threads moossen:
Et ass gläich wéi 16 op menger Maschinn. Loosst eis Connector Benchmarks op 16 parallel thread lafen:
Wéi Dir gesitt, ass d'Resultat nach besser wéi mat asynchronen Extensiounen (net zielt Swoole op 2 Prozesser). Notéiert datt fir de PECL Connector d'Aktualiséierung an Upsert Operatiounen eidel sinn. Dëst ass wéinst der Tatsaach datt dës Operatiounen mat engem Feeler gescheitert sinn - ech weess net ob et de Schold vum ext-parallel, ext-tarantool oder béid war.
Loosst eis elo SQL Leeschtung vergläichen:
Notéiert d'Ähnlechkeet mat der Grafik fir Stecker déi synchron lafen?
Zesummen
A schliisslech, loosst eis all d'Resultater an enger Grafik zesummefaassen fir d'Gesamtbild fir déi getest Extensiounen ze gesinn. Loosst eis just een neien Test un d'Diagramm addéieren, wat mir nach net gemaach hunn - loosst eis Async Coroutines parallel mat Parallel* lafen. D'Iddi fir déi uewe genannte Verlängerungen z'integréieren ass scho Auteuren, awer kee Konsens gouf erreecht, Dir musst et selwer maachen.
* Et war net méiglech Swoole Coroutines mat Parallel ze starten; et schéngt datt dës Extensiounen inkompatibel sinn.
Also, d'Finale Resultater:
Amplaz vun enger Konklusioun
Menger Meenung no sinn d'Resultater ganz wiirdeg erausgestallt, a fir e puer Grënn sinn ech sécher datt dëst net d'Limite ass! Egal ob Dir dëst an engem richtege Projet eleng fir Iech selwer muss entscheeden, ech wäert nëmme soen datt et fir mech en interessanten Experiment war deen Iech erlaabt ze evaluéieren wéi vill Dir aus engem synchronen TCP Connector mat minimalem Ustrengung "auspresse" kënnt. Wann Dir Iddien hutt fir Benchmarks ze verbesseren, wäert ech frou Är Pull Ufro ze berücksichtegen. All Code mat Startinstruktiounen a Resultater gëtt an enger separater publizéiert .
Source: will.com