GitPHP Badoo पर

बुश एक विशालकाय विशाल भंडार वाली परियोजना है जिसमें हजारों शाखाएँ और टैग हैं। हम अत्यधिक संशोधित GitPHP ( http://gitphp.org ) संस्करण 0.2.4 का उपयोग करते हैं, जिस पर कई ऐड-ऑन किए गए हैं (JIRA में हमारे वर्कफ़्लो के साथ एकीकरण, समीक्षा प्रक्रिया के संगठन आदि)। सामान्य तौर पर, इस उत्पाद ने हमें तब तक अनुकूल किया जब तक कि हमने यह नहीं देखना शुरू कर दिया कि हमारा मुख्य भंडार 20 सेकंड से अधिक समय तक खुला रहा। और आज हम इस बारे में बात करेंगे कि हमने GITPHP के प्रदर्शन की जांच कैसे की और इस समस्या को हल करके हमने क्या परिणाम प्राप्त किए।

संरेखण टाइमर

विकास के माहौल में badoo.com का विकास करते समय, हम टाइमर और डीबग एसक्यूएल प्रश्नों को सेट करने के लिए एक बहुत ही सरल डिबग-पैनल का उपयोग करते हैं। इसलिए, पहली चीज जो हमने की थी, उसे GITPHP में फिर से तैयार किया और कोड सेक्शन के निष्पादन समय को मापना शुरू किया, नस्टेड टाइमर पर ध्यान नहीं दिया। यह हमारा डिबग पैनल जैसा दिखता है:



पहले कॉलम में विधि का नाम (या क्रिया) कहा जाता है, दूसरे में अतिरिक्त जानकारी होती है: शुरू करने के लिए तर्क, कमांड के आउटपुट की शुरुआत, और ट्रेस। अंतिम कॉलम में कॉल पर (सेकंड में) खर्च किया गया समय होता है।

यहाँ टाइमर के कार्यान्वयन से एक छोटा सा अंश है:

<?php class GitPHP_Log { // ... public function timerStart() { array_push($this->timers, microtime(true)); } public function timerStop($name, $value = null) { $timer = array_pop($this->timers); $duration = microtime(true) - $timer; //      ,     foreach ($this->timers as &$item) $item += $duration; $this->Log($name, $value, $duration); } // ... } 

ऐसे एपीआई का उपयोग करना बहुत सरल है। timerStart() को मापा कोड timerStart() शुरुआत में कहा जाता है, timerStart() को टाइमर नाम और वैकल्पिक अतिरिक्त डेटा के साथ अंत में timerStop() :

 <?php $Log = new GitPHP_Log; $Log->timerStart(); $result = 0; $mult = 4; for ($i = 1; $i < 1000000; $i+=2) { $result += $mult / $i; $mult = -$mult; } $Log->timerStop("PI computation", $result); 

इस मामले में, कॉल को नेस्टेड किया जा सकता है, और उपरोक्त वर्ग गणना करते समय इसे ध्यान में रखेगा।

स्मार्टी के अंदर आसान कोड डिबगिंग के लिए, हमने "स्व-टाइमर" बनाया। वे कई निकास बिंदुओं के साथ तरीकों पर काम करने में लगने वाले समय को मापना आसान बनाते हैं (कई जगह जहां रिटर्न निष्पादित होता है):

 <?php class GitPHP_DebugAutoLog { private $name; public function __construct($name) { $this->name = $name; GitPHP_Log::GetInstance()->timerStart(); } public function __destruct() { GitPHP_Log::GetInstance()->timerStop($this->name); } } 

ऐसी कक्षा का उपयोग करना बहुत सरल है: आपको $Log = new GitPHP_DebugAutoLog('timer_name'); डालने की आवश्यकता है $Log = new GitPHP_DebugAutoLog('timer_name'); किसी फ़ंक्शन या विधि की शुरुआत में, और जब आप फ़ंक्शन से बाहर निकलते हैं, तो इसका निष्पादन समय स्वचालित रूप से मापा जाएगा:

 <?php function doSomething($a) { $Log = GitPHP_DebugAutoLog('doSomething'); if ($a > 5) { echo "Hello world!\n"; sleep(5); return; } sleep(1); } 

हजारों git कॉल-फाइल -t <प्रतिबद्ध>

सेट अप टाइमर्स के लिए धन्यवाद, हम जल्दी से यह पता लगाने में सक्षम थे कि अधिकांश समय GitPHP संस्करण 0.2.4 कहां खर्च किया गया था। रिपॉजिटरी में प्रत्येक टैग के लिए, एक कॉल git cat-file -t लिए किया गया था ताकि यह पता लगाया जा सके कि क्या यह कमिट है, और क्या यह कमिट "लाइटवेट टैग" है ( http://git-scm.com/book/en/Git-Basics -टैगिंग # लाइटवेट-टैग )। Git में लाइटवेट टैग एक प्रकार का टैग है जो डिफ़ॉल्ट रूप से बनाया जाता है और इसमें एक विशिष्ट कमेंट का लिंक होता है। चूंकि हमारी रिपॉजिटरी में कोई अन्य टैग प्रकार मौजूद नहीं थे, इसलिए हमने बस इस चेक को हटा दिया और git cat-file -t, को कुछ हज़ार कॉल सहेजे git cat-file -t, जिसमें लगभग 20 सेकंड लगे।

यह कैसे हुआ कि GitPHP को रिपॉजिटरी में प्रत्येक टैग के लिए यह पता लगाने की आवश्यकता है कि क्या यह "हल्का" है? सब कुछ बहुत सरल है।

सभी GitPHP पृष्ठों पर, कमिट के आगे, शाखाएँ और टैग प्रदर्शित होते हैं जो इस ओर इशारा करते हैं:



ऐसा करने के लिए, GitPHP_TagList वर्ग में एक विधि है जो उन टैगों की सूची प्राप्त करने के लिए ज़िम्मेदार है जो निर्दिष्ट कोड का संदर्भ देते हैं:

 <?php class GitPHP_TagList extends GitPHP_RefList { // ... public function GetCommitTags($commit) { if (!$commit) return array(); $commitHash = $commit->GetHash(); if (!$this->dataLoaded) $this->LoadData(); $tags = array(); foreach ($this->refs as $tag => $hash) { if (isset($this->commits[$tag])) { // ... } else { $tagObj = $this->project->GetObjectManager()->GetTag($tag, $hash); $tagCommitHash = $tagObj->GetCommitHash(); // ... if ($tagCommitHash == $commitHash) { $tags[] = $tagObj; } } } return $tags; } // ... } 

यानी प्रत्येक कमेटी जिसके लिए आप टैग की एक सूची प्राप्त करना चाहते हैं, निम्नलिखित सत्य है:

1. पहला कॉल रिपॉजिटरी (कॉल लोडडाटा ()) में सभी टैग की सूची लोड करता है।
2. सभी टैगों की सूची में परिवर्तन।
3. प्रत्येक टैग के लिए, संबंधित वस्तु भरी हुई है।
4. GetCommitHash () को टैग ऑब्जेक्ट पर कहा जाता है और परिणामी मूल्य की खोज की गई के साथ तुलना की जाती है।

इस तथ्य के अलावा कि आप सबसे पहले फॉर्म array( commit_hash => array(tags) ) नक्शे को संकलित कर सकते हैं, आपको GetCommitHash() विधि पर ध्यान देने की GetCommitHash() : यह Load($tag) विधि को कॉल करता है, जिसे बाहरी गिट उपयोगिता का उपयोग करते समय कार्यान्वित किया जाता है, जो निम्न कार्य करता है:

 <?php class GitPHP_TagLoad_Git implements GitPHP_TagLoadStrategy_Interface { // ... public function Load($tag) { // ... $args[] = '-t'; $args[] = $tag->GetHash(); $ret = trim($this->exe->Execute($tag->GetProject()->GetPath(), GIT_CAT_FILE, $args)); if ($ret === 'commit') { // ... return array(/* ... */); } // ... $ret = $this->exe->Execute($tag->GetProject()->GetPath(), GIT_CAT_FILE, $args); // ... return array(/* ... */); } } 

यानी यह दिखाने के लिए कि कौन सी शाखाएँ और टैग एक कमिट में शामिल हैं, GitPHP सभी टैग्स की एक सूची लोड करता है और उनमें से प्रत्येक के लिए git कैट-फाइल -t को कॉल करता है। बुरा नहीं है, क्रिस्टोफर, इसे बनाए रखो!

सैकड़ों रीट-सूची-कॉल कॉल --मैक्स-काउंट = 1 ... <प्रतिबद्ध>

प्रतिबद्ध जानकारी के साथ स्थिति समान है। तिथि को लोड करने के लिए, कमिट, संदेश आदि का संदेश, हर बार रीट-लिस्ट - अधिकतम-गणना = 1 ... <प्रतिबद्ध> कहा गया। यह ऑपरेशन भी मुफ्त नहीं है:

 <?php class GitPHP_CommitLoad_Git extends GitPHP_CommitLoad_Base { public function Load($commit) { // ... /* get data from git_rev_list */ $args = array(); $args[] = '--header'; $args[] = '--parents'; $args[] = '--max-count=1'; $args[] = '--abbrev-commit'; $args[] = $commit->GetHash(); $ret = $this->exe->Execute($commit->GetProject()->GetPath(), GIT_REV_LIST, $args); // ... return array( // ... ); } // ... } 

समाधान: बैच अपलोड कमिट (git cat-file --batch)

कैट-फाइल करने के लिए कई सिंगल कॉल नहीं करने के लिए, Git आपको --batch विकल्प का उपयोग करके एक बार में कई कमिट डाउनलोड करने की अनुमति देता है। ऐसा करने में, यह स्टड में कमिट्स की एक सूची लेता है, और स्टडआउट के लिए परिणाम लिखता है। तदनुसार, आप पहले उन सभी हैश के फ़ाइल को लिख सकते हैं जिनकी हमें आवश्यकता है, git cat-file --batch और एक ही बार में सभी परिणाम डाउनलोड करें।

यहाँ कोड का एक उदाहरण है जो ऐसा करता है (कोड संस्करण GitPHP 0.2.4 के लिए दिया गया है और ऑपरेटिंग सिस्टम के * nith मीडिया):

 <?php class GitPHP_Project { // ... public function BatchReadData(array $hashes) { if (!count($hashes)) return array(); $outfile = tempnam('/tmp', 'objlist'); $hashlistfile = tempnam('/tmp', 'objlist'); file_put_contents($hashlistfile, implode("\n", $hashes)); $Git = new GitPHP_GitExe($this); $Git->Execute(GIT_CAT_FILE, array('--batch', ' < ' . escapeshellarg($hashlistfile), ' > ' . escapeshellarg($outfile))); unlink($hashlistfile); $fp = fopen($outfile, 'r'); unlink($outfile); $types = $contents = array(); while (!feof($fp)) { $ln = rtrim(fgets($fp)); if (!$ln) continue; list($hash, $type, $n) = explode(" ", rtrim($ln)); $contents[$hash] = fread($fp, $n); $types[$hash] = $type; } return array('contents' => $contents, 'types' => $types); } // ... } 

हमने इस फ़ंक्शन का उपयोग उन अधिकांश पृष्ठों के लिए करना शुरू कर दिया, जहाँ कमिट्स के बारे में जानकारी प्रदर्शित की गई है (यानी हम कमिट्स की एक सूची एकत्र करते हैं और उन सभी को git cat-file --batch लिए एक कॉल के साथ लोड करते हैं)। इस अनुकूलन ने औसत पृष्ठ लोड समय को 20 सेकंड से 0.5 सेकंड से कम कर दिया। इस प्रकार, हमने अपनी परियोजना में GitPHP के धीमे काम की समस्या को हल किया।

ओपन-सोर्स: GitPHP अनुकूलन 0.2.9 (मास्टर)

थोड़ा सोचने के बाद, हमने महसूस किया कि git cat-file --batch का उपयोग करने के लिए सभी कोड को फिर से लिखना संभव नहीं था। यद्यपि दस्तावेज़ में परिलक्षित नहीं होता है, यह आदेश आपको प्रदर्शन खोए बिना, एक समय में एक प्रतिबद्ध जानकारी डाउनलोड करने की अनुमति देता है! ऑपरेशन के दौरान, मानक इनपुट से एक पंक्ति पढ़ी जाती है और परिणाम बफरिंग के बिना मानक आउटपुट पर भेजे जाते हैं। इसका मतलब है कि हम git cat-file --batch खोल सकते हैं git cat-file --batch proc_open() माध्यम से git cat-file --batch और तुरंत परिणाम प्राप्त करें, बिना आर्किटेक्चर को git cat-file --batch !

यहां कार्यान्वयन से एक अंश है (पठनीयता के लिए त्रुटि को हटा दिया गया है):

 <?php // ... class GitPHP_GitExe implements GitPHP_Observable_Interface { // ... public function GetObjectData($projectPath, $hash) { $process = $this->GetProcess($projectPath); $pipes = $process['pipes']; $data = $hash . "\n"; fwrite($pipes[0], $data); fflush($pipes[0]); $ln = rtrim(fgets($pipes[1])); $parts = explode(" ", rtrim($ln)); list($hash, $type, $n) = $parts; $contents = ''; while (strlen($contents) < $n) { $buf = fread($pipes[1], min(4096, $n - strlen($contents))); $contents .= $buf; } return array( 'contents' => $contents, 'type' => $type, ); } // ... } 

यह देखते हुए कि हम अब हर बार गिट कमांड को कॉल किए बिना वस्तुओं की सामग्री को जल्दी से लोड कर सकते हैं, एक बड़ा प्रदर्शन बूस्ट प्राप्त करना आसान है: बस हमारे अनुकूलित फ़ंक्शन को कॉल करने के लिए git cat-file और git rev-list को सभी कॉल बदलें।

हमने एक ही कमिट में सभी परिवर्तन एकत्र किए और GitPHP डेवलपर को एक पुल-अनुरोध भेजा। कुछ समय बाद, पैच स्वीकार कर लिया गया! यहाँ है:

source.gitphp.org/projects/gitphp.git/commitdiff/3c87676b3afe4b0c1a1f7198995cecc176200482

लेखक ने कोड के लिए कुछ सुधार किए (अलग-अलग कमिट में), और अब मास्टर शाखा में GitPHP का काफी त्वरित संस्करण है! ऑप्टिमाइज़ेशन का उपयोग करने के लिए, आपको "संगतता मोड" को बंद करना होगा, अर्थात $compat = false; सेट करें $compat = false; विन्यास में।

Yuri youROCK Nasretdinov , PHP डेवलपर, Badoo
एवगेनी ईज़ो मखरोव , क्यूए इंजीनियर, बेथ