Shulou(Shulou.com)06/03 Report--

< HT_MAX_SIZE) { /* Let's double the table size */ void *new_data, *old_data = HT_GET_DATA_ADDR(ht); uint32_t nSize = ht->

NTableSize + ht- > nTableSize; Bucket * old_buckets = ht- > arData; ht- > nTableSize = nSize; new_data = pemalloc (HT_SIZE_EX (nSize, HT_SIZE_TO_MASK (nSize)), GC_FLAGS (ht) & IS_ARRAY_PERSISTENT); ht- > nTableMask = HT_SIZE_TO_MASK (ht- > nTableSize); HT_SET_DATA_ADDR (ht, new_data) Memcpy (ht- > arData, old_buckets, sizeof (Bucket) * ht- > nNumUsed); pefree (old_data, GC_FLAGS (ht) & IS_ARRAY_PERSISTENT); zend_hash_rehash (ht);} else {zend_error_noreturn (E_ERROR, "Possible integer overflow in memory allocation (% u *% zu +% zu)", ht- > nTableSize * 2, sizeof (Bucket) + sizeof (uint32_t), sizeof (Bucket)) }} / / rehash (partial Code reduction) ZEND_API int ZEND_FASTCALL zend_hash_rehash (HashTable * ht) {Bucket * p; uint32_t nIndex, I; if (UNEXPECTED (ht- > nNumOfElements = = 0)) {if (! (HT_FLAGS (ht) & HASH_FLAG_UNINITIALIZED)) {ht- > nNumUsed = 0; HT_HASH_RESET (ht);} return SUCCESS } HT_HASH_RESET (ht); I = 0; p = ht- > arData; if (HT_IS_WITHOUT_HOLES (ht)) {/ / Bucket is not marked as IS_UNDEF item do {nIndex = p-> h | ht- > nTableMask; Z_NEXT (p-> val) = HT_HASH (ht, nIndex) HT_HASH (ht, nIndex) = HT_IDX_TO_HASH (I); pairing;} while (+ + I)

< ht->

NNumUsed);} else {/ / Bucket has the item marked IS_UNDEF uint32_t old_num_used = ht- > nNumUsed; do {if (UNEXPECTED (Z_TYPE (p-> val) = = IS_UNDEF)) {/ / Bucket the first item is marked IS_UNDEF uint32_t j = I; Bucket * Q = p If (EXPECTED (! HT_HAS_ITERATORS (ht) {/ / hashtable has no traversal operation while (+ + I)

< ht->

NNumUsed) {pairing; if (EXPECTED (Z_TYPE_INFO (p-> val)! = IS_UNDEF)) {ZVAL_COPY_VALUE (& Q-> val, & p-> val); Q-> h = p-> h; nIndex = Q-> h | ht- > nTableMask Q-> key = p-> key; Z_NEXT (Q-> val) = HT_HASH (ht, nIndex); HT_HASH (ht, nIndex) = HT_IDX_TO_HASH (j) If (UNEXPECTED (ht- > nInternalPointer = = I)) {ht- > nInternalPointer = j;} qroomrooms; jacks + } else {/ / hashtable there is a traversal operation uint32_t iter_pos = zend_hash_iterators_lower_pos (ht, 0); while (+ + I

< ht->

NNumUsed) {pairing; if (EXPECTED (Z_TYPE_INFO (p-> val)! = IS_UNDEF)) {ZVAL_COPY_VALUE (& Q-> val, & p-> val); Q-> h = p-> h; nIndex = Q-> h | ht- > nTableMask Q-> key = p-> key; Z_NEXT (Q-> val) = HT_HASH (ht, nIndex); HT_HASH (ht, nIndex) = HT_IDX_TO_HASH (j) If (UNEXPECTED (ht- > nInternalPointer = = I)) {ht- > nInternalPointer = j } if (UNEXPECTED (I > = iter_pos)) {do {zend_hash_iterators_update (ht, iter_pos, j) Iter_pos = zend_hash_iterators_lower_pos (ht, iter_pos + 1);} while (iter_pos

< i); } q++; j++; } } } ht->

NNumUsed = j; break;} nIndex = p-> h | ht- > nTableMask; Z_NEXT (p-> val) = HT_HASH (ht, nIndex); HT_HASH (ht, nIndex) = HT_IDX_TO_HASH (I); pendant;} while (+ + I)

< ht->

NNumUsed); / * Migrate pointer to one past the end of the array to the new one past the end, so that * newly inserted elements are picked up correctly. * / if (UNEXPECTED (HT_HAS_ITERATORS (ht) {_ zend_hash_iterators_update (ht, old_num_used, ht- > nNumUsed);}} return SUCCESS;}

Hashtable in    PHP 7 also doubles the nTableSize during capacity expansion, and then rehash. During the rehash operation, if there is no IS_UNDEF marked for deletion in the Bucket, the storage order of the Bucket will not change after the rehash operation, but the storage location of the idx index will change due to the change of the nTableMask, which will eventually lead to the change of the hash collision linked list. If there are items in the Bucket that are marked for deletion, these Bucket items are skipped during the rehash process, leaving only those items that have not been deleted. At the same time, because this will cause the index of the Bucket to change compared with the original, it is necessary to update the information of the internal pointer of hashtable and the information related to the traversal operation at the same time in the process of rehash.

Packed hashtable in ⒎ PHP 7

   in PHP 7, if an array is an indexed array and the indexes in the array are arranged in ascending order, then because the Bucket in hashtable is in write order, and the array index is in ascending order, the mapping table is no longer necessary. PHP 7 makes some packed hashtable optimizations for hashtable for this particular situation.

# define HT_MIN_MASK ((uint32_t)-2) # define HT_MIN_SIZE 8#define HT_HASH_RESET_PACKED (ht) do {\ HT_HASH (ht,-2) = HT_INVALID_IDX;\ HT_HASH (ht,-1) = HT_INVALID_IDX;\} while (0) static zend_always_inline void zend_hash_real_init_packed_ex (HashTable * ht) {void * data If (UNEXPECTED (GC_FLAGS (ht) & IS_ARRAY_PERSISTENT) {data = pemalloc (HT_SIZE_EX (ht- > nTableSize, HT_MIN_MASK), 1);} else if (EXPECTED (ht- > nTableSize = = HT_MIN_SIZE)) {data = emalloc (HT_SIZE_EX (HT_MIN_SIZE, HT_MIN_MASK));} else {data = emalloc (HT_SIZE_EX (ht- > nTableSize, HT_MIN_MASK)) } HT_SET_DATA_ADDR (ht, data); / * Don't overwrite iterator count. * / ht- > u.v.flags = HASH_FLAG_PACKED | HASH_FLAG_STATIC_KEYS; HT_HASH_RESET_PACKED (ht);}

When    packed hashtable is initialized, the value of nTableMask defaults to-2 and is marked in the flags of hashtable. If there are no elements in the packed hashtable at this time, the nTableSize will be set to 0.

Static void ZEND_FASTCALL zend_hash_packed_grow (HashTable * ht) {HT_ASSERT_RC1 (ht); if (ht- > nTableSize > = HT_MAX_SIZE) {zend_error_noreturn (E_ERROR, "Possible integer overflow in memory allocation (% u *% zu +% zu)", ht- > nTableSize * 2, sizeof (Bucket), sizeof (Bucket));} ht- > nTableSize + = ht- > nTableSize HT_SET_DATA_ADDR (ht, perealloc2 (HT_GET_DATA_ADDR (ht), HT_SIZE_EX (ht- > nTableSize, HT_MIN_MASK), HT_USED_SIZE (ht), GC_FLAGS (ht) & IS_ARRAY_PERSISTENT);}

   in addition, when packed hashtable expands its capacity, it only needs to double the nTableSize, and because the indexes are arranged in ascending order, the order of Bucket does not need to be adjusted, only memory space needs to be reallocated.

It is important to emphasize that packed hashtable applies only to indexed arrays whose indexes are arranged in ascending order (indexes do not have to be contiguous and can be spaced). If the index order of the index array is broken, or if a string index is added to the index, then the packed hashtable will be converted to a normal hashtable.

Thank you for reading! This is the end of the article on "what is the difference between the implementation of arrays in PHP5 and PHP7". I hope the above content can be of some help to you, so that you can learn more knowledge. if you think the article is good, you can share it for more people to see!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.