xxq250
/
homework-jianmu
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

Merge pull request #29134 from taosdata/enh/TD-32676-3.0 

chore: test CI
This commit is contained in:
Shengliang Guan 2024-12-13 16:43:46 +08:00 committed by GitHub
parent 3f6ddbcf48 c560671e73
commit d1bfc48439
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
3 changed files with 302 additions and 322 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
source/libs/qworker/src/qwMem.c
View File

@ -79,7 +79,7 @@ void qwDestroySession(QW_FPARAMS_DEF, SQWJobInfo *pJobInfo, void* session) {
char id[sizeof(tId) + sizeof(eId) + 1] = {0}; char id[sizeof(tId) + sizeof(eId) + 1] = {0};
QW_SET_TEID(id, tId, eId); QW_SET_TEID(id, tId, eId);
(void)taosHashRemove(pJobInfo->pSessions, id, sizeof(id)); TAOS_UNUSED(taosHashRemove(pJobInfo->pSessions, id, sizeof(id)));
taosMemPoolDestroySession(gMemPoolHandle, session); taosMemPoolDestroySession(gMemPoolHandle, session);
@ -95,7 +95,7 @@ void qwDestroySession(QW_FPARAMS_DEF, SQWJobInfo *pJobInfo, void* session) {
char id2[sizeof(qId) + sizeof(cId) + 1] = {0}; char id2[sizeof(qId) + sizeof(cId) + 1] = {0};
QW_SET_QCID(id2, qId, cId); 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"); QW_TASK_DLOG_E("the whole query job removed");
} else { } else {
@ -152,7 +152,7 @@ int32_t qwRetrieveJobInfo(QW_FPARAMS_DEF, SQWJobInfo** ppJob) {
continue; continue;
} }
atomic_add_fetch_32(&pJob->memInfo->remainSession, 1); (void)atomic_add_fetch_32(&pJob->memInfo->remainSession, 1);
QW_UNLOCK(QW_READ, &pJob->lock); QW_UNLOCK(QW_READ, &pJob->lock);
break; break;

482
source/util/inc/tmempoolInt.h
View File

@ -21,60 +21,56 @@ extern "C" {
#endif #endif
#include "os.h" #include "os.h"
#include "tlockfree.h"
#include "thash.h"
#include "tglobal.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_NSCHUNK_CACHE_ALLOC_BATCH_SIZE 500
#define MP_SESSION_CACHE_ALLOC_BATCH_SIZE 100 #define MP_SESSION_CACHE_ALLOC_BATCH_SIZE 100
#define MP_MAX_KEEP_FREE_CHUNK_NUM 1000 #define MP_MAX_KEEP_FREE_CHUNK_NUM 1000
#define MP_MAX_MALLOC_MEM_SIZE 0xFFFFFFFFFF #define MP_MAX_MALLOC_MEM_SIZE 0xFFFFFFFFFF
#define MP_DEFAULT_MEM_CHK_INTERVAL_MS 10 #define MP_DEFAULT_MEM_CHK_INTERVAL_MS 10
#define MP_MIN_MEM_CHK_INTERVAL_MS 1 #define MP_MIN_MEM_CHK_INTERVAL_MS 1
#define MP_MEMORY_TRIM_INTERVAL_TIMES 500 #define MP_MEMORY_TRIM_INTERVAL_TIMES 500
#define MP_RETIRE_HIGH_THRESHOLD_PERCENT (0.95)
#define MP_RETIRE_HIGH_THRESHOLD_PERCENT (0.95) #define MP_RETIRE_MID_THRESHOLD_PERCENT (0.9)
#define MP_RETIRE_MID_THRESHOLD_PERCENT (0.9) #define MP_RETIRE_LOW_THRESHOLD_PERCENT (0.85)
#define MP_RETIRE_LOW_THRESHOLD_PERCENT (0.85) #define MP_RETIRE_UNIT_PERCENT (0.1)
#define MP_RETIRE_UNIT_PERCENT (0.1) #define MP_RETIRE_UNIT_MIN_SIZE (50 * 1048576L)
#define MP_RETIRE_UNIT_MIN_SIZE (50 * 1048576L) #define MP_CFG_UPDATE_MIN_RESERVE_SIZE (50 * 1024 * 1048576L)
#define MP_CFG_UPDATE_MIN_RESERVE_SIZE (50 * 1024 * 1048576L)
#define MP_DEFAULT_RESERVE_MEM_PERCENT 20 #define MP_DEFAULT_RESERVE_MEM_PERCENT 20
#define MP_MIN_FREE_SIZE_AFTER_RESERVE (4 * 1024 * 1048576L) #define MP_MIN_FREE_SIZE_AFTER_RESERVE (4 * 1024 * 1048576L)
#define MP_MIN_MEM_POOL_SIZE (5 * 1024 * 1048576L) #define MP_MIN_MEM_POOL_SIZE (5 * 1024 * 1048576L)
// FLAGS AREA // FLAGS AREA
#define MP_CHUNK_FLAG_IN_USE (1 << 0) #define MP_CHUNK_FLAG_IN_USE (1 << 0)
#define MP_CHUNK_FLAG_NS_CHUNK (1 << 1) #define MP_CHUNK_FLAG_NS_CHUNK (1 << 1)
// STAT FLAGS // STAT FLAGS
#define MP_LOG_FLAG_ALL_MEM (1 << 0) #define MP_LOG_FLAG_ALL_MEM (1 << 0)
#define MP_LOG_FLAG_ALL_CHUNK (1 << 1) #define MP_LOG_FLAG_ALL_CHUNK (1 << 1)
#define MP_LOG_FLAG_ALL_POS (1 << 2) #define MP_LOG_FLAG_ALL_POS (1 << 2)
#define MP_LOG_FLAG_ALL_SESSION (1 << 3) #define MP_LOG_FLAG_ALL_SESSION (1 << 3)
#define MP_LOG_FLAG_ALL_NODE (1 << 4) #define MP_LOG_FLAG_ALL_NODE (1 << 4)
#define MP_LOG_FLAG_ALL_POOL (1 << 5) #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_SESSION (1 << 7)
#define MP_LOG_FLAG_SOME_NODE (1 << 8) #define MP_LOG_FLAG_SOME_NODE (1 << 8)
#define MP_LOG_FLAG_SOME_POOL (1 << 9) #define MP_LOG_FLAG_SOME_POOL (1 << 9)
#define MP_STAT_FLAG_LOG_ALL (0xFFFFFFFFFFFFFFFF)
#define MP_STAT_FLAG_LOG_ALL (0xFFFFFFFFFFFFFFFF)
// STAT PROCESURE FLAGS // 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_INPUT_ERR (1 << 1)
#define MP_STAT_PROC_FLAG_RES_SUCC (1 << 2) #define MP_STAT_PROC_FLAG_RES_SUCC (1 << 2)
#define MP_STAT_PROC_FLAG_RES_FAIL (1 << 3) #define MP_STAT_PROC_FLAG_RES_FAIL (1 << 3)
// CTRL FUNC FLAGS // CTRL FUNC FLAGS
#define MP_CTRL_FLAG_PRINT_STAT (1 << 0) #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_LOCK_DBG (1 << 2)
#define MP_CTRL_FLAG_LOG_MAXSIZE (1 << 3) #define MP_CTRL_FLAG_LOG_MAXSIZE (1 << 3)
typedef enum EMPStatLogItem { typedef enum EMPStatLogItem {
E_MP_STAT_LOG_MEM_MALLOC = 1, E_MP_STAT_LOG_MEM_MALLOC = 1,
E_MP_STAT_LOG_MEM_CALLOC, E_MP_STAT_LOG_MEM_CALLOC,
@ -102,8 +97,8 @@ typedef enum EMPStatLogItem {
#define MP_MEM_HEADER_FLAG_NS_CHUNK (1 << 0) #define MP_MEM_HEADER_FLAG_NS_CHUNK (1 << 0)
typedef struct SMPMemHeader { typedef struct SMPMemHeader {
uint64_t flags:24; uint64_t flags : 24;
uint64_t size:40; uint64_t size : 40;
} SMPMemHeader; } SMPMemHeader;
typedef struct SMPMemTailer { typedef struct SMPMemTailer {
@ -111,13 +106,13 @@ typedef struct SMPMemTailer {
} SMPMemTailer; } SMPMemTailer;
typedef struct SMPListNode { typedef struct SMPListNode {
void *pNext; void* pNext;
} SMPListNode; } SMPListNode;
typedef struct SMPChunk { typedef struct SMPChunk {
SMPListNode list; SMPListNode list;
char *pMemStart; char* pMemStart;
int32_t flags; int32_t flags;
/* KEEP ABOVE SAME WITH SMPNSChunk */ /* KEEP ABOVE SAME WITH SMPNSChunk */
uint32_t offset; uint32_t offset;
@ -125,36 +120,34 @@ typedef struct SMPChunk {
typedef struct SMPNSChunk { typedef struct SMPNSChunk {
SMPListNode list; SMPListNode list;
char *pMemStart; char* pMemStart;
int32_t flags; int32_t flags;
/* KEEP ABOVE SAME WITH SMPChunk */ /* KEEP ABOVE SAME WITH SMPChunk */
uint64_t offset; uint64_t offset;
uint64_t memBytes; uint64_t memBytes;
} SMPNSChunk; } SMPNSChunk;
typedef struct SMPCacheGroup { typedef struct SMPCacheGroup {
int32_t nodesNum; int32_t nodesNum;
int32_t idleOffset; int32_t idleOffset;
void *pNodes; void* pNodes;
void* pNext; void* pNext;
} SMPCacheGroup; } SMPCacheGroup;
typedef struct SMPStatInput { typedef struct SMPStatInput {
char* file; char* file;
int64_t size; int64_t size;
int64_t origSize; int64_t origSize;
int32_t procFlags; int32_t procFlags;
int32_t line; int32_t line;
void* pMem; void* pMem;
void* pOrigMem; void* pOrigMem;
} SMPStatInput; } SMPStatInput;
typedef struct SMPCtrlInfo { typedef struct SMPCtrlInfo {
int64_t statFlags; int64_t statFlags;
int64_t funcFlags; int64_t funcFlags;
} SMPCtrlInfo; } SMPCtrlInfo;
typedef struct SMPStatSession { typedef struct SMPStatSession {
@ -166,7 +159,7 @@ typedef struct SMPStatSession {
typedef struct SMPAllocStat { typedef struct SMPAllocStat {
int64_t allocTimes; int64_t allocTimes;
int64_t allocBytes; int64_t allocBytes;
//int64_t freeIDs[]; // TODO // int64_t freeIDs[]; // TODO
} SMPAllocStat; } SMPAllocStat;
typedef struct SMPFreeStat { typedef struct SMPFreeStat {
@ -175,21 +168,21 @@ typedef struct SMPFreeStat {
} SMPFreeStat; } SMPFreeStat;
typedef struct SMPFileLineId { typedef struct SMPFileLineId {
uint32_t fileId; uint32_t fileId;
int32_t line; int32_t line;
} SMPFileLineId; } SMPFileLineId;
typedef struct SMPFileLine { typedef struct SMPFileLine {
SMPFileLineId fl; SMPFileLineId fl;
int64_t size; int64_t size;
} SMPFileLine; } SMPFileLine;
typedef struct SMPStatPos { typedef struct SMPStatPos {
int64_t logErrTimes; int64_t logErrTimes;
SHashObj* fileHash; // fileId => fileName SHashObj* fileHash; // fileId => fileName
SHashObj* remainHash; // pointer => SMPFileLine SHashObj* remainHash; // pointer => SMPFileLine
SHashObj* allocHash; // alloc fl => SMPAllocStat SHashObj* allocHash; // alloc fl => SMPAllocStat
SHashObj* freeHash; // free fl => SMPFreeStat SHashObj* freeHash; // free fl => SMPFreeStat
} SMPStatPos; } SMPStatPos;
typedef struct SMPStatInfo { typedef struct SMPStatInfo {
@ -200,99 +193,97 @@ typedef struct SMPStatInfo {
SMPStatPos posStat; SMPStatPos posStat;
} SMPStatInfo; } SMPStatInfo;
typedef struct SMPJob { typedef struct SMPJob {
SMemPoolJob job; // KEEP IT FIRST SMemPoolJob job; // KEEP IT FIRST
SMPStatInfo stat; SMPStatInfo stat;
} SMPJob; } SMPJob;
typedef struct SMPSessionChunk { typedef struct SMPSessionChunk {
int64_t allocChunkNum; int64_t allocChunkNum;
int64_t allocChunkMemSize; int64_t allocChunkMemSize;
int64_t reUseChunkNum; int64_t reUseChunkNum;
int32_t srcChunkNum; int32_t srcChunkNum;
SMPChunk *srcChunkHead; SMPChunk* srcChunkHead;
SMPChunk *srcChunkTail; SMPChunk* srcChunkTail;
int32_t inUseChunkNum; int32_t inUseChunkNum;
SMPChunk *inUseChunkHead; SMPChunk* inUseChunkHead;
SMPChunk *inUseChunkTail; SMPChunk* inUseChunkTail;
SMPNSChunk *inUseNSChunkHead; SMPNSChunk* inUseNSChunkHead;
SMPNSChunk *inUseNSChunkTail; SMPNSChunk* inUseNSChunkTail;
SMPChunk *reUseChunkHead; SMPChunk* reUseChunkHead;
SMPChunk *reUseChunkTail; SMPChunk* reUseChunkTail;
SMPNSChunk *reUseNSChunkHead; SMPNSChunk* reUseNSChunkHead;
SMPNSChunk *reUseNSChunkTail; SMPNSChunk* reUseNSChunkTail;
} SMPSessionChunk; } SMPSessionChunk;
typedef struct SMPSession { typedef struct SMPSession {
//SMPListNode list; // SMPListNode list;
char* sessionId; char* sessionId;
SMPJob* pJob; SMPJob* pJob;
SMPCtrlInfo ctrl; SMPCtrlInfo ctrl;
int64_t allocMemSize; int64_t allocMemSize;
int64_t maxAllocMemSize; int64_t maxAllocMemSize;
//SMPSessionChunk chunk; // SMPSessionChunk chunk;
SMPStatInfo stat; SMPStatInfo stat;
} SMPSession; } SMPSession;
typedef struct SMPCacheGroupInfo { typedef struct SMPCacheGroupInfo {
int16_t nodeSize; int16_t nodeSize;
int64_t allocNum; int64_t allocNum;
int32_t groupNum; int32_t groupNum;
SMPCacheGroup *pGrpHead; SMPCacheGroup* pGrpHead;
void *pIdleList; void* pIdleList;
} SMPCacheGroupInfo; } SMPCacheGroupInfo;
typedef struct SMPChunkMgmt { typedef struct SMPChunkMgmt {
int32_t maxChunkNum; int32_t maxChunkNum;
int16_t maxDiscardSize; int16_t maxDiscardSize;
double threadChunkReserveNum; double threadChunkReserveNum;
int64_t allocChunkNum; int64_t allocChunkNum;
int64_t allocChunkSize; int64_t allocChunkSize;
int64_t allocNSChunkNum; int64_t allocNSChunkNum;
int64_t allocNSChunkSize; int64_t allocNSChunkSize;
SMPCacheGroupInfo chunkCache; SMPCacheGroupInfo chunkCache;
SMPCacheGroupInfo NSChunkCache; SMPCacheGroupInfo NSChunkCache;
int32_t readyChunkNum; int32_t readyChunkNum;
int32_t readyChunkReserveNum; int32_t readyChunkReserveNum;
int32_t readyChunkLowNum; int32_t readyChunkLowNum;
int32_t readyChunkGotNum; int32_t readyChunkGotNum;
SRWLatch readyChunkLock; SRWLatch readyChunkLock;
SMPChunk *readyChunkHead; SMPChunk* readyChunkHead;
SMPChunk *readyChunkTail; SMPChunk* readyChunkTail;
int64_t readyNSChunkNum; int64_t readyNSChunkNum;
SMPChunk *readyNSChunkHead; SMPChunk* readyNSChunkHead;
SMPChunk *readyNSChunkTail; SMPChunk* readyNSChunkTail;
} SMPChunkMgmt; } SMPChunkMgmt;
typedef struct SMemPool { typedef struct SMemPool {
char *name; char* name;
int16_t slotId; int16_t slotId;
SRWLatch cfgLock; SRWLatch cfgLock;
SMemPoolCfg cfg; SMemPoolCfg cfg;
//int64_t retireThreshold[3]; // int64_t retireThreshold[3];
int64_t retireUnit; int64_t retireUnit;
int64_t maxAllocMemSize; int64_t maxAllocMemSize;
int64_t allocMemSize; int64_t allocMemSize;
SMPCacheGroupInfo sessionCache; SMPCacheGroupInfo sessionCache;
SMPChunkMgmt chunk; SMPChunkMgmt chunk;
SMPStatInfo stat; SMPStatInfo stat;
} SMemPool; } SMemPool;
typedef enum EMPMemStrategy { typedef enum EMPMemStrategy {
@ -322,11 +313,10 @@ typedef struct SMemPoolMgmt {
extern SMemPoolMgmt gMPMgmt; extern SMemPoolMgmt gMPMgmt;
typedef int32_t (*mpAllocFunc)(SMemPool*, SMPSession*, int64_t*, uint32_t, void**); 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 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 (*mpInitSessionFunc)(SMemPool*, SMPSession*);
typedef int32_t (*mpInitFunc)(SMemPool*, char*, SMemPoolCfg*); typedef int32_t (*mpInitFunc)(SMemPool*, char*, SMemPoolCfg*);
typedef int32_t (*mpUpdateCfgFunc)(SMemPool*); typedef int32_t (*mpUpdateCfgFunc)(SMemPool*);
@ -352,110 +342,101 @@ enum {
MP_WRITE, MP_WRITE,
}; };
#define MP_STAT_FORMAT "%-8s => inErr:%10" PRId64 ", exec:%12" PRId64 ", succ:%12" PRId64 ", fail:%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_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_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) \ #define MP_INIT_MEM_HEADER(_header, _size, _nsChunk) \
do { \ do { \
(_header)->size = _size; \ (_header)->size = _size; \
if (_nsChunk) { \ if (_nsChunk) { \
MP_SET_FLAG((_header)->flags, MP_MEM_HEADER_FLAG_NS_CHUNK); \ MP_SET_FLAG((_header)->flags, MP_MEM_HEADER_FLAG_NS_CHUNK); \
} \ } \
} while (0) } while (0)
#define MP_ADD_TO_CHUNK_LIST(_chunkHead, _chunkTail, _chunkNum, _chunk) \ #define MP_ADD_TO_CHUNK_LIST(_chunkHead, _chunkTail, _chunkNum, _chunk) \
do { \ do { \
if (NULL == _chunkHead) { \ if (NULL == _chunkHead) { \
_chunkHead = _chunk; \ _chunkHead = _chunk; \
_chunkTail = _chunk; \ _chunkTail = _chunk; \
} else { \ } else { \
(_chunkTail)->list.pNext = _chunk; \ (_chunkTail)->list.pNext = _chunk; \
(_chunkTail) = _chunk; \ (_chunkTail) = _chunk; \
} \ } \
(_chunkNum)++; \ (_chunkNum)++; \
} while (0) } while (0)
#define TD_RWLATCH_WRITE_FLAG_COPY 0x40000000 #define TD_RWLATCH_WRITE_FLAG_COPY 0x40000000
#define MP_TRY_LOCK(type, _lock, _res) \ #define MP_TRY_LOCK(type, _lock, _res) \
do { \ 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 { \
if (MP_READ == (type)) { \ if (MP_READ == (type)) { \
if (MP_GET_FLAG(gMPMgmt.ctrl.funcFlags, MP_CTRL_FLAG_LOCK_DBG)) { \ 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 TRY RLOCK%p:%d, %s:%d B", (_lock), atomic_load_32(_lock), __FILE__, __LINE__); \
uDebug("MP RULOCK%p:%d, %s:%d B", (_lock), atomic_load_32(_lock), __FILE__, __LINE__); \ } \
} \ (_res) = taosRTryLockLatch(_lock); \
taosRUnLockLatch(_lock); \ if (MP_GET_FLAG(gMPMgmt.ctrl.funcFlags, MP_CTRL_FLAG_LOCK_DBG)) { \
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", \
uDebug("MP RULOCK%p:%d, %s:%d E", (_lock), atomic_load_32(_lock), __FILE__, __LINE__); \ __FILE__, __LINE__); \
ASSERTS(atomic_load_32((_lock)) >= 0, "invalid lock value after read unlock"); \ } \
} \ } else { \
} else { \ if (MP_GET_FLAG(gMPMgmt.ctrl.funcFlags, MP_CTRL_FLAG_LOCK_DBG)) { \
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__); \
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__); \ (_res) = taosWTryLockLatch(_lock); \
} \ if (MP_GET_FLAG(gMPMgmt.ctrl.funcFlags, MP_CTRL_FLAG_LOCK_DBG)) { \
taosWUnLockLatch(_lock); \ uDebug("MP TRY WLOCK%p:%d %s, %s:%d E", (_lock), atomic_load_32(_lock), (_res) ? "failed" : "succeed", \
if (MP_GET_FLAG(gMPMgmt.ctrl.funcFlags, MP_CTRL_FLAG_LOCK_DBG)) { \ __FILE__, __LINE__); \
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"); \ } \
} \
} \
} while (0) } 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) \ #define MP_ERR_RET(c) \
do { \ do { \
@ -484,55 +465,56 @@ enum {
} \ } \
} while (0) } while (0)
#define MP_CHECK_QUOTA(_pool, _job, _size) do { \ #define MP_CHECK_QUOTA(_pool, _job, _size) \
if (*(_pool)->cfg.jobQuota > 0) { \ do { \
int64_t cAllocSize = atomic_add_fetch_64(&(_job)->job.allocMemSize, (_size)); \ if (*(_pool)->cfg.jobQuota > 0) { \
if (cAllocSize > (*(_pool)->cfg.jobQuota * 1048576L)) { \ int64_t cAllocSize = atomic_add_fetch_64(&(_job)->job.allocMemSize, (_size)); \
uWarn("job 0x%" PRIx64 " remainSession:%d allocSize %" PRId64 " is over than quota %dMB", (_job)->job.jobId, (_job)->job.remainSession, cAllocSize, *(_pool)->cfg.jobQuota); \ if (cAllocSize > (*(_pool)->cfg.jobQuota * 1048576L)) { \
(_pool)->cfg.cb.reachFp(pJob->job.jobId, (_job)->job.clientId, TSDB_CODE_QRY_REACH_QMEM_THRESHOLD); \ uWarn("job 0x%" PRIx64 " remainSession:%d allocSize %" PRId64 " is over than quota %dMB", (_job)->job.jobId, \
mpSchedTrim(NULL); \ (_job)->job.remainSession, cAllocSize, *(_pool)->cfg.jobQuota); \
terrno = TSDB_CODE_QRY_REACH_QMEM_THRESHOLD; \ (_pool)->cfg.cb.reachFp(pJob->job.jobId, (_job)->job.clientId, TSDB_CODE_QRY_REACH_QMEM_THRESHOLD); \
return NULL; \ mpSchedTrim(NULL); \
} else { \ terrno = TSDB_CODE_QRY_REACH_QMEM_THRESHOLD; \
uDebug("job 0x%" PRIx64 " remainSession:%d allocSize %" PRId64 " is lower than quota %dMB", (_job)->job.jobId, (_job)->job.remainSession, cAllocSize, *(_pool)->cfg.jobQuota); \ return NULL; \
} \ } else { \
} \ uDebug("job 0x%" PRIx64 " remainSession:%d allocSize %" PRId64 " is lower than quota %dMB", (_job)->job.jobId, \
if (atomic_load_64(&tsCurrentAvailMemorySize) <= ((_pool)->cfg.reserveSize + (_size))) { \ (_job)->job.remainSession, cAllocSize, *(_pool)->cfg.jobQuota); \
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); \ if (atomic_load_64(&tsCurrentAvailMemorySize) <= ((_pool)->cfg.reserveSize + (_size))) { \
mpSchedTrim(NULL); \ uWarn("%s pool sysAvailMemSize %" PRId64 " can't alloc %" PRId64 " while keeping reserveSize %" PRId64 " bytes", \
terrno = TSDB_CODE_QRY_QUERY_MEM_EXHAUSTED; \ (_pool)->name, atomic_load_64(&tsCurrentAvailMemorySize), (_size), (_pool)->cfg.reserveSize); \
return NULL; \ (_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) } while (0)
// direct // direct
void* mpDirectAlloc(SMemPool* pPool, SMPJob* pJob, int64_t size); void* mpDirectAlloc(SMemPool* pPool, SMPJob* pJob, int64_t size);
void* mpDirectAlignAlloc(SMemPool* pPool, SMPJob* pJob, uint32_t alignment, 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* 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* mpDirectRealloc(SMemPool* pPool, SMPJob* pJob, void* ptr, int64_t size);
void* mpDirectStrdup(SMemPool* pPool, SMPJob* pJob, const void* ptr); void* mpDirectStrdup(SMemPool* pPool, SMPJob* pJob, const void* ptr);
void* mpDirectStrndup(SMemPool* pPool, SMPJob* pJob, const void* ptr, int64_t size); 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); int32_t mpDirectFullAlloc(SMemPool* pPool, SMPSession* pSession, int64_t* size, uint32_t alignment, void** ppRes);
int64_t mpDirectGetMemSize(SMemPool* pPool, SMPSession* pSession, void *ptr); int64_t mpDirectGetMemSize(SMemPool* pPool, SMPSession* pSession, void* ptr);
void mpDirectFullFree(SMemPool* pPool, SMPSession* pSession, void *ptr, int64_t* origSize); 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 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); int32_t mpDirectTrim(SMemPool* pPool, SMPSession* pSession, int32_t size, bool* trimed);
// chunk // chunk
int32_t mpChunkInit(SMemPool* pPool, char* poolName, SMemPoolCfg* cfg); 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); 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); 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 mpChunkRealloc(SMemPool* pPool, SMPSession* pSession, void** pPtr, int64_t* size, int64_t* origSize);
int32_t mpChunkInitSession(SMemPool* pPool, SMPSession* pSession); int32_t mpChunkInitSession(SMemPool* pPool, SMPSession* pSession);
int32_t mpChunkUpdateCfg(SMemPool* pPool); int32_t mpChunkUpdateCfg(SMemPool* pPool);
int32_t mpPopIdleNode(SMemPool* pPool, SMPCacheGroupInfo* pInfo, void** ppRes); int32_t mpPopIdleNode(SMemPool* pPool, SMPCacheGroupInfo* pInfo, void** ppRes);
int32_t mpChkFullQuota(SMemPool* pPool, SMPSession* pSession, int64_t size); int32_t mpChkFullQuota(SMemPool* pPool, SMPSession* pSession, int64_t size);
void mpUpdateAllocSize(SMemPool* pPool, SMPSession* pSession, int64_t size, int64_t addSize); 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); int32_t mpMalloc(SMemPool* pPool, SMPSession* pSession, int64_t* size, uint32_t alignment, void** ppRes);
void mpSchedTrim(int64_t* loopTimes); void mpSchedTrim(int64_t* loopTimes);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

118
source/util/src/tmempool.c
View File

@ -95,7 +95,7 @@ int32_t mpAddCacheGroup(SMemPool* pPool, SMPCacheGroupInfo* pInfo, SMPCacheGroup
return TSDB_CODE_SUCCESS; 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; 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); pNode = (SMPListNode*)((char*)pGrp->pNodes + offset * pInfo->nodeSize);
break; break;
} else { } else {
atomic_sub_fetch_32(&pGrp->idleOffset, 1); (void)atomic_sub_fetch_32(&pGrp->idleOffset, 1);
} }
MP_ERR_RET(mpAddCacheGroup(pPool, pInfo, pGrp)); 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) { void mpUpdateAllocSize(SMemPool* pPool, SMPSession* pSession, int64_t size, int64_t addSize) {
if (addSize) { if (addSize) {
if (NULL != pSession) { 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) { if (NULL != pSession) {
@ -495,8 +495,8 @@ int32_t mpAddToRemainAllocHash(SHashObj* pHash, SMPFileLine* pFileLine) {
continue; continue;
} }
atomic_add_fetch_64(&pStat->allocBytes, pFileLine->size); (void)atomic_add_fetch_64(&pStat->allocBytes, pFileLine->size);
atomic_add_fetch_64(&pStat->allocTimes, 1); (void)atomic_add_fetch_64(&pStat->allocTimes, 1);
break; break;
} }
@ -593,107 +593,107 @@ void mpLogDetailStat(SMPStatDetail* pDetail, EMPStatLogItem item, SMPStatInput*
switch (item) { switch (item) {
case E_MP_STAT_LOG_MEM_MALLOC: { case E_MP_STAT_LOG_MEM_MALLOC: {
if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_EXEC)) { if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_EXEC)) {
atomic_add_fetch_64(&pDetail->times.memMalloc.exec, 1); (void)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->bytes.memMalloc.exec, pInput->size);
} }
if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_RES_SUCC)) { if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_RES_SUCC)) {
atomic_add_fetch_64(&pDetail->times.memMalloc.succ, 1); (void)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->bytes.memMalloc.succ, pInput->size);
} }
if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_RES_FAIL)) { if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_RES_FAIL)) {
atomic_add_fetch_64(&pDetail->times.memMalloc.fail, 1); (void)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->bytes.memMalloc.fail, pInput->size);
} }
break; break;
} }
case E_MP_STAT_LOG_MEM_CALLOC:{ case E_MP_STAT_LOG_MEM_CALLOC:{
if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_EXEC)) { if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_EXEC)) {
atomic_add_fetch_64(&pDetail->times.memCalloc.exec, 1); (void)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->bytes.memCalloc.exec, pInput->size);
} }
if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_RES_SUCC)) { if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_RES_SUCC)) {
atomic_add_fetch_64(&pDetail->times.memCalloc.succ, 1); (void)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->bytes.memCalloc.succ, pInput->size);
} }
if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_RES_FAIL)) { if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_RES_FAIL)) {
atomic_add_fetch_64(&pDetail->times.memCalloc.fail, 1); (void)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->bytes.memCalloc.fail, pInput->size);
} }
break; break;
} }
case E_MP_STAT_LOG_MEM_REALLOC:{ case E_MP_STAT_LOG_MEM_REALLOC:{
if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_EXEC)) { if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_EXEC)) {
atomic_add_fetch_64(&pDetail->times.memRealloc.exec, 1); (void)atomic_add_fetch_64(&pDetail->times.memRealloc.exec, 1);
atomic_add_fetch_64(&pDetail->bytes.memRealloc.exec, pInput->size); (void)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->bytes.memRealloc.origExec, pInput->origSize);
} }
if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_RES_SUCC)) { if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_RES_SUCC)) {
atomic_add_fetch_64(&pDetail->times.memRealloc.succ, 1); (void)atomic_add_fetch_64(&pDetail->times.memRealloc.succ, 1);
atomic_add_fetch_64(&pDetail->bytes.memRealloc.succ, pInput->size); (void)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->bytes.memRealloc.origSucc, pInput->origSize);
} }
if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_RES_FAIL)) { if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_RES_FAIL)) {
atomic_add_fetch_64(&pDetail->times.memRealloc.fail, 1); (void)atomic_add_fetch_64(&pDetail->times.memRealloc.fail, 1);
atomic_add_fetch_64(&pDetail->bytes.memRealloc.fail, pInput->size); (void)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->bytes.memRealloc.origFail, pInput->origSize);
} }
break; break;
} }
case E_MP_STAT_LOG_MEM_FREE:{ case E_MP_STAT_LOG_MEM_FREE:{
if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_EXEC)) { if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_EXEC)) {
atomic_add_fetch_64(&pDetail->times.memFree.exec, 1); (void)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->bytes.memFree.exec, pInput->size);
} }
if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_RES_SUCC)) { if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_RES_SUCC)) {
atomic_add_fetch_64(&pDetail->times.memFree.succ, 1); (void)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->bytes.memFree.succ, pInput->size);
} }
if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_RES_FAIL)) { if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_RES_FAIL)) {
atomic_add_fetch_64(&pDetail->times.memFree.fail, 1); (void)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->bytes.memFree.fail, pInput->size);
} }
break; break;
} }
case E_MP_STAT_LOG_MEM_STRDUP: { case E_MP_STAT_LOG_MEM_STRDUP: {
if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_EXEC)) { if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_EXEC)) {
atomic_add_fetch_64(&pDetail->times.memStrdup.exec, 1); (void)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->bytes.memStrdup.exec, pInput->size);
} }
if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_RES_SUCC)) { if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_RES_SUCC)) {
atomic_add_fetch_64(&pDetail->times.memStrdup.succ, 1); (void)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->bytes.memStrdup.succ, pInput->size);
} }
if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_RES_FAIL)) { if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_RES_FAIL)) {
atomic_add_fetch_64(&pDetail->times.memStrdup.fail, 1); (void)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->bytes.memStrdup.fail, pInput->size);
} }
break; break;
} }
case E_MP_STAT_LOG_MEM_STRNDUP: { case E_MP_STAT_LOG_MEM_STRNDUP: {
if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_EXEC)) { if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_EXEC)) {
atomic_add_fetch_64(&pDetail->times.memStrndup.exec, 1); (void)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->bytes.memStrndup.exec, pInput->size);
} }
if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_RES_SUCC)) { if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_RES_SUCC)) {
atomic_add_fetch_64(&pDetail->times.memStrndup.succ, 1); (void)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->bytes.memStrndup.succ, pInput->size);
} }
if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_RES_FAIL)) { if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_RES_FAIL)) {
atomic_add_fetch_64(&pDetail->times.memStrndup.fail, 1); (void)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->bytes.memStrndup.fail, pInput->size);
} }
break; break;
} }
case E_MP_STAT_LOG_MEM_TRIM: { case E_MP_STAT_LOG_MEM_TRIM: {
if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_EXEC)) { 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)) { if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_RES_SUCC)) {
atomic_add_fetch_64(&pDetail->times.memTrim.succ, 1); (void)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->bytes.memTrim.succ, pInput->size);
} }
if (MP_GET_FLAG(pInput->procFlags, MP_STAT_PROC_FLAG_RES_FAIL)) { 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; break;
} }
@ -793,8 +793,8 @@ void mpLogPosStat(SMPStatPos* pStat, EMPStatLogItem item, SMPStatInput* pInput,
MP_ERR_JRET(code); MP_ERR_JRET(code);
} }
atomic_add_fetch_64(&pAlloc->allocTimes, 1); (void)atomic_add_fetch_64(&pAlloc->allocTimes, 1);
atomic_add_fetch_64(&pAlloc->allocBytes, pInput->size); (void)atomic_add_fetch_64(&pAlloc->allocBytes, pInput->size);
break; break;
} }
case E_MP_STAT_LOG_MEM_REALLOC: { case E_MP_STAT_LOG_MEM_REALLOC: {
@ -808,7 +808,7 @@ void mpLogPosStat(SMPStatPos* pStat, EMPStatLogItem item, SMPStatInput* pInput,
MP_ERR_JRET(code); 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) { if (pInput->pOrigMem && pInput->origSize > 0) {
code = taosHashRemove(pStat->remainHash, &pInput->pOrigMem, POINTER_BYTES); code = taosHashRemove(pStat->remainHash, &pInput->pOrigMem, POINTER_BYTES);
@ -824,8 +824,8 @@ void mpLogPosStat(SMPStatPos* pStat, EMPStatLogItem item, SMPStatInput* pInput,
MP_ERR_JRET(code); MP_ERR_JRET(code);
} }
atomic_add_fetch_64(&pFree->freeTimes, 1); (void)atomic_add_fetch_64(&pFree->freeTimes, 1);
atomic_add_fetch_64(&pFree->freeBytes, pInput->origSize); (void)atomic_add_fetch_64(&pFree->freeBytes, pInput->origSize);
} }
code = taosHashPut(pStat->remainHash, &pInput->pMem, POINTER_BYTES, &fileLine, sizeof(fileLine)); 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); MP_ERR_JRET(code);
} }
atomic_add_fetch_64(&pAlloc->allocTimes, 1); (void)atomic_add_fetch_64(&pAlloc->allocTimes, 1);
atomic_add_fetch_64(&pAlloc->allocBytes, pInput->size); (void)atomic_add_fetch_64(&pAlloc->allocBytes, pInput->size);
break; break;
} }
case E_MP_STAT_LOG_MEM_FREE: { case E_MP_STAT_LOG_MEM_FREE: {
@ -884,8 +884,8 @@ void mpLogPosStat(SMPStatPos* pStat, EMPStatLogItem item, SMPStatInput* pInput,
MP_ERR_JRET(code); MP_ERR_JRET(code);
} }
atomic_add_fetch_64(&pFree->freeTimes, 1); (void)atomic_add_fetch_64(&pFree->freeTimes, 1);
atomic_add_fetch_64(&pFree->freeBytes, pInput->size); (void)atomic_add_fetch_64(&pFree->freeBytes, pInput->size);
break; break;
} }
case E_MP_STAT_LOG_MEM_TRIM: case E_MP_STAT_LOG_MEM_TRIM:
@ -905,7 +905,7 @@ void mpLogPosStat(SMPStatPos* pStat, EMPStatLogItem item, SMPStatInput* pInput,
_return: _return:
atomic_add_fetch_64(&pStat->logErrTimes, 1); (void)atomic_add_fetch_64(&pStat->logErrTimes, 1);
} }