Exploring the PHP kernel: PHP's FastCGI

CGI stands for Common Gateway Interface, which allows a client to request data from a web browser to a program running on a web server. CGI describes a standard for transmitting data between a client and the program. One of the purposes of CGI is to be independent of any language, so CGI can be written in any language as long as the language has standard input, output and environment variables, such as php, perl, tcl, etc.

FastCGI is a protocol for communication between web servers and processing programs. It is an improvement on CGI. FastCGI is like a long-live CGI. It can be executed all the time. When a request arrives, it will not take time to fork a process to handle it (this is the most criticized fork-and-execute mode of CGI). Because it is just a communication protocol, it also supports distributed computing, that is, FastCGI programs can be executed on hosts other than web servers and accept requests from other web servers.

FastCGI is a language-independent, scalable open extension of CGI that keeps the CGI interpreter process in memory to achieve higher performance. Repeated loading of CGI programs is the main reason for poor CGI performance. If CGI programs are kept in memory and scheduled by the FastCGI process manager, good performance, scalability, and fail-over features can be provided.

In general, the entire workflow of FastCGI is as follows:

1. Load FastCGI process manager (IIS ISAPI or Apache Module) when Web Server starts
2. The FastCGI process manager initializes itself, starts multiple CGI interpreter processes (multiple php-cgi are visible) and waits for connections from the Web Server.
3. When a client request arrives at the Web Server, the FastCGI process manager selects and connects to a CGI interpreter. The Web server sends the CGI environment variables and standard input to the FastCGI child process php-cgi.
4. After the FastCGI child process completes the processing, it returns the standard output and error information to the Web Server through the same connection. When the FastCGI child process closes the connection, the request is processed. The FastCGI child process then waits for and processes the next connection from the FastCGI process manager (running in the Web Server). In CGI mode, php-cgi exits here.

PHP's CGI implements the Fastcgi protocol. It is a TCP or UDP protocol server that accepts requests from Web servers. When it starts, it creates a TCP/UDP protocol server socket listener and receives related requests for processing. Then it enters the PHP life cycle: module initialization, sapi initialization, processing PHP requests, module shutdown, sapi shutdown, etc., which constitute the entire CGI life cycle.

Taking TCP as an example, on the TCP server side, the following steps are generally performed:

1. Call the socket function to create a streaming socket for TCP;
2. Call the bind function to bind the server's local address to the socket created previously;
3. Call the listen function to use the newly created socket as a listener, waiting for the connection initiated by the client. When the client has multiple connections connected to this socket, they may need to be queued;
4. The server process calls the accept function and enters a blocking state until a client process calls the connect function to establish a connection.
5. After establishing a connection with the client, the server calls the read_stream function to read the client's request;
6. After processing the data, the server calls the write function to send a response to the client.

PHP FastCGI enables all of your PHP applications to run through mod_fastci instead of mod_phpsusexec. FastCGI applications are fast because they are persistent and do not have to be started and initialized for every request. This makes it possible to develop applications that would otherwise be impractical in the CGI paradigm (such as a large script, or an application that needs to connect to single or multiple databases).

Advantages of FastCGI:

1. PHP scripts run faster (3 to 30 times). The PHP interpreter is loaded into memory instead of being read from storage every time it is needed, greatly improving the performance of sites that rely on scripts.
2. Requires fewer system resources. Since the server does not have to load the PHP interpreter every time it is needed, you can increase the transmission speed of your site by a lot without increasing the CPU load.
3. No changes are required to your existing code. Everything works with PHP FastCGI.

But there are potential problems:

• You only have one php.ini file available for all subdirectories (/home/USERNAME/public_html/php.ini). This is necessary to optimize your site's code. If you need multiple php.ini files to accommodate different scripts, you can disable PHP Fast CGI in any subdirectory and leave it enabled everywhere else. Please contact support if you need to do this.
• Any updates you make to your PHP environment (such as changes to your php.ini file) will experience a delay of several minutes. This is because your php.ini file is loaded into memory for faster processing, rather than being re-read from memory each time it is needed.