Php betiklerinin yürütme sürelerini ölçmenin doğru yolu

Ben bir PHP for-loop yürütmek için kaç milisaniye sürer bilmek istiyorum.

Ben genel bir algoritma yapısını biliyorum, ama nasıl PHP bunu uygulamak için hiçbir fikrim yok:

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

Bunun için microtimeişlevi kullanabilirsiniz . Gönderen belgeler :

microtime - Mikrosaniye ile geri dönen Unix zaman damgası

---

Eğer get_as_floatayarlandığında TRUE, daha sonra microtime()en yakın mikrosaniye doğru Unix Dönemden beri saniye geçerli saati temsil eden bir şamandıra döndürür.

Örnek kullanım:

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

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

microtime(true)Aşağıdaki şekillerde kullanabilirsiniz :

Bunu php dosyanızın başına koyun:

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

// kod kodunuz buraya gelir

// do something

Bunu php dosyanızın sonuna koyun:

// 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';

Sonuç olarak çıktı verir minutes.

Sen kullanabilirsiniz REQUEST_TIMEgelen $_SERVERsüper küresel dizisine. Belgelerden :

REQUEST_TIME
İsteğin başlamasının zaman damgası. (PHP 5.1.0'dan beri kullanılabilmektedir.)

REQUEST_TIME_FLOAT
Mikrosaniye hassasiyetiyle talebin başlamasının zaman damgası . (PHP 5.4.0'dan beri kullanılabilmektedir.)

Bu şekilde, komut dosyanızın başında bir zaman damgası kaydetmenize gerek kalmaz. Sadece şunları yapabilirsiniz:

<?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";
?>

Burada, $timemikrosaniye hassasiyetiyle (örn. 1.3411 saniye ve 341 mikrosaniye için) komut dosyasının başlamasından bu yana geçen süreyi saniye cinsinden içerir.

Daha fazla bilgi:

PHP belgeleri : $_SERVERdeğişkenler ve microtimeişlev

Loadtime.php dosyası oluştur

<?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";
    }
}

Senaryonuzun başlangıcından daha sonra, <?php yazmainclude 'loadtime.php'; $loadtime=new loadTime();

Sayfa sonuna yüklendiğinde "x saniyede yüklendi" yazılır

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

Bakınız mikro-zaman () .

Python'un timeit modülünün yaptığı gibi, herhangi bir PHP kodunun yürütülmesini zamanlayan bir işlev: https://gist.github.com/flaviovs/35aab0e85852e548a60a

Bu nasıl kullanılır:

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

Sonuç:

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

Feragatname: Bu Gist'in yazarıyım

EDIT: timeit artık ayrı, bağımsız bir proje https://github.com/flaviovs/timeit adresinde

Microtime () fonksiyonu ile daha kesin bir zamanlama mevcut olması dışında doğru fikre sahipsiniz .

Döngünün içindekiler hızlıysa, görünen geçen sürenin sıfır olması mümkündür. Öyleyse, kodun etrafına başka bir döngü sarın ve tekrar tekrar çağırın. Bir kereye mahsus olmak için farkı yineleme sayısına böldüğünüzden emin olun. Tutarlı, güvenilir zamanlama sonuçları elde etmek için 10.000.000 yineleme gerektiren profilli kodum var.

Bir araya getirdiğim işlevi paylaşacağımı düşündüm. Umarım size zaman kazandırabilir.

Başlangıçta metin tabanlı bir komut dosyasının zamanlamasını izlemek için kullanıldığından çıktı metin biçimindedir. Ancak isterseniz HTML olarak kolayca değiştirebilirsiniz.

Komut dosyasının başlangıcından bu yana ve her adımda ne kadar zaman harcadığınızı sizin için tüm hesaplamaları yapacaktır. Tüm çıktıları 3 ondalık hassasiyetle biçimlendirir. (Milisaniyeye kadar.)

Komut dosyanızın üstüne kopyaladıktan sonra, tek yapmanız gereken recordTime işlev çağrılarını zamanlamak istediğiniz her parçadan sonra koymaktır.

Bunu komut dosyanızın üstüne kopyalayın:

$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;
}

Geçen zamanı izlemek için yapmanız gerekenler:

recordTime("What We Just Did")

Örneğin:

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)
}

Bunun gibi çıktılar verir:

//     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

Umarım bu birine yardımcı olur!

İşte çok basit ve kısa bir yöntem

<?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
?>

o zamanı saniye olarak görüntülemek istiyorsanız:

<?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();

İşte kesirli saniyeleri (yani 1.321 saniye) döndüren bir uygulama

/**
 * 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);
    }
}

İşte ortalama süreyi ölçmek için senaryom

<?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';

Tek bir işlevle yürütme süresini saniye olarak bulabilirsiniz.

// 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
}