From 33e7c57fa5a68588b5e36939d39cb2c028f6ffc4 Mon Sep 17 00:00:00 2001 From: dapan1121 Date: Fri, 24 Feb 2023 10:39:25 +0800 Subject: [PATCH] feat: add catalog cache stat --- source/libs/catalog/inc/catalogInt.h | 151 ++++++++++++++++++++++++--- source/libs/catalog/src/catalog.c | 7 +- source/libs/catalog/src/ctgAsync.c | 2 + source/libs/catalog/src/ctgCache.c | 64 +++++++----- source/libs/catalog/src/ctgUtil.c | 13 +-- 5 files changed, 188 insertions(+), 49 deletions(-) diff --git a/source/libs/catalog/inc/catalogInt.h b/source/libs/catalog/inc/catalogInt.h index 8fc7df63be..ea3ba85acd 100644 --- a/source/libs/catalog/inc/catalogInt.h +++ b/source/libs/catalog/inc/catalogInt.h @@ -43,6 +43,29 @@ extern "C" { #define CTG_BATCH_FETCH 1 +typedef enum { + CTG_CI_CLUSTER, + CTG_CI_DNODE, + CTG_CI_QNODE, + CTG_CI_DB, + CTG_CI_DB_VGROUP, + CTG_CI_DB_CFG, + CTG_CI_DB_INFO, + CTG_CI_STABLE_META, + CTG_CI_NTABLE_META, + CTG_CI_CTABLE_META, + CTG_CI_SYSTABLE_META, + CTG_CI_OTHERTABLE_META, + CTG_CI_TBL_INDEX, + CTG_CI_TBL_HASH_VGROUP, + CTG_CI_TBL_CFG, + CTG_CI_SMA, + CTG_CI_USER, + CTG_CI_UDF, + CTG_CI_SVR_VER, + CTG_CI_MAX_VALUE, +} CTG_CACHE_ITEM; + enum { CTG_READ = 1, CTG_WRITE, @@ -347,23 +370,13 @@ typedef struct SCtgRuntimeStat { uint64_t numOfOpAbort; uint64_t numOfOpEnqueue; uint64_t numOfOpDequeue; + uint64_t numOfOpClearCache; } SCtgRuntimeStat; typedef struct SCtgCacheStat { - uint64_t numOfCluster; - uint64_t numOfDb; - uint64_t numOfTbl; - uint64_t numOfStb; - uint64_t numOfUser; - uint64_t numOfVgHit; - uint64_t numOfVgMiss; - uint64_t numOfMetaHit; - uint64_t numOfMetaMiss; - uint64_t numOfIndexHit; - uint64_t numOfIndexMiss; - uint64_t numOfUserHit; - uint64_t numOfUserMiss; - uint64_t numOfClear; + uint64_t cacheNum[CTG_CI_MAX_VALUE]; + uint64_t cacheHit[CTG_CI_MAX_VALUE]; + uint64_t cacheNHit[CTG_CI_MAX_VALUE]; } SCtgCacheStat; typedef struct SCatalogStat { @@ -499,6 +512,116 @@ typedef struct SCtgOperation { #define CTG_CACHE_STAT_INC(item, n) (CTG_STAT_INC(gCtgMgmt.stat.cache.item, n)) #define CTG_CACHE_STAT_DEC(item, n) (CTG_STAT_DEC(gCtgMgmt.stat.cache.item, n)) +#define CTG_CACHE_NUM_INC(item, n) (CTG_STAT_INC(gCtgMgmt.stat.cache.cacheNum[item], n)) +#define CTG_CACHE_NUM_DEC(item, n) (CTG_STAT_DEC(gCtgMgmt.stat.cache.cacheNum[item], n)) +#define CTG_CACHE_HIT_INC(item, n) (CTG_STAT_INC(gCtgMgmt.stat.cache.cacheHit[item], n)) +#define CTG_CACHE_HIT_DEC(item, n) (CTG_STAT_DEC(gCtgMgmt.stat.cache.cacheHit[item], n)) +#define CTG_CACHE_NHIT_INC(item, n) (CTG_STAT_INC(gCtgMgmt.stat.cache.cacheNHit[item], n)) +#define CTG_CACHE_NHIT_DEC(item, n) (CTG_STAT_DEC(gCtgMgmt.stat.cache.cacheNHit[item], n)) + +#define CTG_META_NUM_INC(type, n) do { \ + switch (type) { \ + case TSDB_SUPER_TABLE: \ + CTG_CACHE_NUM_INC(CTG_CI_STABLE_META, n); \ + break; \ + case TSDB_CHILD_TABLE: \ + CTG_CACHE_NUM_INC(CTG_CI_CTABLE_META, n); \ + break; \ + case TSDB_NORMAL_TABLE: \ + CTG_CACHE_NUM_INC(CTG_CI_NTABLE_META, n); \ + break; \ + case TSDB_SYSTEM_TABLE: \ + CTG_CACHE_NUM_INC(CTG_CI_SYSTABLE_META, n); \ + break; \ + default: \ + CTG_CACHE_NUM_INC(CTG_CI_OTHERTABLE_META, n); \ + break; \ + } \ +} while (0) + +#define CTG_META_NUM_DEC(type, n) do { \ + switch (type) { \ + case TSDB_SUPER_TABLE: \ + CTG_CACHE_NUM_DEC(CTG_CI_STABLE_META, n); \ + break; \ + case TSDB_CHILD_TABLE: \ + CTG_CACHE_NUM_DEC(CTG_CI_CTABLE_META, n); \ + break; \ + case TSDB_NORMAL_TABLE: \ + CTG_CACHE_NUM_DEC(CTG_CI_NTABLE_META, n); \ + break; \ + case TSDB_SYSTEM_TABLE: \ + CTG_CACHE_NUM_DEC(CTG_CI_SYSTABLE_META, n); \ + break; \ + default: \ + CTG_CACHE_NUM_DEC(CTG_CI_OTHERTABLE_META, n); \ + break; \ + } \ +} while (0) + +#define CTG_META_HIT_INC(type, n) do { \ + switch (type) { \ + case TSDB_SUPER_TABLE: \ + CTG_CACHE_HIT_INC(CTG_CI_STABLE_META, n); \ + break; \ + case TSDB_CHILD_TABLE: \ + CTG_CACHE_HIT_INC(CTG_CI_CTABLE_META, n); \ + break; \ + case TSDB_NORMAL_TABLE: \ + CTG_CACHE_HIT_INC(CTG_CI_NTABLE_META, n); \ + break; \ + case TSDB_SYSTEM_TABLE: \ + CTG_CACHE_HIT_INC(CTG_CI_SYSTABLE_META, n); \ + break; \ + default: \ + CTG_CACHE_HIT_INC(CTG_CI_OTHERTABLE_META, n); \ + break; \ + } \ +} while (0) + +#define CTG_META_HIT_DEC(type, n) do { \ + switch (type) { \ + case TSDB_SUPER_TABLE: \ + CTG_CACHE_HIT_DEC(CTG_CI_STABLE_META, n); \ + break; \ + case TSDB_CHILD_TABLE: \ + CTG_CACHE_HIT_DEC(CTG_CI_CTABLE_META, n); \ + break; \ + case TSDB_NORMAL_TABLE: \ + CTG_CACHE_HIT_DEC(CTG_CI_NTABLE_META, n); \ + break; \ + case TSDB_SYSTEM_TABLE: \ + CTG_CACHE_HIT_DEC(CTG_CI_SYSTABLE_META, n); \ + break; \ + default: \ + CTG_CACHE_HIT_DEC(CTG_CI_OTHERTABLE_META, n); \ + break; \ + } \ +} while (0) + +#define CTG_META_NHIT_INC(n) CTG_CACHE_NHIT_INC(CTG_CI_OTHERTABLE_META, n) + +#define CTG_META_NHIT_DEC(type, n) do { \ + switch (type) { \ + case TSDB_SUPER_TABLE: \ + CTG_CACHE_NHIT_DEC(CTG_CI_STABLE_META, n); \ + break; \ + case TSDB_CHILD_TABLE: \ + CTG_CACHE_NHIT_DEC(CTG_CI_CTABLE_META, n); \ + break; \ + case TSDB_NORMAL_TABLE: \ + CTG_CACHE_NHIT_DEC(CTG_CI_NTABLE_META, n); \ + break; \ + case TSDB_SYSTEM_TABLE: \ + CTG_CACHE_NHIT_DEC(CTG_CI_SYSTABLE_META, n); \ + break; \ + default: \ + CTG_CACHE_NHIT_DEC(CTG_CI_OTHERTABLE_META, n); \ + break; \ + } \ +} while (0) + + #define CTG_IS_META_NULL(type) ((type) == META_TYPE_NULL_TABLE) #define CTG_IS_META_CTABLE(type) ((type) == META_TYPE_CTABLE) #define CTG_IS_META_TABLE(type) ((type) == META_TYPE_TABLE) diff --git a/source/libs/catalog/src/catalog.c b/source/libs/catalog/src/catalog.c index f9a218835e..c35ca157fe 100644 --- a/source/libs/catalog/src/catalog.c +++ b/source/libs/catalog/src/catalog.c @@ -721,10 +721,13 @@ int32_t catalogGetHandle(uint64_t clusterId, SCatalog** catalogHandle) { if (ctg && (*ctg)) { *catalogHandle = *ctg; + CTG_CACHE_HIT_INC(CTG_CI_CLUSTER, 1); qDebug("got catalog handle from cache, clusterId:0x%" PRIx64 ", CTG:%p", clusterId, *ctg); CTG_API_LEAVE(TSDB_CODE_SUCCESS); } + CTG_CACHE_NHIT_INC(CTG_CI_CLUSTER, 1); + clusterCtg = taosMemoryCalloc(1, sizeof(SCatalog)); if (NULL == clusterCtg) { qError("calloc %d failed", (int32_t)sizeof(SCatalog)); @@ -768,7 +771,7 @@ int32_t catalogGetHandle(uint64_t clusterId, SCatalog** catalogHandle) { *catalogHandle = clusterCtg; - CTG_CACHE_STAT_INC(numOfCluster, 1); + CTG_CACHE_NUM_INC(CTG_CI_CLUSTER, 1); CTG_API_LEAVE(TSDB_CODE_SUCCESS); @@ -1301,6 +1304,7 @@ int32_t catalogGetQnodeList(SCatalog* pCtg, SRequestConnInfo* pConn, SArray* pQn CTG_API_LEAVE(TSDB_CODE_CTG_INVALID_INPUT); } + CTG_CACHE_NHIT_INC(CTG_CI_QNODE, 1); CTG_ERR_JRET(ctgGetQnodeListFromMnode(pCtg, pConn, pQnodeList, NULL)); _return: @@ -1316,6 +1320,7 @@ int32_t catalogGetDnodeList(SCatalog* pCtg, SRequestConnInfo* pConn, SArray** pD CTG_API_LEAVE(TSDB_CODE_CTG_INVALID_INPUT); } + CTG_CACHE_NHIT_INC(CTG_CI_DNODE, 1); CTG_ERR_JRET(ctgGetDnodeListFromMnode(pCtg, pConn, pDnodeList, NULL)); _return: diff --git a/source/libs/catalog/src/ctgAsync.c b/source/libs/catalog/src/ctgAsync.c index 89e92b0cc8..fca7a17a36 100644 --- a/source/libs/catalog/src/ctgAsync.c +++ b/source/libs/catalog/src/ctgAsync.c @@ -1967,6 +1967,7 @@ int32_t ctgLaunchGetQnodeTask(SCtgTask* pTask) { pMsgCtx->pBatchs = pJob->pBatchs; } + CTG_CACHE_NHIT_INC(CTG_CI_QNODE, 1); CTG_ERR_RET(ctgGetQnodeListFromMnode(pCtg, pConn, NULL, pTask)); return TSDB_CODE_SUCCESS; } @@ -1980,6 +1981,7 @@ int32_t ctgLaunchGetDnodeTask(SCtgTask* pTask) { pMsgCtx->pBatchs = pJob->pBatchs; } + CTG_CACHE_NHIT_INC(CTG_CI_DNODE, 1); CTG_ERR_RET(ctgGetDnodeListFromMnode(pCtg, pConn, NULL, pTask)); return TSDB_CODE_SUCCESS; } diff --git a/source/libs/catalog/src/ctgCache.c b/source/libs/catalog/src/ctgCache.c index 06db2c3268..5d71ab20cb 100644 --- a/source/libs/catalog/src/ctgCache.c +++ b/source/libs/catalog/src/ctgCache.c @@ -93,6 +93,7 @@ int32_t ctgAcquireDBCacheImpl(SCatalog *pCtg, const char *dbFName, SCtgDBCache * if (NULL == dbCache) { *pCache = NULL; + CTG_CACHE_NHIT_INC(CTG_CI_DB, 1); ctgDebug("db not in cache, dbFName:%s", dbFName); return TSDB_CODE_SUCCESS; } @@ -107,11 +108,13 @@ int32_t ctgAcquireDBCacheImpl(SCatalog *pCtg, const char *dbFName, SCtgDBCache * } *pCache = NULL; + CTG_CACHE_NHIT_INC(CTG_CI_DB, 1); ctgDebug("db is removing from cache, dbFName:%s", dbFName); return TSDB_CODE_SUCCESS; } *pCache = dbCache; + CTG_CACHE_HIT_INC(CTG_CI_DB, 1); return TSDB_CODE_SUCCESS; } @@ -180,7 +183,7 @@ int32_t ctgAcquireVgInfoFromCache(SCatalog *pCtg, const char *dbFName, SCtgDBCac *pCache = dbCache; - CTG_CACHE_STAT_INC(numOfVgHit, 1); + CTG_CACHE_HIT_INC(CTG_CI_DB_VGROUP, 1); ctgDebug("Got db vgInfo from cache, dbFName:%s", dbFName); @@ -194,7 +197,7 @@ _return: *pCache = NULL; - CTG_CACHE_STAT_INC(numOfVgMiss, 1); + CTG_CACHE_NHIT_INC(CTG_CI_DB_VGROUP, 1); return TSDB_CODE_SUCCESS; } @@ -225,7 +228,7 @@ int32_t ctgAcquireTbMetaFromCache(SCatalog *pCtg, char *dbFName, char *tbName, S ctgDebug("tb %s meta got in cache, dbFName:%s", tbName, dbFName); - CTG_CACHE_STAT_INC(numOfMetaHit, 1); + CTG_META_HIT_INC(pCache->pMeta->tableType, 1); return TSDB_CODE_SUCCESS; @@ -233,7 +236,7 @@ _return: ctgReleaseTbMetaToCache(pCtg, dbCache, pCache); - CTG_CACHE_STAT_INC(numOfMetaMiss, 1); + CTG_META_NHIT_INC(1); return TSDB_CODE_SUCCESS; } @@ -246,34 +249,34 @@ int32_t ctgAcquireVgMetaFromCache(SCatalog *pCtg, const char *dbFName, const cha ctgAcquireDBCache(pCtg, dbFName, &dbCache); if (NULL == dbCache) { ctgDebug("db %s not in cache", dbFName); - CTG_CACHE_STAT_INC(numOfVgMiss, 1); + CTG_CACHE_NHIT_INC(CTG_CI_DB_VGROUP, 1); goto _return; } ctgRLockVgInfo(pCtg, dbCache, &vgInCache); if (!vgInCache) { ctgDebug("vgInfo of db %s not in cache", dbFName); - CTG_CACHE_STAT_INC(numOfVgMiss, 1); + CTG_CACHE_NHIT_INC(CTG_CI_DB_VGROUP, 1); goto _return; } *pDb = dbCache; - CTG_CACHE_STAT_INC(numOfVgHit, 1); + CTG_CACHE_HIT_INC(CTG_CI_DB_VGROUP, 1); ctgDebug("Got db vgInfo from cache, dbFName:%s", dbFName); tbCache = taosHashAcquire(dbCache->tbCache, tbName, strlen(tbName)); if (NULL == tbCache) { ctgDebug("tb %s not in cache, dbFName:%s", tbName, dbFName); - CTG_CACHE_STAT_INC(numOfMetaMiss, 1); + CTG_META_NHIT_INC(1); goto _return; } CTG_LOCK(CTG_READ, &tbCache->metaLock); if (NULL == tbCache->pMeta) { ctgDebug("tb %s meta not in cache, dbFName:%s", tbName, dbFName); - CTG_CACHE_STAT_INC(numOfMetaMiss, 1); + CTG_META_NHIT_INC(1); goto _return; } @@ -281,7 +284,7 @@ int32_t ctgAcquireVgMetaFromCache(SCatalog *pCtg, const char *dbFName, const cha ctgDebug("tb %s meta got in cache, dbFName:%s", tbName, dbFName); - CTG_CACHE_STAT_INC(numOfMetaHit, 1); + CTG_META_HIT_INC(tbCache->pMeta->tableType, 1); return TSDB_CODE_SUCCESS; @@ -343,7 +346,7 @@ int32_t ctgAcquireStbMetaFromCache(SCatalog *pCtg, char *dbFName, uint64_t suid, ctgDebug("stb 0x%" PRIx64 " meta got in cache, dbFName:%s", suid, dbFName); - CTG_CACHE_STAT_INC(numOfMetaHit, 1); + CTG_META_HIT_INC(pCache->pMeta->tableType, 1); return TSDB_CODE_SUCCESS; @@ -351,7 +354,7 @@ _return: ctgReleaseTbMetaToCache(pCtg, dbCache, pCache); - CTG_CACHE_STAT_INC(numOfMetaMiss, 1); + CTG_META_NHIT_INC(1); *pDb = NULL; *pTb = NULL; @@ -387,7 +390,7 @@ int32_t ctgAcquireStbMetaFromCache(SCtgDBCache *dbCache, SCatalog *pCtg, char *d ctgDebug("stb 0x%" PRIx64 " meta got in cache, dbFName:%s", suid, dbFName); - CTG_CACHE_STAT_INC(numOfMetaHit, 1); + CTG_META_HIT_INC(pCache->pMeta->tableType, 1); return TSDB_CODE_SUCCESS; @@ -395,7 +398,7 @@ _return: ctgReleaseTbMetaToCache(pCtg, dbCache, pCache); - CTG_CACHE_STAT_INC(numOfMetaMiss, 1); + CTG_META_NHIT_INC(1); *pTb = NULL; @@ -429,7 +432,7 @@ int32_t ctgAcquireTbIndexFromCache(SCatalog *pCtg, char *dbFName, char *tbName, ctgDebug("tb %s index got in cache, dbFName:%s", tbName, dbFName); - CTG_CACHE_STAT_INC(numOfIndexHit, 1); + CTG_CACHE_HIT_INC(CTG_CI_TBL_INDEX, 1); return TSDB_CODE_SUCCESS; @@ -437,7 +440,7 @@ _return: ctgReleaseTbIndexToCache(pCtg, dbCache, pCache); - CTG_CACHE_STAT_INC(numOfIndexMiss, 1); + CTG_CACHE_NHIT_INC(CTG_CI_TBL_INDEX, 1); return TSDB_CODE_SUCCESS; } @@ -704,7 +707,7 @@ int32_t ctgChkAuthFromCache(SCatalog *pCtg, char *user, char *dbFName, AUTH_TYPE *inCache = true; ctgDebug("Got user from cache, user:%s", user); - CTG_CACHE_STAT_INC(numOfUserHit, 1); + CTG_CACHE_HIT_INC(CTG_CI_USER, 1); if (pUser->superUser) { *pass = true; @@ -733,7 +736,7 @@ int32_t ctgChkAuthFromCache(SCatalog *pCtg, char *user, char *dbFName, AUTH_TYPE _return: *inCache = false; - CTG_CACHE_STAT_INC(numOfUserMiss, 1); + CTG_CACHE_NHIT_INC(CTG_CI_USER, 1); return TSDB_CODE_SUCCESS; } @@ -1384,7 +1387,7 @@ int32_t ctgAddNewDBCache(SCatalog *pCtg, const char *dbFName, uint64_t dbId) { CTG_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY); } - CTG_CACHE_STAT_INC(numOfDb, 1); + CTG_CACHE_NUM_INC(CTG_CI_DB, 1); SDbVgVersion vgVersion = {.dbId = newDBCache.dbId, .vgVersion = -1, .stateTs = 0}; tstrncpy(vgVersion.dbFName, dbFName, sizeof(vgVersion.dbFName)); @@ -1446,7 +1449,7 @@ int32_t ctgRemoveDBFromCache(SCatalog *pCtg, SCtgDBCache *dbCache, const char *d CTG_ERR_RET(TSDB_CODE_CTG_DB_DROPPED); } - CTG_CACHE_STAT_DEC(numOfDb, 1); + CTG_CACHE_NUM_DEC(CTG_CI_DB, 1); ctgInfo("db removed from cache, dbFName:%s, dbId:0x%" PRIx64, dbFName, dbId); return TSDB_CODE_SUCCESS; @@ -1544,7 +1547,7 @@ int32_t ctgWriteTbMetaToCache(SCatalog *pCtg, SCtgDBCache *dbCache, char *dbFNam if (taosHashRemove(dbCache->stbCache, &orig->suid, sizeof(orig->suid))) { ctgError("stb not exist in stbCache, dbFName:%s, stb:%s, suid:0x%" PRIx64, dbFName, tbName, orig->suid); } else { - CTG_CACHE_STAT_DEC(numOfStb, 1); + CTG_META_NUM_DEC(origType, 1); ctgDebug("stb removed from stbCache, dbFName:%s, stb:%s, suid:0x%" PRIx64, dbFName, tbName, orig->suid); } } @@ -1568,7 +1571,7 @@ int32_t ctgWriteTbMetaToCache(SCatalog *pCtg, SCtgDBCache *dbCache, char *dbFNam } if (NULL == orig) { - CTG_CACHE_STAT_INC(numOfTbl, 1); + CTG_META_NUM_INC(pCache->pMeta->tableType, 1); } ctgDebug("tbmeta updated to cache, dbFName:%s, tbName:%s, tbType:%d", dbFName, tbName, meta->tableType); @@ -1583,8 +1586,6 @@ int32_t ctgWriteTbMetaToCache(SCatalog *pCtg, SCtgDBCache *dbCache, char *dbFNam CTG_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); } - CTG_CACHE_STAT_INC(numOfStb, 1); - ctgDebug("stb 0x%" PRIx64 " updated to cache, dbFName:%s, tbName:%s, tbType:%d", meta->suid, dbFName, tbName, meta->tableType); @@ -1768,10 +1769,12 @@ int32_t ctgOpUpdateVgroup(SCtgCacheOperation *operation) { } freeVgInfo(vgInfo); + CTG_CACHE_NUM_DEC(CTG_CI_DB_VGROUP, 1); } vgCache->vgInfo = dbInfo; msg->dbInfo = NULL; + CTG_CACHE_NUM_INC(CTG_CI_DB_VGROUP, 1); ctgDebug("db vgInfo updated, dbFName:%s, vgVer:%d, stateTs:%" PRId64 ", dbId:0x%" PRIx64, dbFName, vgVersion.vgVersion, vgVersion.stateTs, vgVersion.dbId); @@ -1844,6 +1847,7 @@ int32_t ctgOpDropDbVgroup(SCtgCacheOperation *operation) { freeVgInfo(dbCache->vgCache.vgInfo); dbCache->vgCache.vgInfo = NULL; + CTG_CACHE_NUM_DEC(CTG_CI_DB_VGROUP, 1); ctgDebug("db vgInfo removed, dbFName:%s", msg->dbFName); ctgWUnlockVgInfo(dbCache); @@ -1913,6 +1917,7 @@ int32_t ctgOpDropStbMeta(SCtgCacheOperation *operation) { int32_t code = 0; SCtgDropStbMetaMsg *msg = operation->data; SCatalog *pCtg = msg->pCtg; + int32_t tblType = 0; if (pCtg->stopUpdate) { goto _return; @@ -1933,8 +1938,6 @@ int32_t ctgOpDropStbMeta(SCtgCacheOperation *operation) { if (taosHashRemove(dbCache->stbCache, &msg->suid, sizeof(msg->suid))) { ctgDebug("stb not exist in stbCache, may be removed, dbFName:%s, stb:%s, suid:0x%" PRIx64, msg->dbFName, msg->stbName, msg->suid); - } else { - CTG_CACHE_STAT_DEC(numOfStb, 1); } SCtgTbCache *pTbCache = taosHashGet(dbCache->tbCache, msg->stbName, strlen(msg->stbName)); @@ -1944,13 +1947,14 @@ int32_t ctgOpDropStbMeta(SCtgCacheOperation *operation) { } CTG_LOCK(CTG_WRITE, &pTbCache->metaLock); + tblType = pTbCache->pMeta->tableType; ctgFreeTbCacheImpl(pTbCache); CTG_UNLOCK(CTG_WRITE, &pTbCache->metaLock); if (taosHashRemove(dbCache->tbCache, msg->stbName, strlen(msg->stbName))) { ctgError("stb not exist in cache, dbFName:%s, stb:%s, suid:0x%" PRIx64, msg->dbFName, msg->stbName, msg->suid); } else { - CTG_CACHE_STAT_DEC(numOfTbl, 1); + CTG_META_NUM_DEC(tblType, 1); } ctgInfo("stb removed from cache, dbFName:%s, stbName:%s, suid:0x%" PRIx64, msg->dbFName, msg->stbName, msg->suid); @@ -1970,6 +1974,7 @@ int32_t ctgOpDropTbMeta(SCtgCacheOperation *operation) { int32_t code = 0; SCtgDropTblMetaMsg *msg = operation->data; SCatalog *pCtg = msg->pCtg; + int32_t tblType = 0; if (pCtg->stopUpdate) { goto _return; @@ -1994,6 +1999,7 @@ int32_t ctgOpDropTbMeta(SCtgCacheOperation *operation) { } CTG_LOCK(CTG_WRITE, &pTbCache->metaLock); + tblType = pTbCache->pMeta->tableType; ctgFreeTbCacheImpl(pTbCache); CTG_UNLOCK(CTG_WRITE, &pTbCache->metaLock); @@ -2001,7 +2007,7 @@ int32_t ctgOpDropTbMeta(SCtgCacheOperation *operation) { ctgError("tb %s not exist in cache, dbFName:%s", msg->tbName, msg->dbFName); CTG_ERR_JRET(TSDB_CODE_CTG_INTERNAL_ERROR); } else { - CTG_CACHE_STAT_DEC(numOfTbl, 1); + CTG_META_NUM_DEC(tblType, 1); } ctgDebug("table %s removed from cache, dbFName:%s", msg->tbName, msg->dbFName); @@ -2039,6 +2045,8 @@ int32_t ctgOpUpdateUser(SCtgCacheOperation *operation) { taosMemoryFreeClear(msg); + CTG_CACHE_NUM_INC(CTG_CI_USER, 1); + return TSDB_CODE_SUCCESS; } diff --git a/source/libs/catalog/src/ctgUtil.c b/source/libs/catalog/src/ctgUtil.c index 3dd40a4139..45aa95436e 100644 --- a/source/libs/catalog/src/ctgUtil.c +++ b/source/libs/catalog/src/ctgUtil.c @@ -203,7 +203,6 @@ void ctgFreeStbMetaCache(SCtgDBCache* dbCache) { int32_t stbNum = taosHashGetSize(dbCache->stbCache); taosHashCleanup(dbCache->stbCache); dbCache->stbCache = NULL; - CTG_CACHE_STAT_DEC(numOfStb, stbNum); } void ctgFreeTbCacheImpl(SCtgTbCache* pCache) { @@ -223,12 +222,14 @@ void ctgFreeTbCache(SCtgDBCache* dbCache) { int32_t tblNum = taosHashGetSize(dbCache->tbCache); SCtgTbCache* pCache = taosHashIterate(dbCache->tbCache, NULL); while (NULL != pCache) { + if (pCache->pMeta) { + CTG_META_NUM_DEC(pCache->pMeta->tableType, 1); + } ctgFreeTbCacheImpl(pCache); pCache = taosHashIterate(dbCache->tbCache, pCache); } taosHashCleanup(dbCache->tbCache); dbCache->tbCache = NULL; - CTG_CACHE_STAT_DEC(numOfTbl, tblNum); } void ctgFreeVgInfoCache(SCtgDBCache* dbCache) { freeVgInfo(dbCache->vgCache.vgInfo); } @@ -261,7 +262,7 @@ void ctgFreeInstDbCache(SHashObj* pDbCache) { taosHashCleanup(pDbCache); - CTG_CACHE_STAT_DEC(numOfDb, dbNum); + CTG_CACHE_NUM_DEC(CTG_CI_DB, dbNum); } void ctgFreeInstUserCache(SHashObj* pUserCache) { @@ -281,7 +282,7 @@ void ctgFreeInstUserCache(SHashObj* pUserCache) { taosHashCleanup(pUserCache); - CTG_CACHE_STAT_DEC(numOfUser, userNum); + CTG_CACHE_NUM_DEC(CTG_CI_USER, userNum); } void ctgFreeHandleImpl(SCatalog* pCtg) { @@ -307,7 +308,7 @@ void ctgFreeHandle(SCatalog* pCtg) { ctgFreeInstDbCache(pCtg->dbCache); ctgFreeInstUserCache(pCtg->userCache); - CTG_CACHE_STAT_DEC(numOfCluster, 1); + CTG_CACHE_NUM_DEC(CTG_CI_CLUSTER, 1); taosMemoryFree(pCtg); @@ -342,7 +343,7 @@ void ctgClearHandle(SCatalog* pCtg) { ctgError("taosHashInit %d user cache failed", gCtgMgmt.cfg.maxUserCacheNum); } - CTG_CACHE_STAT_INC(numOfClear, 1); + CTG_RT_STAT_INC(numOfOpClearCache, 1); ctgInfo("handle cleared, clusterId:0x%" PRIx64, clusterId); }