Php application performance optimization-PHP Cache Technology 3

The biggest advantage of using PHP programming is that it is very easy to learn this programming language and its rich library. Even if we don't know much about the functions we need, we can guess how to complete a specific task.

The biggest advantage of using PHP programming is that it is very easy to learn this programming language and its rich library. Even if we don't know much about the functions we need, we can guess how to complete a specific task.

Although PHP is easy to learn, we still need to spend a little time learning some PHP programming skills, especially those related to performance and memory usage. In PHP, there are many tips that can help us reduce memory usage and improve application performance. In this chapter, we will give a brief introduction to the analysis of PHP applications, how to change the script code, and various parameter values before and after optimization.

By setting the timing program in the program and executing the code repeatedly, we can obtain a set of data about the program execution speed, which can be used to find bottlenecks in the program, and how to optimize and improve application performance.

Maybe you have heard of the PEAR Library. We will use the PEAR library to create an example for analysis. this is also the simplest method for analyzing existing code, it allows us to analyze code without using commercial products.

The name of the library we want to use is PEAR: Benchmark, which is very useful for code analysis and performance testing. This library provides a class named Benchmark_Timer (), which records the time between a function call and the next function call. When testing the code performance, we can get a detailed script execution result, which is very simple, as shown below:

Include_once ("Benchmark/Timer. php ");

$ Timer = new Benchmark_Timer;

$ Begin-> start ();

$ Marker-> setMarker ('Start of the script ');

// Sleep for several minutes

Sleep (5 );

$ Response-> stop ();

// Obtain the analysis information from the timer

PRint_r ($ response-> getProfiling ());

?>

The output after code execution is as follows:

Array

(

[0] => Array

(

[Name] => Start

[Time] = & gt; 1013214253.05751200

[Diff] =>-

[Total] => 0

)

[1] => Array

(

[Name] => Start of the script

[Time] = & gt; 1013214253.05761100

[Diff] => 9.8943710327148E-05

[Total] => 9.8943710327148E-05

)

[2] => Array

(

[Name] => Stop

[Time] = & gt; 1013214258.04920700

[Diff] = & gt; 4.9915959835052

[Total] = & gt; 4.9916949272156

)

)

The numbers above seem to be a mess of numbers, but they are useful if the program is larger.

Maybe the readers can guess that the first table in the array is actually calling the Benchmark_Timer () class method, for example

$ Marker-> start (), $ marker-> setMarker (), and $ marker-> stop (). the numbers related to these tables are quite simple, now let's take a closer look at these numbers:

[0] => Array

(

[Name] => Start

[Time] = & gt; 1013214253.05751200

[Diff] =>-

[Total] => 0

)

The time table refers to the UNIX timestamp when the start () method of Benchmark_Timer () is called. the diff table indicates the time interval between this call and the last call, because there is no previous one, a broken number is displayed. The total table refers to the total time of code running from the test to the specific call. Next let's take a look at the output of the next array:

[1] => Array

(

[Name] => Start of the script

[Time] = & gt; 1013214253.05761100

[Diff] => 9.8943710327148E-05

[Total] => 9.8943710327148E-05

)

From the preceding figure, we can see that the program runs 9.8943710327148E-05 seconds (that is, 0.0000989 seconds) after calling $ success-> start) then call $ marker-> setMarker (....).

A real performance test experience

Although the above example is good, it is really not a good example of deciding how to optimize your site code design. Next I will explain how to solve the performance problems with my personal experience as a website technician.

I don't quite understand the code used by the website, because it is developed based on special requirements over the years. one module of the website contains the website conversion code, and the other module records the usage of the website, other modules have their respective functions. I and the main website developers both realized that the website code needs to be optimized, but they do not know where the problem is.

To complete the task as soon as possible, I started to study the main script code of the website and added some $ marker-> setMarker () commands to all the script code and its contained files, then, analyze the output of $ response-> getProfiling () and be surprised by the result. the original problem is that you get the name of a specific language (for example, en stands for english) in the function call of the conversion code, the function is used hundreds of times on every page. Each time you call this function, the script code queries a MySQL database and obtains the real language name from a database table.

We created a buffer system for this type of information. After just two days of work, we have greatly improved the system performance. in the first week, the page views increased by 40%. Of course, this is just an example of how the analysis code can improve the performance of Internet applications or internet websites.

Performance Test function call

Although Benchmark_Timer () is particularly useful in analyzing a script or webpage (and its contained files), it is not scientific, because we must load the script multiple times to obtain the analyzed data, and it is not called for a class or function.

PEAR: another class in the Benchmark library called Benchmark_Iterator can solve this problem well. it can display the analysis information of a specific function or class method. Its purpose is to get consistent results from the test, because we know that if a script is run once, its running time is 10 seconds, it does not mean that every running time is always 10 seconds.

In any case, let's see some examples:

// Database connection code

Include_once ("DB. php ");

$ Dsn = array (

'Phptype '=> 'mysql ',

'Hostspec '=> 'localhost ',

'Database' => 'Database _ name ',

'Username' => 'User _ name ',

'Password' => 'password'

);

$ Dbh = DB: connect ($ dsn );

Function getCreatedDate ($ id)

{

Global $ dbh;

> $ Stmt = "SELECT created_date FROM users WHERE id = $ id ";

// Here PEAR: DB is used

$ Created_date = $ dbh-> getOne ($ stmt );

If (PEAR: isError ($ created_date) |

(Empty ($ created_date ))){

Return false;

} Else {

Return $ created_date;

}

}

Include_once 'benchmark/Iterate. php ';

$ Tenant = new Benchmark_Iterate;

// Run the getDate function 10 times

$ Response-> run (10, 'getcreateddate', 1 );

// Print the analysis information

Print_r ($ response-> get ());

?>

The above code can generate similar results as below:

Array

(

[1] => 0.055413007736206.

[2] => 0.0012860298156738.

[3] = & gt; 0.0010279417037964

[4] = & gt; 0.00093603134155273

[5] = & gt; 0.00094103813171387

[6] = & gt; 0.00092899799346924

[7] = & gt; 0.0010659694671631

[8] = & gt; 0.00096404552459717

[9] = & gt; 0.0010690689086914

[10] => 0.00093603134155273.

[Mean] = & gt; 0.0064568161964417

[Iterations] => 10

)

The preceding numbers are easy to understand. mean entries indicate the average time of the getCreatedDate () function to run for 10 times. The actual test should be performed at least 1000 times, but the results obtained in this example are sufficient to explain the problem.