PHP extension development-v1.0_PHP tutorial

In fact, for variable-length structures, the variables we are using cannot be directly defined, such as: Bucket bucket; if you use it this way, the value will definitely not store much information. For variable-length structures, we need to first declare a pointer to the variable-length structure when using it, and then allocate function space through the malloc function. We can malloc as much as the length of the space we need to use. The general usage methods are as follows:

Bucket*pBucket;

pBucket =malloc(sizeof(Bucket)+ n *sizeof(char));

Where n is the length of value you want to use. If used in this way, will the string pointed to by value become longer soon?

11.2 Introduction to Hashtable

Let’s take a look at the definition of HashTable first

struct _hashtable;

typedef struct bucket {

ulong h;//Use

uint nKeyLength;//When using string index, this variable represents the length of the index, and the index (string) is stored in the last element aKey

void *pData;//Used to point to the saved data. If the saved data is a pointer, pDataPtr points to this data, and pData points to pDataPtr

void *pDataPtr;

struct bucket *pListNext;//Previous element

struct bucket *pListLast; //Next element

struct bucket *pNext;//Pointer to the next bucket

struct bucket *pLast;//Pointer to the previous bucket

char arKey[1];//Must be placed at the end, mainly to achieve variable length structure

}Bucket;

typedef struct _hashtable {

uint nTableSize; //The size of the hash table

uint nTableMask; //Numerically equal to nTableSize - 1

uint nNumOfElements; //Records the number of records saved in the current HashTable

ulongnNextFreeElement; //Point to the next free Bucket

Bucket *pInternalPointer; //This variable is used for array inversion

Bucket *pListHead; //Point to the head of the Bucket

Bucket *pListTail; //Point to the tail of the Bucket

Bucket **arBuckets;

dtor_func_tpDestructor; //Function pointer, automatically called when the array is added, deleted, modified, and checked, used for certain cleanup operations

zend_bool persistent; // Is it persistent?

unsigned char nApplyCount;

zend_boolbApplyProtection; //Works together with nApplyCount to prevent infinite recursion during array traversal

#if ZEND_DEBUG

int inconsistent;

#endif

}HashTable;

I hope everyone can take a good look at the above definitions. There are some things that I will not understand when I explain them. It is better for everyone to look at the code and it will be clearer. PHP's array is actually a doubly linked list with a head node, where HashTable is the head and Bucket stores specific node information.

11.3 Analysis of HashTable internal functions

11.3.1 Macro HASH_PROTECT_RECURSION

#defineHASH_PROTECT_RECURSION (ht)

if ((ht)->nApplyCount++ >= 3){

}

This macro is mainly used to prevent circular references.

11.3.2 Macro ZEND_HASH_IF_FULL_DO_RESIZE

#defineZEND_HASH_IF_FULL_DO_RESIZE(ht)                                                                          

} The function of this macro is to check whether the number of elements in the current HashTable is greater than the total size of the HashTable. If the number is greater than the size of the HashTable, then we will reallocate the space. Let’s take a look at zend_hash_do_resizestatic intzend_hash_do_resize(HashTable*ht){ Bucket **t; IS_CONSISTENT(ht); if ((ht->nTableSize<< 1) >0) { /* Let's double the table size */ t = (Bucket**) perealloc_recoverable(ht->arBuckets,(ht->nTableSize<< 1) * sizeof(Bucket*), ht->persistent); if (t){ HANDLE_BLOCK_INTERRUPTIONS(); ht->arBuckets = t; ht->nTableSize = (ht->nTableSize<< 1); ht->nTableMask = ht->nTableSize- 1; zend_hash_rehash(ht); HANDLE_UNBLOCK_INTERRUPTIONS(); return SUCCESS; } return FAILURE; } return SUCCESS;} From the above code we can see that when HashTable allocates space, the newly allocated space is equal to twice the original space. 11.3.3 Function _zend_hash_initThis function is used to initialize HashTable. Let’s take a look at the code first: ZEND_API int_zend_hash_init(HashTable*ht, uint nSize,hash_func_t pHashFunction,dtor_func_t pDestructor,zend_bool persistent ZEND_FILE_LINE_DC){ uint i = 3; //The default size of HashTable is 2 raised to the third power Bucket **tmp; SET_INCONSISTENT(HT_OK); if (nSize>= 0x80000000){ ht->nTableSize = 0x80000000; } else{ while ((1U << i)< nSize){ i++; } ht->nTableSize = 1 << i; } ht->nTableMask = ht->nTableSize-1; ht->pDestructor = pDestructor; ht->arBuckets =NULL; ht->pListHead =NULL; ht->pListTail =NULL; ht->nNumOfElements = 0; ht->nNextFreeElement = 0; ht->pInternalPointer = NULL; ht->persistent = persistent; ht->nApplyCount =0; ht->bApplyProtection = 1; /* Uses ecalloc() so that Bucket* == NULL */ if (persistent){ tmp = (Bucket **)calloc(ht->nTableSize,sizeof(Bucket*)); if (!tmp){ return FAILURE; } ht->arBuckets = tmp; } else{ tmp = (Bucket **)ecalloc_rel(ht->nTableSize,sizeof(Bucket*)); if (tmp){ ht->arBuckets = tmp; } } return SUCCESS;}It can be seen that the size of HashTable is initialized to the nth power of 2. In addition, we see that there are two memory methods, one is calloc and the other is ecalloc_rel. We have discussed these two memory allocation methods in detail. If you are interested, you can check it out yourself. 11.3.4 Function_zend_hash_add_or_updateThis function adds or modifies element information to HashTableZEND_API int_zend_hash_add_or_update(HashTable*ht,const char *arKey, uintnKeyLength,void *pData, uintnDataSize,void **pDest,int flag ZEND_FILE_LINE_DC){ ulong h;