From 49a0daf03d706cc9be4b256926309adc1e5b5a2b Mon Sep 17 00:00:00 2001 From: kailixu Date: Fri, 13 Dec 2024 15:31:57 +0800 Subject: [PATCH 1/5] chore: test CI --- tests/system-test/0-others/grant.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tests/system-test/0-others/grant.py b/tests/system-test/0-others/grant.py index 9e54d9ca37..b5c77937ef 100644 --- a/tests/system-test/0-others/grant.py +++ b/tests/system-test/0-others/grant.py @@ -186,7 +186,8 @@ class TDTestCase: raise Exception(repr(e)) finally: if infoFile: - infoFile.close() + infoFile.flush() + # close() def s3_check_show_grants_granted(self): tdLog.printNoPrefix("======== test show grants granted: ") From b58620cedfdab5bb591fb973989ff41da845f15f Mon Sep 17 00:00:00 2001 From: kailixu Date: Fri, 13 Dec 2024 15:34:19 +0800 Subject: [PATCH 2/5] chore: test CI --- Jenkinsfile2 | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Jenkinsfile2 b/Jenkinsfile2 index 249a8d1c9d..55384a0d76 100644 --- a/Jenkinsfile2 +++ b/Jenkinsfile2 @@ -505,7 +505,7 @@ pipeline { } } stage('linux test') { - agent{label "slave1_47 || slave1_48 || slave1_49 || slave1_50 || slave1_52 || slave1_59 || slave1_63 || worker03 || slave215 || slave217 || slave219 "} + agent{label "slave1_47 || slave1_48 || slave1_49 || slave1_50 || slave1_52 || slave1_59 || slave1_63"} options { skipDefaultCheckout() } when { changeRequest() From 1509df2e91dabd7bf38e6e1a729e0a5874517152 Mon Sep 17 00:00:00 2001 From: kailixu Date: Fri, 13 Dec 2024 15:56:49 +0800 Subject: [PATCH 3/5] chore: remove asserts of mempool --- Jenkinsfile2 | 2 +- source/util/inc/tmempoolInt.h | 500 +++++++++++++--------------- source/util/src/tmempool.c | 2 +- tests/system-test/0-others/grant.py | 3 +- 4 files changed, 243 insertions(+), 264 deletions(-) diff --git a/Jenkinsfile2 b/Jenkinsfile2 index 55384a0d76..249a8d1c9d 100644 --- a/Jenkinsfile2 +++ b/Jenkinsfile2 @@ -505,7 +505,7 @@ pipeline { } } stage('linux test') { - agent{label "slave1_47 || slave1_48 || slave1_49 || slave1_50 || slave1_52 || slave1_59 || slave1_63"} + agent{label "slave1_47 || slave1_48 || slave1_49 || slave1_50 || slave1_52 || slave1_59 || slave1_63 || worker03 || slave215 || slave217 || slave219 "} options { skipDefaultCheckout() } when { changeRequest() diff --git a/source/util/inc/tmempoolInt.h b/source/util/inc/tmempoolInt.h index 183ce3ee04..8d4cb57ddc 100755 --- a/source/util/inc/tmempoolInt.h +++ b/source/util/inc/tmempoolInt.h @@ -21,60 +21,56 @@ extern "C" { #endif #include "os.h" -#include "tlockfree.h" -#include "thash.h" #include "tglobal.h" +#include "thash.h" +#include "tlockfree.h" -#define MP_CHUNK_CACHE_ALLOC_BATCH_SIZE 1000 +#define MP_CHUNK_CACHE_ALLOC_BATCH_SIZE 1000 #define MP_NSCHUNK_CACHE_ALLOC_BATCH_SIZE 500 #define MP_SESSION_CACHE_ALLOC_BATCH_SIZE 100 -#define MP_MAX_KEEP_FREE_CHUNK_NUM 1000 -#define MP_MAX_MALLOC_MEM_SIZE 0xFFFFFFFFFF +#define MP_MAX_KEEP_FREE_CHUNK_NUM 1000 +#define MP_MAX_MALLOC_MEM_SIZE 0xFFFFFFFFFF -#define MP_DEFAULT_MEM_CHK_INTERVAL_MS 10 -#define MP_MIN_MEM_CHK_INTERVAL_MS 1 -#define MP_MEMORY_TRIM_INTERVAL_TIMES 500 +#define MP_DEFAULT_MEM_CHK_INTERVAL_MS 10 +#define MP_MIN_MEM_CHK_INTERVAL_MS 1 +#define MP_MEMORY_TRIM_INTERVAL_TIMES 500 - -#define MP_RETIRE_HIGH_THRESHOLD_PERCENT (0.95) -#define MP_RETIRE_MID_THRESHOLD_PERCENT (0.9) -#define MP_RETIRE_LOW_THRESHOLD_PERCENT (0.85) -#define MP_RETIRE_UNIT_PERCENT (0.1) -#define MP_RETIRE_UNIT_MIN_SIZE (50 * 1048576L) -#define MP_CFG_UPDATE_MIN_RESERVE_SIZE (50 * 1024 * 1048576L) +#define MP_RETIRE_HIGH_THRESHOLD_PERCENT (0.95) +#define MP_RETIRE_MID_THRESHOLD_PERCENT (0.9) +#define MP_RETIRE_LOW_THRESHOLD_PERCENT (0.85) +#define MP_RETIRE_UNIT_PERCENT (0.1) +#define MP_RETIRE_UNIT_MIN_SIZE (50 * 1048576L) +#define MP_CFG_UPDATE_MIN_RESERVE_SIZE (50 * 1024 * 1048576L) #define MP_DEFAULT_RESERVE_MEM_PERCENT 20 #define MP_MIN_FREE_SIZE_AFTER_RESERVE (4 * 1024 * 1048576L) #define MP_MIN_MEM_POOL_SIZE (5 * 1024 * 1048576L) - // FLAGS AREA #define MP_CHUNK_FLAG_IN_USE (1 << 0) #define MP_CHUNK_FLAG_NS_CHUNK (1 << 1) - // STAT FLAGS -#define MP_LOG_FLAG_ALL_MEM (1 << 0) -#define MP_LOG_FLAG_ALL_CHUNK (1 << 1) -#define MP_LOG_FLAG_ALL_POS (1 << 2) +#define MP_LOG_FLAG_ALL_MEM (1 << 0) +#define MP_LOG_FLAG_ALL_CHUNK (1 << 1) +#define MP_LOG_FLAG_ALL_POS (1 << 2) #define MP_LOG_FLAG_ALL_SESSION (1 << 3) -#define MP_LOG_FLAG_ALL_NODE (1 << 4) -#define MP_LOG_FLAG_ALL_POOL (1 << 5) +#define MP_LOG_FLAG_ALL_NODE (1 << 4) +#define MP_LOG_FLAG_ALL_POOL (1 << 5) -#define MP_LOG_FLAG_SOME_POS (1 << 6) +#define MP_LOG_FLAG_SOME_POS (1 << 6) #define MP_LOG_FLAG_SOME_SESSION (1 << 7) -#define MP_LOG_FLAG_SOME_NODE (1 << 8) -#define MP_LOG_FLAG_SOME_POOL (1 << 9) - -#define MP_STAT_FLAG_LOG_ALL (0xFFFFFFFFFFFFFFFF) +#define MP_LOG_FLAG_SOME_NODE (1 << 8) +#define MP_LOG_FLAG_SOME_POOL (1 << 9) +#define MP_STAT_FLAG_LOG_ALL (0xFFFFFFFFFFFFFFFF) // STAT PROCESURE FLAGS -#define MP_STAT_PROC_FLAG_EXEC (1 << 0) +#define MP_STAT_PROC_FLAG_EXEC (1 << 0) #define MP_STAT_PROC_FLAG_INPUT_ERR (1 << 1) -#define MP_STAT_PROC_FLAG_RES_SUCC (1 << 2) -#define MP_STAT_PROC_FLAG_RES_FAIL (1 << 3) +#define MP_STAT_PROC_FLAG_RES_SUCC (1 << 2) +#define MP_STAT_PROC_FLAG_RES_FAIL (1 << 3) // CTRL FUNC FLAGS #define MP_CTRL_FLAG_PRINT_STAT (1 << 0) @@ -82,7 +78,6 @@ extern "C" { #define MP_CTRL_FLAG_LOCK_DBG (1 << 2) #define MP_CTRL_FLAG_LOG_MAXSIZE (1 << 3) - typedef enum EMPStatLogItem { E_MP_STAT_LOG_MEM_MALLOC = 1, E_MP_STAT_LOG_MEM_CALLOC, @@ -91,10 +86,10 @@ typedef enum EMPStatLogItem { E_MP_STAT_LOG_MEM_STRDUP, E_MP_STAT_LOG_MEM_STRNDUP, E_MP_STAT_LOG_MEM_TRIM, - - E_MP_STAT_LOG_CHUNK_MALLOC, - E_MP_STAT_LOG_CHUNK_RECYCLE, - E_MP_STAT_LOG_CHUNK_REUSE, + + E_MP_STAT_LOG_CHUNK_MALLOC, + E_MP_STAT_LOG_CHUNK_RECYCLE, + E_MP_STAT_LOG_CHUNK_REUSE, E_MP_STAT_LOG_CHUNK_FREE, } EMPStatLogItem; @@ -102,8 +97,8 @@ typedef enum EMPStatLogItem { #define MP_MEM_HEADER_FLAG_NS_CHUNK (1 << 0) typedef struct SMPMemHeader { - uint64_t flags:24; - uint64_t size:40; + uint64_t flags : 24; + uint64_t size : 40; } SMPMemHeader; typedef struct SMPMemTailer { @@ -111,13 +106,13 @@ typedef struct SMPMemTailer { } SMPMemTailer; typedef struct SMPListNode { - void *pNext; + void* pNext; } SMPListNode; typedef struct SMPChunk { SMPListNode list; - char *pMemStart; - int32_t flags; + char* pMemStart; + int32_t flags; /* KEEP ABOVE SAME WITH SMPNSChunk */ uint32_t offset; @@ -125,36 +120,34 @@ typedef struct SMPChunk { typedef struct SMPNSChunk { SMPListNode list; - char *pMemStart; - int32_t flags; + char* pMemStart; + int32_t flags; /* KEEP ABOVE SAME WITH SMPChunk */ uint64_t offset; uint64_t memBytes; } SMPNSChunk; - typedef struct SMPCacheGroup { - int32_t nodesNum; - int32_t idleOffset; - void *pNodes; - void* pNext; + int32_t nodesNum; + int32_t idleOffset; + void* pNodes; + void* pNext; } SMPCacheGroup; typedef struct SMPStatInput { - char* file; - int64_t size; - int64_t origSize; - int32_t procFlags; - int32_t line; - void* pMem; - void* pOrigMem; + char* file; + int64_t size; + int64_t origSize; + int32_t procFlags; + int32_t line; + void* pMem; + void* pOrigMem; } SMPStatInput; - typedef struct SMPCtrlInfo { - int64_t statFlags; - int64_t funcFlags; + int64_t statFlags; + int64_t funcFlags; } SMPCtrlInfo; typedef struct SMPStatSession { @@ -166,7 +159,7 @@ typedef struct SMPStatSession { typedef struct SMPAllocStat { int64_t allocTimes; int64_t allocBytes; - //int64_t freeIDs[]; // TODO + // int64_t freeIDs[]; // TODO } SMPAllocStat; typedef struct SMPFreeStat { @@ -175,21 +168,21 @@ typedef struct SMPFreeStat { } SMPFreeStat; typedef struct SMPFileLineId { - uint32_t fileId; - int32_t line; + uint32_t fileId; + int32_t line; } SMPFileLineId; typedef struct SMPFileLine { SMPFileLineId fl; - int64_t size; + int64_t size; } SMPFileLine; typedef struct SMPStatPos { - int64_t logErrTimes; - SHashObj* fileHash; // fileId => fileName - SHashObj* remainHash; // pointer => SMPFileLine - SHashObj* allocHash; // alloc fl => SMPAllocStat - SHashObj* freeHash; // free fl => SMPFreeStat + int64_t logErrTimes; + SHashObj* fileHash; // fileId => fileName + SHashObj* remainHash; // pointer => SMPFileLine + SHashObj* allocHash; // alloc fl => SMPAllocStat + SHashObj* freeHash; // free fl => SMPFreeStat } SMPStatPos; typedef struct SMPStatInfo { @@ -200,99 +193,97 @@ typedef struct SMPStatInfo { SMPStatPos posStat; } SMPStatInfo; - typedef struct SMPJob { - SMemPoolJob job; // KEEP IT FIRST - SMPStatInfo stat; + SMemPoolJob job; // KEEP IT FIRST + SMPStatInfo stat; } SMPJob; typedef struct SMPSessionChunk { - int64_t allocChunkNum; - int64_t allocChunkMemSize; - int64_t reUseChunkNum; - - int32_t srcChunkNum; - SMPChunk *srcChunkHead; - SMPChunk *srcChunkTail; + int64_t allocChunkNum; + int64_t allocChunkMemSize; + int64_t reUseChunkNum; - int32_t inUseChunkNum; - SMPChunk *inUseChunkHead; - SMPChunk *inUseChunkTail; + int32_t srcChunkNum; + SMPChunk* srcChunkHead; + SMPChunk* srcChunkTail; - SMPNSChunk *inUseNSChunkHead; - SMPNSChunk *inUseNSChunkTail; + int32_t inUseChunkNum; + SMPChunk* inUseChunkHead; + SMPChunk* inUseChunkTail; - SMPChunk *reUseChunkHead; - SMPChunk *reUseChunkTail; + SMPNSChunk* inUseNSChunkHead; + SMPNSChunk* inUseNSChunkTail; - SMPNSChunk *reUseNSChunkHead; - SMPNSChunk *reUseNSChunkTail; + SMPChunk* reUseChunkHead; + SMPChunk* reUseChunkTail; + + SMPNSChunk* reUseNSChunkHead; + SMPNSChunk* reUseNSChunkTail; } SMPSessionChunk; typedef struct SMPSession { - //SMPListNode list; + // SMPListNode list; - char* sessionId; - SMPJob* pJob; - SMPCtrlInfo ctrl; - int64_t allocMemSize; - int64_t maxAllocMemSize; + char* sessionId; + SMPJob* pJob; + SMPCtrlInfo ctrl; + int64_t allocMemSize; + int64_t maxAllocMemSize; - //SMPSessionChunk chunk; + // SMPSessionChunk chunk; - SMPStatInfo stat; -} SMPSession; + SMPStatInfo stat; +} SMPSession; typedef struct SMPCacheGroupInfo { - int16_t nodeSize; - int64_t allocNum; - int32_t groupNum; - SMPCacheGroup *pGrpHead; - void *pIdleList; + int16_t nodeSize; + int64_t allocNum; + int32_t groupNum; + SMPCacheGroup* pGrpHead; + void* pIdleList; } SMPCacheGroupInfo; typedef struct SMPChunkMgmt { - int32_t maxChunkNum; - int16_t maxDiscardSize; - double threadChunkReserveNum; - int64_t allocChunkNum; - int64_t allocChunkSize; - int64_t allocNSChunkNum; - int64_t allocNSChunkSize; + int32_t maxChunkNum; + int16_t maxDiscardSize; + double threadChunkReserveNum; + int64_t allocChunkNum; + int64_t allocChunkSize; + int64_t allocNSChunkNum; + int64_t allocNSChunkSize; - SMPCacheGroupInfo chunkCache; - SMPCacheGroupInfo NSChunkCache; - - int32_t readyChunkNum; - int32_t readyChunkReserveNum; - int32_t readyChunkLowNum; - int32_t readyChunkGotNum; - SRWLatch readyChunkLock; - SMPChunk *readyChunkHead; - SMPChunk *readyChunkTail; + SMPCacheGroupInfo chunkCache; + SMPCacheGroupInfo NSChunkCache; - int64_t readyNSChunkNum; - SMPChunk *readyNSChunkHead; - SMPChunk *readyNSChunkTail; + int32_t readyChunkNum; + int32_t readyChunkReserveNum; + int32_t readyChunkLowNum; + int32_t readyChunkGotNum; + SRWLatch readyChunkLock; + SMPChunk* readyChunkHead; + SMPChunk* readyChunkTail; + + int64_t readyNSChunkNum; + SMPChunk* readyNSChunkHead; + SMPChunk* readyNSChunkTail; } SMPChunkMgmt; - typedef struct SMemPool { - char *name; - int16_t slotId; - SRWLatch cfgLock; - SMemPoolCfg cfg; - //int64_t retireThreshold[3]; - int64_t retireUnit; + char* name; + int16_t slotId; + SRWLatch cfgLock; + SMemPoolCfg cfg; + // int64_t retireThreshold[3]; + int64_t retireUnit; - int64_t maxAllocMemSize; - int64_t allocMemSize; + int64_t maxAllocMemSize; + int64_t allocMemSize; - SMPCacheGroupInfo sessionCache; + SMPCacheGroupInfo sessionCache; - SMPChunkMgmt chunk; + SMPChunkMgmt chunk; - SMPStatInfo stat; + SMPStatInfo stat; } SMemPool; typedef enum EMPMemStrategy { @@ -322,11 +313,10 @@ typedef struct SMemPoolMgmt { extern SMemPoolMgmt gMPMgmt; - typedef int32_t (*mpAllocFunc)(SMemPool*, SMPSession*, int64_t*, uint32_t, void**); -typedef void (*mpFreeFunc)(SMemPool*, SMPSession*, void *, int64_t*); +typedef void (*mpFreeFunc)(SMemPool*, SMPSession*, void*, int64_t*); typedef int64_t (*mpGetSizeFunc)(SMemPool*, SMPSession*, void*); -typedef int32_t (*mpReallocFunc)(SMemPool*, SMPSession*, void **, int64_t*, int64_t*); +typedef int32_t (*mpReallocFunc)(SMemPool*, SMPSession*, void**, int64_t*, int64_t*); typedef int32_t (*mpInitSessionFunc)(SMemPool*, SMPSession*); typedef int32_t (*mpInitFunc)(SMemPool*, char*, SMemPoolCfg*); typedef int32_t (*mpUpdateCfgFunc)(SMemPool*); @@ -352,110 +342,101 @@ enum { MP_WRITE, }; -#define MP_STAT_FORMAT "%-8s => inErr:%10" PRId64 ", exec:%12" PRId64 ", succ:%12" PRId64 ", fail:%12" PRId64 -#define MP_STAT_ORIG_FORMAT "%-8s => inErr:%10" PRId64 ", exec:%12" PRId64 ", succ:%12" PRId64 ", fail:%12" PRId64 ", oExec:%12" PRId64 ", oSucc:%12" PRId64 ", oFail:%12" PRId64 +#define MP_STAT_FORMAT "%-8s => inErr:%10" PRId64 ", exec:%12" PRId64 ", succ:%12" PRId64 ", fail:%12" PRId64 +#define MP_STAT_ORIG_FORMAT \ + "%-8s => inErr:%10" PRId64 ", exec:%12" PRId64 ", succ:%12" PRId64 ", fail:%12" PRId64 ", oExec:%12" PRId64 \ + ", oSucc:%12" PRId64 ", oFail:%12" PRId64 #define MP_STAT_VALUE(_name, _item) _name, (_item).inErr, (_item).exec, (_item).succ, (_item).fail -#define MP_STAT_ORIG_VALUE(_name, _item) _name, (_item).inErr, (_item).exec, (_item).succ, (_item).fail, (_item).origExec, (_item).origSucc, (_item).origFail +#define MP_STAT_ORIG_VALUE(_name, _item) \ + _name, (_item).inErr, (_item).exec, (_item).succ, (_item).fail, (_item).origExec, (_item).origSucc, (_item).origFail -#define MP_INIT_MEM_HEADER(_header, _size, _nsChunk) \ - do { \ - (_header)->size = _size; \ - if (_nsChunk) { \ - MP_SET_FLAG((_header)->flags, MP_MEM_HEADER_FLAG_NS_CHUNK); \ - } \ +#define MP_INIT_MEM_HEADER(_header, _size, _nsChunk) \ + do { \ + (_header)->size = _size; \ + if (_nsChunk) { \ + MP_SET_FLAG((_header)->flags, MP_MEM_HEADER_FLAG_NS_CHUNK); \ + } \ } while (0) -#define MP_ADD_TO_CHUNK_LIST(_chunkHead, _chunkTail, _chunkNum, _chunk) \ - do { \ - if (NULL == _chunkHead) { \ - _chunkHead = _chunk; \ - _chunkTail = _chunk; \ - } else { \ - (_chunkTail)->list.pNext = _chunk; \ - (_chunkTail) = _chunk; \ - } \ - (_chunkNum)++; \ +#define MP_ADD_TO_CHUNK_LIST(_chunkHead, _chunkTail, _chunkNum, _chunk) \ + do { \ + if (NULL == _chunkHead) { \ + _chunkHead = _chunk; \ + _chunkTail = _chunk; \ + } else { \ + (_chunkTail)->list.pNext = _chunk; \ + (_chunkTail) = _chunk; \ + } \ + (_chunkNum)++; \ } while (0) #define TD_RWLATCH_WRITE_FLAG_COPY 0x40000000 -#define MP_TRY_LOCK(type, _lock, _res) \ - do { \ - if (MP_READ == (type)) { \ - if (MP_GET_FLAG(gMPMgmt.ctrl.funcFlags, MP_CTRL_FLAG_LOCK_DBG)) { \ - ASSERTS(atomic_load_32((_lock)) >= 0, "invalid lock value before try read lock"); \ - uDebug("MP TRY RLOCK%p:%d, %s:%d B", (_lock), atomic_load_32(_lock), __FILE__, __LINE__); \ - } \ - (_res) = taosRTryLockLatch(_lock); \ - if (MP_GET_FLAG(gMPMgmt.ctrl.funcFlags, MP_CTRL_FLAG_LOCK_DBG)) { \ - uDebug("MP TRY RLOCK%p:%d %s, %s:%d E", (_lock), atomic_load_32(_lock), (_res) ? "failed" : "succeed", __FILE__, __LINE__); \ - ASSERTS((_res) ? atomic_load_32((_lock)) >= 0 : atomic_load_32((_lock)) > 0, "invalid lock value after try read lock"); \ - } \ - } else { \ - if (MP_GET_FLAG(gMPMgmt.ctrl.funcFlags, MP_CTRL_FLAG_LOCK_DBG)) { \ - ASSERTS(atomic_load_32((_lock)) >= 0, "invalid lock value before try write lock"); \ - uDebug("MP TRY WLOCK%p:%d, %s:%d B", (_lock), atomic_load_32(_lock), __FILE__, __LINE__); \ - } \ - (_res) = taosWTryLockLatch(_lock); \ - if (MP_GET_FLAG(gMPMgmt.ctrl.funcFlags, MP_CTRL_FLAG_LOCK_DBG)) { \ - uDebug("MP TRY WLOCK%p:%d %s, %s:%d E", (_lock), atomic_load_32(_lock), (_res) ? "failed" : "succeed", __FILE__, __LINE__); \ - ASSERTS((_res) ? atomic_load_32((_lock)) >= 0 : atomic_load_32((_lock)) == TD_RWLATCH_WRITE_FLAG_COPY, "invalid lock value after try write lock"); \ - } \ - } \ - } while (0) - - -#define MP_LOCK(type, _lock) \ - do { \ - if (MP_READ == (type)) { \ - if (MP_GET_FLAG(gMPMgmt.ctrl.funcFlags, MP_CTRL_FLAG_LOCK_DBG)) { \ - ASSERTS(atomic_load_32((_lock)) >= 0, "invalid lock value before read lock"); \ - uDebug("MP RLOCK%p:%d, %s:%d B", (_lock), atomic_load_32(_lock), __FILE__, __LINE__); \ - } \ - taosRLockLatch(_lock); \ - if (MP_GET_FLAG(gMPMgmt.ctrl.funcFlags, MP_CTRL_FLAG_LOCK_DBG)) { \ - uDebug("MP RLOCK%p:%d, %s:%d E", (_lock), atomic_load_32(_lock), __FILE__, __LINE__); \ - ASSERTS(atomic_load_32((_lock)) > 0, "invalid lock value after read lock"); \ - } \ - } else { \ - if (MP_GET_FLAG(gMPMgmt.ctrl.funcFlags, MP_CTRL_FLAG_LOCK_DBG)) { \ - ASSERTS(atomic_load_32((_lock)) >= 0, "invalid lock value before write lock"); \ - uDebug("MP WLOCK%p:%d, %s:%d B", (_lock), atomic_load_32(_lock), __FILE__, __LINE__); \ - } \ - taosWLockLatch(_lock); \ - if (MP_GET_FLAG(gMPMgmt.ctrl.funcFlags, MP_CTRL_FLAG_LOCK_DBG)) { \ - uDebug("MP WLOCK%p:%d, %s:%d E", (_lock), atomic_load_32(_lock), __FILE__, __LINE__); \ - ASSERTS(atomic_load_32((_lock)) == TD_RWLATCH_WRITE_FLAG_COPY, "invalid lock value after write lock"); \ - } \ - } \ - } while (0) - -#define MP_UNLOCK(type, _lock) \ - do { \ +#define MP_TRY_LOCK(type, _lock, _res) \ + do { \ if (MP_READ == (type)) { \ - if (MP_GET_FLAG(gMPMgmt.ctrl.funcFlags, MP_CTRL_FLAG_LOCK_DBG)) { \ - ASSERTS(atomic_load_32((_lock)) > 0, "invalid lock value before read unlock"); \ - uDebug("MP RULOCK%p:%d, %s:%d B", (_lock), atomic_load_32(_lock), __FILE__, __LINE__); \ - } \ - taosRUnLockLatch(_lock); \ - if (MP_GET_FLAG(gMPMgmt.ctrl.funcFlags, MP_CTRL_FLAG_LOCK_DBG)) { \ - uDebug("MP RULOCK%p:%d, %s:%d E", (_lock), atomic_load_32(_lock), __FILE__, __LINE__); \ - ASSERTS(atomic_load_32((_lock)) >= 0, "invalid lock value after read unlock"); \ - } \ - } else { \ - if (MP_GET_FLAG(gMPMgmt.ctrl.funcFlags, MP_CTRL_FLAG_LOCK_DBG)) { \ - ASSERTS(atomic_load_32((_lock)) == TD_RWLATCH_WRITE_FLAG_COPY, "invalid lock value before write unlock"); \ - uDebug("MP WULOCK%p:%d, %s:%d B", (_lock), atomic_load_32(_lock), __FILE__, __LINE__); \ - } \ - taosWUnLockLatch(_lock); \ - if (MP_GET_FLAG(gMPMgmt.ctrl.funcFlags, MP_CTRL_FLAG_LOCK_DBG)) { \ - uDebug("MP WULOCK%p:%d, %s:%d E", (_lock), atomic_load_32(_lock), __FILE__, __LINE__); \ - ASSERTS(atomic_load_32((_lock)) >= 0, "invalid lock value after write unlock"); \ - } \ - } \ + if (MP_GET_FLAG(gMPMgmt.ctrl.funcFlags, MP_CTRL_FLAG_LOCK_DBG)) { \ + uDebug("MP TRY RLOCK%p:%d, %s:%d B", (_lock), atomic_load_32(_lock), __FILE__, __LINE__); \ + } \ + (_res) = taosRTryLockLatch(_lock); \ + if (MP_GET_FLAG(gMPMgmt.ctrl.funcFlags, MP_CTRL_FLAG_LOCK_DBG)) { \ + uDebug("MP TRY RLOCK%p:%d %s, %s:%d E", (_lock), atomic_load_32(_lock), (_res) ? "failed" : "succeed", \ + __FILE__, __LINE__); \ + } \ + } else { \ + if (MP_GET_FLAG(gMPMgmt.ctrl.funcFlags, MP_CTRL_FLAG_LOCK_DBG)) { \ + uDebug("MP TRY WLOCK%p:%d, %s:%d B", (_lock), atomic_load_32(_lock), __FILE__, __LINE__); \ + } \ + (_res) = taosWTryLockLatch(_lock); \ + if (MP_GET_FLAG(gMPMgmt.ctrl.funcFlags, MP_CTRL_FLAG_LOCK_DBG)) { \ + uDebug("MP TRY WLOCK%p:%d %s, %s:%d E", (_lock), atomic_load_32(_lock), (_res) ? "failed" : "succeed", \ + __FILE__, __LINE__); \ + } \ + } \ } while (0) +#define MP_LOCK(type, _lock) \ + do { \ + if (MP_READ == (type)) { \ + if (MP_GET_FLAG(gMPMgmt.ctrl.funcFlags, MP_CTRL_FLAG_LOCK_DBG)) { \ + uDebug("MP RLOCK%p:%d, %s:%d B", (_lock), atomic_load_32(_lock), __FILE__, __LINE__); \ + } \ + taosRLockLatch(_lock); \ + if (MP_GET_FLAG(gMPMgmt.ctrl.funcFlags, MP_CTRL_FLAG_LOCK_DBG)) { \ + uDebug("MP RLOCK%p:%d, %s:%d E", (_lock), atomic_load_32(_lock), __FILE__, __LINE__); \ + } \ + } else { \ + if (MP_GET_FLAG(gMPMgmt.ctrl.funcFlags, MP_CTRL_FLAG_LOCK_DBG)) { \ + uDebug("MP WLOCK%p:%d, %s:%d B", (_lock), atomic_load_32(_lock), __FILE__, __LINE__); \ + } \ + taosWLockLatch(_lock); \ + if (MP_GET_FLAG(gMPMgmt.ctrl.funcFlags, MP_CTRL_FLAG_LOCK_DBG)) { \ + uDebug("MP WLOCK%p:%d, %s:%d E", (_lock), atomic_load_32(_lock), __FILE__, __LINE__); \ + } \ + } \ + } while (0) + +#define MP_UNLOCK(type, _lock) \ + do { \ + if (MP_READ == (type)) { \ + if (MP_GET_FLAG(gMPMgmt.ctrl.funcFlags, MP_CTRL_FLAG_LOCK_DBG)) { \ + uDebug("MP RULOCK%p:%d, %s:%d B", (_lock), atomic_load_32(_lock), __FILE__, __LINE__); \ + } \ + taosRUnLockLatch(_lock); \ + if (MP_GET_FLAG(gMPMgmt.ctrl.funcFlags, MP_CTRL_FLAG_LOCK_DBG)) { \ + uDebug("MP RULOCK%p:%d, %s:%d E", (_lock), atomic_load_32(_lock), __FILE__, __LINE__); \ + } \ + } else { \ + if (MP_GET_FLAG(gMPMgmt.ctrl.funcFlags, MP_CTRL_FLAG_LOCK_DBG)) { \ + uDebug("MP WULOCK%p:%d, %s:%d B", (_lock), atomic_load_32(_lock), __FILE__, __LINE__); \ + } \ + taosWUnLockLatch(_lock); \ + if (MP_GET_FLAG(gMPMgmt.ctrl.funcFlags, MP_CTRL_FLAG_LOCK_DBG)) { \ + uDebug("MP WULOCK%p:%d, %s:%d E", (_lock), atomic_load_32(_lock), __FILE__, __LINE__); \ + } \ + } \ + } while (0) #define MP_ERR_RET(c) \ do { \ @@ -465,7 +446,7 @@ enum { return _code; \ } \ } while (0) - + #define MP_RET(c) \ do { \ int32_t _code = c; \ @@ -474,7 +455,7 @@ enum { } \ return _code; \ } while (0) - + #define MP_ERR_JRET(c) \ do { \ code = c; \ @@ -484,55 +465,56 @@ enum { } \ } while (0) -#define MP_CHECK_QUOTA(_pool, _job, _size) do { \ - if (*(_pool)->cfg.jobQuota > 0) { \ - int64_t cAllocSize = atomic_add_fetch_64(&(_job)->job.allocMemSize, (_size)); \ - if (cAllocSize > (*(_pool)->cfg.jobQuota * 1048576L)) { \ - uWarn("job 0x%" PRIx64 " remainSession:%d allocSize %" PRId64 " is over than quota %dMB", (_job)->job.jobId, (_job)->job.remainSession, cAllocSize, *(_pool)->cfg.jobQuota); \ - (_pool)->cfg.cb.reachFp(pJob->job.jobId, (_job)->job.clientId, TSDB_CODE_QRY_REACH_QMEM_THRESHOLD); \ - mpSchedTrim(NULL); \ - terrno = TSDB_CODE_QRY_REACH_QMEM_THRESHOLD; \ - return NULL; \ - } else { \ - uDebug("job 0x%" PRIx64 " remainSession:%d allocSize %" PRId64 " is lower than quota %dMB", (_job)->job.jobId, (_job)->job.remainSession, cAllocSize, *(_pool)->cfg.jobQuota); \ - } \ - } \ - if (atomic_load_64(&tsCurrentAvailMemorySize) <= ((_pool)->cfg.reserveSize + (_size))) { \ - uWarn("%s pool sysAvailMemSize %" PRId64 " can't alloc %" PRId64" while keeping reserveSize %" PRId64 " bytes", \ - (_pool)->name, atomic_load_64(&tsCurrentAvailMemorySize), (_size), (_pool)->cfg.reserveSize); \ - (_pool)->cfg.cb.reachFp((_job)->job.jobId, (_job)->job.clientId, TSDB_CODE_QRY_QUERY_MEM_EXHAUSTED); \ - mpSchedTrim(NULL); \ - terrno = TSDB_CODE_QRY_QUERY_MEM_EXHAUSTED; \ - return NULL; \ - } \ +#define MP_CHECK_QUOTA(_pool, _job, _size) \ + do { \ + if (*(_pool)->cfg.jobQuota > 0) { \ + int64_t cAllocSize = atomic_add_fetch_64(&(_job)->job.allocMemSize, (_size)); \ + if (cAllocSize > (*(_pool)->cfg.jobQuota * 1048576L)) { \ + uWarn("job 0x%" PRIx64 " remainSession:%d allocSize %" PRId64 " is over than quota %dMB", (_job)->job.jobId, \ + (_job)->job.remainSession, cAllocSize, *(_pool)->cfg.jobQuota); \ + (_pool)->cfg.cb.reachFp(pJob->job.jobId, (_job)->job.clientId, TSDB_CODE_QRY_REACH_QMEM_THRESHOLD); \ + mpSchedTrim(NULL); \ + terrno = TSDB_CODE_QRY_REACH_QMEM_THRESHOLD; \ + return NULL; \ + } else { \ + uDebug("job 0x%" PRIx64 " remainSession:%d allocSize %" PRId64 " is lower than quota %dMB", (_job)->job.jobId, \ + (_job)->job.remainSession, cAllocSize, *(_pool)->cfg.jobQuota); \ + } \ + } \ + if (atomic_load_64(&tsCurrentAvailMemorySize) <= ((_pool)->cfg.reserveSize + (_size))) { \ + uWarn("%s pool sysAvailMemSize %" PRId64 " can't alloc %" PRId64 " while keeping reserveSize %" PRId64 " bytes", \ + (_pool)->name, atomic_load_64(&tsCurrentAvailMemorySize), (_size), (_pool)->cfg.reserveSize); \ + (_pool)->cfg.cb.reachFp((_job)->job.jobId, (_job)->job.clientId, TSDB_CODE_QRY_QUERY_MEM_EXHAUSTED); \ + mpSchedTrim(NULL); \ + terrno = TSDB_CODE_QRY_QUERY_MEM_EXHAUSTED; \ + return NULL; \ + } \ } while (0) - // direct void* mpDirectAlloc(SMemPool* pPool, SMPJob* pJob, int64_t size); void* mpDirectAlignAlloc(SMemPool* pPool, SMPJob* pJob, uint32_t alignment, int64_t size); void* mpDirectCalloc(SMemPool* pPool, SMPJob* pJob, int64_t num, int64_t size); -void mpDirectFree(SMemPool* pPool, SMPJob* pJob, void *ptr); +void mpDirectFree(SMemPool* pPool, SMPJob* pJob, void* ptr); void* mpDirectRealloc(SMemPool* pPool, SMPJob* pJob, void* ptr, int64_t size); void* mpDirectStrdup(SMemPool* pPool, SMPJob* pJob, const void* ptr); void* mpDirectStrndup(SMemPool* pPool, SMPJob* pJob, const void* ptr, int64_t size); int32_t mpDirectFullAlloc(SMemPool* pPool, SMPSession* pSession, int64_t* size, uint32_t alignment, void** ppRes); -int64_t mpDirectGetMemSize(SMemPool* pPool, SMPSession* pSession, void *ptr); -void mpDirectFullFree(SMemPool* pPool, SMPSession* pSession, void *ptr, int64_t* origSize); -int32_t mpDirectFullRealloc(SMemPool* pPool, SMPSession* pSession, void **pPtr, int64_t* size, int64_t* origSize); +int64_t mpDirectGetMemSize(SMemPool* pPool, SMPSession* pSession, void* ptr); +void mpDirectFullFree(SMemPool* pPool, SMPSession* pSession, void* ptr, int64_t* origSize); +int32_t mpDirectFullRealloc(SMemPool* pPool, SMPSession* pSession, void** pPtr, int64_t* size, int64_t* origSize); int32_t mpDirectTrim(SMemPool* pPool, SMPSession* pSession, int32_t size, bool* trimed); // chunk int32_t mpChunkInit(SMemPool* pPool, char* poolName, SMemPoolCfg* cfg); -int64_t mpChunkGetMemSize(SMemPool* pPool, SMPSession* pSession, void *ptr); +int64_t mpChunkGetMemSize(SMemPool* pPool, SMPSession* pSession, void* ptr); int32_t mpChunkAlloc(SMemPool* pPool, SMPSession* pSession, int64_t* size, uint32_t alignment, void** ppRes); -void mpChunkFree(SMemPool* pPool, SMPSession* pSession, void *ptr, int64_t* origSize); -int32_t mpChunkRealloc(SMemPool* pPool, SMPSession* pSession, void **pPtr, int64_t* size, int64_t* origSize); +void mpChunkFree(SMemPool* pPool, SMPSession* pSession, void* ptr, int64_t* origSize); +int32_t mpChunkRealloc(SMemPool* pPool, SMPSession* pSession, void** pPtr, int64_t* size, int64_t* origSize); int32_t mpChunkInitSession(SMemPool* pPool, SMPSession* pSession); int32_t mpChunkUpdateCfg(SMemPool* pPool); - int32_t mpPopIdleNode(SMemPool* pPool, SMPCacheGroupInfo* pInfo, void** ppRes); int32_t mpChkFullQuota(SMemPool* pPool, SMPSession* pSession, int64_t size); void mpUpdateAllocSize(SMemPool* pPool, SMPSession* pSession, int64_t size, int64_t addSize); @@ -540,8 +522,6 @@ int32_t mpAddCacheGroup(SMemPool* pPool, SMPCacheGroupInfo* pInfo, SMPCacheGroup int32_t mpMalloc(SMemPool* pPool, SMPSession* pSession, int64_t* size, uint32_t alignment, void** ppRes); void mpSchedTrim(int64_t* loopTimes); - - #ifdef __cplusplus } #endif diff --git a/source/util/src/tmempool.c b/source/util/src/tmempool.c index 4189efd684..acb4685927 100644 --- a/source/util/src/tmempool.c +++ b/source/util/src/tmempool.c @@ -808,7 +808,7 @@ void mpLogPosStat(SMPStatPos* pStat, EMPStatLogItem item, SMPStatInput* pInput, MP_ERR_JRET(code); } - ASSERT((pInput->pOrigMem && pInput->origSize > 0) || (NULL == pInput->pOrigMem && pInput->origSize == 0)); + // ASSSRT((pInput->pOrigMem && pInput->origSize > 0) || (NULL == pInput->pOrigMem && pInput->origSize == 0)); if (pInput->pOrigMem && pInput->origSize > 0) { code = taosHashRemove(pStat->remainHash, &pInput->pOrigMem, POINTER_BYTES); diff --git a/tests/system-test/0-others/grant.py b/tests/system-test/0-others/grant.py index b5c77937ef..9e54d9ca37 100644 --- a/tests/system-test/0-others/grant.py +++ b/tests/system-test/0-others/grant.py @@ -186,8 +186,7 @@ class TDTestCase: raise Exception(repr(e)) finally: if infoFile: - infoFile.flush() - # close() + infoFile.close() def s3_check_show_grants_granted(self): tdLog.printNoPrefix("======== test show grants granted: ") From f42e4e89e83caebb88a7e32bc5876d341e6f18aa Mon Sep 17 00:00:00 2001 From: kailixu Date: Fri, 13 Dec 2024 16:01:14 +0800 Subject: [PATCH 4/5] chore: taos unused for hash remove --- source/libs/qworker/src/qwMem.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/source/libs/qworker/src/qwMem.c b/source/libs/qworker/src/qwMem.c index 5d69e14260..a90d90871e 100644 --- a/source/libs/qworker/src/qwMem.c +++ b/source/libs/qworker/src/qwMem.c @@ -79,7 +79,7 @@ void qwDestroySession(QW_FPARAMS_DEF, SQWJobInfo *pJobInfo, void* session) { char id[sizeof(tId) + sizeof(eId) + 1] = {0}; QW_SET_TEID(id, tId, eId); - (void)taosHashRemove(pJobInfo->pSessions, id, sizeof(id)); + TAOS_UNUSED(taosHashRemove(pJobInfo->pSessions, id, sizeof(id))); taosMemPoolDestroySession(gMemPoolHandle, session); @@ -95,7 +95,7 @@ void qwDestroySession(QW_FPARAMS_DEF, SQWJobInfo *pJobInfo, void* session) { char id2[sizeof(qId) + sizeof(cId) + 1] = {0}; QW_SET_QCID(id2, qId, cId); - (void)taosHashRemove(gQueryMgmt.pJobInfo, id2, sizeof(id2)); + TAOS_UNUSED(taosHashRemove(gQueryMgmt.pJobInfo, id2, sizeof(id2))); QW_TASK_DLOG_E("the whole query job removed"); } else { From c560671e734306b615c486e198679b475da2d020 Mon Sep 17 00:00:00 2001 From: dapan1121 Date: Fri, 13 Dec 2024 16:25:01 +0800 Subject: [PATCH 5/5] fix: add void --- source/libs/qworker/src/qwMem.c | 2 +- source/util/src/tmempool.c | 116 ++++++++++++++++---------------- 2 files changed, 59 insertions(+), 59 deletions(-) diff --git a/source/libs/qworker/src/qwMem.c b/source/libs/qworker/src/qwMem.c index a90d90871e..89475bca13 100644 --- a/source/libs/qworker/src/qwMem.c +++ b/source/libs/qworker/src/qwMem.c @@ -152,7 +152,7 @@ int32_t qwRetrieveJobInfo(QW_FPARAMS_DEF, SQWJobInfo** ppJob) { continue; } - atomic_add_fetch_32(&pJob->memInfo->remainSession, 1); + (void)atomic_add_fetch_32(&pJob->memInfo->remainSession, 1); QW_UNLOCK(QW_READ, &pJob->lock); break; diff --git a/source/util/src/tmempool.c b/source/util/src/tmempool.c index acb4685927..0a56c69505 100644 --- a/source/util/src/tmempool.c +++ b/source/util/src/tmempool.c @@ -95,7 +95,7 @@ int32_t mpAddCacheGroup(SMemPool* pPool, SMPCacheGroupInfo* pInfo, SMPCacheGroup return TSDB_CODE_SUCCESS; } - atomic_add_fetch_64(&pInfo->allocNum, pGrp->nodesNum); + (void)atomic_add_fetch_64(&pInfo->allocNum, pGrp->nodesNum); return TSDB_CODE_SUCCESS; } @@ -138,7 +138,7 @@ int32_t mpPopIdleNode(SMemPool* pPool, SMPCacheGroupInfo* pInfo, void** ppRes) { pNode = (SMPListNode*)((char*)pGrp->pNodes + offset * pInfo->nodeSize); break; } else { - atomic_sub_fetch_32(&pGrp->idleOffset, 1); + (void)atomic_sub_fetch_32(&pGrp->idleOffset, 1); } MP_ERR_RET(mpAddCacheGroup(pPool, pInfo, pGrp)); @@ -271,9 +271,9 @@ FORCE_INLINE void mpUpdateMaxAllocSize(int64_t* pMaxAllocMemSize, int64_t newSiz void mpUpdateAllocSize(SMemPool* pPool, SMPSession* pSession, int64_t size, int64_t addSize) { if (addSize) { if (NULL != pSession) { - atomic_add_fetch_64(&pSession->pJob->job.allocMemSize, addSize); + (void)atomic_add_fetch_64(&pSession->pJob->job.allocMemSize, addSize); } - atomic_add_fetch_64(&pPool->allocMemSize, addSize); + (void)atomic_add_fetch_64(&pPool->allocMemSize, addSize); } if (NULL != pSession) { @@ -495,8 +495,8 @@ int32_t mpAddToRemainAllocHash(SHashObj* pHash, SMPFileLine* pFileLine) { continue; } - atomic_add_fetch_64(&pStat->allocBytes, pFileLine->size); - atomic_add_fetch_64(&pStat->allocTimes, 1); + (void)atomic_add_fetch_64(&pStat->allocBytes, pFileLine->size); + (void)atomic_add_fetch_64(&pStat->allocTimes, 1); break; } @@ -593,107 +593,107 @@ void mpLogDetailStat(SMPStatDetail* pDetail, EMPStatLogItem item, SMPStatInput* switch (item) { case E_MP_STAT_LOG_MEM_MALLOC: { if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_EXEC)) { - atomic_add_fetch_64(&pDetail->times.memMalloc.exec, 1); - atomic_add_fetch_64(&pDetail->bytes.memMalloc.exec, pInput->size); + (void)atomic_add_fetch_64(&pDetail->times.memMalloc.exec, 1); + (void)atomic_add_fetch_64(&pDetail->bytes.memMalloc.exec, pInput->size); } if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_RES_SUCC)) { - atomic_add_fetch_64(&pDetail->times.memMalloc.succ, 1); - atomic_add_fetch_64(&pDetail->bytes.memMalloc.succ, pInput->size); + (void)atomic_add_fetch_64(&pDetail->times.memMalloc.succ, 1); + (void)atomic_add_fetch_64(&pDetail->bytes.memMalloc.succ, pInput->size); } if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_RES_FAIL)) { - atomic_add_fetch_64(&pDetail->times.memMalloc.fail, 1); - atomic_add_fetch_64(&pDetail->bytes.memMalloc.fail, pInput->size); + (void)atomic_add_fetch_64(&pDetail->times.memMalloc.fail, 1); + (void)atomic_add_fetch_64(&pDetail->bytes.memMalloc.fail, pInput->size); } break; } case E_MP_STAT_LOG_MEM_CALLOC:{ if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_EXEC)) { - atomic_add_fetch_64(&pDetail->times.memCalloc.exec, 1); - atomic_add_fetch_64(&pDetail->bytes.memCalloc.exec, pInput->size); + (void)atomic_add_fetch_64(&pDetail->times.memCalloc.exec, 1); + (void)atomic_add_fetch_64(&pDetail->bytes.memCalloc.exec, pInput->size); } if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_RES_SUCC)) { - atomic_add_fetch_64(&pDetail->times.memCalloc.succ, 1); - atomic_add_fetch_64(&pDetail->bytes.memCalloc.succ, pInput->size); + (void)atomic_add_fetch_64(&pDetail->times.memCalloc.succ, 1); + (void)atomic_add_fetch_64(&pDetail->bytes.memCalloc.succ, pInput->size); } if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_RES_FAIL)) { - atomic_add_fetch_64(&pDetail->times.memCalloc.fail, 1); - atomic_add_fetch_64(&pDetail->bytes.memCalloc.fail, pInput->size); + (void)atomic_add_fetch_64(&pDetail->times.memCalloc.fail, 1); + (void)atomic_add_fetch_64(&pDetail->bytes.memCalloc.fail, pInput->size); } break; } case E_MP_STAT_LOG_MEM_REALLOC:{ if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_EXEC)) { - atomic_add_fetch_64(&pDetail->times.memRealloc.exec, 1); - atomic_add_fetch_64(&pDetail->bytes.memRealloc.exec, pInput->size); - atomic_add_fetch_64(&pDetail->bytes.memRealloc.origExec, pInput->origSize); + (void)atomic_add_fetch_64(&pDetail->times.memRealloc.exec, 1); + (void)atomic_add_fetch_64(&pDetail->bytes.memRealloc.exec, pInput->size); + (void)atomic_add_fetch_64(&pDetail->bytes.memRealloc.origExec, pInput->origSize); } if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_RES_SUCC)) { - atomic_add_fetch_64(&pDetail->times.memRealloc.succ, 1); - atomic_add_fetch_64(&pDetail->bytes.memRealloc.succ, pInput->size); - atomic_add_fetch_64(&pDetail->bytes.memRealloc.origSucc, pInput->origSize); + (void)atomic_add_fetch_64(&pDetail->times.memRealloc.succ, 1); + (void)atomic_add_fetch_64(&pDetail->bytes.memRealloc.succ, pInput->size); + (void)atomic_add_fetch_64(&pDetail->bytes.memRealloc.origSucc, pInput->origSize); } if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_RES_FAIL)) { - atomic_add_fetch_64(&pDetail->times.memRealloc.fail, 1); - atomic_add_fetch_64(&pDetail->bytes.memRealloc.fail, pInput->size); - atomic_add_fetch_64(&pDetail->bytes.memRealloc.origFail, pInput->origSize); + (void)atomic_add_fetch_64(&pDetail->times.memRealloc.fail, 1); + (void)atomic_add_fetch_64(&pDetail->bytes.memRealloc.fail, pInput->size); + (void)atomic_add_fetch_64(&pDetail->bytes.memRealloc.origFail, pInput->origSize); } break; } case E_MP_STAT_LOG_MEM_FREE:{ if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_EXEC)) { - atomic_add_fetch_64(&pDetail->times.memFree.exec, 1); - atomic_add_fetch_64(&pDetail->bytes.memFree.exec, pInput->size); + (void)atomic_add_fetch_64(&pDetail->times.memFree.exec, 1); + (void)atomic_add_fetch_64(&pDetail->bytes.memFree.exec, pInput->size); } if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_RES_SUCC)) { - atomic_add_fetch_64(&pDetail->times.memFree.succ, 1); - atomic_add_fetch_64(&pDetail->bytes.memFree.succ, pInput->size); + (void)atomic_add_fetch_64(&pDetail->times.memFree.succ, 1); + (void)atomic_add_fetch_64(&pDetail->bytes.memFree.succ, pInput->size); } if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_RES_FAIL)) { - atomic_add_fetch_64(&pDetail->times.memFree.fail, 1); - atomic_add_fetch_64(&pDetail->bytes.memFree.fail, pInput->size); + (void)atomic_add_fetch_64(&pDetail->times.memFree.fail, 1); + (void)atomic_add_fetch_64(&pDetail->bytes.memFree.fail, pInput->size); } break; } case E_MP_STAT_LOG_MEM_STRDUP: { if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_EXEC)) { - atomic_add_fetch_64(&pDetail->times.memStrdup.exec, 1); - atomic_add_fetch_64(&pDetail->bytes.memStrdup.exec, pInput->size); + (void)atomic_add_fetch_64(&pDetail->times.memStrdup.exec, 1); + (void)atomic_add_fetch_64(&pDetail->bytes.memStrdup.exec, pInput->size); } if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_RES_SUCC)) { - atomic_add_fetch_64(&pDetail->times.memStrdup.succ, 1); - atomic_add_fetch_64(&pDetail->bytes.memStrdup.succ, pInput->size); + (void)atomic_add_fetch_64(&pDetail->times.memStrdup.succ, 1); + (void)atomic_add_fetch_64(&pDetail->bytes.memStrdup.succ, pInput->size); } if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_RES_FAIL)) { - atomic_add_fetch_64(&pDetail->times.memStrdup.fail, 1); - atomic_add_fetch_64(&pDetail->bytes.memStrdup.fail, pInput->size); + (void)atomic_add_fetch_64(&pDetail->times.memStrdup.fail, 1); + (void)atomic_add_fetch_64(&pDetail->bytes.memStrdup.fail, pInput->size); } break; } case E_MP_STAT_LOG_MEM_STRNDUP: { if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_EXEC)) { - atomic_add_fetch_64(&pDetail->times.memStrndup.exec, 1); - atomic_add_fetch_64(&pDetail->bytes.memStrndup.exec, pInput->size); + (void)atomic_add_fetch_64(&pDetail->times.memStrndup.exec, 1); + (void)atomic_add_fetch_64(&pDetail->bytes.memStrndup.exec, pInput->size); } if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_RES_SUCC)) { - atomic_add_fetch_64(&pDetail->times.memStrndup.succ, 1); - atomic_add_fetch_64(&pDetail->bytes.memStrndup.succ, pInput->size); + (void)atomic_add_fetch_64(&pDetail->times.memStrndup.succ, 1); + (void)atomic_add_fetch_64(&pDetail->bytes.memStrndup.succ, pInput->size); } if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_RES_FAIL)) { - atomic_add_fetch_64(&pDetail->times.memStrndup.fail, 1); - atomic_add_fetch_64(&pDetail->bytes.memStrndup.fail, pInput->size); + (void)atomic_add_fetch_64(&pDetail->times.memStrndup.fail, 1); + (void)atomic_add_fetch_64(&pDetail->bytes.memStrndup.fail, pInput->size); } break; } case E_MP_STAT_LOG_MEM_TRIM: { if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_EXEC)) { - atomic_add_fetch_64(&pDetail->times.memTrim.exec, 1); + (void)atomic_add_fetch_64(&pDetail->times.memTrim.exec, 1); } if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_RES_SUCC)) { - atomic_add_fetch_64(&pDetail->times.memTrim.succ, 1); - atomic_add_fetch_64(&pDetail->bytes.memTrim.succ, pInput->size); + (void)atomic_add_fetch_64(&pDetail->times.memTrim.succ, 1); + (void)atomic_add_fetch_64(&pDetail->bytes.memTrim.succ, pInput->size); } if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_RES_FAIL)) { - atomic_add_fetch_64(&pDetail->times.memTrim.fail, 1); + (void)atomic_add_fetch_64(&pDetail->times.memTrim.fail, 1); } break; } @@ -793,8 +793,8 @@ void mpLogPosStat(SMPStatPos* pStat, EMPStatLogItem item, SMPStatInput* pInput, MP_ERR_JRET(code); } - atomic_add_fetch_64(&pAlloc->allocTimes, 1); - atomic_add_fetch_64(&pAlloc->allocBytes, pInput->size); + (void)atomic_add_fetch_64(&pAlloc->allocTimes, 1); + (void)atomic_add_fetch_64(&pAlloc->allocBytes, pInput->size); break; } case E_MP_STAT_LOG_MEM_REALLOC: { @@ -824,8 +824,8 @@ void mpLogPosStat(SMPStatPos* pStat, EMPStatLogItem item, SMPStatInput* pInput, MP_ERR_JRET(code); } - atomic_add_fetch_64(&pFree->freeTimes, 1); - atomic_add_fetch_64(&pFree->freeBytes, pInput->origSize); + (void)atomic_add_fetch_64(&pFree->freeTimes, 1); + (void)atomic_add_fetch_64(&pFree->freeBytes, pInput->origSize); } code = taosHashPut(pStat->remainHash, &pInput->pMem, POINTER_BYTES, &fileLine, sizeof(fileLine)); @@ -856,8 +856,8 @@ void mpLogPosStat(SMPStatPos* pStat, EMPStatLogItem item, SMPStatInput* pInput, MP_ERR_JRET(code); } - atomic_add_fetch_64(&pAlloc->allocTimes, 1); - atomic_add_fetch_64(&pAlloc->allocBytes, pInput->size); + (void)atomic_add_fetch_64(&pAlloc->allocTimes, 1); + (void)atomic_add_fetch_64(&pAlloc->allocBytes, pInput->size); break; } case E_MP_STAT_LOG_MEM_FREE: { @@ -884,8 +884,8 @@ void mpLogPosStat(SMPStatPos* pStat, EMPStatLogItem item, SMPStatInput* pInput, MP_ERR_JRET(code); } - atomic_add_fetch_64(&pFree->freeTimes, 1); - atomic_add_fetch_64(&pFree->freeBytes, pInput->size); + (void)atomic_add_fetch_64(&pFree->freeTimes, 1); + (void)atomic_add_fetch_64(&pFree->freeBytes, pInput->size); break; } case E_MP_STAT_LOG_MEM_TRIM: @@ -905,7 +905,7 @@ void mpLogPosStat(SMPStatPos* pStat, EMPStatLogItem item, SMPStatInput* pInput, _return: - atomic_add_fetch_64(&pStat->logErrTimes, 1); + (void)atomic_add_fetch_64(&pStat->logErrTimes, 1); }