PHP Performance Optimization Summary

1, for many code files said, especially contains a lot of include files (include or require). They need to spend more time and parse and generate intermediate code.

2, even if the PHP code file has not changed, the implementation process will be strictly followed by the process. That is, regardless of whether your program changes, each time you call, you need to recompile to generate opcode code. (This is actually the reason that the compiler cache exists)

3, this process is not only happening in the main code files, for every include and require, will carry out this process. (This can continue to be optimized)

Where can they be optimized?

1, will mod_php fast-cgi, avoid every time to load this module, this module will be to initialize each time the interpretation of PHP environment.

2, cache php file opcode code, so that, to avoid every time to compile.

APC can be used to achieve 2nd. The compilation cache removes the parsing process from executing the PHP process, so it works well for applications that contain a lot of PHP code. Generally, you can increase your speed by more than 2-3 times. For projects that contain a large number of include files, the compilation cache is more realistic about its advantages.

Note: Include is not cached by the compilation cache. For example, there are now two files: main.php and tobeinclude.php, where main.php has the statement include tobeinclude.php '. Suppose the suffix for the middle code is. OP (not really). Then add cached cache after Main.php=>main.op, Tobeinclude.php=>tobeinclude.op. But when PHP executes main.php, she still needs to parse the include command in Main.op to invoke Tobeinclude.op's content. The specific process is like this.

...=> perform main.op=> execution tobeinclude.op=>

Rather than between simple executive Main.op

So "Too many include files can degrade program performance".

The specific configuration of the APC.

Alternative PHP cache (APC) is a free and publicly optimized code cache for PHP. It is used to provide a free, open and robust architecture to cache and optimize PHP's intermediate code.

APC official website for HTTP://PECL.PHP.NET/PACKAGE/APC

1, installation

Install in PHP extension form

Phpize

./configure--ENABLE-APC--enable-apc-mmap

Make

Make install

Generate. So, copy. So to the PHP reference modules directory, modify permissions 755

2, configuration

Apc.enabled Boolean

Apc.optimization optimization

Options can be changed in the script

APC php.ini configuration Options Detailed

[APC]

; Alternative PHP cache for caching and optimizing PHP intermediate code

Apc.cache_by_default = On

; SYS

; Whether to enable buffering for all files by default.

; When set to off and used with a apc.filters instruction that starts with a plus sign, the file is cached only when the filter is matched.

APC.ENABLE_CLI = Off

; SYS

; Whether to enable the APC feature for the CLI version and open this directive only for testing and debugging purposes.

apc.enabled = On

; If APC is enabled, it is the only way to disable it if the APC is statically compiled into PHP.

Apc.file_update_protection = 2

; SYS

; When you modify a file on a running server, you should perform an atomic operation.

; That is, first write in a temporary file, and then rename the file (MV) to the final name.

; Programs such as text editors and CP, TAR, and so on, do not operate this way, resulting in the possibility of buffering the defective files.

; The default value of 2 indicates that when the file is accessed, it is not buffered if it finds that the modified time distance is less than 2 seconds.

; The unfortunate visitor may get the incomplete content, but the bad effect will not be magnified by the cache.

; If you can make sure that all of the update operations are atomic, you can turn off this feature with 0.

; If your system is slow to update due to a large number of IO operations, you need to increase this value.

Apc.filters =

; SYS

; A comma-delimited list of POSIX-extended regular expressions.

; If the source file name matches any one of the patterns, the file is not cached.

; Note that the filename used to match is the file name passed to Include/require, not the absolute path.

; If the first character of the regular expression is "+", it means that any file that matches the expression will be cached.

; If the first character is "-", no matches are cached. "-" is the default value and can be omitted.

Apc.ttl = 0

; SYS

; The number of seconds the cache entry allowed to linger in the buffer. 0 means never times out. The recommended value is 7200~36000.

; A setting of 0 means that the buffer may be filled with old cache entries, resulting in the inability to cache new entries.

Apc.user_ttl = 0

; SYS

; Similar to Apc.ttl, the recommended value is 7200~36000 for each user.

; A setting of 0 means that the buffer may be filled with old cache entries, resulting in the inability to cache new entries.

Apc.gc_ttl = 3600

; SYS

; The number of seconds the cache entry can exist in the garbage collection table.

; This value provides a security measure, even if a server process crashes while executing the cached source files.

; And the source file has been modified, and the memory allocated for the old version will not be reclaimed until this TTL value is reached.

; Setting to zero disables this attribute.

Apc.include_once_override = Off

; SYS

; Keep off, or you may cause unexpected results.

Apc.max_file_size = 1M

; SYS

; Prevents files larger than this size from being cached.

Apc.mmap_file_mask =

; SYS

; If you use –enable-mmap (default enabled) to compile Mmap support for APC,

; The value here is the Mktemp-style file mask passed to the Mmap module (the recommended value is "/TMP/APC.") XXXXXX ").

; The mask is used to determine whether the memory-mapped area is to be file-backed or shared memory backed.

; For a direct file-backed memory mapping, set to "/TMP/APC." XXXXXX "appearance (exactly 6 x).

; To use POSIX-style shm_open/mmap, you need to set it to "/apc.shm.xxxxxx."

; You can also set the "/dev/zero" to use the kernel's "/dev/zero" interface for anonymous mapped memory.

; Not defining this directive means enforcing the use of anonymous mappings.

Apc.num_files_hint = 1000

; SYS

; The approximate number of different source files that may be included or requested on the Web server (the recommended value is 1024~4096).

; If you are unsure, set to 0; This setting is primarily used for sites that have thousands of source files.

apc.optimization = 0

; Optimization level (recommended value is 0).

; A positive integer value indicates that the optimizer is enabled, and the higher the value, the more aggressive optimization is used.

; Higher values may have very limited speed increases, but are still being tested.

Apc.report_autofilter = Off

; SYS

; Whether to log all scripts that are automatically not cached due to early/late binding reasons.

Apc.shm_segments = 1

; SYS

; The number of shared memory blocks allocated for the compiler buffer (the recommended value is 1).

; If the APC runs out of shared memory and the Apc.shm_size directive is set to the maximum allowed by the system,

; You can try to increase this value.

Apc.shm_size = 30

; SYS

; The size of each shared memory block (in MB, the recommended value is 128~256).

; Some systems, including most BSD variants, have a very small default shared memory block size.

Apc.slam_defense = 0

; SYS (against using the directive, it is recommended to use the Apc.write_lock Directive)

; On a very busy server, whether you start a service or modify a file,

; can result in competitive conditions because multiple processes attempt to cache a single file at the same time.

; This directive is used to set the percentage of cache steps that the process skips when processing files that are not cached.

; For example, set to 75 means that when you encounter a file that is not cached, 75% of the probability is not cached, thereby reducing the collision probability.

; Encourage set to 0来 disable this feature.

Apc.stat = On

; SYS

; Whether to enable script update checking.

; Change this instruction value to be very careful.

; The default value on means that the APC checks whether the script is updated every time the script is requested.

; If updated, the compiled content is automatically recompiled and cached. But doing so has a detrimental effect on performance.

; If set to OFF, the performance is significantly improved by not checking.

; But for the updated content to take effect, you must restart the Web server.

; This instruction is also valid for Include/require files. But it should be noted that

; If you are using a relative path, the APC must check every time it include/require to locate the file.

; Using an absolute path allows you to skip the check, so you are encouraged to use an absolute path for include/require operations.

Apc.user_entries_hint = 100

; SYS

; Similar to the Num_files_hint directive, just for each individual user.

; If you are unsure, set to 0.

Apc.write_lock = On

; SYS

; Whether write locks are enabled.

; On a very busy server, whether you start a service or modify a file,

; can result in competitive conditions because multiple processes attempt to cache a single file at the same time.

; Enabling this directive avoids the appearance of competitive conditions.

apc.rfc1867 = Off

; SYS

; When the directive is opened, APC automatically creates a Upload_ user cache entry (the Apc_upload_progress field value) for each upload file that contains the Apc_upload_progress field just before the file field.

3. php function

Apc_cache_info-retrieves cached information (and meta-data) from APC ' s data store

Apc_clear_cache-clears the APC cache

Apc_define_constants-defines a set of constants for later retrieval and mass-definition

Apc_delete-removes a stored variable from the cache

Apc_fetch-fetch a stored variable from the cache

Apc_load_constants-loads a set of constants from the cache

Apc_sma_info-retrieves APC Shared Memory allocation information

Apc_store-cache a variable in the data store

4. Note:

APC and Apache process share memory, so only in the execution of the Apache process can be stored in the APC, the normal PHP process can not access the APC shared memory.

Chapter II Coding techniques for improving PHP performance

0. It is quicker to use single quotes instead of double quotes to contain strings. Because PHP searches for variables in a string enclosed in double quotes, single quotes are not, note: only echo can do this, it is a "function" that can take multiple strings as arguments: ECHO is the language structure, not the real function, so the function is added double quotes.

1, if you can define the method of the class as static, as far as possible to define static, it will increase the speed of nearly 4 times times.

2, $row [' ID '] speed is $row[id] 7 times times.

3, ECHO is faster than print, and uses Echo's multiple arguments (to refer to a comma rather than a period) instead of a string connection, such as Echo $str 1, $str 2.

4, before executing the For loop to determine the maximum number of loops, do not calculate the maximum value per cycle, preferably using foreach instead.

5, the cancellation of those unused variables, especially large arrays, in order to free memory.

6, try to avoid the use of __get,__set,__autoload.

7, require_once () costly.

8, include files as far as possible using the absolute path, because it avoids the PHP to include_path to find the file speed, parsing the operating system path requires less time.

9, if you want to know the script to start execution (that is, the server to receive client requests) at the moment, using $_server[' request_time ' is better than time ().

10. Functions do the same function instead of regular expressions.

11, the Str_replace function is faster than the Preg_replace function, but the efficiency of the STRTR function is four times times that of the Str_replace function.

12. If a string substitution function can accept an array or character as a parameter, and the parameter length is not too long, consider writing an extra paragraph of substitution code so that each pass parameter is a character, rather than writing a single line of code to accept the array as a query and replacement parameter.

13. Using the Select Branch statement (switch case) is better than using multiple if,else if statements.

14, using the @ block error message is very inefficient, extremely inefficient.

15, open the Apache mod_deflate module, you can improve the browsing speed of the Web page.

16, the database connection should be turned off when use is finished, do not use long connection.

17. Error messages are costly.

18, in the method to increase the local variable, speed is the fastest. Almost as fast as calling a local variable in a function.

19, incrementing a global variable is twice times slower than incrementing a local variable.

20, incrementing an object property (such as: $this->prop++) is 3 times times slower than incrementing a local variable.

21. Incrementing an undefined local variable is 9 to 10 times times slower than incrementing a predefined local variable.

22. Defining only one local variable instead of calling it in a function also slows down the speed (which is equivalent to incrementing a local variable). PHP will probably check to see if there are any global variables.

23. The method call appears to have nothing to do with the number of methods defined in the class, because I added 10 methods (both before and after the test method), but there was no change in performance.

24. Methods in a derived class run faster than the same method defined in the base class.

25. Call an empty function with one parameter, which takes as much time as 7 to 8 local variable increment operations. A similar method invocation takes approximately 15 times of local variable increments.

26, the time of Apache parsing a PHP script is 2 to 10 times times slower than parsing a static HTML page. Use static HTML pages as much as possible and use less scripting.

27. Unless the script can be cached, it will be recompiled every time it is invoked. The introduction of a set of PHP caching mechanisms typically increases performance from 25% to 100% to exempt compilation overhead.

28, try to do the cache, you can use memcached. Memcached is a high-performance memory object caching system that can be used to speed up dynamic Web applications and reduce database load. It is useful to cache the operation Code (OP code) so that the script does not have to recompile for each request.

29. When manipulating strings and having to check whether their lengths meet certain requirements, you will of course use the strlen () function. This function executes fairly quickly because it does not do any calculations and returns only the known string lengths stored in the Zval structure (c's built-in data structure for storing PHP variables). However, since strlen () is a function, it will be somewhat slower, because function calls go through a number of steps, such as lowercase letters, PHP is case-insensitive, and hash lookups follow the functions that are called. In some cases, you can use the isset () technique to speed up the execution of your code.

(Examples below)

if (strlen ($foo) < 5) {echo "Foo is too Short" $$}

(compare with the following tips)

if (!isset ($foo {5})) {echo "Foo is too Short" $$}

Calling Isset () happens to be faster than strlen (), because unlike the latter, Isset () as a language structure means that its execution does not require function lookup and lowercase. That is, you're actually not spending too much on the top-level code that verifies the length of the string.

34, when the execution variable $i increment or decrement, $i + + will be slower than the + + $i. This difference is specific to PHP and does not apply to other languages, so please do not modify your C or Java code and expect them to quickly become useless. + + $i faster because it requires only 3 instructions (opcodes), $i + + requires 4 instructions. A post increment actually produces a temporary variable, which is then incremented. And the predecessor increment increases directly on the original value. This is one of the most optimized processes, as Zend's PHP optimizer has done. Keeping this optimization in mind is a good idea, because not all command optimizer will do the same optimization, and there are a large number of Internet service providers (ISPs) and servers that do not have assembly instruction optimizer.

35, is not a matter of object-oriented (OOP), object-oriented often expensive, each method and object calls will consume a lot of memory.

36, not to use the class to implement all the data structure, the array is also useful.

37, do not subdivide the method too much, carefully think about what you really intend to reuse the code?

38, when you need, you can always break down the code into a method.

39, try to use a large number of PHP built-in functions.

40. If there are a lot of time-consuming functions in your code, you can consider using C extensions to implement them.

41, evaluate the test (profile) your code. The inspector will tell you which parts of the code are consuming much of the time. The Xdebug debugger includes a test procedure that can be used to show code bottlenecks in general.

42, Mod_zip can be used as Apache module, to instantly compress your data, and to reduce the amount of data transfer by 80%.

43, can use file_get_contents instead of file, fopen, feof, Fgets, and other series of methods, as far as possible with file_get_contents, because his efficiency is much higher! But pay attention to file_get_ Contents PHP version problem when opening a URL file;

44, as far as possible the file operation, although the PHP file operation efficiency is not low;

45, optimize the Select SQL statement, as far as possible in the case of INSERT, update operation;

46, as far as possible the use of PHP internal functions (but I was in order to find a PHP does not exist in the function, wasted the time to write a custom function, experience problems ah!);

47, the circulation inside do not * * variable, especially large variables: objects (this seems to be not just PHP to pay attention to the problem?);

48, multidimensional array as far as possible not to cycle nested assignment;

49, in the case of PHP internal string manipulation function, do not use regular expression;

50, foreach more efficient, as far as possible with foreach instead while and for loops;

51, the use of single quotes instead of double quotes quoted strings;

52, "Replace I=i+1 with I+=1." In line with C + + habits, efficiency is also high ";

53, to global variables, should be used up on the unset () off;