Php स्क्रिप्ट के निष्पादन समय को मापने का सटीक तरीका

Question

मैं यह जानना चाहता हूं कि PHP के लिए कितने मिलिसेकंड से लूप निष्पादित होता है।

मैं एक सामान्य एल्गोरिथ्म की संरचना जानता हूं, लेकिन यह नहीं पता कि इसे PHP में कैसे लागू किया जाए:

Begin
init1 = timer(); // where timer() is the amount of milliseconds from midnight
the loop begin
some code
the loop end
total = timer() - init1;
End

Comments

यदि आपको उत्पादन में इसकी आवश्यकता है, तो आप माइक्रोटाइम () स्टेटमेंट्स के स्वैथ्स के साथ फील कर सकते हैं, लेकिन यदि यह सिर्फ परीक्षण के लिए है, तो उदाहरण के लिए बस xdebug के प्रोफाइलर का उपयोग करें । कोई गन्दा कोड एक वास्तविक प्लस नहीं है।

— 21

Answer 1

आप इसके लिए microtimeफ़ंक्शन का उपयोग कर सकते हैं । से प्रलेखन :

microtime - माइक्रोसेकंड के साथ वर्तमान यूनिक्स टाइमस्टैम्प लौटें

---

यदि get_as_floatसेट किया गया है TRUE, तो microtime()एक फ्लोट देता है, जो सेकंड में वर्तमान समय का प्रतिनिधित्व करता है क्योंकि यूनिक्स युग निकटतम माइक्रोसेकंड के लिए सटीक है।

उदाहरण का उपयोग:

$start = microtime(true);
while (...) {

}
$time_elapsed_secs = microtime(true) - $start;

Comments

microtime(true)यदि आप रिटर्न वैल्यू के साथ गणना करना चाहते हैं तो आपको इसकी आवश्यकता होगी ।

— lonesomeday

मुझे पता है कि यह waaaaaay बहुत देर हो चुकी है (लगभग 4 साल), लेकिन एक टिप्पणी के रूप में ... PHP गणना के अनुसार, इन गणनाओं का उपयोग करके (पैरामीटर के get_as_floatरूप में true) आपको सेकंड में परिणाम देगा ।

— एलेजांद्रो इवान

@ हैट्रिक और यही मैंने कहा: यदि get_as_floatहै true, microtime()तो सेकंड का प्रतिनिधित्व करने वाला मान लौटाता है ...

— एलेजांद्रो इवान

हालांकि यह एक बहुत पुरानी पोस्ट है, हमें इस तथ्य का उल्लेख करना चाहिए कि फ्लोट ने जो वापसी की है, उसमें माइक्रोसेकंड शामिल हैं ... सबसे अच्छा समाधान 1000 बार इस तक है ... एक उदाहरण के रूप में stackoverflow.com/questions/3656713/… देखें । ।

— गुस्सा 84

यह उत्तर पुराना है। आजकल स्क्रिप्ट निष्पादन के समय को रिपोर्ट करने का सबसे अच्छा तरीका आपके कोड के अंत में एक पंक्ति है: $time = microtime(true) - $_SERVER["REQUEST_TIME_FLOAT"]; ( नीचे एक उत्तर में अधिक जानकारी ।)

— ashleedawg

Answer 2

आप microtime(true)निम्नलिखित शिष्टाचार के साथ उपयोग कर सकते हैं :

इसे अपनी php फ़ाइल की शुरुआत में रखें:

//place this before any script you want to calculate time
$time_start = microtime(true);

// आपका स्क्रिप्ट कोड यहाँ जाता है

// do something

इसे अपनी php फ़ाइल के अंत में रखें:

// Display Script End time
$time_end = microtime(true);

//dividing with 60 will give the execution time in minutes other wise seconds
$execution_time = ($time_end - $time_start)/60;

//execution time of the script
echo '<b>Total Execution Time:</b> '.$execution_time.' Mins';

यह आपको परिणाम देगा minutes।

Answer 3

आप सुपरग्लोबल सरणी REQUEST_TIMEसे उपयोग कर सकते हैं $_SERVER। प्रलेखन से :

REQUEST_TIME
अनुरोध की शुरुआत का टाइमस्टैम्प। (PHP 5.1.0 के बाद से उपलब्ध।)

REQUEST_TIME_FLOAT
माइक्रोसेकंड परिशुद्धता के साथ अनुरोध की शुरुआत का टाइमस्टैम्प । (PHP 5.4.0 के बाद से उपलब्ध।)

इस तरह आपको अपनी स्क्रिप्ट की शुरुआत में टाइमस्टैम्प को बचाने की आवश्यकता नहीं है। आप बस कर सकते हैं:

<?php
// Do stuff
usleep(mt_rand(100, 10000));

// At the end of your script
$time = microtime(true) - $_SERVER["REQUEST_TIME_FLOAT"];

echo "Did stuff in $time seconds\n";
?>

यहां, $timeसेकंड की स्क्रिप्ट की शुरुआत के बाद का समय समाहित होता है, जिसमें माइक्रोसेकंड परिशुद्धता (उदाहरण के 1.341लिए 1 सेकंड और 341 माइक्रोसेकंड) होता है।

---

और जानकारी:

PHP प्रलेखन : $_SERVERचर और microtimeकार्य

Comments

यह जानना आसान है। तो आप उपयोग कर सकते हैं:$start = $_SERVER["REQUEST_TIME_FLOAT"]; $myscript = microtime(true); $bootstrap = $myscript - $start; ...do stuff ...; $myscripttime = microtime(true) - $myscript;

— pspahn

अच्छी तरह से इस का उपयोग करने के बारे में पूरी बात यह है कि आप बस कर सकते हैं: $myscripttime = microtime(true) - $_SERVER["REQUEST_TIME_FLOAT"];अपनी स्क्रिप्ट के अंत में शुरुआत में टाइमस्टैम्प को बचाने के बिना।

— इजारु

लिंक किए गए दस्तावेज़ के अनुसार, सेकंड$time में अंतर होगा , माइक्रोसेकंड में नहीं ।

— विम डेलाउवे

@WimDeblauwe स्पष्ट करने के लिए, हां परिणाम सेकंड में है। लेकिन माइक्रोसेकंड परिशुद्धता के साथ । उदाहरण के 1.1लिए 1 सेकंड + 100 माइक्रोसेकंड के बराबर है।

— क्रिस हैरिसन

प्रतिक्रिया समय को मापने का यह सबसे अच्छा तरीका है

— माइक एरोन

Answer 4

फ़ाइल loadtime.php बनाएँ

<?php
class loadTime{
    private $time_start     =   0;
    private $time_end       =   0;
    private $time           =   0;
    public function __construct(){
        $this->time_start= microtime(true);
    }
    public function __destruct(){
        $this->time_end = microtime(true);
        $this->time = $this->time_end - $this->time_start;
        echo "Loaded in $this->time seconds\n";
    }
}

<?phpलिखने के बाद अपनी स्क्रिप्ट की शुरुआत मेंinclude 'loadtime.php'; $loadtime=new loadTime();

जब पृष्ठ के अंत में लोड किया जाता है तो लिखा जाएगा "एक्स सेकंड में लोड"

Comments

साफ! लेकिन अगर आप स्पष्ट रूप से अपनी वस्तु को नष्ट नहीं करते हैं, तो आउटपुट क्लोजिंग </html>टैग के बाद दिखाई देगा जो अमान्य है

— दिमित्री पश्केविच

@ गोंडो नहीं, यह सेकंड होगा (माइक्रोसेकंड के साथ sceconds के दशमलव मान के रूप में व्यक्त किया गया)

— फ्रांसेस्कोएम

Answer 5

$start = microtime(true);
for ($i = 0; $i < 10000; ++$i) {
    // do something
}
$total = microtime(true) - $start;
echo $total;

Answer 6

माइक्रोटाइम () देखें ।

Answer 7

यहाँ एक फ़ंक्शन है जो किसी भी समय PHP कोड के निष्पादन, पायथन के टाइमिट मॉड्यूल की तरह होता है: https://gist.github.com/flaviovs/35aab0e85852e548a60a

इसे कैसे उपयोग करे:

include('timeit.php');
const SOME_CODE = '
        strlen("foo bar");
';
$t = timeit(SOME_CODE);
print "$t[0] loops; $t[2] per loop\n";

परिणाम:

$ php x.php 
100000 loops; 18.08us per loop

डिस्क्लेमर: मैं इस जिस्ट का लेखक हूं

EDIT: timeit अब https://github.com/flaviovs/timeit पर एक अलग, स्व-निहित परियोजना है

Answer 8

आपके पास सही विचार है, सिवाय एक अधिक सटीक समय के माइक्रोटाइम () फ़ंक्शन के साथ उपलब्ध है ।

यदि लूप के अंदर जो तेजी है, वह संभव है कि स्पष्ट बीता हुआ समय शून्य हो। यदि हां, तो कोड के चारों ओर एक और लूप लपेटें और इसे बार-बार कॉल करें। प्रति-बार प्राप्त करने के लिए पुनरावृत्तियों की संख्या से अंतर को विभाजित करना सुनिश्चित करें। मेरे पास कोड है जो लगातार, विश्वसनीय समय परिणाम प्राप्त करने के लिए 10,000,000 पुनरावृत्तियों की आवश्यकता है।

Answer 9

मुझे लगा कि मैं एक साथ रखा गया फंक्शन साझा करूँगा। उम्मीद है कि यह आपको समय बचा सकता है।

यह मूल रूप से एक पाठ-आधारित स्क्रिप्ट के समय को ट्रैक करने के लिए उपयोग किया गया था, इसलिए आउटपुट पाठ रूप में है। लेकिन आप चाहें तो इसे आसानी से HTML में संशोधित कर सकते हैं।

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

एक बार जब आप इसे अपनी स्क्रिप्ट के शीर्ष पर कॉपी कर लेते हैं, तो आप जो कुछ भी करना चाहते हैं, उसके बाद रिकॉर्डटाइम फ़ंक्शन कॉल डालते हैं।

इसे अपनी स्क्रिप्ट फ़ाइल के शीर्ष पर कॉपी करें:

$tRecordStart = microtime(true);
header("Content-Type: text/plain");
recordTime("Start");

function recordTime ($sName) {
  global $tRecordStart;
  static $tStartQ;
  $tS = microtime(true);
  $tElapsedSecs = $tS - $tRecordStart;
  $tElapsedSecsQ = $tS - $tStartQ;
  $sElapsedSecs = str_pad(number_format($tElapsedSecs, 3), 10, " ", STR_PAD_LEFT);
  $sElapsedSecsQ = number_format($tElapsedSecsQ, 3);
  echo "//".$sElapsedSecs." - ".$sName;
  if (!empty($tStartQ)) echo " In ".$sElapsedSecsQ."s";
  echo "\n";
  $tStartQ = $tS;
}

गुजरने वाले समय को ट्रैक करने के लिए, बस करें:

recordTime("What We Just Did")

उदाहरण के लिए:

recordTime("Something Else")
//Do really long operation.
recordTime("Really Long Operation")
//Do a short operation.
recordTime("A Short Operation")
//In a while loop.
for ($i = 0; $i < 300; $i ++) {
  recordTime("Loop Cycle ".$i)
}

इस तरह आउटपुट देता है:

//     0.000 - Start
//     0.001 - Something Else In 0.001s
//    10.779 - Really Long Operation In 10.778s
//    11.986 - A Short Operation In 1.207s
//    11.987 - Loop Cycle 0 In 0.001s
//    11.987 - Loop Cycle 1 In 0.000s
...
//    12.007 - Loop Cycle 299 In 0.000s

आशा है कि यह किसी की मदद करता है!

Answer 10

यहाँ बहुत ही सरल और छोटी विधि है

<?php
$time_start = microtime(true);
//the loop begin
//some code
//the loop end
$time_end = microtime(true);
$total_time = $time_end - $time_start;
echo $total_time; // or whatever u want to do with the time
?>

Comments

मुझे लगता है कि मुझे कुछ याद आ रहा है, जब मैंने उत्तर पोस्ट किया तो मैंने उस कोड का परीक्षण किया

— दीपक कुमार

var_dump (microtime (सही)); // फ्लोट (1283846202.89) जब आप सूक्ष्मचर का सही उपयोग करते हैं, तो वह है

— दीपक कुमार

आप फ्लोट का उपयोग कुल समय में भी कर सकते हैं

— दीपक कुमार

Answer 11

यदि आप उस समय को सेकंड में प्रदर्शित करना चाहते हैं:

<?php
class debugTimer 
{
    private $startTime;
    private $callsCounter;

    function __construct() 
    {
        $this->startTime = microtime(true);
        $this->callsCounter = 0;
    }

    public function getTimer(): float
    {
        $timeEnd = microtime(true);
        $time = $timeEnd - $this->startTime;
        $this->callsCounter++;
        return $time;
    }

    public function getCallsNumer(): int
    {
        return $this->callsCounter;
    }
}

$timer = new debugTimer();
usleep(100);
echo '<br />\n
'.$timer->getTimer(). ' seconds before call #'.$timer->getCallsNumer();

usleep(100);
echo '<br />\n
'.$timer->getTimer(). ' seconds before call #'.$timer->getCallsNumer();

Answer 12

यहां एक कार्यान्वयन है जो आंशिक सेकंड (यानी 1.321 सेकंड) लौटाता है

/**
 * MICROSECOND STOPWATCH FOR PHP
 *
 * Class FnxStopwatch
 */
class FnxStopwatch
{
    /** @var float */
    private $start,
            $stop;

    public function start()
    {
        $this->start = self::microtime_float();
    }
    public function stop()
    {
        $this->stop = self::microtime_float();
    }
    public function getIntervalSeconds() : float
    {
        // NOT STARTED
        if (empty($this->start))
            return 0;
        // NOT STOPPED
        if (empty($this->stop))
            return ($this->stop - self::microtime_float());

        return $interval = $this->stop - $this->start;
    }

    /**
     * FOR MORE INFO SEE http://us.php.net/microtime
     *
     * @return float
     */
    private static function microtime_float() : float
    {
        list($usec, $sec) = explode(" ", microtime());

        return ((float)$usec + (float)$sec);
    }
}

Answer 13

औसत समय मापने के लिए यहां मेरी स्क्रिप्ट है

<?php

$times = [];
$nbrOfLoops = 4;
for ($i = 0; $i < $nbrOfLoops; ++$i) {
    $start = microtime(true);
    sleep(1);
    $times[] = microtime(true) - $start;
}

echo 'Average: ' . (array_sum($times) / count($times)) . 'seconds';

Answer 14

आप एकल फ़ंक्शन के साथ दूसरे में निष्पादन समय पा सकते हैं।

// ampersand is important thing here
function microSec( & $ms ) {
    if (\floatval( $ms ) == 0) {
        $ms = microtime( true );
    }
    else {
        $originalMs = $ms;
        $ms = 0;
        return microtime( true ) - $originalMs;
    }
}

// you don't have to define $ms variable. just function needs
// it to calculate the difference.
microSec($ms);
sleep(10);
echo microSec($ms) . " seconds"; // 10 seconds

for( $i = 0; $i < 10; $i++) {
    // you can use same variable everytime without assign a value
    microSec($ms);
    sleep(1);
    echo microSec($ms) . " seconds"; // 1 second
}

for( $i = 0; $i < 10; $i++) {
    // also you can use temp or useless variables
    microSec($xyzabc);
    sleep(1);
    echo microSec($xyzabc) . " seconds"; // 1 second
}