Microscopic Analysis of PHP Performance_PHP Tutorial

Micro-analysis of PHP performance

1. Functions and commands related to performance analysis

1.1. Time measurement function

We usually use the time() function, but it returns the number of seconds. For internal performance analysis of a certain piece of code, the precision of seconds is not enough. So use the microtime function. The microtime function can return two forms, one is in the form of a string, and the other is in the form of a floating point number. However, it should be noted that by default, the precision returned is only 4 decimal places. In order to obtain higher accuracy, we need to configure precision.

The following are the results of using microtime.

    $start= microtime(true);
    echo $start."\n";
    $end = microtime(true);
    echo $end."\n";
    echo ($end-$start)."\n";

The output is:

bash-3.2# phptime.php

1441360050.3286

1441360050.3292

0.00053000450134277

And add a line in front of the code:

ini_set("precision", 16);

The output is:

bash-3.2# phptime.php

1441360210.932628

1441360210.932831

0.0002031326293945312

In addition to microtime internal statistics, you can also use getrusage to obtain user state events. In actual operations, the time command is also commonly used to calculate the running time of the entire program. By running it multiple times or modifying the code, different time lengths can be obtained to obtain differences in efficiency. The specific usage is: time phptime.php. After the program is completed, regardless of whether it ends normally and exits, there will be relevant statistics.

bash-3.2# time phptime.php

1441360373.150756

1441360373.150959

0.0002031326293945312

real 0m0.186s

user 0m0.072s

sys 0m0.077s

Because of the performance issues discussed in this article, we often analyze the gaps and trends after millions of calls. In order to avoid the existence of some time statistics code in the code, we will mostly use the time command later.

1.2. Memory usage related functions

There are two functions for analyzing memory usage: memory_ get_ usage and memory_ get_ peak_usage. The former can get the memory used at the time when the program is called, that is, the memory currently used, and the latter can get the memory used during the peak period so far. . The memory used is in bytes.

    $base_memory= memory_get_usage();
    echo "Hello,world!\n";
    $end_memory= memory_get_usage();
    $peak_memory= memory_get_peak_usage();

    echo $base_memory,"\t",$end_memory,"\t",($end_memory-$base_memory),"\t", $peak_memory,"\n";

The output is as follows:

bash-3.2# phphelloworld.php

Hello, world!

224400 224568 168 227424

As you can see, even if only one sentence is output in the middle of the program, plus variable storage, 168 bytes of memory are consumed.

For the same program, the memory usage of different PHP versions is not the same, or even very different.

   $baseMemory= memory_get_usage();
    class User
    {
    private $uid;
    function __construct($uid)
        {
    $this->uid= $uid;
        }
    }
    
    for($i=0;$i<100000;$i++)
    {
    $obj= new User($i);
    if ( $i% 10000 === 0 )
        {
    echo sprintf( &#39;%6d: &#39;, $i), memory_get_usage(), " bytes\n";
        }
    }
    echo "  peak: ",memory_get_peak_usage(true), " bytes\n";

In PHP 5.2, memory usage is as follows:

    [root@localhostphpperf]# php52 memory.php


    0: 93784 bytes
    10000: 93784 bytes
    ……
    80000: 93784 bytes
    90000: 93784 bytes
    peak: 262144 bytes

In PHP 5.3, memory usage is as follows

    [root@localhostphpperf]# phpmemory.php


    0: 634992 bytes
    10000: 634992 bytes
    ……
    80000: 634992 bytes
    90000: 634992 bytes
    peak: 786432 bytes

It can be seen that PHP 5.3 is more extensive in memory usage.

PHP 5.4 - 5.6 is almost the same, with some optimizations:

 [root@localhostphpperf]# php56 memory.php


    0: 224944 bytes
    10000: 224920 bytes
    ……
    80000: 224920 bytes
    90000: 224920 bytes
    peak: 262144 bytes

When PHP 7 is used in small quantities, the peak memory usage increases a lot.

  [root@localhostphpperf]# php7 memory.php


    0: 353912 bytes
    10000: 353912 bytes
    ……
    80000: 353912 bytes
    90000: 353912 bytes
    peak: 2097152 bytes

As you can see from the above, the PHP used above has a relatively good garbage collection mechanism. After 100,000 initializations, the memory usage does not increase with the increase in object initialization. PHP7 has the highest peak memory usage, reaching nearly 2M.

Let’s look at another example. Based on the above code, we add a line, which is the bold line as follows:

$obj->self = $obj;

The code is as follows:

    $baseMemory= memory_get_usage();
    class User
    {
    private $uid;
    function __construct($uid)
        {
    $this->uid= $uid;
        }
    }
    
    for($i=0;$i<100000;$i++)
    {
    $obj= new User($i);
    $obj->self = $obj;
    if ( $i% 5000 === 0 )
        {
    echo sprintf( &#39;%6d: &#39;, $i), memory_get_usage(), " bytes\n";
        }
    }

echo " peak: ",memory_get_peak_usage(true), " bytesn";

http://www.bkjia.com/PHPjc/1053349.htmlwww.bkjia.comtruehttp: //www.bkjia.com/PHPjc/1053349.htmlTechArticleMicro-analysis of PHP performance 1. Functions and commands related to performance analysis 1.1. Time measurement function We usually use time ( ) function, but returns the number of seconds, for the internal part of a certain code...