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

feat: add catalog cache stat

This commit is contained in:
dapan1121 2023-02-24 10:39:25 +08:00
parent 7337f5ff7d
commit 33e7c57fa5
5 changed files with 188 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

151
source/libs/catalog/inc/catalogInt.h
View File

@ -43,6 +43,29 @@ extern "C" {
#define CTG_BATCH_FETCH 1 #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 { enum {
CTG_READ = 1, CTG_READ = 1,
CTG_WRITE, CTG_WRITE,
@ -347,23 +370,13 @@ typedef struct SCtgRuntimeStat {
uint64_t numOfOpAbort; uint64_t numOfOpAbort;
uint64_t numOfOpEnqueue; uint64_t numOfOpEnqueue;
uint64_t numOfOpDequeue; uint64_t numOfOpDequeue;
uint64_t numOfOpClearCache;
} SCtgRuntimeStat; } SCtgRuntimeStat;
typedef struct SCtgCacheStat { typedef struct SCtgCacheStat {
uint64_t numOfCluster; uint64_t cacheNum[CTG_CI_MAX_VALUE];
uint64_t numOfDb; uint64_t cacheHit[CTG_CI_MAX_VALUE];
uint64_t numOfTbl; uint64_t cacheNHit[CTG_CI_MAX_VALUE];
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;
} SCtgCacheStat; } SCtgCacheStat;
typedef struct SCatalogStat { 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_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_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_NULL(type) ((type) == META_TYPE_NULL_TABLE)
#define CTG_IS_META_CTABLE(type) ((type) == META_TYPE_CTABLE) #define CTG_IS_META_CTABLE(type) ((type) == META_TYPE_CTABLE)
#define CTG_IS_META_TABLE(type) ((type) == META_TYPE_TABLE) #define CTG_IS_META_TABLE(type) ((type) == META_TYPE_TABLE)

7
source/libs/catalog/src/catalog.c
View File

@ -721,10 +721,13 @@ int32_t catalogGetHandle(uint64_t clusterId, SCatalog** catalogHandle) {
if (ctg && (*ctg)) { if (ctg && (*ctg)) {
*catalogHandle = *ctg; *catalogHandle = *ctg;
CTG_CACHE_HIT_INC(CTG_CI_CLUSTER, 1);
qDebug("got catalog handle from cache, clusterId:0x%" PRIx64 ", CTG:%p", clusterId, *ctg); qDebug("got catalog handle from cache, clusterId:0x%" PRIx64 ", CTG:%p", clusterId, *ctg);
CTG_API_LEAVE(TSDB_CODE_SUCCESS); CTG_API_LEAVE(TSDB_CODE_SUCCESS);
} }
CTG_CACHE_NHIT_INC(CTG_CI_CLUSTER, 1);
clusterCtg = taosMemoryCalloc(1, sizeof(SCatalog)); clusterCtg = taosMemoryCalloc(1, sizeof(SCatalog));
if (NULL == clusterCtg) { if (NULL == clusterCtg) {
qError("calloc %d failed", (int32_t)sizeof(SCatalog)); qError("calloc %d failed", (int32_t)sizeof(SCatalog));
@ -768,7 +771,7 @@ int32_t catalogGetHandle(uint64_t clusterId, SCatalog** catalogHandle) {
*catalogHandle = clusterCtg; *catalogHandle = clusterCtg;
CTG_CACHE_STAT_INC(numOfCluster, 1); CTG_CACHE_NUM_INC(CTG_CI_CLUSTER, 1);
CTG_API_LEAVE(TSDB_CODE_SUCCESS); 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_API_LEAVE(TSDB_CODE_CTG_INVALID_INPUT);
} }
CTG_CACHE_NHIT_INC(CTG_CI_QNODE, 1);
CTG_ERR_JRET(ctgGetQnodeListFromMnode(pCtg, pConn, pQnodeList, NULL)); CTG_ERR_JRET(ctgGetQnodeListFromMnode(pCtg, pConn, pQnodeList, NULL));
_return: _return:
@ -1316,6 +1320,7 @@ int32_t catalogGetDnodeList(SCatalog* pCtg, SRequestConnInfo* pConn, SArray** pD
CTG_API_LEAVE(TSDB_CODE_CTG_INVALID_INPUT); CTG_API_LEAVE(TSDB_CODE_CTG_INVALID_INPUT);
} }
CTG_CACHE_NHIT_INC(CTG_CI_DNODE, 1);
CTG_ERR_JRET(ctgGetDnodeListFromMnode(pCtg, pConn, pDnodeList, NULL)); CTG_ERR_JRET(ctgGetDnodeListFromMnode(pCtg, pConn, pDnodeList, NULL));
_return: _return:

2
source/libs/catalog/src/ctgAsync.c
View File

@ -1967,6 +1967,7 @@ int32_t ctgLaunchGetQnodeTask(SCtgTask* pTask) {
pMsgCtx->pBatchs = pJob->pBatchs; pMsgCtx->pBatchs = pJob->pBatchs;
} }
CTG_CACHE_NHIT_INC(CTG_CI_QNODE, 1);
CTG_ERR_RET(ctgGetQnodeListFromMnode(pCtg, pConn, NULL, pTask)); CTG_ERR_RET(ctgGetQnodeListFromMnode(pCtg, pConn, NULL, pTask));
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
@ -1980,6 +1981,7 @@ int32_t ctgLaunchGetDnodeTask(SCtgTask* pTask) {
pMsgCtx->pBatchs = pJob->pBatchs; pMsgCtx->pBatchs = pJob->pBatchs;
} }
CTG_CACHE_NHIT_INC(CTG_CI_DNODE, 1);
CTG_ERR_RET(ctgGetDnodeListFromMnode(pCtg, pConn, NULL, pTask)); CTG_ERR_RET(ctgGetDnodeListFromMnode(pCtg, pConn, NULL, pTask));
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }

64
source/libs/catalog/src/ctgCache.c
View File

@ -93,6 +93,7 @@ int32_t ctgAcquireDBCacheImpl(SCatalog *pCtg, const char *dbFName, SCtgDBCache *
if (NULL == dbCache) { if (NULL == dbCache) {
*pCache = NULL; *pCache = NULL;
CTG_CACHE_NHIT_INC(CTG_CI_DB, 1);
ctgDebug("db not in cache, dbFName:%s", dbFName); ctgDebug("db not in cache, dbFName:%s", dbFName);
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
@ -107,11 +108,13 @@ int32_t ctgAcquireDBCacheImpl(SCatalog *pCtg, const char *dbFName, SCtgDBCache *
} }
*pCache = NULL; *pCache = NULL;
CTG_CACHE_NHIT_INC(CTG_CI_DB, 1);
ctgDebug("db is removing from cache, dbFName:%s", dbFName); ctgDebug("db is removing from cache, dbFName:%s", dbFName);
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
*pCache = dbCache; *pCache = dbCache;
CTG_CACHE_HIT_INC(CTG_CI_DB, 1);
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
@ -180,7 +183,7 @@ int32_t ctgAcquireVgInfoFromCache(SCatalog *pCtg, const char *dbFName, SCtgDBCac
*pCache = dbCache; *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); ctgDebug("Got db vgInfo from cache, dbFName:%s", dbFName);
@ -194,7 +197,7 @@ _return:
*pCache = NULL; *pCache = NULL;
CTG_CACHE_STAT_INC(numOfVgMiss, 1); CTG_CACHE_NHIT_INC(CTG_CI_DB_VGROUP, 1);
return TSDB_CODE_SUCCESS; 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); 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; return TSDB_CODE_SUCCESS;
@ -233,7 +236,7 @@ _return:
ctgReleaseTbMetaToCache(pCtg, dbCache, pCache); ctgReleaseTbMetaToCache(pCtg, dbCache, pCache);
CTG_CACHE_STAT_INC(numOfMetaMiss, 1); CTG_META_NHIT_INC(1);
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
@ -246,34 +249,34 @@ int32_t ctgAcquireVgMetaFromCache(SCatalog *pCtg, const char *dbFName, const cha
ctgAcquireDBCache(pCtg, dbFName, &dbCache); ctgAcquireDBCache(pCtg, dbFName, &dbCache);
if (NULL == dbCache) { if (NULL == dbCache) {
ctgDebug("db %s not in cache", dbFName); ctgDebug("db %s not in cache", dbFName);
CTG_CACHE_STAT_INC(numOfVgMiss, 1); CTG_CACHE_NHIT_INC(CTG_CI_DB_VGROUP, 1);
goto _return; goto _return;
} }
ctgRLockVgInfo(pCtg, dbCache, &vgInCache); ctgRLockVgInfo(pCtg, dbCache, &vgInCache);
if (!vgInCache) { if (!vgInCache) {
ctgDebug("vgInfo of db %s not in cache", dbFName); 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; goto _return;
} }
*pDb = dbCache; *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); ctgDebug("Got db vgInfo from cache, dbFName:%s", dbFName);
tbCache = taosHashAcquire(dbCache->tbCache, tbName, strlen(tbName)); tbCache = taosHashAcquire(dbCache->tbCache, tbName, strlen(tbName));
if (NULL == tbCache) { if (NULL == tbCache) {
ctgDebug("tb %s not in cache, dbFName:%s", tbName, dbFName); ctgDebug("tb %s not in cache, dbFName:%s", tbName, dbFName);
CTG_CACHE_STAT_INC(numOfMetaMiss, 1); CTG_META_NHIT_INC(1);
goto _return; goto _return;
} }
CTG_LOCK(CTG_READ, &tbCache->metaLock); CTG_LOCK(CTG_READ, &tbCache->metaLock);
if (NULL == tbCache->pMeta) { if (NULL == tbCache->pMeta) {
ctgDebug("tb %s meta not in cache, dbFName:%s", tbName, dbFName); ctgDebug("tb %s meta not in cache, dbFName:%s", tbName, dbFName);
CTG_CACHE_STAT_INC(numOfMetaMiss, 1); CTG_META_NHIT_INC(1);
goto _return; 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); 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; 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); 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; return TSDB_CODE_SUCCESS;
@ -351,7 +354,7 @@ _return:
ctgReleaseTbMetaToCache(pCtg, dbCache, pCache); ctgReleaseTbMetaToCache(pCtg, dbCache, pCache);
CTG_CACHE_STAT_INC(numOfMetaMiss, 1); CTG_META_NHIT_INC(1);
*pDb = NULL; *pDb = NULL;
*pTb = 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); 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; return TSDB_CODE_SUCCESS;
@ -395,7 +398,7 @@ _return:
ctgReleaseTbMetaToCache(pCtg, dbCache, pCache); ctgReleaseTbMetaToCache(pCtg, dbCache, pCache);
CTG_CACHE_STAT_INC(numOfMetaMiss, 1); CTG_META_NHIT_INC(1);
*pTb = NULL; *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); 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; return TSDB_CODE_SUCCESS;
@ -437,7 +440,7 @@ _return:
ctgReleaseTbIndexToCache(pCtg, dbCache, pCache); ctgReleaseTbIndexToCache(pCtg, dbCache, pCache);
CTG_CACHE_STAT_INC(numOfIndexMiss, 1); CTG_CACHE_NHIT_INC(CTG_CI_TBL_INDEX, 1);
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
@ -704,7 +707,7 @@ int32_t ctgChkAuthFromCache(SCatalog *pCtg, char *user, char *dbFName, AUTH_TYPE
*inCache = true; *inCache = true;
ctgDebug("Got user from cache, user:%s", user); 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) { if (pUser->superUser) {
*pass = true; *pass = true;
@ -733,7 +736,7 @@ int32_t ctgChkAuthFromCache(SCatalog *pCtg, char *user, char *dbFName, AUTH_TYPE
_return: _return:
*inCache = false; *inCache = false;
CTG_CACHE_STAT_INC(numOfUserMiss, 1); CTG_CACHE_NHIT_INC(CTG_CI_USER, 1);
return TSDB_CODE_SUCCESS; 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_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}; SDbVgVersion vgVersion = {.dbId = newDBCache.dbId, .vgVersion = -1, .stateTs = 0};
tstrncpy(vgVersion.dbFName, dbFName, sizeof(vgVersion.dbFName)); 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_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); ctgInfo("db removed from cache, dbFName:%s, dbId:0x%" PRIx64, dbFName, dbId);
return TSDB_CODE_SUCCESS; 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))) { 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); ctgError("stb not exist in stbCache, dbFName:%s, stb:%s, suid:0x%" PRIx64, dbFName, tbName, orig->suid);
} else { } 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); 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) { 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); 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_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, ctgDebug("stb 0x%" PRIx64 " updated to cache, dbFName:%s, tbName:%s, tbType:%d", meta->suid, dbFName, tbName,
meta->tableType); meta->tableType);
@ -1768,10 +1769,12 @@ int32_t ctgOpUpdateVgroup(SCtgCacheOperation *operation) {
} }
freeVgInfo(vgInfo); freeVgInfo(vgInfo);
CTG_CACHE_NUM_DEC(CTG_CI_DB_VGROUP, 1);
} }
vgCache->vgInfo = dbInfo; vgCache->vgInfo = dbInfo;
msg->dbInfo = NULL; 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, ctgDebug("db vgInfo updated, dbFName:%s, vgVer:%d, stateTs:%" PRId64 ", dbId:0x%" PRIx64, dbFName,
vgVersion.vgVersion, vgVersion.stateTs, vgVersion.dbId); vgVersion.vgVersion, vgVersion.stateTs, vgVersion.dbId);
@ -1844,6 +1847,7 @@ int32_t ctgOpDropDbVgroup(SCtgCacheOperation *operation) {
freeVgInfo(dbCache->vgCache.vgInfo); freeVgInfo(dbCache->vgCache.vgInfo);
dbCache->vgCache.vgInfo = NULL; dbCache->vgCache.vgInfo = NULL;
CTG_CACHE_NUM_DEC(CTG_CI_DB_VGROUP, 1);
ctgDebug("db vgInfo removed, dbFName:%s", msg->dbFName); ctgDebug("db vgInfo removed, dbFName:%s", msg->dbFName);
ctgWUnlockVgInfo(dbCache); ctgWUnlockVgInfo(dbCache);
@ -1913,6 +1917,7 @@ int32_t ctgOpDropStbMeta(SCtgCacheOperation *operation) {
int32_t code = 0; int32_t code = 0;
SCtgDropStbMetaMsg *msg = operation->data; SCtgDropStbMetaMsg *msg = operation->data;
SCatalog *pCtg = msg->pCtg; SCatalog *pCtg = msg->pCtg;
int32_t tblType = 0;
if (pCtg->stopUpdate) { if (pCtg->stopUpdate) {
goto _return; goto _return;
@ -1933,8 +1938,6 @@ int32_t ctgOpDropStbMeta(SCtgCacheOperation *operation) {
if (taosHashRemove(dbCache->stbCache, &msg->suid, sizeof(msg->suid))) { 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, ctgDebug("stb not exist in stbCache, may be removed, dbFName:%s, stb:%s, suid:0x%" PRIx64, msg->dbFName,
msg->stbName, msg->suid); msg->stbName, msg->suid);
} else {
CTG_CACHE_STAT_DEC(numOfStb, 1);
} }
SCtgTbCache *pTbCache = taosHashGet(dbCache->tbCache, msg->stbName, strlen(msg->stbName)); 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); CTG_LOCK(CTG_WRITE, &pTbCache->metaLock);
tblType = pTbCache->pMeta->tableType;
ctgFreeTbCacheImpl(pTbCache); ctgFreeTbCacheImpl(pTbCache);
CTG_UNLOCK(CTG_WRITE, &pTbCache->metaLock); CTG_UNLOCK(CTG_WRITE, &pTbCache->metaLock);
if (taosHashRemove(dbCache->tbCache, msg->stbName, strlen(msg->stbName))) { 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); ctgError("stb not exist in cache, dbFName:%s, stb:%s, suid:0x%" PRIx64, msg->dbFName, msg->stbName, msg->suid);
} else { } 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); 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; int32_t code = 0;
SCtgDropTblMetaMsg *msg = operation->data; SCtgDropTblMetaMsg *msg = operation->data;
SCatalog *pCtg = msg->pCtg; SCatalog *pCtg = msg->pCtg;
int32_t tblType = 0;
if (pCtg->stopUpdate) { if (pCtg->stopUpdate) {
goto _return; goto _return;
@ -1994,6 +1999,7 @@ int32_t ctgOpDropTbMeta(SCtgCacheOperation *operation) {
} }
CTG_LOCK(CTG_WRITE, &pTbCache->metaLock); CTG_LOCK(CTG_WRITE, &pTbCache->metaLock);
tblType = pTbCache->pMeta->tableType;
ctgFreeTbCacheImpl(pTbCache); ctgFreeTbCacheImpl(pTbCache);
CTG_UNLOCK(CTG_WRITE, &pTbCache->metaLock); 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); ctgError("tb %s not exist in cache, dbFName:%s", msg->tbName, msg->dbFName);
CTG_ERR_JRET(TSDB_CODE_CTG_INTERNAL_ERROR); CTG_ERR_JRET(TSDB_CODE_CTG_INTERNAL_ERROR);
} else { } 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); ctgDebug("table %s removed from cache, dbFName:%s", msg->tbName, msg->dbFName);
@ -2039,6 +2045,8 @@ int32_t ctgOpUpdateUser(SCtgCacheOperation *operation) {
taosMemoryFreeClear(msg); taosMemoryFreeClear(msg);
CTG_CACHE_NUM_INC(CTG_CI_USER, 1);
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }

13
source/libs/catalog/src/ctgUtil.c
View File

@ -203,7 +203,6 @@ void ctgFreeStbMetaCache(SCtgDBCache* dbCache) {
int32_t stbNum = taosHashGetSize(dbCache->stbCache); int32_t stbNum = taosHashGetSize(dbCache->stbCache);
taosHashCleanup(dbCache->stbCache); taosHashCleanup(dbCache->stbCache);
dbCache->stbCache = NULL; dbCache->stbCache = NULL;
CTG_CACHE_STAT_DEC(numOfStb, stbNum);
} }
void ctgFreeTbCacheImpl(SCtgTbCache* pCache) { void ctgFreeTbCacheImpl(SCtgTbCache* pCache) {
@ -223,12 +222,14 @@ void ctgFreeTbCache(SCtgDBCache* dbCache) {
int32_t tblNum = taosHashGetSize(dbCache->tbCache); int32_t tblNum = taosHashGetSize(dbCache->tbCache);
SCtgTbCache* pCache = taosHashIterate(dbCache->tbCache, NULL); SCtgTbCache* pCache = taosHashIterate(dbCache->tbCache, NULL);
while (NULL != pCache) { while (NULL != pCache) {
if (pCache->pMeta) {
CTG_META_NUM_DEC(pCache->pMeta->tableType, 1);
}
ctgFreeTbCacheImpl(pCache); ctgFreeTbCacheImpl(pCache);
pCache = taosHashIterate(dbCache->tbCache, pCache); pCache = taosHashIterate(dbCache->tbCache, pCache);
} }
taosHashCleanup(dbCache->tbCache); taosHashCleanup(dbCache->tbCache);
dbCache->tbCache = NULL; dbCache->tbCache = NULL;
CTG_CACHE_STAT_DEC(numOfTbl, tblNum);
} }
void ctgFreeVgInfoCache(SCtgDBCache* dbCache) { freeVgInfo(dbCache->vgCache.vgInfo); } void ctgFreeVgInfoCache(SCtgDBCache* dbCache) { freeVgInfo(dbCache->vgCache.vgInfo); }
@ -261,7 +262,7 @@ void ctgFreeInstDbCache(SHashObj* pDbCache) {
taosHashCleanup(pDbCache); taosHashCleanup(pDbCache);
CTG_CACHE_STAT_DEC(numOfDb, dbNum); CTG_CACHE_NUM_DEC(CTG_CI_DB, dbNum);
} }
void ctgFreeInstUserCache(SHashObj* pUserCache) { void ctgFreeInstUserCache(SHashObj* pUserCache) {
@ -281,7 +282,7 @@ void ctgFreeInstUserCache(SHashObj* pUserCache) {
taosHashCleanup(pUserCache); taosHashCleanup(pUserCache);
CTG_CACHE_STAT_DEC(numOfUser, userNum); CTG_CACHE_NUM_DEC(CTG_CI_USER, userNum);
} }
void ctgFreeHandleImpl(SCatalog* pCtg) { void ctgFreeHandleImpl(SCatalog* pCtg) {
@ -307,7 +308,7 @@ void ctgFreeHandle(SCatalog* pCtg) {
ctgFreeInstDbCache(pCtg->dbCache); ctgFreeInstDbCache(pCtg->dbCache);
ctgFreeInstUserCache(pCtg->userCache); ctgFreeInstUserCache(pCtg->userCache);
CTG_CACHE_STAT_DEC(numOfCluster, 1); CTG_CACHE_NUM_DEC(CTG_CI_CLUSTER, 1);
taosMemoryFree(pCtg); taosMemoryFree(pCtg);
@ -342,7 +343,7 @@ void ctgClearHandle(SCatalog* pCtg) {
ctgError("taosHashInit %d user cache failed", gCtgMgmt.cfg.maxUserCacheNum); 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); ctgInfo("handle cleared, clusterId:0x%" PRIx64, clusterId);
} }