PHP Kernel Explorer: Zend virtual machine

Through the previous study, we learned that a PHP file on the server side of the execution process consists of the following two large processes:

1. The PHP program needs to execute the file, PHP program to complete basic preparation work after starting PHP and Zend engine, load the registered extension module.
2. After the initialization is completed, the script file is read, and the Zend engine parses the script file, parsing the parser. It is then compiled into opcode execution. If a opcode cache such as APC is installed, the compile link may be skipped and read opcode execution directly from the cache.

In the second step, lexical analysis, parsing, compiling intermediate code, executing intermediate code, etc. are collectively referred to as Zend virtual machines. Compared with the Java, C # and other compiled languages, PHP is less a manual compilation process, they do not need to compile to run, we call it an explanatory language. Java has its own Java Virtual machine, which implements a unified language on multiple platforms; C # has its own. NET virtual machine, which implements multiple languages on a single platform; PHP, like them, has its own zend virtual machine. They are essentially the same, they are abstract computers. These virtual machines are in a lower level of the language to abstract another language, has its own instruction set, has its own memory management system. They eventually translate higher-level language implementations into lower-level language implementations, and implement other ancillary functions such as memory management, garbage collection, and so on, to reduce the programmer's work on specific implementations, thus allowing more time and effort into the business logic. From the level of abstraction, Zend virtual machines are a bit more advanced than those in Java, where the advanced is not to say that they are more powerful or more efficient, and simply say that the Zend virtual machine is farther from the real machine. In recent years, the development of language has been a constant abstraction, constantly moving away from machines, without fundamental changes.

Here we from the virtual machine's past life, the description of the implementation of the Zend virtual machine, the key data structure, and interspersed with an example of the implementation of the syntax and the source code encryption and decryption process description.

The definition of a virtual machine in a wiki is a virtual machine, which, in the architecture of computer science, is a special kind of software that creates an environment between a computer platform and an end user, while the end user operates the software based on the environment created by the software. In computer science, a virtual machine is a software implementation of a computer that can run a program like a real machine.

Virtual machine is an abstract computer, it has its own instruction set, has its own memory management system. The languages implemented on this type of virtual machine are more concise and easy to learn than the lower level of abstraction.

How the php file is parsed, what is generated by the intermediate code, and how the resulting intermediate code corresponds to the actual PHP code, and how the resulting intermediate code is executed? What intermediate data will be in the process of execution? Can the entire virtual machine be optimized? How to optimize?

Zend Virtual Machine Architecture

By abstracting the implementation of the Zend virtual machine from the conceptual layer, we can divide the architecture of the Zend virtual machine into: The interpretation layer, the execution engine, and the intermediate data layer.

Zend Virtual Machine Architecture diagram

When a piece of PHP code enters the Zend virtual machine, it is executed in two steps: Compile and execute. For an explanatory language, this is a creative move, but the present implementation is not exhaustive. Now when the PHP code enters the Zend virtual machine, it will be executed in two steps, but these two operations are continuous for a regular execution, that is, it does not turn into the same compiler language as Java: Generate an intermediate file to store the compiled results. If you do this every time, the performance of the PHP script is a huge loss. Although there are caching solutions similar to Apc,eaccelerator. But there is no change in nature, and it is not possible to separate two steps from each other and grow.

Interpretation Layer

The interpretation layer is where the Zend virtual machine performs the compilation process. It includes lexical parsing, parsing, and compilation to generate three parts of intermediate code. Lexical analysis is the PHP source file we want to execute, remove the space, remove the comment, cut into a token (token), and the hierarchy of the processing program (hierarchical structure).

Parsing is a sequence of accepted tokens (tokens) that performs some action according to the defined grammatical rules, and the bison used by the Zend virtual machine uses the Backus paradigm (BNF) to describe the syntax. Compilation generated intermediate code is based on the results of the parsing of the Zend virtual machine opcode generated intermediate code, in PHP5.3.1, Zend virtual machine Support 135 instructions (see Zend/zend_vm_opcodes.h file), Whether it is a simple output statement or a complex recursive invocation of a program, the Zend virtual machine eventually translates all of the PHP code we have written into sequences of these 135 instructions, which are then executed sequentially in the execution engine.

Intermediate Data Layer

When a Zend virtual machine executes a PHP code, it needs memory to store many things, such as the intermediate Code, PHP's own list of functions, a list of user-defined functions, PHP's own classes, user-defined classes, constants, objects created by the program, arguments passed to functions or methods, return values, Local variables and the intermediate results of some operations. We refer to all of these places where data is stored as intermediate data layers.

If PHP is attached to the APACHE2 server in the form of a mod extension, some of the data in the intermediate data layer may be shared by multiple threads, if PHP comes with a list of functions. If only a single process is considered, when a process is created it will be loaded with PHP's various function lists, class lists, constant lists, and so on. When the interpretation layer compiles the PHP code, various user-defined functions, classes, or constants are added to the previous list, except that some of the fields in their own structure are assigned different values.

When the execution engine executes the generated intermediate code, a new execution intermediate data structure (zend_execute_data) is added to the stack of the Zend virtual machine, which includes a snapshot of the active symbol list of the current execution, some local variables, and so on.

Execution engine

Zend the execution engine of a virtual machine is a very simple implementation, it is only based on the intermediate Code sequence (EX (opline)), step by step call the corresponding method execution. In the execution engine does not have a similar to the PC registers the same variable to hold the next instruction, when the Zend virtual machine executes to an instruction, when all of its tasks are executed, this instruction will call the next instruction itself, the sequence of the pointer to move forward one position, so that the next command to execute, And in the final execution of the return statement, so repeated. This is essentially a function nested call.

Back to the beginning of the problem, PHP through lexical analysis, parsing and intermediate code generation three steps, the PHP file will be parsed into PHP intermediate code opcode. There is not a complete one by one correspondence between the generated intermediate code and the actual PHP code. It just generates intermediate code for the PHP code that the user gives and the syntax rules for PHP and some internal conventions, and these intermediate codes also rely on some global variables to relay data and associations. The execution of the generated intermediate code is based on the smooth execution of the intermediate code, which relies on the global variables in the execution process, step-by-step. Of course, there will also be offsets in the event of some function jumps, but eventually it will return to the offset point.

Extended Reading

The list of topics for this article is as follows:

2. PHP Kernel Explorer: Starting with the SAPI interface
4. PHP kernel exploration: Start and end of a single request
6. PHP kernel exploration: One-time request life cycle
8. PHP Kernel Exploration: single-process SAPI life cycle
10. PHP kernel Exploration: SAPI lifecycle of multiple processes/threads
12. PHP Kernel Explorer: Zend Engine
14. PHP Kernel Explorer: Explore SAPI again
16. PHP kernel Discovery: Apache module Introduction
18. PHP Kernel Explorer: PHP support via MOD_PHP5
20. PHP kernel exploration: Apache Run with hook function
22. PHP Kernel Explorer: embedded PHP
24. PHP Kernel Explorer: PHP fastcgi
26. PHP kernel exploration: How to execute PHP scripts
28. PHP Kernel Explorer: PHP script execution details
30. PHP kernel exploration: opcode opcode
32. PHP kernel Explorer: PHP opcode
34. PHP kernel exploration: Interpreter execution process
36. PHP Kernel Exploration: Variables overview
38. PHP kernel exploration: variable storage and type
40. PHP Kernel Explorer: Hash table in PHP
42. PHP Kernel Exploration: Understanding the hash table in Zend
44. PHP kernel exploration: PHP hash Algorithm design
46. PHP kernel Exploration: translating an article hashtables
48. PHP Kernel exploration: What is a hash collision attack?
50. PHP Kernel exploration: implementation of constants
52. PHP kernel exploration: Storage of variables
54. PHP kernel exploration: Types of variables
56. PHP Kernel Explorer: Variable value operation
58. PHP Kernel exploration: Creation of variables
60. PHP kernel exploration: pre-defined variables
62. PHP Kernel Explorer: variable retrieval
64. PHP kernel Exploration: Variable type conversion
66. PHP Kernel exploration: implementation of weakly typed variables
68. PHP Kernel exploration: implementation of static variables
70. PHP Kernel Explorer: Variable type hints
72. PHP kernel exploration: The life cycle of a variable
74. PHP Kernel Exploration: variable assignment and destruction
76. PHP Kernel exploration: variable scope
78. PHP kernel Explorer: Weird variable names
80. PHP Kernel Explorer: variable value and type storage
82. PHP Kernel Explorer: global variables
84. PHP kernel Exploration: Conversion of variable types
86. PHP kernel Exploration: The memory management begins
88. PHP Kernel Explorer: Zend Memory manager
90. PHP Kernel Explorer: PHP's memory management
92. PHP Kernel Exploration: Application and destruction of memory
94. PHP Kernel Exploration: reference count vs. write-time replication
96. PHP kernel exploration: PHP5.3 garbage collection mechanism
98. PHP Kernel Explorer: Cache in memory management
100. PHP Kernel Exploration: write-time copy cow mechanism
102. PHP kernel Exploration: arrays and Linked lists
104. PHP kernel exploration: Using the Hash Table API
106. PHP kernel exploration: array manipulation
108. PHP kernel Exploration: Array source code Analysis
110. PHP Kernel Exploration: Classification of functions
112. PHP kernel Exploration: internal structure of functions
114. PHP Kernel exploration: function structure transformation
116. PHP Kernel Exploration: The process of defining a function
118. PHP kernel Exploration: Parameters for functions
120. PHP kernel exploration: zend_parse_parameters function
122. PHP Kernel exploration: function return value
124. PHP kernel exploration: formal parameter return value
126. PHP Kernel exploration: function invocation and execution
128. PHP kernel exploration: Referencing and function execution
130. PHP kernel exploration: anonymous functions and closures
132. PHP Kernel Exploration: object-oriented opening
134. PHP kernel Exploration: The structure and implementation of classes
136. PHP kernel exploration: member Variables for classes
138. PHP Kernel Exploration: Member Methods for classes
140. PHP Kernel Exploration: class prototype Zend_class_entry
142. PHP kernel exploration: Definition of class
144. PHP Kernel Explorer: Access control
146. PHP kernel exploration: inheritance, polymorphism and abstract classes
148. PHP Kernel Exploration: magic function and delay binding
150. PHP kernel Exploration: Preserving classes and special classes
152. PHP Kernel Explorer: objects
154. PHP kernel Exploration: Creating object instances
156. PHP Kernel Explorer: Object properties Read and write
158. PHP Kernel Exploration: namespaces
160. PHP kernel exploration: Defining interfaces
162. PHP kernel Exploration: Inheritance and Implementation interface
164. PHP Kernel Exploration: resource resource type
166. PHP Kernel Explorer: Zend virtual machine
168. PHP Kernel Exploration: Lexical parsing of virtual machines
170. PHP Kernel Explorer: virtual machine Syntax analysis
172. PHP kernel exploration: Execution of intermediate code opcode
174. PHP Kernel Exploration: Code encryption and decryption
176. PHP kernel exploration: zend_execute specific execution process
178. PHP kernel exploration: Reference and counting rules for variables
180. PHP kernel exploration: New garbage collection Mechanism description

