PHP RFC: Implicit Move Optimisation

• Version: 0.1
• Date: 2023-05-13
• Author: Niels Dossche (nielsdos), dossche.niels@gmail.com
• Status: Draft
• First Published at: http://wiki.php.net/rfc/implicit_move_optimisation

PHP currently contains two data types which are copy-on-write (CoW): string and arrays. When you pass a variable containing a CoW type as an argument to a function, you don't copy the data. Instead, you increment the reference count of the data by one. The lowest possible reference count for a variable passed to a function is therefore 2: one reference is the variable, and the other is the function argument. Let's look at a toy code example:

function my_function(array $my_array) {
    // Remember: $my_array has a reference count of 2:
    //   one reference in $array (main), and one in $my_array (my_function).
    $my_array[] = 3;
    return $my_array;
}
 
function main() {
    $array = [0, 1, 2];
    $array = my_function($array);
    var_dump($array);
}
 
main();

The code example shows an array being passed to “my_function”, which modifies the array and returns the modified result. However, due to the copy-on-write (CoW) mechanism, the variable “$my_array” is duplicated within “my_function” because the array's reference count is greater than 1 and it is modified. In this example, the duplication is unnecessary since the result always overwrites the original array. The purpose of this RFC is to propose an optimisation for avoiding such unnecessary duplications.

While this example may not highlight the significance of the copy cost, there are scenarios where it does matter, such as processing large data batches (e.g., ETL-like processes) or complex functions. The reason for creating a separate “main()” function will become clear later in the proposal.

This will be implemented as an addition to the existing DFA optimisation pass.

What breaks, and what is the justification for it?

Next PHP 8.x (which is PHP 8.3 at the time of writing).

None.

None.

This proposal implements an extra optimisation in the DFA pass in the optimiser. There needed to be changes to SCCP, DFG, and SSA construction to account for the behaviour change in SEND_VAR. Specifically, the SEND_VAR opcode now redefines op1 because it can set its type to UNDEF.

None.

None.

Make sure there are no open issues when the vote starts!

Everything that's not the optimiser.

This proposal depends on functions being able to operate on data in-place. Support for this has already been added in 8.3 for the “array_merge”, “array_replace”, “array_unique”, and “array_intersect”. More functions (and especially string functions) may follow.

One primary vote with a simple yes/no option.

Current implementation: https://github.com/php/php-src/pull/11166

After the project is implemented, this section should contain

1. the version(s) it was merged into
2. a link to the git commit(s)
3. a link to the PHP manual entry for the feature
4. a link to the language specification section (if any)

Links to external references, discussions or RFCs

Keep this updated with features that were discussed on the mail lists.