In-depth understanding of PHP7 kernel Reference

I mentioned before that reference (REFERENCE) was a flag in PHP5, but after PHP7 we turned it into a new type: IS_REFERNCE. However, reference is a very common application, so this change It has brought a lot of changes, and also caused many bugs when we were developing PHP7 because we sometimes neglected to handle this type.

The simplest case is when dealing with various types. From now on, we have to consider this new type more. For example, in PHP7, this code form has become very common:

try_again:
swtich (Z_TYPE_P(zv)) {
     case IS_TRING:
     break;
     case IS_ARRAY:
     break;
    ...
     case IS_REFERENCE:
     zv = Z_REFVAL_P(zv); //解引用
     goto try_again;
     break;
}

If you write your own extensions and forget to consider this new type, it will cause problems.

Why?

So since this new type will It brings so many problems, so why did you use the reference to become a type? Why not just use a flag?

In a word, we have to do this. -_

#As mentioned earlier, Hashtable directly stores zval, so in the symbol table, how can two zval share a value? It is okay for complex types such as strings. It seems that we can use it in the zend_refcounted structure Add a flag to indicate that it is a reference to solve. However, this will also encounter copying caused by Change On Write, but we know that in PHP7, some types are directly stored in zval, such as IS_LONG, but reference types are required Reference counting, so how to represent a zval that is IS_LONG and IS_REFERNCE?

For this reason, we created this new type:

As shown in the figure, reference is a new type: zend_reference. For zval of IS_REFERNCE type, zval.value.ref is a pointer to zend_reference, which contains a reference count and a zval. The specific value of zval is exists in zval.value.ref->val.

So for the reference of IS_LONG, use a zval of type IS_REFERNCE, which points to a zend_reference, and this zend_reference->val is A zval of type IS_LONG.

Change On Write

PHP uses reference counting to do simple garbage collection. Consider the following code:

<?php
1. $val = "laruence";
2. $ref = &$val;
3. $copy = $val;
?>

$ref and $val are references pointing to the same zval. In PHP5, we represent this situation through a reference count of 2 and a reference flag of 1. When $val is copied to $copy(line 3), we found that $val is a reference with a count greater than 1, so a Change on write is required, that is, separation. So we need to copy this zval.

And in PHP7, the situation becomes It is much simpler. First, when assigning a reference to $ref (line 2), an IS_REFERNCE type is generated, and then because there are two variables referencing it at this time, the reference count of the zend_reference structure is zval.value.ref->gc. The refcount is 2.

When the value is subsequently assigned to $copy (line 3), it is found that $val is a reference, so $copy points to zval.value.ref->val, that is The string value is laruence's zval, and then the reference count of zval is 1, that is, zval.value.ref->val.value.str.gc.refcount is 2. No copying occurs.

Thus This is a good solution to the classic problem of PHP5 mentioned in the previous chapter. For example, when we run the problem in the previous chapter under PHP7, the result we get is:

$ php-7.0/sapi/cli/php /tmp/1.php
Used 0.00021380008539
Used 0.00020173048281

It can be seen that it did not happen. Copy, so as not to cause any performance problems.

Recommended: "PHP Tutorial"

The above is the detailed content of In-depth understanding of PHP7 kernel Reference. For more information, please follow other related articles on the PHP Chinese website!