21% of CPU time is spent on memory management.
12% of CPU time is spent on hash table operations, mainly adding, deleting, modifying and checking PHP arrays.
30% of CPU time is spent in built-in functions, such as strlen.
25% of CPU time is spent in VM (Zend Engine).
After analysis, two conclusions were drawn:
(1) If the ByteCodes generated by JIT are too large , will cause the CPU cache hit rate to decrease (CPU Cache Miss)
In the PHP5.5 code, because there is no obvious type definition, type inference can only be relied on. Define the variable types that can be inferred as much as possible, and then, combined with type inference, remove branch codes that are not of that type and generate directly executable machine code. However, type inference cannot infer all types. In WordPress, less than 30% of the type information that can be inferred is limited, and the branch code that can be reduced is limited. As a result, after JIT, machine code is directly generated, and the generated ByteCodes are too large, eventually causing a significant decrease in CPU cache hits (CPU Cache Miss).
CPU cache hit means that when the CPU reads and executes instructions, if the required data cannot be read in the CPU's first-level cache (L1), it has to Continue to search downwards, all the way to the second-level cache (L2) and third-level cache (L3), and eventually try to find the required instruction data in the memory area, and the read time gap between the memory and the CPU cache can reach 100x level. Therefore, if the ByteCodes are too large and the number of executed instructions is too large, the multi-level cache cannot accommodate so much data, and some instructions will have to be stored in the memory area.
The size of the cache at all levels of the CPU is also limited. The following picture is the configuration information of the Intel i7 920:
Therefore, the decrease in CPU cache hit rate will cause a serious increase in time consumption. On the other hand, the performance improvement brought by JIT is also offset by it. .
Through JIT, the overhead of VM can be reduced. At the same time, through instruction optimization, the development of memory management can be indirectly reduced because the number of memory allocations can be reduced. However, for real WordPress projects, only 25% of the CPU time is spent on the VM, and the main problem and bottleneck is not actually on the VM. Therefore, the JIT optimization plan was not included in the PHP7 features of this version. However, it is likely to be implemented in a later version, which is worth looking forward to.
(2) The improvement effect of JIT performance depends on the actual bottleneck of the project
JIT has a large impact in the benchmark The improvement in magnitude is because the amount of code is relatively small, the final generated ByteCodes are also relatively small, and the main overhead is in the VM. However, there is no obvious performance improvement in the actual WordPress project because the code volume of WordPress is much larger than that of the benchmark. Although JIT reduces the overhead of the VM, it causes a decrease in CPU cache hits and extra memory because the ByteCodes are too large. Overhead, ultimately, there is no improvement.
Different types of projects will have different CPU overhead ratios and will get different results. Performance testing without actual projects is not very representative.
3). Changes in Zval
In fact, the actual storage carrier of various types of variables in PHP is Zval, which is characterized by its tolerance and tolerance. Essentially, it is a structure (struct) implemented in C language. For students who write PHP, you can roughly understand it as something similar to an array.
PHP5's Zval, the memory occupies 24 bytes:
PHP7's Zval, the memory occupies 16 bytes:
Zval dropped from 24 bytes to 16 bytes. Why did it drop? I need to add a little bit of C language foundation here. , to assist students who are not familiar with C to understand. There is a slight difference between struct and union (union). Each member variable of Struct occupies an independent memory space, while the member variables in union share a memory space (that is to say, if one of the member variables is modified, the public space will be After modification, there will be no records of other member variables). Therefore, although there appear to be a lot more member variables, the actual memory space occupied has decreased.
In addition, there are other features that have been significantly changed. Some simple types no longer use references.
Zval structure diagram:
Zval in the picture consists of two 64bits (1 byte = 8bit, bit is "bit"). If the variable If the type is long or bealoon, and the length does not exceed 64 bits, it will be stored directly in value, and there will be no following reference. When the variable type is array, objec, string, etc. that exceeds 64 bits, the value stored is a pointer pointing to the real storage structure address.
For simple variable types, Zval storage becomes very simple and efficient.
Types that do not require references: NULL, Boolean, Long, Double
Types that require references: String, Array, Object, Resource, Reference
4) . The internal type zend_string
Zend_string is the structure that actually stores the string, and the actual content will be stored in val(char , character type), and val is a char array with a length of 1 (convenient for member variable occupancy).
The last member variable of the structure uses a char array instead of using char*. Here is a small optimization trick that can reduce the CPU cache miss.
If you use a char array, when malloc applies for the memory of the above structure, it is applied in the same area, usually the length is sizeof(_zend_string) actual char storage space. However, if you use char*, what is stored in this location is only a pointer, and the actual storage is in another independent memory area.
Comparison of memory allocation using char[1] and char*:
From the perspective of logic implementation, there is actually not much difference between the two, and the effects are very similar. In fact, when these memory blocks are loaded into the CPU, they look very different. Because the former is the same piece of memory allocated continuously together, it can usually be obtained together when the CPU reads it (because it will be in the same level cache). The latter, because it contains data from two memories, when the CPU reads the first memory, it is very likely that the second memory data is not in the same level cache, so the CPU has to search below L2 (secondary cache), or even to The desired second piece of memory data is found in the memory area. This will cause CPU Cache Miss, and the time-consuming difference between the two can be up to 100 times.
#In addition, when copying a string, using reference assignment, zend_string can avoid memory copying.
5). Changes in PHP arrays (HashTable and Zend Array)
in In the process of writing PHP programs, the most frequently used type is arrays. PHP5 arrays are implemented using HashTable. To put it in a rough summary, it is a HashTable that supports doubly linked lists. It not only supports hash mapping to access elements through array keys, but can also traverse array elements by accessing doubly linked lists through foreach.
PHP5 HashTable:
This picture looks very complicated, with various pointers jumping around. When we access the content of an element through the key value , sometimes it takes three pointer jumps to find the right content. The most important point is that the storage of these array elements is scattered in different memory areas. In the same way, when the CPU reads, because they are likely not in the same level cache, the CPU will have to search in the lower-level cache or even the memory area, which will cause the CPU cache hit to decrease, thereby increasing more consumption. hour.
Zend Array of PHP7 (screenshot from PPT):
The new version of the array structure, Very simple and eye-catching. The biggest feature is that the entire array elements and hash mapping table are all connected together and allocated in the same memory. If you are traversing a simple type array of integers, the efficiency will be very fast, because the array elements (Bucket) themselves are continuously allocated in the same memory, and the zval of the array elements will store the integer elements internally. There is also a pointer external link, and all data is stored in the current memory area. Of course, the most important thing is that it can avoid CPU Cache Miss (CPU cache hit rate decrease).
Changes in Zend Array:
(1) The value of the array defaults to zval.
(2) The size of HashTable is reduced from 72 to 56 bytes, a reduction of 22%.
(3) The size of Buckets is reduced from 72 to 32 bytes, a reduction of 50%.
(4) The memory space of the buckets of array elements is allocated together.
(5) The key of the array element (Bucket.key) points to zend_string.
(6) The value of the array element is embedded in the Bucket.
(7) Reduce CPU Cache Miss.
6). Function Calling Convention
PHP7 has been improved The function calling mechanism reduces some instructions and improves execution efficiency by optimizing the parameter transfer process.
PHP5’s function calling mechanism (screenshot from PPT):
In the figure, the instructions send_val and recv parameters in the vm stack are the same. PHP7 reduces the duplication of these two, To achieve the underlying optimization of the function calling mechanism.
The function calling mechanism of PHP7 (screenshot from PPT):
7). Through macro definitions and inline functions (inline), let the compiler complete part of the work in advance
The macro definition of C language will be executed in the preprocessing stage (compilation stage), part of the work is completed in advance, and there is no need to allocate memory when the program is running. It can realize function-like functions, but there is no stack push or pop-up of function calls. Stack overhead, efficiency will be higher. The same is true for inline functions. In the preprocessing stage, the functions in the program are replaced with function bodies. When the actual running program is executed here, there will be no overhead of function calls.
PHP7 has made a lot of optimizations in this regard and put a lot of work that needs to be performed in the running phase into the compilation phase. For example, parameter type judgment (Parameters Parsing), because all involved here are fixed character constants, can be completed in the compilation stage, thereby improving subsequent execution efficiency.
For example, in the figure below, the way to handle the type of passed parameters is optimized from the writing method on the left to the macro writing method on the right.
PHP 7.0.0 RC 2 Released new features
- Improved performance: PHP 7 is up to twice as fast as PHP 5.6: The performance is twice as fast as php5.6
- Consistent 64-bit support supports 64-bit, unifies the integer length under different platforms, supports strings and file uploads larger than 2GB.
- Many fatal errors are now Exceptions More Error errors can be handled with exceptions
- Removal of old and unsupported SAPIs and extensions Removed old and unsupported SAPIs and extensions Supported SAPIs and extensions
- The null coalescing operator (??) null coalescing operator (??)
- Combined comparison Operator (<=>) Combined comparison operator (<=>)
- Return Type Declarations Return Type Declarations
- Scalar Type Declarations Scalar Type Declarations
- Anonymous Classes Anonymous Classes
##Specific examples:
More Errors become catchable Exceptions
PHP7 implements a global throwable interface, the original Exception and some Errors are implemented This interface is used to define the inheritance structure of exceptions in the form of interfaces. As a result, more Errors in PHP7 become catchable Exceptions and are returned to developers. If they are not caught, they are Errors. If they are caught, they become Exceptions that can be handled within the program. These catchable Errors are usually Errors that will not cause fatal harm to the program, such as a function that does not exist. PHP7 further facilitates developers' processing and gives developers greater control over the program. Because by default, Error will directly cause the program to interrupt, and PHP7 provides the ability to capture and process it, allowing the program to continue executing, providing programmers with more flexible choices.
#For example, to execute a function that we are not sure exists or not, the PHP5-compatible method is to append the judgment function_exist before the function is called, while PHP7 supports capture How to handle Exception.
The example in the picture below
AST (Abstract Syntax Tree, abstract syntax tree)
AST plays the role of a middleware in the PHP compilation process, replacing the original method of spitting out opcode directly from the interpreter, decoupling the interpreter (parser) and the compiler (compliler). It can reduce some Hack code, and at the same time, make the implementation easier to understand and maintain.
PHP5：
PHP7：
More AST information: https://wiki.php.net/rfc/abstract_syntax_tree
##Native TLS (Native Thread local storage, native Thread local storage)#
PHP needs to solve the problem of "thread safety" (TS, Thread Safe) in multi-threaded mode (for example, the woker and event modes of the web server Apache, which are multi-threaded), because threads share the memory space of the process. , so each thread itself needs to build a private space in some way to save its own private data to avoid mutual contamination with other threads. The method adopted by PHP5 is to maintain a large global array and allocate an independent storage space to each thread. Threads access this global data group through their own key values.
This unique key value needs to be passed to every function that needs to use global variables in PHP5. PHP7 believes that this method of passing is not friendly and has some problems. Therefore, try to use a global thread-specific variable to save this key value.
Related Native TLS issues: https://wiki.php.net/rfc/native-tls
##Combined comparison Operator (< ;=>) Combined with comparison operator (<=>)
// PHP 7之前的写法：比较两个数的大小
function order_func($a, $b) {
return ($a < $b) ? -1 : (($a > $b) ? 1 : 0);
}
// PHP新增的操作符 <=>,perfect
function order_func($a, $b) {
return $a <=> $b;
}Copy after login
![[Web front-end] Node.js quick start](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
