मैं PHP में लिखे गए कोड की गति को कैसे माप सकता हूं? [बन्द है]

Question

मैं यह कैसे कह सकता हूं कि किस वर्ग का कई (जो सभी एक ही काम करते हैं) तेजी से निष्पादित होते हैं? वहाँ एक सॉफ्टवेयर है कि मापने के लिए है?

Answer 1

आपके पास (कम से कम) दो समाधान हैं:

काफी "भोले" एक microtime का उपयोग कर रहा है (सच) tobefore और कोड के एक हिस्से के बाद, इसके निष्पादन के दौरान कितना समय बीत चुका है; अन्य जवाबों ने कहा कि और उदाहरण पहले से ही दिया है, इसलिए मैंने जीता "टी कहना बहुत अधिक है।

यदि आप निर्देशों के एक जोड़े को बेंचमार्क करना चाहते हैं तो यह एक अच्छा समाधान है; उदाहरण के लिए, दो प्रकार के कार्यों की तुलना करना, जैसे कि हजारों बार किया जाए तो बेहतर है, यह सुनिश्चित करने के लिए कि किसी भी "गड़बड़ी करने वाले तत्व" का औसतन उपयोग नहीं किया जाता है।

कुछ इस तरह से, इसलिए, यदि आप जानना चाहते हैं कि किसी सरणी को क्रमबद्ध करने में कितना समय लगता है:

$before = microtime(true);

for ($i=0 ; $i<100000 ; $i++) {
    serialize($list);
}

$after = microtime(true);
echo ($after-$before)/$i . " sec/serialize\n";

सही नहीं है, लेकिन उपयोगी है, और इसे स्थापित करने में ज्यादा समय नहीं लगता है।

---

अन्य समाधान, जो काफी अच्छा काम करता है यदि आप यह पहचानना चाहते हैं कि कौन सा फ़ंक्शन पूरी स्क्रिप्ट में बहुत समय लेता है, तो इसका उपयोग करना है:

• Xdebug विस्तार, स्क्रिप्ट के लिए डेटा की रूपरेखा उत्पन्न करने के लिए
• सॉफ्टवेयर जो प्रोफाइलिंग डेटा को पढ़ता है, और आपको कुछ पठनीय प्रस्तुत करता है। मैं उनमें से तीन को जानता हूं:
  • वेबग्राइंड ; वेब इंटरफेस ; किसी भी Apache + PHP सर्वर पर काम करना चाहिए
  • WinCacheGrind ; केवल खिड़कियों पर
  • केचगग्रिंड ; शायद केवल लिनक्स और लिनक्स की तरह; वह है जो मुझे पसंद है, btw

प्रोफाइलिंग फ़ाइलें प्राप्त करने के लिए, आपको Xdebug को स्थापित और कॉन्फ़िगर करना होगा; प्रलेखन के प्रोफाइलिंग PHP लिपियों पृष्ठ पर एक नज़र डालें ।

जो मैं आमतौर पर करता हूं वह डिफ़ॉल्ट रूप से प्रोफाइलर को सक्षम नहीं करता है (यह काफी बड़ी फाइलें बनाता है, और चीजों को धीमा कर देता है) , लेकिन XDEBUG_PROFILEजीईटी डेटा नामक पैरामीटर को भेजने की संभावना का उपयोग करें, केवल उस पृष्ठ के लिए प्रोफाइलिंग को सक्रिय करने के लिए जिसकी मुझे आवश्यकता है।
मेरी php.ini की प्रोफाइलिंग-संबंधित हिस्सा कुछ इस तरह है:

xdebug.profiler_enable = 0              ; Profiling not activated by default
xdebug.profiler_enable_trigger = 1      ; Profiling activated when requested by the GET parameter
xdebug.profiler_output_dir = /tmp/ouput_directory
xdebug.profiler_output_name = files_names

(अधिक informations के लिए प्रलेखन पढ़ें)

यह स्क्रीनशॉट KcacheGrind में C ++ प्रोग्राम से है: _{(source: sourceforge.net )} आपको PHP स्क्रिप्ट्स के साथ ठीक उसी तरह की चीज़ मिलेगी ;-) (KCacheGrind के साथ, मेरा मतलब है; WinCacheGrind KCacheGrind जितना अच्छा नहीं है ... )

यह आपको अपने आवेदन में जो समय लगता है, उसका एक अच्छा दृश्य प्राप्त करने की अनुमति देता है - और यह कभी-कभी निश्चित रूप से उस फ़ंक्शन का पता लगाने में मदद करता है जो सब कुछ धीमा कर रहा है ^ ^

ध्यान दें कि Xdebug PHP द्वारा खर्च किए गए सीपीयू समय की गणना करता है; जब PHP डेटाबेस (उदाहरण के लिए) से उत्तर की प्रतीक्षा कर रहा है, तो यह काम नहीं कर रहा है; केवल प्रतीक्षा कर रहा है। तो Xdebug सोचेंगे DB अनुरोध में ज्यादा समय नहीं लगता है!
यह SQL सर्वर पर होना चाहिए, PHP नहीं, इसलिए ...

आशा है कि यह उपयोगी है :-)
मज़े करो!

Comments

QCacheGrind का एक विंडो बिल्ड मौजूद है :-) sourceforge.net/projects/qcachegrindwin

— फ़्राँस्वा ब्रेटन

Answer 2

त्वरित सामग्री के लिए मैं ऐसा करता हूं (PHP में):

$startTime = microtime(true);
doTask(); // whatever you want to time
echo "Time:  " . number_format(( microtime(true) - $startTime), 4) . " Seconds\n";

आप http://xdebug.org/ जैसे प्रोफाइलर का भी उपयोग कर सकते हैं ।

Comments

अतिरिक्त सटीकता के लिए, मैं सुझाव दूंगा (ए) लूप का उपयोग करके और समय का औसत (बी) प्रत्येक परीक्षण के लिए अलग-अलग फ़ाइलों का उपयोग कर। यदि आपके पास एक स्क्रिप्ट के भीतर कई समय हैं, तो उनका क्रम कभी-कभी अंतर कर सकता है।

— असंतुष्टगीतगृह

Answer 3

मैंने एक साधारण समय वर्ग बनाया है, शायद यह किसी के लिए उपयोगी है:

class TimingHelper {

    private $start;

    public function __construct() {
        $this->start = microtime(true);
    }

    public function start() {
        $this->start = microtime(true);
    }

    public function segs() {
        return microtime(true) - $this->start;
    }

    public function time() {
        $segs = $this->segs();
        $days = floor($segs / 86400);
        $segs -= $days * 86400;
        $hours = floor($segs / 3600);
        $segs -= $hours * 3600;
        $mins = floor($segs / 60);
        $segs -= $mins * 60;
        $microsegs = ($segs - floor($segs)) * 1000;
        $segs = floor($segs);

        return 
            (empty($days) ? "" : $days . "d ") . 
            (empty($hours) ? "" : $hours . "h ") . 
            (empty($mins) ? "" : $mins . "m ") . 
            $segs . "s " .
            $microsegs . "ms";
    }

}

उपयोग:

$th = new TimingHelper();
<..code being mesured..>
echo $th->time();
$th->start(); // if it's the case
<..code being mesured..>
echo $th->time();

// result: 4d 17h 34m 57s 0.00095367431640625ms 

Comments

आप गलत echo$echo

— समझे

Answer 4

2020 अद्यतन

मुझे इस प्रश्न का उत्तर देते हुए कई साल हो चुके हैं, इसलिए मैंने सोचा कि यह एपीएम परिदृश्य पर एक अपडेट के योग्य है।

• AppDynamics को सिस्को द्वारा खरीदा गया है और हमेशा के लिए मुफ्त खाते जो वे पेश करते थे वह उनकी वेबसाइट से निकाल लिया गया है।
• NewRelic ने अपने मूल्य को $ 149 / माह / होस्ट से $ 25 / महीना / होस्ट तक गिरा दिया है, जिससे एपीएम बाज़ार, दाताडोग को 31 कॉम / $ / होस्ट की पेशकश की जा रही है।
• डेटाडॉग एपीएम की विशेषताएं अभी भी हल्की हैं और वांछित होने के लिए बहुत कुछ छोड़ देता है। हालाँकि, मैं उन्हें अगले साल भर में बढ़ाता और सुधारता हुआ देखता हूँ।
• रक्सिट को डायनाट्रेस द्वारा खरीदा गया है। यहाँ कोई शॉकर नहीं है जैसा कि Ruxit पूर्व डायनाट्रेस कर्मचारियों द्वारा बनाया गया है। इसने डायनाट्रेस को बेहतर के लिए वास्तव में सास मॉडल में बदलने की अनुमति दी। यदि आप चाहें तो उस भारी जावा क्लाइंट को अलविदा कहें।
• अब मुफ्त / ओपन-सोर्स विकल्प भी मौजूद हैं। चेकआउट अपाचे Skywalking जो उनके शीर्ष तकनीक कंपनियों के बीच चीन में बहुत लोकप्रिय है और ठीक से निर्धारित जो एक डेमो है कि आप स्थापित करने से पहले कोशिश कर सकते हैं प्रदान करता है। इन दोनों को आपको होस्ट करने की आवश्यकता है ताकि कुछ वर्चुअल मशीन को स्पिन करने के लिए तैयार हो जाएं और स्थापना और कॉन्फ़िगरेशन के साथ कुछ समय बिताएं।
• मैंने इनमें से किसी भी ओपनसोर्स एपीएम समाधान की कोशिश नहीं की है, इसलिए मैं उन्हें सलाह देने की स्थिति में नहीं हूं, हालांकि, मैंने व्यक्तिगत रूप से इन एपीएम समाधानों को कई संगठनों के लिए या तो ऑन-प्रिमाइसेस या क्लाउड पर सैकड़ों एप्लिकेशन / के लिए तैनात करने में कामयाब रहा है / microservices। इसलिए मैं विश्वास के साथ कह सकता हूं, यदि आप आपका बिल फिट करते हैं तो आप किसी भी विक्रेता के साथ गलत नहीं कर सकते।

---

मूल रूप से अक्टूबर 2015 को उत्तर दिया गया

यहाँ आपके प्रश्न का सीधा उत्तर है

वहाँ एक सॉफ्टवेयर है कि मापने के लिए है?

हाँ वहाँ है। मैं सोच रहा हूं कि किसी ने अभी तक इसका उल्लेख क्यों नहीं किया है। यद्यपि ऊपर दिए गए उत्तर त्वरित जांच के लिए ठीक हैं, लेकिन लंबे समय तक या बड़ी परियोजना के लिए स्केलेबल नहीं है।

क्यों नहीं एक अनुप्रयोग प्रदर्शन निगरानी (APM) उपकरण का उपयोग करें जो बिलकुल उसी के लिए बनाए जाते हैं और बहुत कुछ। निष्पादन के समय, संसाधन उपयोग, विधि के स्तर तक हर एप्लिकेशन के थ्रूपुट की निगरानी करने के लिए NewRelic, AppDynamics, Ruxit (सभी का मुफ्त संस्करण है) देखें।

Answer 5

यदि आप किसी फ्रेमवर्क का त्वरित परीक्षण करना चाहते हैं, तो आप index.php फ़ाइल में डाल सकते हैं

//at beginning
$milliseconds = round(microtime(true) * 1000);

//and at the end
echo round(microtime(true) * 1000) - $milliseconds;

हर बार आपको मिलीसेकंड में निष्पादन का समय मिलेगा । क्योंकि माइक्रोसेकंड एक फ्रेमवर्क केस के परीक्षण में बहुत उपयोगी नहीं है।

Answer 6

मैं XHProf हाल ही में http://pecl.php.net/package/xhprof का उपयोग कर रहा हूं । यह मूल रूप से फेसबुक द्वारा विकसित किया गया था और यह एक सभ्य वेब इंटरफेस के साथ आता है।

Answer 7

मैं आपके साथ एक स्वनिर्मित फ़ंक्शन साझा करना चाहता हूं जिसका उपयोग मैं किसी भी मौजूदा फ़ंक्शन की गति को 10 तर्कों तक मापने के लिए करता हूं:

function fdump($f_name='', $f_args=array()){

    $f_dump=array();
    $f_result='';

    $f_success=false;

    $f_start=microtime();
    $f_start=explode(' ', $f_start);
    $f_start=$f_start[1] + $f_start[0];

    if(function_exists($f_name)){

        if(isset($f_args[0])&&is_array($f_args[0])){
            if($f_result=$f_name($f_args)){
                $f_success=true;
            }
        }
        elseif(!isset($f_args[1])){
            if($f_result=$f_name($f_args[0])){
                $f_success=true;
            }
        }
        elseif(!isset($f_args[2])){
            if($f_result=$f_name($f_args[0],$f_args[1])){
                $f_success=true;
            }
        }
        elseif(!isset($f_args[3])){
            if($f_result=$f_name($f_args[0],$f_args[1],$f_args[2])){
                $f_success=true;
            }
        }
        elseif(!isset($f_args[4])){
            if($f_result=$f_name($f_args[0],$f_args[1],$f_args[2],$f_args[3])){
                $f_success=true;
            }
        }
        elseif(!isset($f_args[5])){
            if($f_result=$f_name($f_args[0],$f_args[1],$f_args[2],$f_args[3],$f_args[4])){
                $f_success=true;
            }
        }
        elseif(!isset($f_args[6])){
            if($f_result=$f_name($f_args[0],$f_args[1],$f_args[2],$f_args[3],$f_args[4],$f_args[5])){
                $f_success=true;
            }
        }
        elseif(!isset($f_args[7])){
            if($f_result=$f_name($f_args[0],$f_args[1],$f_args[2],$f_args[3],$f_args[4],$f_args[5],$f_args[6])){
                $f_success=true;
            }
        }
        elseif(!isset($f_args[8])){
            if($f_result=$f_name($f_args[0],$f_args[1],$f_args[2],$f_args[3],$f_args[4],$f_args[5],$f_args[6],$f_args[7])){
                $f_success=true;
            }
        }
        elseif(!isset($f_args[9])){
            if($f_result=$f_name($f_args[0],$f_args[1],$f_args[2],$f_args[3],$f_args[4],$f_args[5],$f_args[6],$f_args[7],$f_args[8])){
                $f_success=true;
            }
        }
        elseif(!isset($f_args[10])){
            if($f_result=$f_name($f_args[0],$f_args[1],$f_args[2],$f_args[3],$f_args[4],$f_args[5],$f_args[6],$f_args[7],$f_args[8],$f_args[9])){
                $f_success=true;
            }
        }
    }
    $f_end=microtime();
    $f_end=explode(' ', $f_end);
    $f_end=$f_end[1] + $f_end[0];

    $f_time=round(($f_end - $f_start), 4);
    $f_dump['f_success']=$f_success;
    $f_dump['f_time']=$f_time;
    $f_dump['f_result']=$f_result;

    var_dump($f_dump);exit;

    //return $f_result;

}

उदाहरण

function do_stuff($arg1='', $arg2=''){
    return $arg1.' '.$arg2;
}

fdump('do_stuff',array('hello', 'world'));

रिटर्न

  array(3) {
    ["f_success"]=>
    bool(true)
    ["f_time"]=>
    float(0)            //too fast...
    ["f_result"]=>
    string(11) "hello world"
  }

Answer 8

यदि यह ऐसा कुछ है जिसे वेब संदर्भ के बाहर परीक्षण किया जा सकता है, तो मैं यूनिक्स timeकमांड का उपयोग करता हूं ।

Answer 9

Zend Studio ने XDebug या ZendDebugger का उपयोग करके प्रोफाइलिंग के समर्थन में बनाया है। यह आपके कोड को बताएगा, जिससे आपको पता चलेगा कि हर फंक्शन में कितना समय लगा। यह पता लगाने के लिए एक शानदार उपकरण है जहां आपकी अड़चनें हैं।

Answer 10

आप समय की गणना करने के लिए ऑपरेशन से पहले और बाद में स्टोरेज टाइमस्टैम्प या माइक्रोटाइम () जैसे बुनियादी सामान का उपयोग कर सकते हैं। यह करना आसान है, लेकिन बहुत सटीक नहीं। शायद एक बेहतर समाधान Xdebug है , मैंने इसके साथ कभी काम नहीं किया है लेकिन यह सबसे अच्छा ज्ञात PHP डिबगर / प्रोफाइलर है जो मुझे मिल सकता है।