CODEWITHSUNDEEP
php
DomingoSL
DomingoSL

Reputation: 15504

Accurate way to measure execution times of php scripts

I want to know how many milliseconds a PHP for-loop takes to execute.

I know the structure of a generic algorithm, but no idea how to implement it in 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

Upvotes: 365

Views: 400610

Answers (17)

Aditya P Bhatt
Aditya P Bhatt

Reputation: 22081

You can use microtime(true) with following manners:

Put this at the start of your php file:

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

// your script code goes here

// do something

Put this at the end of your php file:

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

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

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

It will output you result in minutes.

Upvotes: 125

Hamed Yarandi
Hamed Yarandi

Reputation: 1211

It would be more clear this way

<?php

$start = hrtime(true);

while (...) {
}

$duration = hrtime(true) - $start;
echo  $duration * 1000 ." -> microseconds". PHP_EOL; 
echo  $duration * 1000000 ." -> milliseconds". PHP_EOL; 
echo  $duration * 1e6 ." -> milliseconds". PHP_EOL;

the result

37180000 -> microseconds
37180000000 -> milliseconds
37180000000 -> milliseconds

Upvotes: -2

Engr.Aftab Ufaq
Engr.Aftab Ufaq

Reputation: 6424

<?php
// Randomize sleeping time
usleep(mt_rand(100, 10000));

// REQUEST_TIME_FLOAT is available in the $_SERVER superglobal array.
// It contains the timestamp of the start of the request with microsecond precision.
$time = microtime(true) - $_SERVER["REQUEST_TIME_FLOAT"];

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

here is the link for this

Upvotes: 2

Waqleh
Waqleh

Reputation: 10181

The way I do it is by using hrtime, it's created for performance metrics and it is independent from system time. hrtime does not get affected by system time changes. hrtime is available since PHP 7.3.0

$start = hrtime(true);
sleep(5); // do something, in your case a loop
$end = hrtime(true);
$eta = $end - $start;
// convert nanoseconds to milliseconds
$eta /= 1e+6;
echo "Code block was running for $eta milliseconds";

Output:

Code block was running for 5000.495206 milliseconds

Upvotes: 34

Eugene Kaurov
Eugene Kaurov

Reputation: 2991

if you like to display that time in seconds:

<?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 getCallsNumber(): int
    {
        return $this->callsCounter;
    }
}

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

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

Upvotes: 3

kodmanyagha
kodmanyagha

Reputation: 1005

You can find the execution time in second with a single function.

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

Upvotes: -1

William Desportes
William Desportes

Reputation: 1711

Here is my script to measure average time

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

Upvotes: 3

clemlatz
clemlatz

Reputation: 8063

You can use REQUEST_TIME from the $_SERVER superglobal array. From the documentation:

REQUEST_TIME
The timestamp of the start of the request. (Available since PHP 5.1.0.)

REQUEST_TIME_FLOAT
The timestamp of the start of the request, with microsecond precision. (Available since PHP 5.4.0.)

This way you don't need to save a timestamp at the beginning of your script. You can simply do:

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

Here, $time would contain the time elapsed since the start of the script in seconds, with microseconds precision (eg. 1.341 for 1 second and 341 microseconds)

More info:

PHP documentation: $_SERVER variables and microtime function

Upvotes: 100

azoundria
azoundria

Reputation: 1025

I thought I'd share the function I put together. Hopefully it can save you time.

It was originally used to track timing of a text-based script, so the output is in text form. But you can easily modify it to HTML if you prefer.

It will do all the calculations for you for how much time has been spent since the start of the script and in each step. It formats all the output with 3 decimals of precision. (Down to milliseconds.)

Once you copy it to the top of your script, all you do is put the recordTime function calls after each piece you want to time.

Copy this to the top of your script file:

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

To track the time that passes, just do:

recordTime("What We Just Did")

For example:

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

Gives output like this:

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

Hope this helps someone!

Upvotes: 4

mils
mils

Reputation: 1916

Here's an implementation that returns fractional seconds (i.e. 1.321 seconds)

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

Upvotes: 2

Deepak Kumar
Deepak Kumar

Reputation: 413

Here is very simple and short method

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

Upvotes: 3

user142162
user142162

Reputation:

You can use the microtime function for this. From the documentation:

microtime — Return current Unix timestamp with microseconds

If get_as_float is set to TRUE, then microtime() returns a float, which represents the current time in seconds since the Unix epoch accurate to the nearest microsecond.

Example usage:

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

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

Upvotes: 711

flaviovs
flaviovs

Reputation: 595

Here is a function that times execution of any piece of PHP code, much like Python's timeit module does: https://gist.github.com/flaviovs/35aab0e85852e548a60a

How to use it:

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

Result:

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

Disclaimer: I am the author of this Gist

EDIT: timeit is now a separate, self-contained project at https://github.com/flaviovs/timeit

Upvotes: 7

Solo Omsarashvili
Solo Omsarashvili

Reputation: 990

Create file 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";
    }
}

Than in the beggining of your script, after <?php write include 'loadtime.php'; $loadtime=new loadTime();

When page is loaded at the end there will be written "Loaded in x seconds"

Upvotes: 31

wallyk
wallyk

Reputation: 57794

You have the right idea, except a more precise timing is available with the microtime() function.

If what is inside the loop is fast, it is possible that the apparent elapsed time will be zero. If so, wrap another loop around the code and call it repeatedly. Be sure to divide the difference by the number of iterations to get a per-once time. I have profiled code which required 10,000,000 iterations to get consistent, reliable timing results.

Upvotes: 5

dvir
dvir

Reputation: 5115

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

Upvotes: 22

patapizza
patapizza

Reputation: 2398

See microtime().

Upvotes: 6

Related Questions