From e7852552a17684e9bc0715f4e732c7c1ae07e50d Mon Sep 17 00:00:00 2001 From: Shengliang Guan Date: Mon, 28 Feb 2022 13:53:11 +0800 Subject: [PATCH] hash --- include/util/thash.h | 83 +++++++++--------- source/util/src/thash.c | 184 +++++++++++++++++++--------------------- 2 files changed, 128 insertions(+), 139 deletions(-) diff --git a/include/util/thash.h b/include/util/thash.h index 1f72045a83..5c344f3f0f 100644 --- a/include/util/thash.h +++ b/include/util/thash.h @@ -13,22 +13,22 @@ * along with this program. If not, see . */ -#ifndef TDENGINE_HASH_H -#define TDENGINE_HASH_H +#ifndef _TD_UTIL_HASH_H_ +#define _TD_UTIL_HASH_H_ + +#include "tarray.h" +#include "tlockfree.h" #ifdef __cplusplus extern "C" { #endif -#include "tarray.h" -#include "tlockfree.h" - typedef uint32_t (*_hash_fn_t)(const char *, uint32_t); -typedef int32_t (*_equal_fn_t)(const void*, const void*, size_t len); +typedef int32_t (*_equal_fn_t)(const void *, const void *, size_t len); typedef void (*_hash_before_fn_t)(void *); typedef void (*_hash_free_fn_t)(void *); -#define HASH_MAX_CAPACITY (1024 * 1024 * 16) +#define HASH_MAX_CAPACITY (1024 * 1024 * 16) #define HASH_DEFAULT_LOAD_FACTOR (0.75) #define HASH_INDEX(v, c) ((v) & ((c)-1)) @@ -59,43 +59,43 @@ _equal_fn_t taosGetDefaultEqualFunction(int32_t type); typedef struct SHashNode { struct SHashNode *next; - uint32_t hashVal; // the hash value of key - uint32_t dataLen; // length of data - uint32_t keyLen; // length of the key - uint16_t count; // reference count - int8_t removed; // flag to indicate removed + uint32_t hashVal; // the hash value of key + uint32_t dataLen; // length of data + uint32_t keyLen; // length of the key + uint16_t count; // reference count + int8_t removed; // flag to indicate removed char data[]; } SHashNode; -#define GET_HASH_NODE_KEY(_n) ((char*)(_n) + sizeof(SHashNode) + (_n)->dataLen) -#define GET_HASH_NODE_DATA(_n) ((char*)(_n) + sizeof(SHashNode)) -#define GET_HASH_PNODE(_n) ((SHashNode *)((char*)(_n) - sizeof(SHashNode))) +#define GET_HASH_NODE_KEY(_n) ((char *)(_n) + sizeof(SHashNode) + (_n)->dataLen) +#define GET_HASH_NODE_DATA(_n) ((char *)(_n) + sizeof(SHashNode)) +#define GET_HASH_PNODE(_n) ((SHashNode *)((char *)(_n) - sizeof(SHashNode))) typedef enum SHashLockTypeE { - HASH_NO_LOCK = 0, - HASH_ENTRY_LOCK = 1, + HASH_NO_LOCK = 0, + HASH_ENTRY_LOCK = 1, } SHashLockTypeE; typedef struct SHashEntry { - int32_t num; // number of elements in current entry - SRWLatch latch; // entry latch + int32_t num; // number of elements in current entry + SRWLatch latch; // entry latch SHashNode *next; } SHashEntry; typedef struct SHashObj { - SHashEntry **hashList; - uint32_t capacity; // number of slots - uint32_t size; // number of elements in hash table + SHashEntry **hashList; + uint32_t capacity; // number of slots + uint32_t size; // number of elements in hash table - _hash_fn_t hashFp; // hash function - _hash_free_fn_t freeFp; // hash node free callback function - _equal_fn_t equalFp; // equal function - _hash_before_fn_t callbackFp; // function invoked before return the value to caller + _hash_fn_t hashFp; // hash function + _hash_free_fn_t freeFp; // hash node free callback function + _equal_fn_t equalFp; // equal function + _hash_before_fn_t callbackFp; // function invoked before return the value to caller - SRWLatch lock; // read-write spin lock - SHashLockTypeE type; // lock type - bool enableUpdate; // enable update - SArray *pMemBlock; // memory block allocated for SHashEntry + SRWLatch lock; // read-write spin lock + SHashLockTypeE type; // lock type + bool enableUpdate; // enable update + SArray *pMemBlock; // memory block allocated for SHashEntry } SHashObj; /** @@ -128,7 +128,6 @@ int32_t taosHashPut(SHashObj *pHashObj, const void *key, size_t keyLen, void *da int32_t taosHashPutExt(SHashObj *pHashObj, const void *key, size_t keyLen, void *data, size_t size, bool *newAdded); - /** * return the payload data with the specified key * @@ -147,7 +146,7 @@ void *taosHashGet(SHashObj *pHashObj, const void *key, size_t keyLen); * @param destBuf * @return */ -void *taosHashGetClone(SHashObj *pHashObj, const void *key, size_t keyLen, void* destBuf); +void *taosHashGetClone(SHashObj *pHashObj, const void *key, size_t keyLen, void *destBuf); /** * Clone the result to interval allocated buffer @@ -157,7 +156,7 @@ void *taosHashGetClone(SHashObj *pHashObj, const void *key, size_t keyLen, void* * @param destBuf * @return */ -void* taosHashGetCloneExt(SHashObj *pHashObj, const void *key, size_t keyLen, void (*fp)(void *), void** d, size_t *sz); +void *taosHashGetCloneExt(SHashObj *pHashObj, const void *key, size_t keyLen, void (*fp)(void *), void **d, size_t *sz); /** * remove item with the specified key @@ -206,15 +205,14 @@ void *taosHashIterate(SHashObj *pHashObj, void *p); * @param pHashObj * @param p */ -void taosHashCancelIterate(SHashObj *pHashObj, void *p); +void taosHashCancelIterate(SHashObj *pHashObj, void *p); /** * Get the corresponding key information for a given data in hash table * @param data * @return */ -int32_t taosHashGetKey(void *data, void** key, size_t* keyLen); - +int32_t taosHashGetKey(void *data, void **key, size_t *keyLen); /** * Get the corresponding key information for a given data in hash table, using memcpy @@ -222,13 +220,13 @@ int32_t taosHashGetKey(void *data, void** key, size_t* keyLen); * @param dst * @return */ -static FORCE_INLINE int32_t taosHashCopyKey(void *data, void* dst) { +static FORCE_INLINE int32_t taosHashCopyKey(void *data, void *dst) { if (NULL == data || NULL == dst) { return -1; } - - SHashNode * node = GET_HASH_PNODE(data); - void* key = GET_HASH_NODE_KEY(node); + + SHashNode *node = GET_HASH_PNODE(data); + void *key = GET_HASH_NODE_KEY(node); memcpy(dst, key, node->keyLen); return 0; @@ -249,7 +247,7 @@ int32_t taosHashGetDataLen(void *data); * @param keyLen * @return */ -void* taosHashAcquire(SHashObj *pHashObj, const void *key, size_t keyLen); +void *taosHashAcquire(SHashObj *pHashObj, const void *key, size_t keyLen); /** * release the prevous acquired obj @@ -262,9 +260,8 @@ void taosHashRelease(SHashObj *pHashObj, void *p); void taosHashSetEqualFp(SHashObj *pHashObj, _equal_fn_t fp); - #ifdef __cplusplus } #endif -#endif // TDENGINE_HASH_H +#endif // _TD_UTIL_HASH_H_ diff --git a/source/util/src/thash.c b/source/util/src/thash.c index 9f39b79968..219fc739ca 100644 --- a/source/util/src/thash.c +++ b/source/util/src/thash.c @@ -13,16 +13,15 @@ * along with this program. If not, see . */ -#include "os.h" +#define _DEFAULT_SOURCE #include "thash.h" -#include "tlog.h" -#include "taos.h" #include "tdef.h" +#include "tlog.h" // the add ref count operation may trigger the warning if the reference count is greater than the MAX_WARNING_REF_COUNT #define MAX_WARNING_REF_COUNT 10000 #define EXT_SIZE 1024 -#define HASH_NEED_RESIZE(_h) ((_h)->size >= (_h)->capacity * HASH_DEFAULT_LOAD_FACTOR) +#define HASH_NEED_RESIZE(_h) ((_h)->size >= (_h)->capacity * HASH_DEFAULT_LOAD_FACTOR) #define DO_FREE_HASH_NODE(_n) \ do { \ @@ -74,10 +73,12 @@ static FORCE_INLINE int32_t taosHashCapacity(int32_t length) { return i; } -static FORCE_INLINE SHashNode *doSearchInEntryList(SHashObj *pHashObj, SHashEntry *pe, const void *key, size_t keyLen, uint32_t hashVal) { +static FORCE_INLINE SHashNode *doSearchInEntryList(SHashObj *pHashObj, SHashEntry *pe, const void *key, size_t keyLen, + uint32_t hashVal) { SHashNode *pNode = pe->next; while (pNode) { - if ((pNode->keyLen == keyLen) && ((*(pHashObj->equalFp))(GET_HASH_NODE_KEY(pNode), key, keyLen) == 0) && pNode->removed == 0) { + if ((pNode->keyLen == keyLen) && ((*(pHashObj->equalFp))(GET_HASH_NODE_KEY(pNode), key, keyLen) == 0) && + pNode->removed == 0) { assert(pNode->hashVal == hashVal); break; } @@ -115,7 +116,8 @@ static SHashNode *doCreateHashNode(const void *key, size_t keyLen, const void *p * @param dsize size of actual data * @return hash node */ -static FORCE_INLINE SHashNode *doUpdateHashNode(SHashObj *pHashObj, SHashEntry* pe, SHashNode* prev, SHashNode *pNode, SHashNode *pNewNode) { +static FORCE_INLINE SHashNode *doUpdateHashNode(SHashObj *pHashObj, SHashEntry *pe, SHashNode *prev, SHashNode *pNode, + SHashNode *pNewNode) { assert(pNode->keyLen == pNewNode->keyLen); pNode->count--; @@ -129,11 +131,11 @@ static FORCE_INLINE SHashNode *doUpdateHashNode(SHashObj *pHashObj, SHashEntry* pNewNode->next = pNode->next; DO_FREE_HASH_NODE(pNode); } else { - pNewNode->next = pNode; + pNewNode->next = pNode; pe->num++; atomic_add_fetch_32(&pHashObj->size, 1); } - + return pNewNode; } @@ -175,7 +177,7 @@ SHashObj *taosHashInit(size_t capacity, _hash_fn_t fn, bool update, SHashLockTyp pHashObj->capacity = taosHashCapacity((int32_t)capacity); assert((pHashObj->capacity & (pHashObj->capacity - 1)) == 0); pHashObj->equalFp = memcmp; - pHashObj->hashFp = fn; + pHashObj->hashFp = fn; pHashObj->type = type; pHashObj->enableUpdate = update; @@ -201,8 +203,8 @@ SHashObj *taosHashInit(size_t capacity, _hash_fn_t fn, bool update, SHashLockTyp void taosHashSetEqualFp(SHashObj *pHashObj, _equal_fn_t fp) { if (pHashObj != NULL && fp != NULL) { pHashObj->equalFp = fp; - } -} + } +} int32_t taosHashGetSize(const SHashObj *pHashObj) { if (!pHashObj) { @@ -211,9 +213,7 @@ int32_t taosHashGetSize(const SHashObj *pHashObj) { return (int32_t)atomic_load_32(&pHashObj->size); } -static FORCE_INLINE bool taosHashTableEmpty(const SHashObj *pHashObj) { - return taosHashGetSize(pHashObj) == 0; -} +static FORCE_INLINE bool taosHashTableEmpty(const SHashObj *pHashObj) { return taosHashGetSize(pHashObj) == 0; } int32_t taosHashPutImpl(SHashObj *pHashObj, const void *key, size_t keyLen, void *data, size_t size, bool *newAdded) { uint32_t hashVal = (*pHashObj->hashFp)(key, (uint32_t)keyLen); @@ -224,12 +224,12 @@ int32_t taosHashPutImpl(SHashObj *pHashObj, const void *key, size_t keyLen, void // need the resize process, write lock applied if (HASH_NEED_RESIZE(pHashObj)) { - __wr_lock((void*) &pHashObj->lock, pHashObj->type); + __wr_lock((void *)&pHashObj->lock, pHashObj->type); taosHashTableResize(pHashObj); - __wr_unlock((void*) &pHashObj->lock, pHashObj->type); + __wr_unlock((void *)&pHashObj->lock, pHashObj->type); } - __rd_lock((void*) &pHashObj->lock, pHashObj->type); + __rd_lock((void *)&pHashObj->lock, pHashObj->type); int32_t slot = HASH_INDEX(hashVal, pHashObj->capacity); SHashEntry *pe = pHashObj->hashList[slot]; @@ -245,9 +245,10 @@ int32_t taosHashPutImpl(SHashObj *pHashObj, const void *key, size_t keyLen, void assert(pNode == NULL); } - SHashNode* prev = NULL; + SHashNode *prev = NULL; while (pNode) { - if ((pNode->keyLen == keyLen) && ((*(pHashObj->equalFp))(GET_HASH_NODE_KEY(pNode), key, keyLen) == 0) && pNode->removed == 0) { + if ((pNode->keyLen == keyLen) && ((*(pHashObj->equalFp))(GET_HASH_NODE_KEY(pNode), key, keyLen) == 0) && + pNode->removed == 0) { assert(pNode->hashVal == hashVal); break; } @@ -271,13 +272,13 @@ int32_t taosHashPutImpl(SHashObj *pHashObj, const void *key, size_t keyLen, void } // enable resize - __rd_unlock((void*) &pHashObj->lock, pHashObj->type); + __rd_unlock((void *)&pHashObj->lock, pHashObj->type); atomic_add_fetch_32(&pHashObj->size, 1); if (newAdded) { *newAdded = true; } - + return 0; } else { // not support the update operation, return error @@ -292,7 +293,7 @@ int32_t taosHashPutImpl(SHashObj *pHashObj, const void *key, size_t keyLen, void } // enable resize - __rd_unlock((void*) &pHashObj->lock, pHashObj->type); + __rd_unlock((void *)&pHashObj->lock, pHashObj->type); if (newAdded) { *newAdded = false; @@ -310,13 +311,13 @@ int32_t taosHashPutExt(SHashObj *pHashObj, const void *key, size_t keyLen, void return taosHashPutImpl(pHashObj, key, keyLen, data, size, newAdded); } - void *taosHashGet(SHashObj *pHashObj, const void *key, size_t keyLen) { return taosHashGetClone(pHashObj, key, keyLen, NULL); } -//TODO(yihaoDeng), merge with taosHashGetClone -void* taosHashGetCloneExt(SHashObj *pHashObj, const void *key, size_t keyLen, void (*fp)(void *), void** d, size_t *sz) { +// TODO(yihaoDeng), merge with taosHashGetClone +void *taosHashGetCloneExt(SHashObj *pHashObj, const void *key, size_t keyLen, void (*fp)(void *), void **d, + size_t *sz) { if (taosHashTableEmpty(pHashObj) || keyLen == 0 || key == NULL) { return NULL; } @@ -324,14 +325,14 @@ void* taosHashGetCloneExt(SHashObj *pHashObj, const void *key, size_t keyLen, vo uint32_t hashVal = (*pHashObj->hashFp)(key, (uint32_t)keyLen); // only add the read lock to disable the resize process - __rd_lock((void*) &pHashObj->lock, pHashObj->type); + __rd_lock((void *)&pHashObj->lock, pHashObj->type); int32_t slot = HASH_INDEX(hashVal, pHashObj->capacity); SHashEntry *pe = pHashObj->hashList[slot]; // no data, return directly if (atomic_load_32(&pe->num) == 0) { - __rd_unlock((void*) &pHashObj->lock, pHashObj->type); + __rd_unlock((void *)&pHashObj->lock, pHashObj->type); return NULL; } @@ -353,19 +354,19 @@ void* taosHashGetCloneExt(SHashObj *pHashObj, const void *key, size_t keyLen, vo if (fp != NULL) { fp(GET_HASH_NODE_DATA(pNode)); } - + if (*d == NULL) { - *sz = pNode->dataLen + EXT_SIZE; - *d = calloc(1, *sz); - } else if (*sz < pNode->dataLen){ *sz = pNode->dataLen + EXT_SIZE; - *d = realloc(*d, *sz); + *d = calloc(1, *sz); + } else if (*sz < pNode->dataLen) { + *sz = pNode->dataLen + EXT_SIZE; + *d = realloc(*d, *sz); } memcpy((char *)(*d), GET_HASH_NODE_DATA(pNode), pNode->dataLen); - // just make runtime happy + // just make runtime happy if ((*sz) - pNode->dataLen > 0) { memset((char *)(*d) + pNode->dataLen, 0, (*sz) - pNode->dataLen); - } + } data = GET_HASH_NODE_DATA(pNode); } @@ -374,11 +375,11 @@ void* taosHashGetCloneExt(SHashObj *pHashObj, const void *key, size_t keyLen, vo taosRUnLockLatch(&pe->latch); } - __rd_unlock((void*) &pHashObj->lock, pHashObj->type); + __rd_unlock((void *)&pHashObj->lock, pHashObj->type); return data; } -void* taosHashGetCloneImpl(SHashObj *pHashObj, const void *key, size_t keyLen, void* d, bool acquire) { +void *taosHashGetCloneImpl(SHashObj *pHashObj, const void *key, size_t keyLen, void *d, bool acquire) { if (taosHashTableEmpty(pHashObj) || keyLen == 0 || key == NULL) { return NULL; } @@ -386,14 +387,14 @@ void* taosHashGetCloneImpl(SHashObj *pHashObj, const void *key, size_t keyLen, v uint32_t hashVal = (*pHashObj->hashFp)(key, (uint32_t)keyLen); // only add the read lock to disable the resize process - __rd_lock((void*) &pHashObj->lock, pHashObj->type); + __rd_lock((void *)&pHashObj->lock, pHashObj->type); int32_t slot = HASH_INDEX(hashVal, pHashObj->capacity); SHashEntry *pe = pHashObj->hashList[slot]; // no data, return directly if (atomic_load_32(&pe->num) == 0) { - __rd_unlock((void*) &pHashObj->lock, pHashObj->type); + __rd_unlock((void *)&pHashObj->lock, pHashObj->type); return NULL; } @@ -431,20 +432,19 @@ void* taosHashGetCloneImpl(SHashObj *pHashObj, const void *key, size_t keyLen, v taosRUnLockLatch(&pe->latch); } - __rd_unlock((void*) &pHashObj->lock, pHashObj->type); + __rd_unlock((void *)&pHashObj->lock, pHashObj->type); return data; } -void* taosHashGetClone(SHashObj *pHashObj, const void *key, size_t keyLen, void* d) { +void *taosHashGetClone(SHashObj *pHashObj, const void *key, size_t keyLen, void *d) { return taosHashGetCloneImpl(pHashObj, key, keyLen, d, false); } -void* taosHashAcquire(SHashObj *pHashObj, const void *key, size_t keyLen) { +void *taosHashAcquire(SHashObj *pHashObj, const void *key, size_t keyLen) { return taosHashGetCloneImpl(pHashObj, key, keyLen, NULL, true); } - -int32_t taosHashRemove(SHashObj *pHashObj, const void *key, size_t keyLen/*, void *data, size_t dsize*/) { +int32_t taosHashRemove(SHashObj *pHashObj, const void *key, size_t keyLen /*, void *data, size_t dsize*/) { if (pHashObj == NULL || taosHashTableEmpty(pHashObj)) { return -1; } @@ -452,7 +452,7 @@ int32_t taosHashRemove(SHashObj *pHashObj, const void *key, size_t keyLen/*, voi uint32_t hashVal = (*pHashObj->hashFp)(key, (uint32_t)keyLen); // disable the resize process - __rd_lock((void*) &pHashObj->lock, pHashObj->type); + __rd_lock((void *)&pHashObj->lock, pHashObj->type); int32_t slot = HASH_INDEX(hashVal, pHashObj->capacity); SHashEntry *pe = pHashObj->hashList[slot]; @@ -466,23 +466,23 @@ int32_t taosHashRemove(SHashObj *pHashObj, const void *key, size_t keyLen/*, voi assert(pe->next == NULL); taosWUnLockLatch(&pe->latch); - __rd_unlock((void*) &pHashObj->lock, pHashObj->type); + __rd_unlock((void *)&pHashObj->lock, pHashObj->type); return -1; } - int code = -1; + int32_t code = -1; SHashNode *pNode = pe->next; SHashNode *prevNode = NULL; while (pNode) { - if ((pNode->keyLen == keyLen) && ((*(pHashObj->equalFp))(GET_HASH_NODE_KEY(pNode), key, keyLen) == 0) && pNode->removed == 0) + if ((pNode->keyLen == keyLen) && ((*(pHashObj->equalFp))(GET_HASH_NODE_KEY(pNode), key, keyLen) == 0) && + pNode->removed == 0) break; prevNode = pNode; pNode = pNode->next; } - if (pNode) { code = 0; // it is found @@ -495,7 +495,7 @@ int32_t taosHashRemove(SHashObj *pHashObj, const void *key, size_t keyLen/*, voi pe->next = pNode->next; } -// if (data) memcpy(data, GET_HASH_NODE_DATA(pNode), dsize); + // if (data) memcpy(data, GET_HASH_NODE_DATA(pNode), dsize); pe->num--; atomic_sub_fetch_32(&pHashObj->size, 1); @@ -507,7 +507,7 @@ int32_t taosHashRemove(SHashObj *pHashObj, const void *key, size_t keyLen/*, voi taosWUnLockLatch(&pe->latch); } - __rd_unlock((void*) &pHashObj->lock, pHashObj->type); + __rd_unlock((void *)&pHashObj->lock, pHashObj->type); return code; } @@ -518,7 +518,7 @@ int32_t taosHashCondTraverse(SHashObj *pHashObj, bool (*fp)(void *, void *), voi } // disable the resize process - __rd_lock((void*) &pHashObj->lock, pHashObj->type); + __rd_lock((void *)&pHashObj->lock, pHashObj->type); int32_t numOfEntries = (int32_t)pHashObj->capacity; for (int32_t i = 0; i < numOfEntries; ++i) { @@ -533,7 +533,7 @@ int32_t taosHashCondTraverse(SHashObj *pHashObj, bool (*fp)(void *, void *), voi // todo remove the first node SHashNode *pNode = NULL; - while((pNode = pEntry->next) != NULL) { + while ((pNode = pEntry->next) != NULL) { if (fp && (!fp(param, GET_HASH_NODE_DATA(pNode)))) { pEntry->num -= 1; atomic_sub_fetch_32(&pHashObj->size, 1); @@ -582,7 +582,7 @@ int32_t taosHashCondTraverse(SHashObj *pHashObj, bool (*fp)(void *, void *), voi } } - __rd_unlock((void*) &pHashObj->lock, pHashObj->type); + __rd_unlock((void *)&pHashObj->lock, pHashObj->type); return 0; } @@ -593,7 +593,7 @@ void taosHashClear(SHashObj *pHashObj) { SHashNode *pNode, *pNext; - __wr_lock((void*) &pHashObj->lock, pHashObj->type); + __wr_lock((void *)&pHashObj->lock, pHashObj->type); for (int32_t i = 0; i < pHashObj->capacity; ++i) { SHashEntry *pEntry = pHashObj->hashList[i]; @@ -617,7 +617,7 @@ void taosHashClear(SHashObj *pHashObj) { } atomic_store_32(&pHashObj->size, 0); - __wr_unlock((void*) &pHashObj->lock, pHashObj->type); + __wr_unlock((void *)&pHashObj->lock, pHashObj->type); } void taosHashCleanup(SHashObj *pHashObj) { @@ -676,7 +676,7 @@ void taosHashTableResize(SHashObj *pHashObj) { } int64_t st = taosGetTimestampUs(); - void *pNewEntryList = realloc(pHashObj->hashList, sizeof(void *) * newSize); + void *pNewEntryList = realloc(pHashObj->hashList, sizeof(void *) * newSize); if (pNewEntryList == NULL) { // todo handle error // uDebug("cache resize failed due to out of memory, capacity remain:%d", pHashObj->capacity); return; @@ -685,7 +685,7 @@ void taosHashTableResize(SHashObj *pHashObj) { pHashObj->hashList = pNewEntryList; size_t inc = newSize - pHashObj->capacity; - void * p = calloc(inc, sizeof(SHashEntry)); + void *p = calloc(inc, sizeof(SHashEntry)); for (int32_t i = 0; i < inc; ++i) { pHashObj->hashList[i + pHashObj->capacity] = (void *)((char *)p + i * sizeof(SHashEntry)); @@ -756,15 +756,13 @@ void taosHashTableResize(SHashObj *pHashObj) { } else { assert(pe->next != NULL); } - } - } int64_t et = taosGetTimestampUs(); uDebug("hash table resize completed, new capacity:%d, load factor:%f, elapsed time:%fms", (int32_t)pHashObj->capacity, - ((double)pHashObj->size) / pHashObj->capacity, (et - st) / 1000.0); + ((double)pHashObj->size) / pHashObj->capacity, (et - st) / 1000.0); } SHashNode *doCreateHashNode(const void *key, size_t keyLen, const void *pData, size_t dsize, uint32_t hashVal) { @@ -775,12 +773,12 @@ SHashNode *doCreateHashNode(const void *key, size_t keyLen, const void *pData, s return NULL; } - pNewNode->keyLen = (uint32_t)keyLen; + pNewNode->keyLen = (uint32_t)keyLen; pNewNode->hashVal = hashVal; - pNewNode->dataLen = (uint32_t) dsize; - pNewNode->count = 1; + pNewNode->dataLen = (uint32_t)dsize; + pNewNode->count = 1; pNewNode->removed = 0; - pNewNode->next = NULL; + pNewNode->next = NULL; memcpy(GET_HASH_NODE_DATA(pNewNode), pData, dsize); memcpy(GET_HASH_NODE_KEY(pNewNode), key, keyLen); @@ -802,15 +800,16 @@ size_t taosHashGetMemSize(const SHashObj *pHashObj) { return 0; } - return (pHashObj->capacity * (sizeof(SHashEntry) + POINTER_BYTES)) + sizeof(SHashNode) * taosHashGetSize(pHashObj) + sizeof(SHashObj); + return (pHashObj->capacity * (sizeof(SHashEntry) + POINTER_BYTES)) + sizeof(SHashNode) * taosHashGetSize(pHashObj) + + sizeof(SHashObj); } -FORCE_INLINE int32_t taosHashGetKey(void *data, void** key, size_t* keyLen) { +FORCE_INLINE int32_t taosHashGetKey(void *data, void **key, size_t *keyLen) { if (NULL == data || NULL == key) { return -1; } - - SHashNode * node = GET_HASH_PNODE(data); + + SHashNode *node = GET_HASH_PNODE(data); *key = GET_HASH_NODE_KEY(node); if (keyLen) { *keyLen = node->keyLen; @@ -820,19 +819,17 @@ FORCE_INLINE int32_t taosHashGetKey(void *data, void** key, size_t* keyLen) { } FORCE_INLINE int32_t taosHashGetDataLen(void *data) { - SHashNode * node = GET_HASH_PNODE(data); + SHashNode *node = GET_HASH_PNODE(data); return node->keyLen; } FORCE_INLINE uint32_t taosHashGetDataKeyLen(SHashObj *pHashObj, void *data) { - SHashNode * node = GET_HASH_PNODE(data); + SHashNode *node = GET_HASH_PNODE(data); return node->keyLen; } - // release the pNode, return next pNode, and lock the current entry -static void *taosHashReleaseNode(SHashObj *pHashObj, void *p, int *slot) { - +static void *taosHashReleaseNode(SHashObj *pHashObj, void *p, int32_t *slot) { SHashNode *pOld = (SHashNode *)GET_HASH_PNODE(p); SHashNode *prevNode = NULL; @@ -847,14 +844,13 @@ static void *taosHashReleaseNode(SHashObj *pHashObj, void *p, int *slot) { SHashNode *pNode = pe->next; while (pNode) { - if (pNode == pOld) - break; + if (pNode == pOld) break; prevNode = pNode; pNode = pNode->next; } - if (pNode) { + if (pNode) { pNode = pNode->next; while (pNode) { if (pNode->removed == 0) break; @@ -862,17 +858,17 @@ static void *taosHashReleaseNode(SHashObj *pHashObj, void *p, int *slot) { } pOld->count--; - if (pOld->count <=0) { + if (pOld->count <= 0) { if (prevNode) { prevNode->next = pOld->next; } else { pe->next = pOld->next; } - + pe->num--; atomic_sub_fetch_32(&pHashObj->size, 1); FREE_HASH_NODE(pHashObj, pOld); - } + } } else { uError("pNode:%p data:%p is not there!!!", pNode, p); } @@ -881,13 +877,13 @@ static void *taosHashReleaseNode(SHashObj *pHashObj, void *p, int *slot) { } void *taosHashIterate(SHashObj *pHashObj, void *p) { - if (pHashObj == NULL) return NULL; + if (pHashObj == NULL) return NULL; - int slot = 0; + int32_t slot = 0; char *data = NULL; // only add the read lock to disable the resize process - __rd_lock((void*) &pHashObj->lock, pHashObj->type); + __rd_lock((void *)&pHashObj->lock, pHashObj->type); SHashNode *pNode = NULL; if (p) { @@ -896,7 +892,7 @@ void *taosHashIterate(SHashObj *pHashObj, void *p) { SHashEntry *pe = pHashObj->hashList[slot]; if (pHashObj->type == HASH_ENTRY_LOCK) { taosWUnLockLatch(&pe->latch); - } + } slot = slot + 1; } @@ -921,7 +917,7 @@ void *taosHashIterate(SHashObj *pHashObj, void *p) { if (pHashObj->type == HASH_ENTRY_LOCK) { taosWUnLockLatch(&pe->latch); - } + } } } @@ -947,10 +943,10 @@ void *taosHashIterate(SHashObj *pHashObj, void *p) { if (pHashObj->type == HASH_ENTRY_LOCK) { taosWUnLockLatch(&pe->latch); - } + } } - __rd_unlock((void*) &pHashObj->lock, pHashObj->type); + __rd_unlock((void *)&pHashObj->lock, pHashObj->type); return data; } @@ -958,21 +954,17 @@ void taosHashCancelIterate(SHashObj *pHashObj, void *p) { if (pHashObj == NULL || p == NULL) return; // only add the read lock to disable the resize process - __rd_lock((void*) &pHashObj->lock, pHashObj->type); + __rd_lock((void *)&pHashObj->lock, pHashObj->type); - int slot; + int32_t slot; taosHashReleaseNode(pHashObj, p, &slot); SHashEntry *pe = pHashObj->hashList[slot]; if (pHashObj->type == HASH_ENTRY_LOCK) { taosWUnLockLatch(&pe->latch); - } + } - __rd_unlock((void*) &pHashObj->lock, pHashObj->type); + __rd_unlock((void *)&pHashObj->lock, pHashObj->type); } -void taosHashRelease(SHashObj *pHashObj, void *p) { - taosHashCancelIterate(pHashObj, p); -} - - +void taosHashRelease(SHashObj *pHashObj, void *p) { taosHashCancelIterate(pHashObj, p); }