Analyser l'implémentation interne des variables dans le noyau PHP7

La structure de base de l'implémentation des variables PHP est zval. Différents types d'implémentations sont basés sur cette structure. C'est la structure la plus basique de chaque variable PHP. correspondent tous à un zval. Regardons cette structure et le mécanisme de gestion de la mémoire des variables PHP.

Structure zval

Recommandations d'apprentissage associées : PHP Programmation du débutant au compétent

zval结构比较简单，内嵌一个union类型的zend_value保存具体变量类型的值或指针，zval中还有两个union：u1、u2:

• u1 : Sa signification est relativement intuitive, et le type de variables se distingue par u1.type, et l'autre La valeur type_flags est un masque de type, qui sera utilisé dans la gestion de la mémoire des variables et le mécanisme gc. Elle sera analysée en détail dans la troisième partie. Quant aux deux prochaines const_flags et , laissez-les tranquilles pour l'instant reserved

• u2 : Cette valeur est purement une valeur auxiliaire Si n'a que deux valeurs : zval et , la taille de l'intégralité du zval sera également alignée sur 16 octets. Puisque cela n'a pas d'importance. La taille de u2 est de 16 octets. Il est très rentable d'utiliser les 4 octets supplémentaires à des fins spéciales, par exemple. est utilisé dans la table de hachage pour résoudre les conflits de hachage, et fe_pos est utilisé dans foreach... .valueu1

Comme on peut le voir sur

, à l'exception des

et zend_value les types qui stockent directement les valeurs, les autres types sont des pointeurs, pointant vers leurs structures respectives. longdouble

Type

Type :

zval.u1.type

Type scalaire

Les types les plus simples sont vrai, faux, long, double et nul Parmi eux, vrai, faux et nul n'ont aucune valeur et se distinguent directement par type, tandis que les valeurs. de long et double existent directement dans value. Medium : zend_long, double, c'est-à-dire que les types scalaires ne nécessitent pas de pointeurs de valeur supplémentaires.

String

La chaîne en PHP est représentée par zend_string :

• gc : Informations de référence sur les variables, telles que le nombre de références à la valeur actuelle. Tous les types de variables qui utilisent le comptage de références auront cette structure. La section 3.1 l'analysera en détail

• h : valeur de hachage, qui est utilisée lors du calcul de l'index dans le tableau

• len : longueur de la chaîne. value garantit la sécurité binaire.

• val : contenu de la chaîne, structure de longueur variable, demande de mémoire en fonction de la longueur de la longueur lors de l'allocation

en fait, les chaînes de caractères peuvent être divisées en plusieurs catégories : IS_STR_PERSISTENT (alloué via malloc), IS_STR_INTERNED (certains littéraux écrits en code PHP, tels que les noms de fonctions, les valeurs de variables), IS_STR_PERMANENT (valeur permanente, le cycle de vie est supérieur à la demande) , IS_STR_CONSTANT (constant ), IS_STR_CONSTANT_UNQUALIFIED, ces informations sont enregistrées via l'indicateur : zval.value->gc.u.flags, et seront analysées en détail lorsqu'elles seront utilisées ultérieurement.

Array

array est une structure de données très puissante en PHP Son implémentation sous-jacente est une HashTable ordonnée ordinaire. Voici un bref aperçu de sa structure. analyser la mise en œuvre des tableaux séparément.

Objet/Ressource

L'objet est plus courant et les ressources font référence vers la connexion TCP, le handle de fichier et d'autres types. Ce type est plus flexible. Vous pouvez définir struct à volonté et le faire passer par ptr. Ce type sera analysé séparément plus tard, je n'entrerai donc pas dans les détails ici.

Référence

La référence est un type spécial en PHP, elle pointe en fait vers une autre variable PHP. , sa modification modifiera directement le zval réel pointé, qui peut être simplement compris comme un pointeur en C. En PHP, une variable de référence est générée via l'opérateur &, ce qui signifie que quel que soit le type précédent, &Tout d'abord, un nouveau zval sera généré avec le type IS_REFERENCE, puis la valeur de val sera pointée vers la valeur du zval d'origine.

La structure est très simple Hormis la partie publique zend_refcounted_h, il n'y en a qu'une seule val. Prenons un exemple pour voir la relation structurelle spécifique : <.>

Le résultat final est le suivant :

Remarque : les références ne peuvent être générées que via & et ne peuvent pas être transmises par affectation, comme :

$b = &$aÀ l'heure actuelle, les types de $a et $b sont des références, mais $c = $b n'attribuera pas directement $b à $c, mais attribuera le zval qui $b pointe en fait vers $c Si vous voulez que $c soit une référence, vous devez faire ceci :

Cela signifie également que la référence

en PHP ne peut avoir qu'une seule couche de , et n'aura pas une référence pointant vers une autre référence , c'est-à-dire qu'il n'y a pas de concept de en langage C . 指针的指针

Gestion de la mémoire

Ensuite, analysons l'allocation et la destruction des variables.

在分析变量内存管理之前我们先自己想一下可能的实现方案，最简单的处理方式：定义变量时alloc一个zval及对应的value结构(ref/arr/str/res...)，赋值、函数传参时硬拷贝一个副本，这样各变量最终的值完全都是独立的，不会出现多个变量同时共用一个value的情况，在执行完以后直接将各变量及value结构free掉。

这种方式是可行的，而且内存管理也很简单，但是，硬拷贝带来的一个问题是效率低，比如我们定义了一个变量然后赋值给另外一个变量，可能后面都只是只读操作，假如硬拷贝的话就会有多余的一份数据，这个问题的解决方案是：引用计数+写时复制。PHP变量的管理正是基于这两点实现的。

引用计数

引用计数是指在value中增加一个字段refcount记录指向当前value的数量，变量复制、函数传参时并不直接硬拷贝一份value数据，而是将refcount++，变量销毁时将refcount--，等到refcount减为0时表示已经没有变量引用这个value，将它销毁即可。

引用计数的信息位于给具体value结构的gc中：

从上面的zend_value结构可以看出并不是所有的数据类型都会用到引用计数，long、double直接都是硬拷贝，只有value是指针的那几种类型才可能会用到引用计数。

下面再看一个例子：

$a = "hi~";$b = $a;

猜测一下变量$a/$b的引用情况。

这个不跟上面的例子一样吗？字符串"hi~"有$a/$b两个引用，所以zend_string1(refcount=2)。但是这是错的，gdb调试发现上面例子zend_string的引用计数为0。这是为什么呢？

$a,$b -> zend_string_1(refcount=0,val="hi~")

事实上并不是所有的PHP变量都会用到引用计数，标量：true/false/double/long/null是硬拷贝自然不需要这种机制，但是除了这几个还有两个特殊的类型也不会用到：interned string(内部字符串，就是上面提到的字符串flag：IS_STR_INTERNED)、immutable array，它们的type是IS_STRING、IS_ARRAY，与普通string、array类型相同，那怎么区分一个value是否支持引用计数呢？还记得zval.u1中那个类型掩码type_flag吗？正是通过这个字段标识的，这个字段除了标识value是否支持引用计数外还有其它几个标识位，按位分割，注意：type_flag与zval.value->gc.u.flag不是一个值。

支持引用计数的value类型其zval.u1.type_flag包含(注意是&amp;amp;，不是等于)IS_TYPE_REFCOUNTED：

#define IS_TYPE_REFCOUNTED          (1<<2)

下面具体列下哪些类型会有这个标识：

|     type       | refcounted |
+----------------+------------+
|simple types    |            |
|string          |      Y     |
|interned string |            |
|array           |      Y     |
|immutable array |            |
|object          |      Y     |
|resource        |      Y     |
|reference       |      Y     |

simple types很显然用不到，不再解释，string、array、object、resource、reference有引用计数机制也很容易理解，下面具体解释下另外两个特殊的类型：

• interned string：内部字符串，这是种什么类型？我们在PHP中写的所有字符都可以认为是这种类型，比如function name、class name、variable name、静态字符串等等，我们这样定义:$a = "hi~;"后面的字符串内容是唯一不变的，这些字符串等同于C语言中定义在静态变量区的字符串：char *a = "hi~";，这些字符串的生命周期为request期间，request完成后会统一销毁释放，自然也就无需在运行期间通过引用计数管理内存。

• immutable array：只有在用opcache的时候才会用到这种类型，不清楚具体实现，暂时忽略。

写时复制

上一小节介绍了引用计数，多个变量可能指向同一个value，然后通过refcount统计引用数，这时候如果其中一个变量试图更改value的内容则会重新拷贝一份value修改，同时断开旧的指向，写时复制的机制在计算机系统中有非常广的应用，它只有在必要的时候(写)才会发生硬拷贝，可以很好的提高效率，下面从示例看下：

$a = array(1,2);$b = &$a;$c = $a;//发生分离$b[] = 3;

最终的结果：

不是所有类型都可以copy的，比如对象、资源，实时上只有string、array两种支持，与引用计数相同，也是通过zval.u1.type_flag标识value是否可复制的：

#define IS_TYPE_COLLECTABLE         (1<<3)

|     type       |  copyable  |
+----------------+------------+
|simple types    |            |
|string          |      Y     |
|interned string |            |
|array           |      Y     |
|immutable array |            |
|object          |            |
|resource        |            |
|reference       |            |

copyable的意思是当value发生duplication时是否需要copy，这个具体有两种情形下会发生：

• a.从literal变量区复制到局部变量区，比如：$a = [];实际会有两个数组，而$a = "hi~";//interned string则只有一个string

• b.局部变量区分离时(写时复制)：如改变变量内容时引用计数大于1则需要分离，$a = [];$b = $a; $b[] = 1;这里会分离，类型是array所以可以复制，如果是对象：$a = new user;$b = $a;$a->name = "dd";这种情况是不会复制object的，$a、$b指向的对象还是同一个<p style="color:rgb(51,51,51);clear:both;min-height:1em;font-family:'Helvetica Neue', Helvetica, 'Hiragino Sans GB', 'Microsoft YaHei', '微软雅黑', Arial, sans-serif;font-size:16px;">具体literal、局部变量区变量的初始化、赋值后面编译、执行两篇文章会具体分析，这里知道变量有个<code>copyable的属性就行了。

  变量回收

  PHP变量的回收主要有两种：主动销毁、自动销毁。主动销毁指的就是unset，而自动销毁就是PHP的自动管理机制，在return时减掉局部变量的refcount，即使没有显式的return，PHP也会自动给加上这个操作。

  垃圾回收

  PHP变量的回收是根据refcount实现的，当unset、return时会将变量的引用计数减掉，如果refcount减到0则直接释放value，这是变量的简单gc过程，但是实际过程中出现gc无法回收导致内存泄漏的bug，先看下一个例子：

  $a = [1];$a[] = &$a;unset($a);

  unset($a)之前引用关系：

  

  unset($a)之后：

  

  可以看到，unset($a)之后由于数组中有子元素指向$a，所以refcount > 0，无法通过简单的gc机制回收，这种变量就是垃圾，垃圾回收器要处理的就是这种情况，目前垃圾只会出现在array、object两种类型中，所以只会针对这两种情况作特殊处理：当销毁一个变量时，如果发现减掉refcount后仍然大于0，且类型是IS_ARRAY、IS_OBJECT则将此value放入gc可能垃圾双向链表中，等这个链表达到一定数量后启动检查程序将所有变量检查一遍，如果确定是垃圾则销毁释放。

  标识变量是否需要回收也是通过u1.type_flag区分的：

  #define IS_TYPE_COLLECTABLE

  |     type       | collectable |
  +----------------+-------------+
  |simple types    |             |
  |string          |             |
  |interned string |             |
  |array           |      Y      |
  |immutable array |             |
  |object          |      Y      |
  |resource        |             |
  |reference       |             |

  具体的垃圾回收过程这里不再介绍。

  Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!