Exemples de faible utilisation de la mémoire et de types faibles de tableaux PHP

Cet article présente principalement l'interprétation détaillée de la faible utilisation de la mémoire et des types faibles de tableaux PHP. Il a une certaine valeur de référence et les amis intéressés peuvent s'y référer.

Les tâches de ces deux jours ont été réalisées plus tôt que prévu. Vous pouvez prendre une pause pour vous installer et apprendre le PHP en profondeur. En fait, je voulais à l'origine apprendre quelque chose lié à l'optimisation des performances PHP, mais j'ai été choqué par une phrase sur Internet : « L'utilisation de la mémoire de la matrice PHP est faible. Une matrice de mémoire de 100 Mo en langage C nécessite 1 Go en PHP. PHP consomme-t-il vraiment autant de mémoire ? J'ai donc profité de cette occasion pour en savoir plus sur l'implémentation des types de données PHP.

Faisons d'abord un test :

<?php 
  echo memory_get_usage() , &#39;<br>&#39;; 
  $start = memory_get_usage(); 
  $a = Array(); 
  for ($i=0; $i<1000; $i++) { 
   $a[$i] = $i + $i; 
  } 
  $end = memory_get_usage(); 
  echo memory_get_usage() , &#39;<br>&#39;; 
  echo &#39;argv:&#39;, ($end - $start)/1000 ,&#39;bytes&#39; , &#39;<br>&#39;;

Les résultats obtenus :

353352
437848
argv:84.416bytes

Un tableau entier de 1000 éléments consomme (437848 - 353352) octets de mémoire, soit environ 82 Ko, ce qui signifie que chaque élément occupe 84 octets de mémoire. En langage C, un int occupe 4 octets, ce qui représente globalement une différence de 20 fois.

Mais il est dit en ligne que les résultats renvoyés par memory_get_usage() ne sont pas tous occupés par des tableaux, mais incluent également certaines structures de PHP lui-même. Par conséquent, essayez une autre méthode et utilisez les fonctions intégrées de PHP. pour générer des tableaux :

<?php 
  $start = memory_get_usage(); 
  $a = array_fill(0, 10000, 1); 
  $end = memory_get_usage(); //10k elements array; 
  echo &#39;argv:&#39;, ($end - $start )/10000,&#39;byte&#39; , &#39;<br>&#39;;

Le résultat est :

argv:54.5792byte

C'est légèrement mieux qu'avant , mais cela fait toujours 54 octets, ce qui est vraiment mauvais environ 10 fois.

La raison doit commencer par l'implémentation sous-jacente de PHP. PHP est un langage faiblement typé, quel que soit l'int, le double, la chaîne, etc., un '$' unifié peut résoudre tous les problèmes. La couche inférieure de PHP est implémentée en langage C. Chaque variable correspond à une structure zval, qui est définie en détail comme :

typedef struct _zval_struct zval; 
struct _zval_struct { 
  /* Variable information */ 
  zvalue_value value;   /* The value 1 12字节(32位机是12，64位机需要8+4+4=16) */ 
  zend_uint refcount__gc; /* The number of references to this value (for GC) 4字节 */ 
  zend_uchar type;    /* The active type 1字节*/ 
  zend_uchar is_ref__gc; /* Whether this value is a reference (&) 1字节*/ 
};

PHP utilise la structure union pour stocker la valeur de la variable, zval La variable valeur de type zvalue_value est une union, définie comme suit :

typedef union _zvalue_value { 
  long lval;         /* long value */ 
  double dval;        /* double value */ 
  struct {          /* string value */ 
    char *val; 
    int len; 
  } str;  
  HashTable *ht;       /* hash table value */ 
  zend_object_value obj;   /*object value */ 
} zvalue_value;

La taille de la mémoire occupée par l'union le type est déterminé par l’espace de données occupé par son plus grand membre. Dans zvalue_value, l'int de la structure str occupe 4 octets et le pointeur char occupe 4 octets, donc la mémoire occupée par l'intégralité de zvalue_value est de 8 octets.

La taille de zval est de 8 + 4 + 1 + 1 = 14 octets.

Remarquez qu'il existe également une HashTable dans zvalue_value. Que fait-elle ? Dans zval, les tableaux, les chaînes et les objets nécessitent également des structures de stockage supplémentaires. La structure de stockage des tableaux est HashTable.

La définition de HashTable donne :

typedef struct _hashtable { 
   uint nTableSize; //表长度，并非元素个数 
   uint nTableMask;//表的掩码，始终等于nTableSize-1 
   uint nNumOfElements;//存储的元素个数 
   ulong nNextFreeElement;//指向下一个空的元素位置 
   Bucket *pInternalPointer;//foreach循环时，用来记录当前遍历到的元素位置 
   Bucket *pListHead; 
   Bucket *pListTail; 
   Bucket **arBuckets;//存储的元素数组 
   dtor_func_t pDestructor;//析构函数 
   zend_bool persistent;//是否持久保存。从这可以发现，PHP数组是可以实现持久保存在内存中的，而无需每次请求都重新加载。 
   unsigned char nApplyCount; 
   zend_bool bApplyProtection; 
} HashTable;

En plus de plusieurs variables d'attribut qui enregistrent la taille de la table et le nombre d'éléments qu'elle contient contient, Bucket est Il a été utilisé à plusieurs reprises, comment Bucket est défini :

typedef struct bucket { 
   ulong h; //数组索引 
   uint nKeyLength; //字符串索引的长度 
   void *pData; //实际数据的存储地址 
   void *pDataPtr; //引入的数据存储地址 
   struct bucket *pListNext; 
   struct bucket *pListLast; 
   struct bucket *pNext; //双向链表的下一个元素的地址 
   struct bucket *pLast;//双向链表的下一个元素地址 
   char arKey[1]; /* Must be last element */ 
} Bucket;

est un peu comme une liste chaînée, Bucket est comme un nœud de liste chaînée, avec des données et des pointeurs spécifiques, et HashTable est un tableau contenant une liste d'éléments Bucket. L'implémentation de tableaux multidimensionnels en PHP n'est qu'une autre HashTable stockée dans le Bucket.

Calculez que HashTable occupe 39 octets et que Bucket occupe 33 octets. Un tableau vide occupe 14 + 39 + 33 = 86 octets. La structure Bucket nécessite 33 octets, et la partie avec une longueur de clé supérieure à quatre octets est ajoutée à la fin du Bucket, et la valeur de l'élément est probablement une structure zval. De plus, chaque tableau se verra attribuer un pointeur Bucket. tableau pointé par arBuckets, bien qu'on ne puisse pas le dire. Chaque élément supplémentaire nécessite un pointeur, mais la situation pourrait être pire. Cela calcule qu'un élément du tableau occupera 54 octets, ce qui est presque identique à l'estimation ci-dessus.

D'un point de vue spatial, le coût moyen des petits tableaux est relativement élevé. Bien sûr, un script ne sera pas rempli d'un grand nombre de petits tableaux, et vous pouvez gagner en commodité de programmation à un prix plus petit. coût de l'espace. Mais si vous utilisez un tableau comme conteneur, c'est une autre histoire. Dans les applications pratiques, vous rencontrez souvent des tableaux multidimensionnels comportant de nombreux éléments. Par exemple, un tableau unidimensionnel de 10 000 éléments consomme environ 540 Ko de mémoire, tandis qu'un tableau bidimensionnel de 10 000 éléments consomme en réalité 23 Mo. Les petits tableaux n'en valent vraiment pas la peine.

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!