PHP7 数组的实现

前提
  • PHP版本：php7.0.29
  • 使用到的文件
    • php-src/Zend/zend_types.h
    • php-src/Zend/zend_hash.h
    • php-src/Zend/zend_hash.c
    • php-src/Zend/zend_string.h
  • 本文 是《PHP7底层设计和源码实现》第5章 数组的实现，学习笔记
功能分析
整体结构

  • 请添加图片描述

    • bucket 里面增加h字段，h代表的是数字key(packed array 模式下，直接是数组下标)
    • 哈希函数拆分为 hash1函数和hash2函数。hash1 将key映射为h值，hash2将h值映射为slot的索引值
    • key字段作为字符串key，不再表示数字key
数据结构
bucket结构分析
// Bucket: 散列表中存储的元素
typedef struct _Bucket {zval              val;  // 存储的具体value，这里嵌入一个zval，而不是一个指针zend_ulong        h;    // key 根据times 33 计算得到的哈希值，或者是数值索引编号zend_string      *key;  // 存储元素的key
};
  • 参数说明
    • val 参数
      • 对应HashTable设计中的value。始终是zval类型
      • zval结构
        struct _zval_struct {zend_value        value;			/* 表明zval类型 */union {struct {ZEND_ENDIAN_LOHI_4(zend_uchar    type,			/* active type */zend_uchar    type_flags,zend_uchar    const_flags,zend_uchar    reserved)	    /* call info for EX(This) */} v;uint32_t type_info;} u1;union {uint32_t     var_flags;uint32_t     next;                 /* 用来解决哈希冲突 */uint32_t     cache_slot;           /* 运行时缓存 */uint32_t     lineno;               /* 对于zend_ast_zval存行号 */uint32_t     num_args;             /* EX(This) 参数个数*/uint32_t     fe_pos;               /* foreach 位置 */uint32_t     fe_iter_idx;          /* foreach 游标的标记 */} u2;
};
      • 每个zval类型16个字节
      • h 参数
        • 对应HashTable设计中的h，表示数字key或者字符串key的h值
      • key 参数
        • 对应HashTable设计中的key，表示字符串的key
        • zend_string结构
          struct _zend_string {zend_refcounted_h gc;	/* 8字节，内嵌的gc，引用计数及字符串类别存储*/zend_ulong        h;   /* hash值，8字节，字符串的哈希值 */size_t            len;	/* 8字节，字符串的长度*/char              val[1]; /*柔性数数组，占1位，字符串的值存储的位置*/
};typedef struct _zend_refcounted_h {uint32_t         refcount;			/* gc,整块占用8字节 */union { // 4字节struct {ZEND_ENDIAN_LOHI_3(zend_uchar    type,	/* 等同于zval的u1.v.type*/zend_uchar    flags,    /* 字符串的类型数据 */uint16_t      gc_info)  /* 垃圾回收标记颜色用 */} v;uint32_t type_info;} u;
} zend_refcounted_h;
          • zend_string是一种带有字符串长度，h值，gc信息的字符串数组的包装，提升了性能和空间效率
  • bucket 的类型
    • 未使用bucket
      • 最初所有的bucket都是未使用的状态
    • 有效bucket
      • 存储着有效的数据(key, val, h),当进行插入时，会选择一个未使用bucket，这样该bucket就变成了有效bucket
      • 更新操作只能发生在有效bucket上，更新后，仍然是有效bucket
    • 无效bucket
      • 当bucket上存储的数据被删除时，有效bucket就会变成无效bucket
  • bucket类型间的转换
    • 在内存分布上有效bucket和无效bucket会交替分布，但都在未使用bucket的前面
    • 插入的时候永远在未使用bucket上进行
    • 当由于删除等操作，导致无效bucket非常多，而有效bucket很少时，会对整个bucket数组进行rehash操作，这样，稀疏的有效bucket就会变得连续和紧密
    • 部分无效bucket会被重新利用而变为有效bucket
    • 还有一部分有效bucket和无效bucket会被释放出来，重新变成未使用bucket
    • 请添加图片描述
HashTable结构分析
// HashTable 结构
typedef struct _zend_array HashTable;
struct _zend_array {zend_refcounted_h gc;union {struct {ZEND_ENDIAN_LOHI_4(zend_uchar    flags,zend_uchar    nApplyCount,zend_uchar    nIteratorsCount,zend_uchar    reserve)} v;uint32_t flags;} u;uint32_t          nTableMask;   // 哈希值计算掩码，等于nTableSize的负值(nTableMask = -nTableSize)Bucket           *arData;   // 存储元素数组，指向第一个Bucketuint32_t          nNumUsed; // 已用Bucket数uint32_t          nNumOfElements;   // 哈希表有效元素数uint32_t          nTableSize;   // 哈希表总大小，为2的n次方uint32_t          nInternalPointer;zend_long         nNextFreeElement; // 下一个可能的数值索引，如: arr[] = 1; arr["a"] = 2;arr[] = 3; 则nNextFreeElement = 2dtor_func_t       pDestructor;
};
  • 参数说明
    • gc 参数
      • 引用计数相关
      • 在PHP7中，引用计数不再是zval的字段，而是被设计在zval的value字段所指向的结构体中
    • argData 参数
      • 实际的存储容器
      • 通过指针指向一段连续的内存，存储着bucket数组
    • nTableSize 参数
      • HashTable 的大小
      • 表示 arData指向的bucket数组的大小，即所有bucket的数量
      • 最小值未8
      • 最大值在32位系统中是0x40000000(2 ^ 30)，在64位系统中0x80000000(2 ^ 31)
    • nNumUsed 参数
      • 指向已使用bucket的数量，包括有效bucket和无效bucket的数量
      • 在bucket数组中，下标从0 ~ (nNumUsed - 1)的bucket都属于已使用bucket
      • 而下标为nNumUsed ~ (nTableSize - 1)的bucket都属于未使用bucket
    • nNumOfElements 参数
      • 有效bucket的数量
      • 该值总是小于或等于nNumUsed
    • nTableMask 参数
      • 掩码。一般为-nTableSize
    • nInternalPointer 参数
      • HashTable的全局默认游标
    • nNextFreeElement 参数
      • HashTable的自然key
      • 自然key是指HashTable的应用语义是纯数组时，插入元素无须指定key，key会以nNextFreeElement的值为准
      • 例如
        • 该字段初始值为0
        • $a[] = 1，实际上是插入到key等于0的bucket上
        • 然后nNextFreeElement会递增1，代表下一个自然插入的元素的key是1
    • pDestructor 参数
      • 析构函数
      • 当bucket元素被更新或被删除时，会对bucket的value调用该函数
      • 如果value是引用计数的类型，那么会对value应用计数减1，进而引发可能的gc
    • u 联合体
      • 占用4个字节。可以存储一个uint32_t类型的flags
      • 也可以存储由4个unsigned char 组成的结构体v
      • u.v.flags 参数
        • 用各个bit来表达HashTable的各种标记
        • 共有下面6中flag，分别对应 u.v.flags的第1位到6位
          #define HASH_FLAG_PERSISTENT       (1<<0)	// 是否使用持久化内存（不使用内存池）
#define HASH_FLAG_APPLY_PROTECTION (1<<1)	// 是否开启递归遍历保护
#define HASH_FLAG_PACKED           (1<<2)	// 是否是packed array
#define HASH_FLAG_INITIALIZED      (1<<3)	// 是否初始化
#define HASH_FLAG_STATIC_KEYS      (1<<4)	// 标记HashTable的Key是否为long key
#define HASH_FLAG_HAS_EMPTY_IND    (1<<5)	// 是否存在空的间接val
      • u.v.nApplyCount 参数
        • 递归遍历计数
        • 为了解决循环引用导致的死循环问题
        • 当对某个数组进行某种递归操作时，在递归调入栈之前将nApplyCount加1，递归调出栈之后将nApplyCount减1
        • 当循环引用出现时，递归调用会不断入栈，当nApplyCount增加到一定阀值时，不再继续递归下去，返回一个合法的值，并打印"recursion detected"之类的warning或者error日志
        • 这个阀值一般不大于3
      • u.v.nIteratorsCount 参数
        • 迭代器计数
        • PHP中每一个foreach语句都会在全局变量EG中创建一个迭代器
        • 迭代器包含正在遍历的HashTable和游标信息
        • 该字段记录了runtime正在迭代当前的HashTable的迭代器的数量
      • u.v.consistency 参数
        • 成员用于调试目的
          #define HT_OK					0x00	// 正常状态，各种数据完全一致
#define HT_IS_DESTROYING		0x40	// 正在删除所有的内容，包括arBuckets本身
#define HT_DESTROYED			0x80	// 已删除，包括arBuckets本身
#define HT_CLEANING				0xc0	// 正在清除所有的arBuckets执行的内容，但不包括arBuckets本身
  • 为什么HashTable 掩码(nTableMask)是负数?
    • PHP7在分配bucket数据内存的时候，在bucket数组的前面额外多申请内存
    • 这段内存是一个索引数组(也加索引表)，数组里面的每个元素代表一个Slot,存储着每个slot链表的第一个bucket在bucket数组中的下标
    • 索引表的默认值：-1
    • 为了实现逻辑链表，由于bucket元素的val是zval，PHP7通过bucket.val.u2.next表达链表中下一个元素在数组中的下标
    • 请添加图片描述
HashTable 初始化
初始化一：为HashTable分配内存，初始化HashTable各个字段
  • 例如: $arr = array();
  • 初始化流程
    • 申请内存
      (ht) = (HashTable *)emalloc(sizeof(HashTable));
    • 调用_zend_hash_init
      static const uint32_t uninitialized_bucket[-HT_MIN_MASK] = {HT_INVALID_IDX, HT_INVALID_IDX};ZEND_API void ZEND_FASTCALL _zend_hash_init(HashTable *ht, uint32_t nSize, dtor_func_t pDestructor, zend_bool persistent ZEND_FILE_LINE_DC)
{GC_REFCOUNT(ht) = 1;	// 设置引用计数GC_TYPE_INFO(ht) = IS_ARRAY; 	// 7 类别设置成数组ht->u.flags = (persistent ? HASH_FLAG_PERSISTENT : 0) | HASH_FLAG_APPLY_PROTECTION | HASH_FLAG_STATIC_KEYS;ht->nTableSize = zend_hash_check_size(nSize);   // 能包含nSize的最小2 ^ n的数字最小值 8ht->nTableMask = HT_MIN_MASK;	// -2，默认是packed arrayHT_SET_DATA_ADDR(ht, &uninitialized_bucket);    // ptr偏移到arrData地址ht->nNumUsed = 0;ht->nNumOfElements = 0;ht->nInternalPointer = HT_INVALID_IDX;ht->nNextFreeElement = 0;ht->pDestructor = pDestructor;
}
  • 参数说明
    • nTableSzie = 8
      • 因为HashTable 内部的arBuckets的大小是2的n次方，并且最小是8，最大值为0x8000000
    • u.vflags = 18
      #define HASH_FLAG_PERSISTENT       (1<<0)
#define HASH_FLAG_APPLY_PROTECTION (1<<1)
#define HASH_FLAG_PACKED           (1<<2)
#define HASH_FLAG_INITIALIZED      (1<<3)
#define HASH_FLAG_STATIC_KEYS      (1<<4)
#define HASH_FLAG_HAS_EMPTY_IND    (1<<5)
      • flag = 18 = HASH_FLAG_STATIC_KEYS | HASH_FLAG_APPLY_PROTECTION
      • 而flag & HASH_FLAG_INITIALIZED 等于0说明，该数组尚未完成真正的初始化，即尚未为arData分配内存
    • 设置nNumberUsed, nNumOfElement为0
      • 因为现在还没有使用任何数据元素
    • 设置nInternalPointer为-1
      • 表示尚未设置全局遍历游标
    • 设置nNextFreeElement 为 0
      • 表示数组的自然key从0开始
    • 设置nTableSize
      • 如果传递的nSize 不是 2 ^ n，会通过zend_hash_check_size函数计算大于等于nSize的最小的 2 ^ n
      • 例如 nSize = 10, 那么最终ht->nTableSize取值为16
    • nTableMask = -2
      • 表示索引表大小为2
      • packed array的索引表未使用到，即nTableMask永远等于-2
初始化二：为bucket数组分配内存，修改HashTable某些字段
  • 例如: $arr[] = ‘foo’;
  • 流程
    • 调用 zend_hash_real_init_ex
      static void zend_always_inline zend_hash_real_init_ex(HashTable *ht, int packed)
{HT_ASSERT(GC_REFCOUNT(ht) == 1);ZEND_ASSERT(!((ht)->u.flags & HASH_FLAG_INITIALIZED));// packed: h < ht->nTableSize, h = 0, ht->nTableSize 默认为8if (packed) {	// packed array 初始化/* 为arData分配内存, 并把arData的指针偏移指向buckets数组的首地址*/HT_SET_DATA_ADDR(ht, pemalloc(HT_SIZE(ht), (ht)->u.flags & HASH_FLAG_PERSISTENT));// 修改flags为 已经初始化并且为packed array(ht)->u.flags |= HASH_FLAG_INITIALIZED | HASH_FLAG_PACKED;// nIndex置为无效标识-1，arData[-1], arrData[-2] = -1HT_HASH_RESET_PACKED(ht);} else {	// 普通哈希表的初始化/*掩码nTableMask为nTableSize的负数，即nTableMask = -nTableSize, 因为nTableSize 等于 2 ^ n，所以nTableMask二进制位右侧全部为0，也就保证了nIndex落在数组索引范围之内(|nIndex| <= nTableSize)*/(ht)->nTableMask = -(ht)->nTableSize;HT_SET_DATA_ADDR(ht, pemalloc(HT_SIZE(ht), (ht)->u.flags & HASH_FLAG_PERSISTENT));(ht)->u.flags |= HASH_FLAG_INITIALIZED;if (EXPECTED(ht->nTableMask == -8)) {Bucket *arData = ht->arData;HT_HASH_EX(arData, -8) = -1;HT_HASH_EX(arData, -7) = -1;HT_HASH_EX(arData, -6) = -1;HT_HASH_EX(arData, -5) = -1;HT_HASH_EX(arData, -4) = -1;HT_HASH_EX(arData, -3) = -1;HT_HASH_EX(arData, -2) = -1;HT_HASH_EX(arData, -1) = -1;} else {HT_HASH_RESET(ht);	// 调用memset函数把所有内存设置成无符号整型的-1}}
}
  • 参数说明
    • HashTable的arData被真正地分配内存
      • 并且按最小值8分配了8个bucket的存储空间
    • flags = 30
      • flags = 30 = HASH_FLAG_STATIC_KEYS | HASH_FLAG_APPLY_PROTECTION | HASH_FLAG_PACKED | HASH_FLAG_INITIALIZED
      • 说明当前HashTable.arData已经被初始化完毕，并且当前HashTable是packed array
    • nTableMask = -2
      • 因为是packed array
    • h = 0
      • $arr[] 对于首次插入，h 等于0
      • packed array 插入到bucket数组的第一个位置(下标为0)
    • bucket 里面内嵌了 zval
    • nNumUsed = 1
      • 由于bucket数组是连续分配的内存，nNumUsed = 1代表了已经使用了1个bucket
      • 那就是arData[0]这个bucket
    • nNumOfElements = 1
      • 表示当前HashTable中有一个有效元素arData[0]
    • nInternalPointer = 0
      • 遍历下标，表示遍历HashTable时从arData[0]开始
    • nNextFreeElement = 1
      • 自然下标，下次自然序插入时, h值为1
packed array 和 hash array 的区别

  • packed array

    • 例如：$a = array(1, 2, 3); // 纯数组
    • 特性和约束
      • key 全部数字key
      • key 按插入顺序排列，仍然是递增的
      • 每一个key-value对的存储位置都是非常确定的，都存储在bucket数组的第key个元素上
      • packed array 不需要索引数组
    • 请添加图片描述

  • hash array

    • 例如：$b = array(‘x’ => 1, ‘y’ => 2, ‘z’ => 3);
    • 说明
      • hash array 依赖数组来维护每个slot链表中首元素在bucket中的下标
      • 拿key 为 x举例，字符串x的h值是9223372036854953501，它与nTableMask(-8)做位或运算之后，结果是-3
      • 然后到索引数组上去查询-3这个slot值，得到该slot链表首元素在bucket数组的下标为0
    • 请添加图片描述
Hash 算法
static zend_always_inline zend_ulong zend_inline_hash_func(const char *str, size_t len)
{register zend_ulong hash = Z_UL(5381);/* variant with the hash unrolled eight times */for (; len >= 8; len -= 8) {hash = ((hash << 5) + hash) + *str++;hash = ((hash << 5) + hash) + *str++;hash = ((hash << 5) + hash) + *str++;hash = ((hash << 5) + hash) + *str++;hash = ((hash << 5) + hash) + *str++;hash = ((hash << 5) + hash) + *str++;hash = ((hash << 5) + hash) + *str++;hash = ((hash << 5) + hash) + *str++;}switch (len) {case 7: hash = ((hash << 5) + hash) + *str++; /* fallthrough... */case 6: hash = ((hash << 5) + hash) + *str++; /* fallthrough... */case 5: hash = ((hash << 5) + hash) + *str++; /* fallthrough... */case 4: hash = ((hash << 5) + hash) + *str++; /* fallthrough... */case 3: hash = ((hash << 5) + hash) + *str++; /* fallthrough... */case 2: hash = ((hash << 5) + hash) + *str++; /* fallthrough... */case 1: hash = ((hash << 5) + hash) + *str++; break;case 0: break;
EMPTY_SWITCH_DEFAULT_CASE()}/* Hash value can't be zero, so we always set the high bit */
#if SIZEOF_ZEND_LONG == 8return hash | Z_UL(0x8000000000000000);
#elif SIZEOF_ZEND_LONG == 4return hash | Z_UL(0x80000000);
#else
# error "Unknown SIZEOF_ZEND_LONG"
#endif
}
  • PHP的Hash采用的是目前最为普遍的DJBX33A (Daniel J. Bernstein, Times 33 with Addition)
  • 算法的核心思想就是:
    • hash(i) = hash(i-1) * 33 + str[i]
  • PHP中并没有使用直接乘33, 而是采用了: hash << 5 + hash
映射函数
  • 映射函数(散列函数)是散列表的关键部分，它将key 与 value 建立映射关系,一般映射函数可以根据key的哈希值与Bucket数组大小取模得到
    • 即 key->h % ht->nTableSize
    • PHP的做法： nIndex = key->h | nTablesMask
  • nTablesMask 为 nTableSize 的负数，即：nTablesMask = -nTableSize
  • 因为 nTableSize 等于 2 ^ n, 所以nTablesMask二进制右侧全部为0，也就保证了nIndex 落在数组索引的范围之内([-n, -1])
    • 11111111 11111111 11111111 11111000 -8
    • 11111111 11111111 11111111 11111001 -7
    • 11111111 11111111 11111111 11111010 -6
    • 11111111 11111111 11111111 11111011 -5
    • 11111111 11111111 11111111 11111100 -4
    • 11111111 11111111 11111111 11111101 -3
    • 11111111 11111111 11111111 11111110 -2
    • 11111111 11111111 11111111 11111111 -1
HashTable 插入
情景分析
  • 例子1: $arr[] = ‘foo’; // 默认为packed array
    • 流程
      • 调用 zend_hash_init 函数，进行hashtable的初始化
        • 初始化为packed array 模式
      • 调用 _zend_hash_next_index_insert 函数将uninitialized_zval插入到HashTable中
        • 然后将字符串foo(zend string 类型)拷贝到对应的zval中
    • 调用函数分析
      • _zend_hash_next_index_insert
        • _zend_hash_next_index_insert 会调用 _zend_hash_index_add_or_update_i
        /**
* @description 向数值索引哈希表的尾部插入数据
* @param HashTable* ht 待操作的哈希表
* @param zval* pData 待保存的数据
* @return: zval*
*/
ZEND_API zval* ZEND_FASTCALL _zend_hash_next_index_insert(HashTable *ht, zval *pData ZEND_FILE_LINE_DC)
{return _zend_hash_index_add_or_update_i(ht, ht->nNextFreeElement, pData, HASH_ADD | HASH_ADD_NEXT ZEND_FILE_LINE_RELAY_CC);
}
      • _zend_hash_index_add_or_update_i
        static zend_always_inline zval *_zend_hash_index_add_or_update_i(HashTable *ht, zend_ulong h, zval *pData, uint32_t flag ZEND_FILE_LINE_DC)
{uint32_t nIndex;uint32_t idx;Bucket *p;IS_CONSISTENT(ht);HT_ASSERT(GC_REFCOUNT(ht) == 1);if (UNEXPECTED(!(ht->u.flags & HASH_FLAG_INITIALIZED))) {	//  检测hash table 是否初始化CHECK_INIT(ht, h < ht->nTableSize);if (h < ht->nTableSize) {p = ht->arData + h;goto add_to_packed;}goto add_to_hash;} else if (ht->u.flags & HASH_FLAG_PACKED) {	// hash table 为 packed array// 使用已有的bucketif (h < ht->nNumUsed) {p = ht->arData + h;// p 不是要删除的bucketif (Z_TYPE(p->val) != IS_UNDEF) {if (flag & HASH_ADD) {return NULL;}if (ht->pDestructor) {ht->pDestructor(&p->val);}ZVAL_COPY_VALUE(&p->val, pData);if ((zend_long)h >= (zend_long)ht->nNextFreeElement) {ht->nNextFreeElement = h < ZEND_LONG_MAX ? h + 1 : ZEND_LONG_MAX;}return &p->val;} else { /* we have to keep the order :( */goto convert_to_hash;}} else if (EXPECTED(h < ht->nTableSize)) {p = ht->arData + h;} else if ((h >> 1) < ht->nTableSize &&(ht->nTableSize >> 1) < ht->nNumOfElements) {zend_hash_packed_grow(ht);p = ht->arData + h;} else {goto convert_to_hash;}add_to_packed:HANDLE_BLOCK_INTERRUPTIONS();/* incremental initialization of empty Buckets */if ((flag & (HASH_ADD_NEW|HASH_ADD_NEXT)) == (HASH_ADD_NEW|HASH_ADD_NEXT)) {ht->nNumUsed = h + 1;	// nNumUsed(实际bucket)增加 h + 1} else if (h >= ht->nNumUsed) {// h 大于 nNumUsed: 意味着，这个是新插入的数据if (h > ht->nNumUsed) {Bucket *q = ht->arData + ht->nNumUsed;	// 指针移动到 ht->arData + ht->nNumUsed 位置while (q != p) {ZVAL_UNDEF(&q->val);	// 把val设置为 is_undef(标记为无效bucket)q++;}}ht->nNumUsed = h + 1;}ht->nNumOfElements++;if (ht->nInternalPointer == HT_INVALID_IDX) {ht->nInternalPointer = h;}zend_hash_iterators_update(ht, HT_INVALID_IDX, h);if ((zend_long)h >= (zend_long)ht->nNextFreeElement) {ht->nNextFreeElement = h < ZEND_LONG_MAX ? h + 1 : ZEND_LONG_MAX;}// packey array。h 不需要 h | nTableSizep->h = h;p->key = NULL;// 把pData 赋值到 val中ZVAL_COPY_VALUE(&p->val, pData);HANDLE_UNBLOCK_INTERRUPTIONS();return &p->val;convert_to_hash:// packed array 模式 转换成 hash array模式zend_hash_packed_to_hash(ht);} else if ((flag & HASH_ADD_NEW) == 0) {p = zend_hash_index_find_bucket(ht, h);if (p) {if (flag & HASH_ADD) {return NULL;}ZEND_ASSERT(&p->val != pData);HANDLE_BLOCK_INTERRUPTIONS();if (ht->pDestructor) {ht->pDestructor(&p->val);}ZVAL_COPY_VALUE(&p->val, pData);HANDLE_UNBLOCK_INTERRUPTIONS();if ((zend_long)h >= (zend_long)ht->nNextFreeElement) {ht->nNextFreeElement = h < ZEND_LONG_MAX ? h + 1 : ZEND_LONG_MAX;}return &p->val;}}ZEND_HASH_IF_FULL_DO_RESIZE(ht);		/* If the Hash table is full, resize it */add_to_hash:HANDLE_BLOCK_INTERRUPTIONS();idx = ht->nNumUsed++;	// nNumUsed++为bucket下标ht->nNumOfElements++;	// 有效的bucket个数增加1if (ht->nInternalPointer == HT_INVALID_IDX) {ht->nInternalPointer = idx;}zend_hash_iterators_update(ht, HT_INVALID_IDX, idx);if ((zend_long)h >= (zend_long)ht->nNextFreeElement) {ht->nNextFreeElement = h < ZEND_LONG_MAX ? h + 1 : ZEND_LONG_MAX;}p = ht->arData + idx;	// 指针移动到 ht->arData + idx位置p->h = h;p->key = NULL;nIndex = h | ht->nTableMask;	// nIndex为slot位置// // 把pData 赋值到 val中ZVAL_COPY_VALUE(&p->val, pData);// 哈希冲突处理，把p->val.u2.next 设置为 slot位置Z_NEXT(p->val) = HT_HASH(ht, nIndex);// 把slot位置的内容设置为 idxHT_HASH(ht, nIndex) = HT_IDX_TO_HASH(idx);HANDLE_UNBLOCK_INTERRUPTIONS();return &p->val;
}
  • 例子2: $arr[‘a’] = ‘bar’
    • 流程
      • 首先调用zend_hash_find根据 key = 'a’查找,查找不到对应的key
      • 然后通过zend_hash_add_new把uninitialized_zval插入到HashTable中
      • 如果此时是packed array，需要调用zend_hash_packed_to_hash进行转换
    • 函数解析
      • zend_hash_find
        ZEND_API zval* ZEND_FASTCALL zend_hash_find(const HashTable *ht, zend_string *key)
{Bucket *p;IS_CONSISTENT(ht);p = zend_hash_find_bucket(ht, key);return p ? &p->val : NULL;
}
      • zend_hash_find_bucket
        static zend_always_inline Bucket *zend_hash_find_bucket(const HashTable *ht, zend_string *key)
{zend_ulong h;uint32_t nIndex;uint32_t idx;Bucket *p, *arData;// key 通过 zend_string_hash_val获得h = zend_string_hash_val(key);arData = ht->arData;// slot 位置nIndex = h | ht->nTableMask;// slot 里的内容idx = HT_HASH_EX(arData, nIndex);// idx不为空while (EXPECTED(idx != HT_INVALID_IDX)) {// arData 中寻找idx下标的bucketp = HT_HASH_TO_BUCKET_EX(arData, idx);// 找到对应的值if (EXPECTED(p->key == key)) { /* check for the same interned string */return p;} else if (EXPECTED(p->h == h) &&EXPECTED(p->key) &&EXPECTED(ZSTR_LEN(p->key) == ZSTR_LEN(key)) &&EXPECTED(memcmp(ZSTR_VAL(p->key), ZSTR_VAL(key), ZSTR_LEN(key)) == 0)) {return p;}idx = Z_NEXT(p->val);}return NULL;
}
      • zend_hash_add_new
        • 最后是调用_zend_hash_add_or_update_i
      • zend_hash_packed_to_hash
        ZEND_API void ZEND_FASTCALL zend_hash_packed_to_hash(HashTable *ht)
{// 把当前的hash table 设置为旧hash tablevoid *new_data, *old_data = HT_GET_DATA_ADDR(ht);Bucket *old_buckets = ht->arData;HT_ASSERT(GC_REFCOUNT(ht) == 1);HANDLE_BLOCK_INTERRUPTIONS();// ~HASH_FLAG_PACKED 把 packed array 变成 hash arrayht->u.flags &= ~HASH_FLAG_PACKED;// 申请nTableSize + nTableMask数量的内存new_data = pemalloc(HT_SIZE_EX(ht->nTableSize, -ht->nTableSize), (ht)->u.flags & HASH_FLAG_PERSISTENT);ht->nTableMask = -ht->nTableSize;// 修改ht内存指向HT_SET_DATA_ADDR(ht, new_data);// 复制旧数据到新hash tablememcpy(ht->arData, old_buckets, sizeof(Bucket) * ht->nNumUsed);// 释放旧数据pefree(old_data, (ht)->u.flags & HASH_FLAG_PERSISTENT);// 重建索引zend_hash_rehash(ht);HANDLE_UNBLOCK_INTERRUPTIONS();
}
  • 例子3: $arr[2] = ‘abc’
    • 流程
      • 首先使用 zend_hash_index_find函数根据h = 2来查找，查找不到的话
      • 调用zend_hash_index_add_new 将其插入HashTable中去
    • 函数分析
      • zend_hash_index_find
        ZEND_API zval* ZEND_FASTCALL zend_hash_index_find(const HashTable *ht, zend_ulong h)
{Bucket *p;IS_CONSISTENT(ht);//hash table 是否是packed arrayif (ht->u.flags & HASH_FLAG_PACKED) {// 查找的值，小于hash table 实际的bucketif (h < ht->nNumUsed) {p = ht->arData + h;// p 不是被标记删除的数据if (Z_TYPE(p->val) != IS_UNDEF) {return &p->val;}}return NULL;}// 如果是hash array就使用 zend_hash_index_find_bucketp = zend_hash_index_find_bucket(ht, h);return p ? &p->val : NULL;
}
      • zend_hash_index_add_new
        • 最后调用 _zend_hash_index_add_or_update_i
  • 例子4: $arr[] = ‘xyz’
    • 流程
      • 调用_zend_hash_next_index_insert
      • 对于h，使用的是ht->nNextFreeElement
      • 如此时ht->nNextFreeElement == 3, 同样传入 h = 3调用zend_hash_index_find_bucket查找
      • 查找不到的话，进行插入
    • 函数分析
      • _zend_hash_next_index_insert
        • 最后调用 _zend_hash_index_add_or_update_i
      • zend_hash_index_find_bucket
        static zend_always_inline Bucket *zend_hash_index_find_bucket(const HashTable *ht, zend_ulong h)
{uint32_t nIndex;uint32_t idx;Bucket *p, *arData;arData = ht->arData;// 获取slot位置nIndex = h | ht->nTableMask;// 获取 slot的内容idx = HT_HASH_EX(arData, nIndex);// idx 不为空while (idx != HT_INVALID_IDX) {// 断言，idx小于 ht->nTableSizeZEND_ASSERT(idx < HT_IDX_TO_HASH(ht->nTableSize));// 获取 arrData下标处的内容p = HT_HASH_TO_BUCKET_EX(arData, idx);// h相等，且key不为空。意味着是hash array类型if (p->h == h && !p->key) {return p;}// 不然，需要选择p的冲突链表里的next值idx = Z_NEXT(p->val);}return NULL;
}
  • 例子5: $arr[‘a’] = ‘foo’
    • 流程
      • 调用zend_hash_find_bucket，通过 key = a查找，通过zend_string_hash_val可以计算 h值
      • 然后通过 nIndex = h | ht->nTableMask , nIndex = -2, 而-2位置对应1，找到arData的第1个位置，判断key是否等于’a’,然后将对应的值改为’foo’，并做优化
HashTable 哈希冲突解决
  • 说明
    • PHP7 hash array 的做法，把每个冲突的idx存储在bucket的zval.u2.next中
    • 插入的时候把老的value存储的地址(idx)放到新value的next中，再把新value的存储地址更新到索引数组
    • 通过 zval.u2.next的值，就可以形成一条隐藏的链表
  • 例如

    • 请添加图片描述

    • 1). 插入第1个bucket，对应nIdex为-3，那么此时nIndex = -3的位置值为1

    • 2). 若此时插入第2个bucket，与第1个冲突，也就是对应的nIndex也为-3

      • 所以，令nIndex = -3的位置值为2，同时将第2个bucket中zval里面的u2.next值置为1
      • 这样，在查找第1个bucket的key对应的nIndex时，找到第2个bucket，校验key值不同，会取u2.next对应的1，取第1个bucket中的内容，与key校验一致，则返回

    • 3). 若此时插入第3个bucket，与第1个和第2个冲突，那么用同样的方式，令nIndex = -3的位置值为3，同时将第3个bucket中zval里面的u2.next值置为2

HashTable 扩容和rehash操作

  • 扩容和rehash整体流程流程

    • hash array 的容量分配的是固定的，初始化每次申请的是2 ^ n的容量，容量最小值为 2 ^ 3，最大值为0x8000000
    • 当容量足够时候，直接执行插入操作
    • 当容量不够时候(nNumUsed >= nTableSize)
      • 检查已删除元素所占的比例，假如达到阀值(ht->nNumUsed - ht->nNumOfElements > (ht->nNumOfElements >> 5))
      • 则将已删除元素从HashTable中移除，并重建索引
      • 如果未到阀值，则要进行扩容操作，新的容量扩大到当前的大小的2倍(2 * nTableSzie),将当前bucket数组复制到新的空间，然后重建索引
    • 重建完索引后，有足够的空余空间再执行插入操作
    • 请添加图片描述

  • 重建索引的过程

    • rehash对应源码中的zend_hash_rehash(ht)方法

    • rehash的主要功能就是HashTable bucket数组中标识为IS_UNDEF的数据剔除，把有效数据重新聚合到bucket数组并更新插入索引表

    • rehash不重新申请内存，整个过程是在原有结构上做聚合调整

    • 请添加图片描述

      • 具体步骤
        • 重置所有Index数组为-1
        • 初始化两个bucket类型的指针p, q,循环遍历bucket数组
        • 每次循环, p++，遇到第一个IS_UNDEF， q =p;继续循环数组
        • 当再一次遇到一个正常数据时，把正常数据拷贝到q指向的位置，q++
        • 直到遍历完数据，更新nNumUsed等计数

  • 代码分析

    • zend_hash_rehash
      ZEND_API int ZEND_FASTCALL zend_hash_rehash(HashTable *ht)
{Bucket *p;uint32_t nIndex, i;IS_CONSISTENT(ht);// 有效bucket为0if (UNEXPECTED(ht->nNumOfElements == 0)) {// hash table 还没有初始化if (ht->u.flags & HASH_FLAG_INITIALIZED) {ht->nNumUsed = 0;HT_HASH_RESET(ht);}return SUCCESS;}// 把slot 数组设置为-1HT_HASH_RESET(ht);i = 0;p = ht->arData;// 全部都是有效bucketif (ht->nNumUsed == ht->nNumOfElements) {// 重建slot索引do {nIndex = p->h | ht->nTableMask;Z_NEXT(p->val) = HT_HASH(ht, nIndex);HT_HASH(ht, nIndex) = HT_IDX_TO_HASH(i);p++;} while (++i < ht->nNumUsed);} else {do {// 如果是要剔除的数据if (UNEXPECTED(Z_TYPE(p->val) == IS_UNDEF)) {uint32_t j = i;Bucket *q = p;/*** 初始化两个bucket类型的指针p, q,循环遍历bucket数组* 每次循环, p++，遇到第一个IS_UNDEF， q =p;继续循环数组* 当再一次遇到一个正常数据时，把正常数据拷贝到q指向的位置，q++* 直到遍历完数据，更新nNumUsed等计数*/// 迭代计数器为0if (EXPECTED(ht->u.v.nIteratorsCount == 0)) {while (++i < ht->nNumUsed) {p++;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;}q++;j++;}}} else {uint32_t iter_pos = zend_hash_iterators_lower_pos(ht, 0);while (++i < ht->nNumUsed) {p++;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)) {zend_hash_iterators_update(ht, i, j);iter_pos = zend_hash_iterators_lower_pos(ht, iter_pos + 1);}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);p++;} while (++i < ht->nNumUsed);}return SUCCESS;
}
参考资料
  • 《PHP7底层设计和源码实现》
  • 《PHP7内核剖析》
  • PHP中的Hash算法

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/854188.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

欣九康诊疗系统助力诊所向数字化转型

欣九康诊疗系统助力诊所向数字化转型

数字化已经成为各行各业转型的重点方向&#xff0c;而为了不被时代所淘汰&#xff0c;医疗机构也势必要紧跟潮流&#xff0c;本人作为门诊部的负责人深知医疗机构要想实现数字化转型那么拥有一款便捷实用的医疗平台是必不可少的&#xff0c;近几年&#xff0c;随着国家大力支持…
阅读更多...
动态 SQL

动态 SQL

动态 SQL 是 MyBatis 的强大特性之一&#xff0c;能够完成不同条件下不同的 sql 拼接。也就是说执行的 SQL 语句并不是固定的&#xff0c;而是不同人的不同操作执行的语句会有所差异。MyBatis 通过使用 标签 的方式来实现这种灵活性的。 <if>标签 例如在有一些网站进行…
阅读更多...
【可控图像生成系列论文（一）】MimicBrush 港大、阿里、蚂蚁集团合作论文解读

【可控图像生成系列论文（一）】MimicBrush 港大、阿里、蚂蚁集团合作论文解读

背景&#xff1a;考虑到用户的不同需求&#xff0c;图像编辑是一项实用而富有挑战性的任务&#xff0c;其中最困难的部分之一是准确描述编辑后的图像应该是什么样子。 创新点&#xff1a;在本文作者提出了一种新的编辑形式&#xff0c;称为模仿编辑&#xff0c;以帮助用户更方…
阅读更多...
开放式耳机哪个品牌质量比较好？2024高性价比机型推荐！

开放式耳机哪个品牌质量比较好？2024高性价比机型推荐！

随着音乐技术的不断进步&#xff0c;耳机也必不可少&#xff0c;开放式耳机成为一部分音乐发烧友们的选择。从最初的简单音质系统&#xff0c;到如今的高清解析&#xff0c;开放式耳机也在不断升级。音质也能够和入耳式一样纯净自然&#xff0c;佩戴舒适&#xff0c;无论是街头…
阅读更多...
清华停招土木，新增地球科学引热议

清华停招土木，新增地球科学引热议

早在今年2月26日&#xff0c;多个自媒体平台上有人发布消息称“清华大学停止土木工程等专业招生”&#xff0c;引发广泛关注。 在清华大学的官网可以看到下图的公告。 可以看到&#xff0c;清华大学停招土木工程等专业&#xff0c;新增地球系统科学等专业。这一举措引起全网热…
阅读更多...
亚马逊测评沃尔玛下单砍单率、死号率高是什么原因？

亚马逊测评沃尔玛下单砍单率、死号率高是什么原因？

很多卖家和服务商在进行自养号测评补单过程中会出现砍单率、封号率高的问题&#xff0c;其实造成这种的原因很多&#xff0c;一套稳定的测评系统并不是单解决IP的纯净度问题或者支付卡的卡头风控问题就可以解决的&#xff0c;亚马逊测评下单砍单率、死号率高的原因可以归纳为以…
阅读更多...
Vue50-mixin混入

Vue50-mixin混入

一、为什么要使用 mixin混入 两个组件共享一个配置。 二、使用 mixin混入 2-1、创建一个混合js文件 2-2、引入混合js文件 1、局部混合 在每个组件中都引入混合js文件 注意&#xff1a; 混合就是复用配置&#xff0c;vm实例中的所有的配置项&#xff0c;都能在混合.js文件中写…
阅读更多...
elasticsearch过滤器filter：原理及使用

elasticsearch过滤器filter：原理及使用

码到三十五 &#xff1a; 个人主页 目录 一、引言二、Elasticsearch的过滤器概述三、使用DSL进行过滤操作术语过滤范围过滤复合过滤 四、优化策略五、结语 一、引言 Elasticsearch是一个功能强大的开源搜索引擎&#xff0c;广泛应用于各种数据检索和处理场景。在Elasticsearch…
阅读更多...
WPS如何合并多个word文档到一个文档中

WPS如何合并多个word文档到一个文档中

将多个Word文档合并成一个 【插入】---》【附件】----》【文件中的文字】----》选择多个需要合并的word文档&#xff0c;点击确定即可。 用的工具是WPS。
阅读更多...
MS1112驱动开发（iio框架）

MS1112驱动开发（iio框架）

作者简介&#xff1a; 一个平凡而乐于分享的小比特&#xff0c;中南民族大学通信工程专业研究生在读&#xff0c;研究方向无线联邦学习 擅长领域&#xff1a;驱动开发&#xff0c;嵌入式软件开发&#xff0c;BSP开发 作者主页&#xff1a;一个平凡而乐于分享的小比特的个人主页…
阅读更多...
Qt实现单例模式：Q_GLOBAL_STATIC和Q_GLOBAL_STATIC_WITH_ARGS

Qt实现单例模式：Q_GLOBAL_STATIC和Q_GLOBAL_STATIC_WITH_ARGS

目录 1.引言 2.了解Q_GLOBAL_STATIC 3.了解Q_GLOBAL_STATIC_WITH_ARGS 4.实现原理 4.1.对象的创建 4.2.QGlobalStatic 4.3.宏定义实现 4.4.注意事项 5.总结 1.引言 设计模式之单例模式-CSDN博客 所谓的全局静态对象&#xff0c;大多是在单例类中所见&#xff0c;在之前…
阅读更多...
idea插件开发之在项目右键添加菜单

idea插件开发之在项目右键添加菜单

写在前面 本文看下如何在右键列表中增加菜单。 正戏 首先创建一个Action&#xff0c;要显示的menu选择ProjectViewPopupMenu&#xff0c;如下&#xff1a; action public class CAction extends AnAction {Overridepublic void actionPerformed(AnActionEvent e) { // …
阅读更多...
C#语言入门详解 --- 方法（含传值 输出 引用 数组）

C#语言入门详解 --- 方法（含传值 输出 引用 数组）

方法 方法标准式 <Access Specifier> <Return Type> <Method Name>(Parameter List) { Method Body } 让我们逐一对每一个模块进行解释&#xff1a; Access Specifier&#xff1a;访问修饰符&#xff0c;这决定了接下来的主题的可见性&#xff0c;包含p…
阅读更多...
使用python绘制三维直方图

使用python绘制三维直方图

使用python绘制三维直方图 三维直方图定义特点 效果代码 三维直方图 维直方图&#xff08;3D直方图&#xff09;是一种用于展示三维数据分布情况的图表。它扩展了二维直方图的概念&#xff0c;通过在三维空间中绘制柱体来表示数据在三个维度&#xff08;X、Y、Z&#xff09;上…
阅读更多...
结合gin框架在沙箱环境下实现电脑网站支付和当面支付

结合gin框架在沙箱环境下实现电脑网站支付和当面支付

文章目录 配置支付宝开放平台编写代码测试电脑网站支付当面扫码支付 配置支付宝开放平台 支付宝开放平台 点击链接&#xff0c;扫码进入后&#xff0c;点击沙箱&#xff1a; 点击沙箱应用&#xff0c;可以看到APPID&#xff0c;接口加签方式选择系统默认密钥就行&#xff0…
阅读更多...
基于Python的垃圾分类检测识别系统（Yolo4网络）【W8】

基于Python的垃圾分类检测识别系统（Yolo4网络）【W8】

简介&#xff1a; 垃圾分类检测识别系统旨在利用深度学习和计算机视觉技术&#xff0c;实现对不同类别垃圾的自动识别和分类。应用环境包括Python编程语言、主流深度学习框架如TensorFlow或PyTorch&#xff0c;以及图像处理库OpenCV等&#xff0c;通过这些工具集成和优化模型&a…
阅读更多...
成都爱尔林江院长建议近视防控从小做起，具体怎么做

成都爱尔林江院长建议近视防控从小做起，具体怎么做

预防近视应从小做起&#xff0c;知识储备多多益善。孩子如何做到近视防控&#xff1f; 成都爱尔眼科医院小儿眼科专家林江院长建议家长和孩子同时树立科学观念&#xff0c;让孩子拥有一个丰富多彩假期的同时强身健体也保护好眼睛。 不宅家、多户外 确保每天至少2个小时的户外…
阅读更多...
解锁5G新营销：视频短信的优势与全方位推广策略

解锁5G新营销：视频短信的优势与全方位推广策略

随着5G时代的全面来临&#xff0c;企业的数字化转型步伐日益加快&#xff0c;视频短信作为新兴的数字营销工具&#xff0c;正逐步展现出其巨大的潜力。视频短信群发以其独特的形式和内容&#xff0c;将图片、文字、视频、声音融为一体&#xff0c;为用户带来全新的直观感受&…
阅读更多...
线上盲盒小程序：前景展望

线上盲盒小程序：前景展望

在移动互联网的浪潮下&#xff0c;线上盲盒小程序作为一种新兴的购物模式&#xff0c;具有广阔的发展前景和潜力。以下是对线上盲盒小程序未来前景的展望&#xff1a; 一、市场规模持续扩大 随着消费者需求的不断增长和市场竞争的加剧&#xff0c;线上盲盒小程序的市场规模将持…
阅读更多...
无人机比赛有哪些？

无人机比赛有哪些？

无人机比赛项目可是多种多样&#xff0c;精彩纷呈呢&#xff01; 常见的比赛项目包括S形绕桩赛、平台起降赛、应用航拍、投掷物品和定点飞行等。这些项目不仅考验无人机的性能&#xff0c;更考验飞行员的操控技巧。 在S形绕桩赛中&#xff0c;飞行员需要操控无人机快速而准确…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023