Alexey Romanenko: Ang pangalan ko ay Alexey Romanenko, nagtatrabaho ako sa RBC. Ang paksa ng ulat na ito ay medyo kontrobersyal. Tila, bakit mag-compile ng mga script ng PHP kung ang lahat ay tila gumagana nang ganoon?

Marahil ang pangunahing tanong ay: "Bakit?" Sa pangkalahatan, ang layunin ng pagtatanghal na ito ay subukang maunawaan kung ang naturang compilation ay kailangan, kung gayon, bakit, sa anong anyo at para kanino.

Ano ang isang PHP compiler?

Una, isang maikling pangkalahatang-ideya kung ano ang isang PHP compiler. Sasabihin ko sa iyo kung paano ito gumagana, kung ano ito at kung paano mo ito mapabilis.

Ang unang functional module ay ang tinatawag na SAPI (Server API), na nagbibigay ng interface para sa pag-access ng PHP mula sa iba't ibang kliyente (Apache, ilang uri ng CGI server (Common Gateway Interface) at iba pa). Mayroon ding naka-embed na SAPI, na nagpapahintulot sa iyo na i-embed ang PHP sa anumang application.

Ang pangalawang pangunahing bahagi ay ang PHP Core, na nagpoproseso ng mga kahilingan, nagpapatupad ng lahat ng trabaho sa network, file system at pag-parse ng mga script mismo.

Ang ikatlong pandaigdigang bahagi ay ang Zend Engine, na nagsasama-sama ng aming mga script sa ilang bytecode, nagpapatupad nito sa virtual machine nito at pinangangasiwaan ang pamamahala ng memorya (nagpapatupad ng mga komprehensibong allocator).

Isa sa pinakamahalaga at pinakamalaking bahagi ay ang Extentions module, na nagpapatupad ng 99% ng ginagamit namin sa PHP. Ang mga ito ay alinman sa "mga wrapper" para sa ilang library, o functionality, o mga klase, built-in na library, atbp. Maaari din kaming magsulat ng aming sariling mga extension.

Paano isinasagawa ang script mismo?

Una. Nangyayari ang lexical analysis - ang file ay na-download, na-parse, ang lahat ng mga character mula sa set ng file na ito ay isinalin sa isang tiyak na hanay ng mga token, na kung saan kami ay gumagana sa.

Ang yugto ng pag-parse ay nag-parse ng mga token na ito. Batay sa pagsusuri na ito, ang isang tiyak na istruktura ng gramatika ay pinagsama-sama, sa batayan kung saan bubuo ang bytecode.

Sa dulo, ipapatupad ito ng Zend Engine. Ang resulta ay ibinalik sa kliyente.

Pinag-uusapan natin ang tungkol sa mataas na pagkarga. Kung uulitin mo ang pamamaraang ito ng mga aksyon sa bawat oras, ang lahat ay gagana nang napakabagal. Kapag ang aming interpreter ay nakatanggap ng ilang daan o libong mga kahilingan sa parehong oras, ang bilis ay wala lang.

Ngunit may mga solusyon. Matagal na silang kilala.

Paano makamit ang acceleration?

Ang pinakasimpleng, pinakamurang at mahusay na nasubok na solusyon ay bytecode caching. Sa halip na dumaan sa yugto ng pag-parse, ini-cache lang namin ang aming bytecode. Mayroong mga espesyal na extension para dito - kilala ang mga ito sa lahat na nagtrabaho sa PHP - ito ay APC, eAccelerator, Xcache at iba pa. Pinapatupad lang ng Zend Engine ang bytecode.

Ang pangalawang opsyon ay code profiling, pagtukoy ng mga bottleneck. Maaari naming muling isulat ang isang bagay bilang mga extension ng PHP (ito ay magiging isang extension sa C/C++), i-compile ito at gamitin ito bilang mga module.

Ang ikatlong opsyon ay mas pandaigdigan - kalimutan ang tungkol sa PHP at muling isulat ang lahat. Sa pangkalahatan, ang pagpipiliang ito ay may karapatan sa buhay, ngunit lamang sa kaso kapag walang sapat na PHP code. Sa malalaki at malalaking proyekto (o matagal nang umiral), marami sa mga ito ang kadalasang naiipon, at aabutin ng mahabang panahon para muling isulat ang lahat. Hindi ka papayagan ng mga kinakailangan sa negosyo na gawin ito. Sa pangkalahatan, ang pagsusulat ng isang bagay sa PHP, halimbawa, para sa isang front-end server, ay hindi masyadong mahaba, dahil ito ay isang simpleng wika. Binibigyang-daan ka nitong mabilis na gumawa ng mga bagay na mas matagal gawin sa mababang antas ng mga wika.

Mayroong alternatibong opsyon, na kamakailan lamang ay naging laganap, at iyon ay ang pag-compile ng PHP sa isang lugar, sa isang bagay na mas mabilis.

Mag-compile tayo ng isang bagay?

Sa salitang "compilation" ang ibig kong sabihin ay ang pagsasalin ng PHP script code sa ibang bagay, sa ibang code.

Sa kasong ito maaari itong maging ng dalawang uri.

Ang native code ay isang uri ng binary file na maaaring isagawa sa isang pisikal na makina.

Hindi katutubong code. Maaari kang mag-compile ng ilang bytecode na maaaring isagawa sa isa pang virtual machine, halimbawa, sa JVM.

Paano ka makakaipon ng katutubong code mula sa PHP?

Roadsend compiler. Ang sequel nito ay si Raven. Mayroon ding PHC (ito ay isang PHP Open Source compiler). Kamakailan, lumitaw din ang HipHop (Facebook).

Magbibigay ako ng maikling pangkalahatang-ideya ng kung ano ang maaaring gawin para sa hindi katutubong code. Sa pagkakaalam ko, may 3 working options. Ito ay bytecode generation para sa Java at bytecode generation para sa .Net: Quercus, Project Zero, Phalanger. Hindi ko isasaalang-alang ang compilation sa non-native code, dahil hindi namin ito ginagamit. Bumalik tayo sa compilation sa native code.

Sa aking opinyon, ang pinakalumang compiler ay Roadsend. Ito ay nagsimulang binuo medyo matagal na ang nakalipas, noong 2002. Ito ay orihinal na isang komersyal na aplikasyon. Ito ay sarado, noong 2007 lamang ito ay inilabas sa Open Source. Mayroong isang napakakomplikadong scheme ng compilation: isang partikular na Bigloo compiler ang ginagamit para sa wika ng Scheme, pagkatapos ay nabuo ang native code. Hindi ginagamit ng compiler na ito ang Zend Engine.

Maaari tayong bumuo ng hiwalay na executable binary o bumuo ng module para sa Apache. Posible rin na bumuo ng isang binary na gagana bilang isang web server. Ngunit hindi ito gumagana. Hindi ko alam kung bakit, ngunit hindi ito gumagana para sa akin.

Sa pagkakaalam ko, ang trabaho sa Roadsend ay kasalukuyang hindi isinasagawa. Nag-evolve ito sa proyektong Raven, na ganap na muling isinulat sa C++. Bilang isang compiler, gumagamit ito ng LLVM upang makabuo ng code.

Sa ngayon ang lahat ay mukhang napaka-promising.

Pero under construction pa rin ito. Kahit na sa dokumentasyon ay may mga pahiwatig na hindi kami bubuo ng mga binary. Teka.

Nakakalungkot ang mga pangyayari kung wala tayong PHC. Ito ay isang OpenSource compiler. Ito ay binuo mula noong 2005. Isa sa mga disadvantage nito: gumagamit ito ng built-in na SAPI. Hindi namin iniiwan ang Java machine, ang Zend Engine. Sa esensya, isinasalin nito ang PHP code sa PHP extension module code. Pagkatapos nito, nag-compile ito, ngunit ang proseso ng pagpapatupad, muli, ay nagsasangkot ng Zend Engine.

Halimbawa ng paggamit ng PHC

Katulad ng kung paano kami nagtatrabaho, halimbawa, sa mga conventional compiler, gcc. Ang una ay nagpapakita na mayroong isang binary, maaari din nating gawing simple ang C code. Dahil ang parehong gcc ay ginagamit sa loob pagkatapos mabuo ang code na ito, maaari naming gamitin ang mga flag na iyon na nilayon para sa pag-optimize at iba pang mga bagay.

Pinag-uusapan namin ang tungkol sa isang application na tumatakbo sa command line.

Upang ilunsad ang isang web application kailangan mong magsagawa ng ilang mga hakbang, ito ay medyo kumplikado. Una kailangan mong bumuo ng isang extension, pagkatapos ay i-compile ang code, at pagkatapos ay sa anumang paraan (alinman sa dynamic o statically) ikonekta ito.

Mga pangunahing benepisyo ng PHC

Sa esensya, pareho ang PHP na ginagamit namin, ganap kaming magkatugma. Sinusuportahan ang lahat ng iba pang extension. Ginagamit namin ang lahat ng aming pinagsama-sama. Medyo magandang dokumentasyon.

Siyanga pala, ang isa sa mga karagdagang bonus ng PHC ay na maaari mong buuin ang XML na gawa ng aming script batay sa kung paano binuo ang XML, kung minsan ito ay maaaring maging kapaki-pakinabang.

Cons

Sa aking opinyon, ito ay isang mababang binary, dahil mayroon pa rin itong dependency sa Zend Engine. Mayroon ding ilang kumplikado sa mga tuntunin ng pagkonekta ng mga proyekto sa web.

Tungkol sa pangunahing bagay

Ang ulat na ito ay malamang na hindi mangyayari kung ang HipHop, isang solusyon mula sa Facebook, ay hindi lumitaw. Nakaipon din ang mga tagalikha nito ng malaking halaga ng PHP code at matagal na nag-isip kung ano ang gagawin dito.

Sa pagkakaintindi ko, matapos tanggihan ang mga opsyon para muling isulat ang lahat, napagpasyahan na magsulat ng ilang uri ng tagasalin (sa kasong ito sa C++ code). Ang proyekto ay medyo bata pa; ito ay opisyal na inilabas lamang noong Pebrero ng taong ito. Ang PHP code ay isinalin sa C++ code at pagkatapos ay nabuo gamit ang mga karaniwang tool sa iyong operating system. Gayunpaman, sa ngayon ay ang Linux operating system lamang ang sinusuportahan.

Kahapon lang tinanong ko ang isang kinatawan ng Facebook tungkol sa desisyong ito. Sinabi niya na kasalukuyang 100% ng PHP code ay pinagsama-sama sa pamamagitan ng HipHop. Ang code ay hindi gumagana sa dalisay nitong anyo sa pamamagitan ng PHP interpreter. Muli, inihayag ng mga tagalikha ang isang makabuluhang pagbawas sa pagkarga ng processor.

Pangunahing pag-andar ng HipHop

Direkta itong bumubuo ng binary mismo, na maaaring isagawa sa command line. Mayroong isang pagpipilian para sa paglulunsad nito bilang isang streaming web server. Mayroon ding hiwalay na built-in na debugger. Maaari itong mag-debug ng mga script sa parehong lokal at malayuan (ito ay gagana bilang isang server).

Ang proseso ng pagpupulong ay medyo hindi mahalaga. Mayroong isang paglalarawan, ngunit hindi ito nakolekta sa lahat ng dako. Sa ngayon, tulad ng sinabi ko, ang lahat ay binuo para sa Linux, at sa una ang lahat ay "iniayon" para sa 64 bits. Bagama't ang 32 bits ay sinusuportahan na ngayon ng eksperimento. Ngunit nagawa kong tipunin ito at i-patch ito ng kaunti - sa pangkalahatan, ginawa nito ang lahat ng ito, dahil hindi ito binuo bilang default.

Bilang karagdagan, mayroon silang sariling mga bersyon ng libcore at, sa palagay ko, mayroong ilang mga aklatan na kailangan ding i-patch. Sa pangkalahatan, ang proseso ng pagpupulong ay hindi ganoon kasimple.

Sa output pagkatapos ng pagpupulong, nakatanggap kami ng isang tiyak na hphp file, na isang tagasalin ng aming PHP code sa C++. Kung titingnan natin ang mga bandila, medyo marami sila. Na-highlight ko dito ang ilang mga pangunahing bagay na maaaring kailanganin mo.

Maaari kaming gumamit ng file sa HDF format bilang configuration file (config), na tumutukoy sa iba't ibang mga direktiba. Maaari naming itakda ang antas ng error at iba pang mga bagay doon (Ang HDF ay lahat ng magagamit sa isang structured form). Maaari rin nating kunin ang mismong config mula sa database o gamitin ito nang direkta sa command line.

Itinakda namin ang antas ng pag-log sa panahon ng compilation: ipakita ang lahat ng mga error o ipakita din ang mga babala, karagdagang impormasyon, o sa pangkalahatan ay panatilihin ang isang buong log ng lahat ng nangyayari.

Ang isang napaka-kapaki-pakinabang na direktiba ay input_list=FILE, na nagpapahintulot sa amin na tukuyin ang isang listahan ng mga script na gusto naming i-compile. Ito rin ay nagkakahalaga ng pagbanggit ng isang direktiba tulad ng lazy-bind. Maaari naming tukuyin ang lahat ng mga file ng proyekto - ang mga isasama-sama.

Halimbawa ng pagpapatakbo ng PHP script compilation

Ang ikatlong antas ng pag-log ay na-install, mayroong medyo pangkalahatang impormasyon sa oras, maaari mong makita kung gaano katagal ito kinuha. Sa katunayan, ang script ay medyo simple. This is the usual “Hello, World”, kaka-screenshot ko lang.

Ang pinakamabigat na file ay ang aming "program" binary, ang laki nito ay 28 MB. Sa pangkalahatan, ang aming "Hello, World" ay tumitimbang ng 28 MB. Nais kong tandaan na bilang karagdagan sa karaniwang linya na "Echo "Hello, World!", ang binary na ito ay may kasamang higit pa. Ito ay isang ganap na web server, isang ganap na server para sa pangangasiwa.

Anong ginagawa natin?

Mayroon kaming "Hello..." sa C++, na gumaganap ng isang function na binubuo ng isang linyang "echo "Hello, World". sa C++.

Ito ang resultang programa. Naglalaman na ito ng ilang iba't ibang mga susi para sa iba't ibang mga pagsasaayos, ngunit babanggitin ko lamang ang ilan sa mga ito.

Ito ay --mode, ito ang launch mode ng aming programa. Maaari naming patakbuhin ito nang direkta (mula sa command line) o sa web server o ganap na daemon mode. Mayroong ilang higit pang mga pagpipilian, ngunit ang mga ito ay hindi mahalaga.

config ay ginagamit sa parehong format. Hindi ako nagbigay ng direktiba dahil marami sila. HipHop ay may kasamang dokumentasyon. Wala ito sa site ng wiki, ngunit ang dokumentasyon ay ibinigay kasama ang pamamahagi, kung saan malinaw na inilarawan ang lahat. Hindi ko rin inasahan na ang paglalarawan ay magiging napakadetalyado.

Upang tumakbo sa server mode, maaari naming tukuyin ang port. Para sa pangangasiwa, ginagamit ang isang hiwalay na port, kung saan maaari kang magpadala ng ilang mga kahilingan na nagpapahintulot sa iyo na pamahalaan ang server. Kung mayroon kaming isang server ng pag-debug na tumatakbo, pagkatapos ay ipinapahiwatig namin ang host at port kung saan kami ay "magbibigkis" para sa pag-debug.

Halimbawa ng paglunsad

Halimbawa, tinukoy namin ang port 9999 para sa pagsasahimpapawid Sa pamamagitan ng pagsasagawa ng mga simpleng kahilingan sa http, maaari kaming makatanggap ng alinman sa mga istatistika, o kahit papaano ay pamahalaan ang server, o makakuha ng ilang karagdagang impormasyon. Sa pangkalahatan, ito ay napaka-maginhawa.

Pagpipilian upang makakuha ng impormasyon sa katayuan

Posibleng matanggap ang status ng server na itinakda sa iba't ibang mga built-in na format (xml, json, html). Mahalaga, ang impormasyon ay ibinibigay tungkol sa proseso ng master ng server mismo at ang mga humahawak - mga thread na nagpoproseso ng mga kahilingan.

Karagdagang Istatistika

Sa katunayan, maraming mga istatistika ang ibinigay. Dahil ang HipHop ay katutubong gumagana sa memcache at SQL sa anyo ng MySQL, nagbibigay ito ng detalyadong impormasyon sa lahat ng mga operasyon na ginagawa kasama nito.

Kumpletuhin ang mga istatistika ng memorya

Mayroong isang napaka-kapaki-pakinabang na tampok dito - Application Stats. Gamit ang mga karagdagang function ng HipHop mismo sa PHP, maaari kaming sumulat ng mga istatistika sa aming mga script, na pagkatapos ay natatanggap namin sa pamamagitan ng regular na pag-access sa http.

Pag-debug

Gaya ng nasabi ko na, posibleng gamitin ang built-in na "debug" para i-debug ang mga script. Ito ay napaka-maginhawa dahil ang hphpi interpreter ay gumagana nang katulad sa kung ano ang aming pinagsama-sama. Mayroong pagkakaiba sa "pag-uugali" ng mga script kapag ang mga ito ay naisakatuparan sa karaniwang PHP at kapag gumagamit ng ilang pinagsama-samang data. Upang i-debug kung ano ang pinagsama-sama, sumulat ang Facebook ng isang hiwalay na interpreter.

Sa unang kaso, pinapatakbo namin ang code gamit ang switch na "-f" at tingnan kung paano kumikilos ang file; lahat ng output ay napupunta sa stdout. O maaari naming patakbuhin ito sa debug mode at makapasok sa interactive na debugger. Ito ay halos kapareho sa karaniwang GDB: maaari ka ring magtakda ng mga breakpoint, tumakbo, magpasok ng mga variable na halaga, track, at higit pa.

Isa sa mga karagdagang tampok

Mayroon kaming isang programa na lumabas pagkatapos ng compilation. Maaari itong magamit bilang isang RPC server. Nagpapatakbo kami ng mga kahilingan sa http, at sa pamamagitan ng pagtawag sa function ng params, maaari kaming magpasa ng isang parameter bilang isang json array o isang hiwalay na parameter. Ibabalik namin ang json, na nagbabalik ng mga resulta ng mga function na ito. Ito ay napaka-maginhawa - ang kinakailangang pag-andar ay naka-built in na mula pa sa simula.

Kahinaan ng HipHop

Sa kasalukuyan, hindi sinusuportahan ng HipHop ang mga construct at function ng wika tulad ng eval(), create_function() at preg_replace() sa /e, bagama't ang lahat ng ito ay kahalintulad ng eval(). Gayunpaman, sa mga pinakabagong release, sa aking opinyon, maaari mo pa ring paganahin ang eval() sa pamamagitan ng config. Ngunit hindi inirerekomenda na gawin ito. Sa pangkalahatan, ang paggamit ng eval() ay masama.

Ang pangunahing bentahe ng HipHop

Siyempre, ang pangunahing bentahe ay suporta mula sa Facebook. Gumagana ito at medyo aktibong binuo. Ang isang komunidad ng mga developer ay umuusbong sa paligid ng proyektong ito. Isang ganap na bagong pagpapatupad ng PHP ang naisulat.

Tulad ng sinabi ko na, ang kalamangan ay nabuo ang katutubong code. Inaangkin ang pagtaas ng pagganap sa pamamagitan ng pagbabawas ng mga gastos sa pag-load ng processor (kinukumpirma ito ng mga pagsubok).

Ito ay medyo nababaluktot sa pagsasaayos. Ako ay kawili-wiling nagulat na mayroong ilang mga pagpipilian para sa pagpapasadya. Sa tingin ko ito ay dahil sa ang katunayan na ang proyekto ay talagang gumagana. Lahat ng ginagamit ay dinadagdagan.

Tulad ng nabanggit ko na, ang HipHop ay nagbibigay ng maraming karagdagang mga tampok. Kabilang dito ang paggamit bilang isang RPC server, pangangasiwa, iba't ibang istatistika at marami pa. Sa pamamagitan ng paraan, mayroon ding isang API para sa pagtatrabaho sa iba pang mga wika.

Napakahusay na dokumentasyon ang naisulat para sa solusyong ito. Isa pang bentahe: ito ay isang solusyon na talagang handa nang gamitin sa produksyon (halimbawa: Facebook).

Cons

Ang pangunahing kawalan ay na sa sandaling ito ay isang medyo limitadong bilang ng mga module ay suportado. Halimbawa, kapag nagtatrabaho sa isang database, maaari lamang kaming gumamit ng mga function para sa pagtatrabaho sa MySQL. Walang suporta sa PostgreSQL dito.

Mayroon ding isang bagay tulad ng pagiging kumplikado ng pagpupulong, na nabanggit ko na. May mga problema sa pagbuo sa 32-bit system. Ngunit sa tingin ko ito ay maayos sa lalong madaling panahon. Sa ngayon, compilation lang mula sa PHP 5.2 ang ginagamit. Ang Bersyon 5.3 ay hindi pa sinusuportahan, ngunit susuportahan gaya ng ipinangako.

Ano ang hindi mo dapat asahan mula sa compilation sa pangkalahatan at mula sa HipHop sa partikular?

Ang pag-compile ay hindi magpapabilis sa iyong mabagal na mga query sa SQL sa database. Kung ang bottleneck ay ang database, pagkatapos ay i-compile ito o huwag i-compile ito, wala itong magandang maidudulot.

Hindi pinapabilis ng compilation ang static loading, dynamic loading lang. Ginagawa nitong mas mahirap ang pag-debug. Maraming tao ang malamang na sanay sa katotohanan na ang lahat ay medyo madaling i-debug sa PHP. Hindi na ito mangyayari sa panahon ng compilation. Bagama't, tulad ng nabanggit ko, ginawa ng Facebook ang prosesong ito bilang madali hangga't maaari, kung wala ito ay magiging mas mahirap na mag-compile sa bawat oras.

Huwag asahan na ito ay isang uri ng "balang pilak" na lulutasin ang lahat ng iyong mga problema. Sa katunayan, nalulutas ng compilation ang isang medyo makitid na hanay ng mga problema. Kung oo, maaaring makatulong ito.

Anong mga problema ang nalulutas ng compilation?

Binabawasan nito ang pag-load sa CPU, dahil kapag aktibong nagtatrabaho sa PHP at isang malaking bilang ng mga kahilingan, ang pag-load dito ay tumataas nang malaki. Siyempre, gusto kong magsagawa ng ilang mga pagsubok.

Pagsubok

Ang unang pagsubok (ang pinakasimpleng) ay isang medyo mahal na operasyon na tumatagal ng medyo mahabang oras upang makumpleto. Sa mga pagsubok, sinubukan kong i-abstract ang aking sarili at hindi gumawa ng mga kahilingan gamit ang ilang panlabas na mapagkukunan.

Ang pag-load ay bumagsak nang buo sa processor. Ang pagsubok ay nagpakita na ang HipHop ay "nanalo" laban sa lahat: ito ay gumagana halos isa at kalahating beses na mas mabilis kaysa sa karaniwang PHP compiler. Napakabagal na naipasa ng PHC ang pagsusulit na ito.

Para sa pangalawang pagsubok sa pagganap, ginamit ko ang opisyal na script ng PHP, na maaaring i-download mula sa SVN. Ito ay gumaganap ng isang bilang ng mga function na nagsasagawa ng pag-uuri, pagtatalaga, pagbubuod - medyo mahal na mga operasyon mula sa isang mathematical na punto ng view.

Nauna na naman ang HipHop. Bukod dito, sa karaniwang PHP ang pagkakaiba ng oras ay humigit-kumulang 3 beses. Ang PHC ay gumanap nang mas mahusay dito, ngunit halos kalahating kasing sama ng HipHop.

Pangunahing ginagamit ang PHP para sa mga thread na humahawak sa mga kahilingan sa http - ito ay dapat tandaan.

Maraming mga karaniwang pagsasaayos (Apache na may PHP, Nginx na may fpm-php at plug-in APC para sa pag-cache ng code). Bilang isang ikalimang opsyon - HipHop.

Upang maging matapat, nagsagawa ako ng mga pagsubok hindi sa server, ngunit sa isang laptop. Ang mga numero, siyempre, ay maaaring hindi ganap na tumutugma sa katotohanan, ngunit sa kasong ito ang mga resulta ay normal. Kapansin-pansin na habang tumataas ang load, sabay na tumataas ang bilang ng mga kahilingan at kabuuang bilang ng mga kahilingan. Sunod ay RPS. Sinubukan namin ang isang karaniwang pahina na may kasamang 10 simpleng pagsasama. Sa esensya, ito ay sumusubok sa PHP bilang isang interpreter.

Tanong mula sa madla: Ano ang mga numero sa cell - segundo?

Alexey Romanenko: Ito ay fps.

Dito natin mahihinuha na habang dumarami ang mga sabay-sabay na kahilingan, napakahusay ng pagkilos ng HipHop.

Makikita na ang paggamit ng APC ay karaniwang kasanayan. Ipinapakita nito na nagdaragdag ito, halimbawa, bilang Apache ng pagpapalakas ng pagganap ng halos 2 beses. Nangyayari din ito sa Nginx. Ngunit ang katotohanan na ang Nginx ay mabagal ay hindi nangangahulugan na ang package na ito ay mas masahol pa. Isang tiyak na pagsubok lamang. Kung talagang susubukan natin dito, ang Apache ay "mamamatay" sa mabagal na mga kahilingan.

Marahil ay nais nating maunawaan kung kailangan natin ito o hindi.

Kailan mo dapat isipin ang tungkol sa compilation?

Malamang, kailangan ito kapag nakita natin na ang ating bottleneck ay ang CPU. Kung kami ay nakatali sa CPU gamit ang PHP bilang karaniwang interpreter, marahil ay nagkakahalaga ng pagsasaalang-alang na maaaring bahagi ng proyekto ang maaaring i-compile.

Para sa ilang mga kaso kapag ang iyong aplikasyon ay nangangailangan ng awtonomiya upang tumakbo, ang pamamaraang ito ay malamang na hindi angkop.

Pagbabawas ng bilang ng mga server. Kapag maraming mga server, pagkatapos ay sa pamamagitan ng pagbabawas ng pagiging produktibo ng 2 beses, halos nagsasalita, binabawasan din namin ang bilang ng kalahati. Kapag ito ay isang server, ito ay walang kahulugan, ngunit kapag mayroong 100-200 sa kanila, malamang na ito ay makatuwiran.

Ang pangunahing dahilan kung bakit nagsimulang gumamit ang Facebook ng HipHop ay ang pagkakaroon ng malalaking halaga ng PHP code na walang paraan upang muling isulat (o walang sinuman, o ito ay mahal lang). Ang pagtaas ng pagiging produktibo ng 2 beses ay mabuti na.

Malamang lahat. Naghihintay ako ng mga tanong.

Mga tanong at sagot

Tanong mula sa madla: Hello. Mangyaring sabihin sa akin kung mayroon kang anumang iba pang mga halimbawa ng matagumpay na pagpapatupad ng Hiphop, bukod sa Facebook. Gusto mo bang ilipat ang RBC website, halimbawa, sa HipHop? Alexey Romanenko: Sisimulan ko sa pangalawa. Ang RBC website ay mahirap isalin. Tungkol sa matagumpay na pagpapatupad. Ako mismo ang nag-compile ng PHP Unit, matagumpay itong na-compile. Gayundin, sa pagkakaalam ko, matagumpay na nag-compile ang PHP Bunty board. Ang ilang mga organisasyon, sa katunayan, ay gumagamit na ng compilation. Ipapakita ng mga karagdagang pagsusuri kung gaano katuwiran ang paggamit ng proyektong ito. Tanong mula sa madla: Maaari ka bang magbigay ng isang halimbawa ng isang organisasyon na gumagamit nito? Alexey Romanenko: Sa totoo lang, hindi ko sasabihin sa iyo ngayon, ngunit ito ang Kanluran. Sa pagkakaalam ko, walang gumagamit nito dito. Tanong mula sa madla: Ano ang pagkakaiba sa runtime maliban sa kakulangan ng suporta para sa ilan sa mga tampok na iyong binanggit. Gaano kapanganib ang pagsasalin ng isang "live" na proyekto? Alexey Romanenko: Ang pagkakaiba ay ang anumang pinagsama-samang programa ay maaaring mag-crash. Marahil ay lilitaw ang ilang mga problema na hindi pa natukoy. Sa katunayan, mayroong isang bilang ng mga pagkakaiba sa "pag-uugali" ng PHP mismo. Hindi ko sila isinama dahil mas detalyadong impormasyon ang makikita sa dokumentasyon. Ang Facebook team ay nagsulat ng sarili nitong interpreter, na, sa katunayan, 99.9% katumbas ng isa na gagana sa compiled form. Mas mainam na subukan ang iyong code hindi sa isang karaniwang interpreter ng PHP, ngunit, tulad ng sinabi ko, sa hphpi para sa PHP.

Ang pag-compile ng PHP mula sa source code ay kadalasang ginagawa sa mga sistemang katulad ng Unix. Ang mga nagtatrabaho sa isang kapaligiran ng Windows OS ay malamang na magda-download at mag-install ng PHP mula sa mga binary na pakete. At bagama't hindi ako sumasang-ayon na mas madaling gumamit ng precompiled na solusyon, kahit na sa mga Unix system ay may ilang mga benepisyo na maaaring dumating sa pag-compile ng binary mula sa pinagmulan. Lahat sa lahat:

• May kakayahan kang i-fine-tune ang huling produkto sa panahon ng compilation. Siguro gusto mo ng isang partikular na extension na direktang nag-compile sa binary sa halip na i-load ito bilang isang panlabas na library. O baka gusto mong i-off ang isang bagay na karaniwang available bilang default.
• Maaari kang gumawa ng isang trick, sa panahon ng proseso ng pagsasama-sama kung kinakailangan, na maaaring mapabuti ang pagganap para sa isang partikular na kapaligiran (siyempre, ipinapalagay na alam mo na kung ano ang iyong ginagawa sa kasong ito. hindi mo mababasa ang artikulong ito !).
• Ang pag-compile ay maaaring ang tanging paraan upang mapagana ang mga bagay kung ang mga pinagsama-samang binary ay binuo sa mga mas lumang bersyon ng pagsuporta sa software at mga aklatan, at tumatakbo ka na ngayon sa isang bagong system.

Babala: Ang compilation ay maaaring nakakabigo, lalo na sa Windows! Dapat mong tiyakin na ang build environment ay naka-set up nang tama, matutunan kung paano gamitin nang maayos ang compiler at iba pang mga tool sa build, at matugunan ang anumang mga dependency sa library. Inaasahan namin na ang artikulong ito ang iyong unang hakbang sa pagtagumpayan ng marami sa mga hadlang na ito.

Pagse-set up ng build environment

Ang PHP ay nakasulat sa C at samakatuwid ang isang C compiler ay kinakailangan kung ikaw ay gagawa ng PHP mula sa source code. Ang C++ ay isang super suite ng C, kaya ang isang mahusay na C++ compiler ay dapat na makapag-compile ng C code, at bagaman hindi ito palaging nangyayari. Para sa Windows, ang Visual Microsoft, C ++ Express (na tatawaging VC ++) ay malayang magagamit sa website ng Microsoft. Ang 2010 na edisyon ay ginamit.

Kapag pumipili ng bersyon ng compiler, dapat mong tandaan kung paano mo tatakbo ang PHP. Kung kailangan mong magtrabaho sa mod_php ng ​​opisyal na pinagsama-samang mga binary ng Apache, at gusto mong, i-compile ang PHP gamit ang Visual Studio 6, dahil ito ang bersyon ng compilation ng Apache. Dapat i-target ng module ang parehong runtime library bilang Apache, sa kasong ito msvcrt.dll. Kung bubuo ka rin ng Apache mula sa pinagmulan, o kung tatakbo ka ng PHP bilang FastCGI o CLI, hindi ito problema at gagana nang maayos ang 2010.

Dapat mo ring i-install ang software ng Windows Development Kit (SDK). Ang SDK ay nagbibigay sa amin ng mahahalagang header file para sa Windows platform na kakailanganin naming matagumpay na ma-compile. Ito rin, bersyon 7.1 ang ginamit.

I-install ang compiler at pagkatapos ay ang SDK. Hindi ko tatalakayin ang pag-install dahil pareho silang may graphical installation wizard na gagabay sa iyo sa buong proseso.

Kung mayroon kang gumaganang compiler build, i-download ang Binary Tools at Known Packages mula sa windows.php.net. Ang binary tools package (ginagamit ko ang 20110915 archive) ay naglalaman ng mga development tool tulad ng re2c, bison, at ilang karagdagang command na kakailanganin mong bumuo ng PHP. Ang kilalang package (ginagamit ko ang 5.4 archive dahil tumutugma ito sa bersyon ng PHP na iko-compile ko) ay naglalaman ng kaunting mga header at dependency na library na kailangan, hal zlib.h.

Malamang na hindi sinasabi na gusto mong i-download din ang pinagmulan ng PHP mula sa windows.php.net. Sa pagsulat na ito, ang kasalukuyang bersyon ng PHP ay 5.4.6, kaya iyon ang numero ng bersyon na makikita mo sa mga halimbawa.

Magandang ideya na gumawa ng workspace kung saan maaari mong i-extract ang source code at i-compile ito nang sa gayon ay hindi ito makaapekto sa iba pang bahagi ng iyong system. Lumikha ng isang folder na C:\PHP-Dev na magsisilbing iyong gumaganang direktoryo, at pagkatapos ay i-extract ang binary archive at mga tool dito.

Susunod, i-extract ang mga nilalaman ng archive, PHP source sa C:\PHP-Dev ngayon ay mayroon ka nang php5.4 sa source folder, pagkatapos ay i-extract ang deps archive nito sa deps sibling folder. Ang istraktura ng direktoryo ay dapat magmukhang ganito:

Buksan ang Windows SDK Command Prompt na na-install gamit ang SDK (Start => Microsoft Windows SDK => Windows SDK Command Prompt) at patakbuhin ang mga sumusunod na command:

Setenv /release /xp /x86 cd C:\PHP-Dev bin\phpsdk_setvars.bat

Ang paggamit ng SDK console command line ay mas mainam bago ang regular na cmd.exe console, dahil nagtatakda ito ng maraming environment variable na partikular sa source code compilation. Ang mga pagsasama-sama ng mga utos sa ibang pagkakataon ay dapat ding gawin sa console na ito.

Ang setenv ay nagtatakda ng ilang build properties para sa environment, sa kasong ito ang target na environment ay Windows XP 32-bit na bersyon ng build. Maaari mong subukan at bumuo gamit ang /x64 kung naghahanap ka ng pakikipagsapalaran. Ang pagtukoy sa iba't ibang bersyon ng Windows gaya ng /Vista ay malamang na magkaroon ng mga problema sa output dahil sa ilang kakaibang kahulugan sa mga script (gusto pa rin ng PHP na maging tugma sa XP). Maliban kung talagang alam mo kung ano ang iyong ginagawa, malamang na pinakaligtas na manatili sa mga inirerekomendang halaga na ginamit ko sa itaas.

Ang script ng phpsdk_setvars.bat ay nag-a-access ng ilang karagdagang mga variable ng kapaligiran, nagawang mahanap ng proseso ng pagbuo ang mga binary na tool.

Tandaan na ang lahat ng mga variable na setting na ito ay pansamantalang session lamang sa console. Kung mabilis mong isinara ang lahat upang bumalik sa pag-compile sa ibang pagkakataon, kakailanganin mong patakbuhin muli ang command, at kung hindi mo gagawin, makakakuha ka ng mga error tulad ng sumusunod, kapag nagpatakbo ka sa pag-configure sa ibang pagkakataon, hindi mo magagawang magpatuloy:

Sinusuri ang bison.exe ... ERROR: kailangan ang bison

Ang pagtiyak na mayroon kang tamang build environment, ang mga kinakailangang source, at anumang dependencies ang pinakamahirap na bahagi ng proseso. Kaya ngayon ang iyong kapaligiran ay naka-set up na may source code at mga dependency sa lugar, oras na para mag-compile!

Pag-compile ng PHP

Sa command line ng SDK, pumunta sa PHP source folder at patakbuhin ang buildconf. Ang command ay responsable para sa pagbuo ng mga configuration file na gagawin ng Makefile upang makontrol ang proseso ng compilation.

Pagkatapos makumpleto ang buildconf (tatagal lang ito ng isang segundo), patakbuhin ang configure --help - at suriin ang tulong para sa kung anong mga feature ang gusto mong paganahin/paganahin, pagkatapos ay patakbuhin muli ang configure gamit ang anumang opsyon na gusto mo. Magandang ideya na suriin ang output bago lumipat, dahil babalaan ka nito kung hindi available ang alinman sa mga kinakailangang dependency. Kung mangyari ito, maaari mong i-install ang mga dependency at muling patakbuhin ang setup, o isaayos ang mga tawag upang i-disable ang mga extension na nangangailangan ng mga ito.

Panghuli, patakbuhin ang NMAKE upang simulan ang pag-compile.

Cd C:\PHP-Dev\php5.4 buildconf i-configure ang nmake nmake test

Kung ang anumang configuration o NMAKE ay nabigo, ang problema ay isa sa dalawa: Una, ang kapaligiran ay hindi na-configure nang tama, pangalawa, pinagana mo ang isang tampok na nakasalalay sa mga panlabas na aklatan at ang mga aklatan ay hindi naka-install sa iyong system. I-double check kung nagawa mo ang environment ayon sa mga tagubilin sa itaas, at na-configure na ang anumang karagdagang library na maaaring kailanganin sa pinagbabatayan na mga setting ng configuration.

Kapag kumpleto na ang unang NMAKE ng proseso ng compilation, makikita mo ang iyong mga bagong PHP file sa Release_TS folder. Ang NMAKE test ay nagpapatakbo ng mga bagong double capacity na error test para matiyak na gumagana ang lahat ayon sa nararapat. Ang mga resulta ng pagsubok ng NMAKE ay ipinapadala sa QA team na umaasa sa kanila upang pahusayin ang PHP, kaya maaaring tumagal ng ilang minuto upang magtrabaho, ito ay isang malaking bagay.

Sa puntong ito maaari mo ring samantalahin ang karagdagang hakbang ng pagpapatakbo ng NMAKE snap-in, na lilikha ng mga ZIP archive at binary na maaari mong kopyahin.

Mga extension ng compilation

Mayroong dalawang paraan upang mag-compile ng mga extension ng PHP: static at dynamic. Ang isang statically compiled extension ay pinagsama-sama sa isang PHP binary, habang ang isang dynamically compiled extension ay isang hiwalay na DLL na maaaring i-load sa ibang pagkakataon sa pamamagitan ng isang php.ini file. Ang mga extension ay karaniwang pinagsama-sama bilang mga DLL, bagama't may ilang mga pakinabang sa static na compilation, at sa huli ay depende ito sa iyong mga pangangailangan.

Upang mag-compile ng mga PHP extension sa Windows, i-extract ang source code extension folder sa ext folder ng iyong PHP source directory. Pagkatapos, muling i-configure ang script sa pamamagitan ng pagpapatakbo ng buildconf --force at muling pag-compile ng PHP gamit ang naaangkop na mga opsyon upang paganahin ang extension.

Bilang halimbawa, i-compile natin ang extension ng AOP nang statically. I-download ang source code mula sa PECL, at i-extract ito sa isang folder, ext. Pagkatapos ay sundin ang mga hakbang na ito:

Cd C:\PHP-Dev\php5.4 buildconf --force configure --enable-aop nmake

Pinipilit ito ng --force, buildconf na opsyon na ibalik ang configuration script. Susunod, patakbuhin ang configure --help at dapat mong makita ang opsyon upang paganahin ang bagong extension sa output. Sa kasong ito, ito ay --enable-AOP.

Kapag natapos ang nmake, magkakaroon ka ng bagong binuong PHP binary na may AOP.

Ang mga extension ay magiging available bilang isang DLL sa halip na inihurnong sa PHP, maaari mong sundin ang parehong mga hakbang tulad ng sa itaas ngunit tinukoy ang "ibinahagi" bilang ang halaga para sa configuration ay nagbibigay-daan sa opsyon.

Buildconf --force configure --enable-aop=shared

Bilang resulta, ang DLL ay nasa Release_TS folder kasama ang PHP binary kapag natapos ang compilation, sa kasong ito ang pangalan ay php_aop.dll .

P.S.

Ang pag-compile sa Windows ay medyo nakakalito pa rin, lalo na pagdating sa mga extension. Ang kakayahang mag-compile ng source code ay isang mahusay na kasanayan, lalo na kung gusto mong baguhin ang PHP sa ibang pagkakataon.

Ang artikulo ay inihanda para sa iyo ng pangkat ng site
Orihinal na artikulo:
Isinalin ni: Victor Klim

Halos lahat ng mga developer ay maaga o huli ay nahaharap sa pangangailangan na tumakbo o mabilis na suriin ang ilang code, ngunit hindi alam ng lahat na para sa ganoong simpleng gawain ay hindi kinakailangan na magpatakbo ng mabibigat na desktop IDE o application compiler. Ito ay sapat na upang gumamit ng mga online na tool na nagbibigay-daan sa iyo upang gawin ang lahat nang mas mabilis: Ctrl+C, Ctrl+V, Run, whack - at ang output ng programa ay nasa harap na ng iyong mapupulang mga mata.

Pinili namin ang pinakamahusay na mga online compiler: ang ilan sa mga ito ay medyo unibersal, ang iba ay iniakma para sa mahigpit na tinukoy na mga gawain. Sa anumang kaso, hindi sila magiging labis.

Koding

Ang Koding.com ay hindi isang online compiler sa tradisyonal na kahulugan. Ang bawat gumagamit ng serbisyo ay maaaring lumikha ng ilang ganap na virtual machine na nagpapatakbo ng Ubuntu 14.04 sa cloud, kung saan maaari nilang gawin ang anumang gusto nila, kabilang ang pag-compile ng code. Ang lahat ng mga sikat na wika ay sinusuportahan bilang default, ngunit madali mong maidaragdag ang iyong sarili.

Bilang karagdagan sa control panel para sa iyong server, ang isang maginhawang IDE at isang terminal window ay magagamit sa interface. Ang Koding ay ang pinaka-unibersal na tool sa susunod na titingnan natin ang mas simple at mas espesyal na mga opsyon.

IdeaOne

Ang IdeOne ay isang online na compiler at debugging tool na nagbibigay-daan sa iyong magpatakbo ng code sa mahigit 60 programming language at ang kanilang mga partikular na bersyon nang direkta sa browser.

Para sa mga walang kasintahan, ang mga tagalikha ay nagbigay ng code compilation sa Brainfuck na wika.

JDoodle

Isa pang online compiler na sumusuporta sa maraming wika, kabilang ang ilan na hindi mo mahahanap sa maraming iba pang online compiler. Ang isang magandang tampok ng JDoodle ay ang kakayahang makipagtulungan - magpadala lamang ng link sa iyong kasalukuyang session at bumuo ng mga bug sa dobleng bilis!

jsFiddle

Huwag hayaang lokohin ka ng pangalan - hindi lang ginawa ang jsFiddle para sa JavaScript. Binibigyang-daan ka ng online na front-end na editor na ito na subukan ang anumang kumbinasyon ng JavaScript, HTML at CSS. Siyempre, mayroong suporta para sa iba't ibang mga balangkas, halimbawa, jQuery, Vue, React, TypeScript, pati na rin ang mga preprocessor ng CSS tulad ng SCSS. Para sa kaginhawahan, maaari kang pumili ng key binding mula sa iyong paboritong editor. Totoo, kung ang iyong paboritong editor ay Vim, Emacs o Sublime Text.

CodePad

Ang CodePad ay isang minimalistic na serbisyo kung saan maaari kang mag-imbak ng code, ibahagi ito, at patakbuhin ito nang may kasunod na output ng mga resulta ng pagpapatupad nito. Mayroong ilan sa mga pinakakaraniwang wikang mapagpipilian, ngunit, sa kasamaang-palad, walang mapagpipiliang partikular na bersyon ng mga interpreter o compiler.

Ang pangunahing bentahe nito ay ang pagiging simple at kadalian nito: ang site ay gagana nang mabilis kahit na may mabagal na koneksyon sa Internet. Ang awtomatikong koneksyon ng mga karaniwang header ay ibinibigay, pati na rin ang pagsasama sa Vim o Emacs.

Ang isa sa mga kawalan ay ang kumpletong kakulangan ng pag-highlight ng syntax kapag naglalagay ng code sa form. Gayunpaman, kapag tinitingnan ang isang naka-save na recording, ang backlight ay naroroon.

GCC GodBolt

Ang GCC GodBolt ay isang interactive na C++ compiler. Nakapasok ako sa koleksyong ito sa kadahilanang mayroon itong simpleng interface, pati na rin ang malaking bilang ng mga setting, kabilang ang mga opsyon na maaaring ayusin gamit ang mga susi.

Mayroong maraming mga bersyon ng compiler na mapagpipilian, kabilang ang mga pinakabagong bersyon. Ang isa sa mga kagiliw-giliw na tampok ay ang agarang pagsasalin ng code ng programa sa wika ng pagpupulong.

Ang PHP ay isang interpreted programming language sa bawat kahilingan, ang source code ay sinusuri at "isinasagawa". Ang diskarte na ito, siyempre, ay napaka-maginhawa sa yugto ng pagbuo ng proyekto, ngunit nagpapakilala ito ng karagdagang hakbang sa proseso ng pagpapatupad ng code ng produksyon. Kaya, ang interpretasyon, na sa unang tingin ay ang pinakamatibay na punto ng PHP, ay nagkakahalaga ng dagdag na oras at mapagkukunan ng CPU.

Sa ibaba ay pag-uusapan natin ang tungkol sa mga compiler na nagbibigay-daan sa iyong i-compile ang PHP code sa C++, at ito sa executable code. Kaya, ang mga aplikasyon ng PHP ay direktang isinasagawa ng processor, na lumalampas sa interpreter.

Suriin natin kung ang lahat ay napakahusay sa pagsasanay.

Paano gumagana ang interpreter

Ang interpretasyon ng PHP code ay nagaganap sa dalawang yugto:

1. Pag-parse ng code at pagbuo ng mga opcode (Zend opcodes) - mga tagubilin na mauunawaan ng interpreter.
2. Pagpapatupad ng mga opcode.

Habang ang unang yugto ay mahusay na nagpapahiram sa pag-optimize (gamit ang isang opcode cache), ang pangalawa ay medyo sarado - ang interpreter ay palaging isang tagapamagitan sa pagitan ng hanay ng mga tagubilin at ang processor na nagpapatupad ng mga ito. Kung walang interpreter, hindi mauunawaan ng processor kung ano ang gagawin sa mga opcode.

Upang maalis ang link ng interpreter, naimbento ang mga compiler, ang pinakasikat at pinakabago ay ang HipHop mula sa Facebook. Mas damhin natin.

HipHop PHP

Ang HipHop ay isinulat ng mga developer ng Facebook at isang application na:

1. ino-optimize ang PHP code
2. nagko-convert sa C++
3. bubuo mula sa iyong application ng isang multi-threaded web server na nagsasagawa nito
4. nag-compile sa executable code gamit ang g++

Kaya, ang input ay PHP code, ang output ay isang server, na bahagi nito ay ang nakasulat na pag-andar.

Suriin natin kung paano kakayanin ng HipHop ang pag-compile ng isang application na nakasulat gamit ang isang framework, tulad ng Wordpress.

Pag-compile ng Wordpress

Pagkatapos i-install ang HipHop, sa src/hphp/ folder ay makukuha natin ang hphp file, na siyang compiler. Bago magsimula ang compilation, itakda ang mga variable ng kapaligiran:

Cd .. # pumunta sa folder na may hiphop export HPHP_HOME=`pwd` export HPHP_LIB=`pwd`/bin export CMAKE_PREFIX_PATH=`/bin/pwd`/../

at sige!

I-download ang Wordpress at i-unzip ang archive:

Wget http://wordpress.org/latest.tar.gz tar zxvf latest.tar.gz

Kopyahin ang wp-config-sample.php sa wp-config.php at tukuyin ang mga setting para sa pagkonekta sa database (sa mga setting ng host ay tinukoy namin ang 127.0.0.1, hindi localhost).

Para sa matagumpay na compilation kailangan mong i-patch ng kaunti ang Wordpress:

1. Buksan ang wp-includes/js/tinymce/plugins/spellchecker/classes/SpellChecker.php at palitan ang: function &loopback(/* args.. */) ( return func_get_args(); ) with function &loopback(/* args.. */ ) ($ ret = func_get_args(); ibalik $ret; )
2. Sa wp-includes/query.php, sa halip na if (!isset($q["suppress_filters"])) $q["suppress_filters"] = false; ipasok ang $q["suppress_filters"] = totoo;

Handa na ang Wordpress.

Kailangang tukuyin ng Hiphop ang listahan ng mga file na isasama namin - kukunin namin ito at i-save ito sa files.list:

Hanapin. -pangalan "*.php" > files.list

Ang lahat ay handa na para sa compilation, magpatuloy tayo:

$HPHP_HOME/src/hphp/hphp --input-list=files.list -k 1 --log=3 --force=1 --cluster-count=50

Matapos makumpleto ang utos, sa pansamantalang folder (sa simula ng compilation, ipapakita ng hphp ang landas nito, tulad ng "/tmp/hphp_ptRgV1") makakatanggap kami ng isang pinagsama-samang web server. Ilunsad natin ito (kung may nakabitin sa port 80, halimbawa apache o nginx, kailangan mo munang ihinto ito upang malaya ang port):

Sudo /tmp/hphp_6s0pzd/program -m server -v "Server.SourceRoot=`pwd`" -v "Server.DefaultDocument=index.php" -c $HPHP_HOME/bin/mime.hdf

Voila! Sa pamamagitan ng pagpunta sa http://localos makikita natin ang isang gumaganang blog ng Wordpress.

Pagganap

Tingnan natin kung magkakaroon ng pagtaas ng performance kumpara sa uncompiled na bersyon ng WordPress na tumatakbo sa apache2. Nasa ibaba ang mga graph ng dependence ng bilis ng pagbuo ng page sa bilang ng mga parallel na user.

Tulad ng nakikita mo, ang mga resulta ay nakakagulat: ang pinagsama-samang blog ay tumatakbo sa average na 6 na beses na mas mabilis! Ang average na bilang ng mga kahilingan na naproseso bawat segundo sa hindi pinagsama-samang bersyon ay 9, at sa pinagsama-samang bersyon ito ay 50! Hindi ko alam ang tungkol sa iyo, ngunit ang mga resultang ito ay namangha sa akin;

Isa-isahin natin

Pagkatapos ng gayong mga nakamamanghang resulta, isang bagay lamang ang masasabi - ang mga lalaki mula sa Facebook ay gumawa ng mahusay na trabaho. Ang compiler ay talagang gumagawa ng isang rocket mula sa isang application, at kahit na ang application ay kailangang ihanda bago mag-compile, ang resulta ay sulit.

Sa paksa:

Kung nagustuhan mo ang post, mag-click sa Google +1 - ito ay magbibigay sa akin ng higit pang pagganyak na magsulat at ito ay magiging isang kasiyahan lamang.

Mayroong dalawang uri ng programming language: interpreted at compiled. Anong wika ang PHP? Upang masagot ang tanong na ito, kailangan nating maunawaan ang terminolohiya.

Ang isang programa na nagsasalin ng code na nakasulat sa isang programming language patungo sa isa pa ay tinatawag na translator. Ang isang compiler ay isa ring tagasalin. Isinasalin nito ang code na nakasulat sa isang mataas na antas ng wika sa machine code. Ang proseso ng compilation ay lumilikha ng binary executable file na maaaring patakbuhin nang walang compiler.

Ang isang interpreter ay isang ganap na naiibang kategorya. Hindi isinasalin ng interpreter ang code, ngunit ipinapatupad ito. Sinusuri ng interpreter ang program code at isinasagawa ang bawat linya nito. Sa tuwing ipapatupad mo ang naturang code, dapat kang gumamit ng interpreter.

Sa mga tuntunin ng pagganap, ang mga interpreter ay makabuluhang mas mababa kaysa sa mga compiler, dahil ang binary code ay gumagana nang mas mabilis. Ngunit pinapayagan ka ng mga interpreter na ganap na kontrolin ang programa sa panahon ng pagpapatupad nito.

Tulad ng para sa PHP, ito ay hindi isang compiler o isang interpreter. Ang PHP ay isang cross sa pagitan ng isang compiler at isang interpreter. Subukan nating unawain ito at tingnan kung paano pinoproseso ng PHP ang code.

Tingnan natin ang larawan:

Nakita namin na ang PHP ay binubuo ng dalawang halos independiyenteng mga bloke - isang tagasalin at isang interpreter. Bakit kailangan mong gawin ito? Siyempre, para sa mga kadahilanan ng bilis.

Ang PHP input ay isang script. Isinasalin nito ito (isinasalin), sinusuri ang syntax, sa isang espesyal na bytecode (internal na representasyon). Pagkatapos ay ipapatupad ng PHP ang bytecode (hindi ang program code mismo), ngunit hindi ito gumagawa ng executable file.

Ang Bytecode ay mas compact kaysa sa ordinaryong program code, kaya mas madali (at mas mabilis) ang interpretasyon (execute). Hukom para sa iyong sarili: ang pag-parse ay isinasagawa nang isang beses lamang sa yugto ng pagsasalin, at ang isang "semi-finished na produkto" ay isinasagawa - bytecode, na mas maginhawa para sa mga layuning ito. Samakatuwid, ang PHP ay higit na isang interpreter kaysa isang compiler. Ang "dobleng gawain" ay kinakailangan para sa mga sumusunod na layunin.

Isaalang-alang ang loop:

Para sa (i=0;i<10; i++) { Operator_1; Operator_2; Operator_3; ............ Operator_99; Operator_100; }

Ang cycle na ito ay "iikot" ng 10 beses. Para sa bawat isa sa sampung pass na ito, dapat ang interpreter 100 mga linya ng code. At kailangan nitong pag-aralan at isagawa ang 10*100 = 1000 linya ng code! Kung iko-convert mo ang buong loop sa bytecode nang isang beses, kakailanganin nitong pag-aralan nang 10 beses na mas kaunti! Nangangahulugan ito na ang mga script ay tatakbo nang 10 beses na mas mabilis!

Ang PHP pala.

Ang pangunahing yugto ng gawain ng PHP ay ang interpretasyon ng panloob na representasyon ng programa at ang pagpapatupad nito. Ito ang yugtong ito na tumatagal ng pinakamaraming oras sa mga seryosong senaryo. Gayunpaman, ang pagbagal ay hindi gaanong kapansin-pansin.

Ito ay nagkakahalaga ng pag-alala na ang PHP bersyon 3 ay isang "purong" interpreter, at sa PHP 4 na mga script ay nagsimulang tumakbo nang mas mabilis, dahil ang PHP bersyon 4 (at PHP5) ay isang interpretive translator.

Ang wikang Perl, na halos palaging tinatawag na compiler, ay gumagana nang eksakto sa parehong paraan - isinasalin nito ang teksto ng programa sa isang panloob na representasyon, at pagkatapos ay ginagamit ang resultang code sa panahon ng pagpapatupad. Kaya, maaari mong sabihin na ang bersyon 4 ng PHP ay isang compiler tulad ng Perl.

Kaya, napipilitan kaming tapusin na ang PHP ay isang interpreter na may built-in na block ng pagsasalin na nag-o-optimize sa daloy ng interpretasyon.

Ang paggamit ng isang interpreter (at samakatuwid ay PHP) ay may hindi maikakailang mga pakinabang:

• Hindi na kailangang mag-alala tungkol sa pagpapalaya sa inilalaan na memorya, hindi na kailangang isara ang mga file kapag tapos ka nang magtrabaho sa kanila - gagawin ng interpreter ang lahat ng nakagawiang gawain, dahil ang programa ay isinasagawa sa ilalim ng maingat na kontrol nito;
• Hindi na kailangang mag-isip tungkol sa mga uri ng variable, at hindi na kailangang magdeklara ng variable bago ang unang paggamit nito;
• Ang mga programa sa pag-debug at pag-detect ng mga error ay lubos na pinasimple - ang interpreter ay may kumpletong kontrol sa prosesong ito;
• Sa konteksto ng mga web application, ang interpreter ay mayroon ding napakahalagang kalamangan - walang panganib na "magyeyelo" ang server kung hindi gumana nang tama ang programa.

Mayroon ding iba pang mga pakinabang. Sa pangkalahatan, ang paggamit ng isang interpreter ay maaaring magbigay sa mga script ng kapangyarihan na inaasahan ng mga gumagamit ng Web mula sa kanila.

Ang parusa sa pagganap ng PHP ay kapansin-pansin sa kaso ng malalaki at kumplikadong mga loop, kapag nagpoproseso ng malaking bilang ng mga linya, atbp. Gayunpaman, tandaan na ito ang tanging disbentaha ng PHP, na lilitaw nang mas kaunti habang ang mas malakas na mga processor ay inilabas , para tuluyang mawala.

<<< Назад (Ano ang bago sa PHP5?)

Nilalaman

Pasulong >>> (Transition sa PHP 5.3)

Kung mayroon kang anumang iba pang mga katanungan o isang bagay ay hindi malinaw - maligayang pagdating sa aming