diff --git a/source/libs/catalog/inc/catalogInt.h b/source/libs/catalog/inc/catalogInt.h index 8fc7df63be2204f872bcf0eca8def42deb819d9e..c4e1fd3078b18d74df3e89a4a9ea2d82f26cef0e 100644 --- a/source/libs/catalog/inc/catalogInt.h +++ b/source/libs/catalog/inc/catalogInt.h @@ -43,6 +43,32 @@ extern "C" { #define CTG_BATCH_FETCH 1 +typedef enum { + CTG_CI_CLUSTER = 0, + 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_SMA, + CTG_CI_TBL_CFG, + CTG_CI_INDEX_INFO, + CTG_CI_USER, + CTG_CI_UDF, + CTG_CI_SVR_VER, + CTG_CI_MAX_VALUE, +} CTG_CACHE_ITEM; + +#define CTG_CI_FLAG_LEVEL_GLOBAL (1) +#define CTG_CI_FLAG_LEVEL_CLUSTER (1<<1) +#define CTG_CI_FLAG_LEVEL_DB (1<<2) + enum { CTG_READ = 1, CTG_WRITE, @@ -76,9 +102,9 @@ typedef enum { CTG_TASK_GET_DB_INFO, CTG_TASK_GET_TB_META, CTG_TASK_GET_TB_HASH, - CTG_TASK_GET_TB_INDEX, + CTG_TASK_GET_TB_SMA_INDEX, CTG_TASK_GET_TB_CFG, - CTG_TASK_GET_INDEX, + CTG_TASK_GET_INDEX_INFO, CTG_TASK_GET_UDF, CTG_TASK_GET_USER, CTG_TASK_GET_SVR_VER, @@ -96,9 +122,16 @@ typedef struct SCtgDebug { bool cacheEnable; bool apiEnable; bool metaEnable; + bool statEnable; uint32_t showCachePeriodSec; } SCtgDebug; +typedef struct SCtgCacheStat { + uint64_t cacheNum[CTG_CI_MAX_VALUE]; + uint64_t cacheHit[CTG_CI_MAX_VALUE]; + uint64_t cacheNHit[CTG_CI_MAX_VALUE]; +} SCtgCacheStat; + typedef struct SCtgTbCacheInfo { bool inCache; uint64_t dbId; @@ -191,12 +224,13 @@ typedef struct SCtgVgCache { } SCtgVgCache; typedef struct SCtgDBCache { - SRWLatch dbLock; // RC between destroy tbCache/stbCache and all reads - uint64_t dbId; - int8_t deleted; - SCtgVgCache vgCache; - SHashObj* tbCache; // key:tbname, value:SCtgTbCache - SHashObj* stbCache; // key:suid, value:char* + SRWLatch dbLock; // RC between destroy tbCache/stbCache and all reads + uint64_t dbId; + int8_t deleted; + SCtgVgCache vgCache; + SHashObj* tbCache; // key:tbname, value:SCtgTbCache + SHashObj* stbCache; // key:suid, value:char* + uint64_t dbCacheNum[CTG_CI_MAX_VALUE]; } SCtgDBCache; typedef struct SCtgRentSlot { @@ -223,12 +257,13 @@ typedef struct SCtgUserAuth { } SCtgUserAuth; typedef struct SCatalog { - uint64_t clusterId; - bool stopUpdate; - SHashObj* userCache; // key:user, value:SCtgUserAuth - SHashObj* dbCache; // key:dbname, value:SCtgDBCache - SCtgRentMgmt dbRent; - SCtgRentMgmt stbRent; + uint64_t clusterId; + bool stopUpdate; + SHashObj* userCache; // key:user, value:SCtgUserAuth + SHashObj* dbCache; // key:dbname, value:SCtgDBCache + SCtgRentMgmt dbRent; + SCtgRentMgmt stbRent; + SCtgCacheStat cacheStat; } SCatalog; typedef struct SCtgBatch { @@ -347,25 +382,9 @@ 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; -} SCtgCacheStat; - typedef struct SCatalogStat { SCtgApiStat api; SCtgRuntimeStat runtime; @@ -472,7 +491,7 @@ typedef struct SCatalogMgmt { SCtgQueue queue; TdThread updateThread; SHashObj* pCluster; // key: clusterId, value: SCatalog* - SCatalogStat stat; + SCatalogStat statInfo; SCatalogCfg cfg; } SCatalogMgmt; @@ -485,6 +504,11 @@ typedef struct SCtgOperation { ctgOpFunc func; } SCtgOperation; +typedef struct SCtgCacheItemInfo { + char *name; + int32_t flag; +} SCtgCacheItemInfo; + #define CTG_AUTH_READ(_t) ((_t) == AUTH_TYPE_READ || (_t) == AUTH_TYPE_READ_OR_WRITE) #define CTG_AUTH_WRITE(_t) ((_t) == AUTH_TYPE_WRITE || (_t) == AUTH_TYPE_READ_OR_WRITE) @@ -495,9 +519,87 @@ typedef struct SCtgOperation { #define CTG_STAT_DEC(_item, _n) atomic_sub_fetch_64(&(_item), _n) #define CTG_STAT_GET(_item) atomic_load_64(&(_item)) -#define CTG_RT_STAT_INC(item, n) (CTG_STAT_INC(gCtgMgmt.stat.runtime.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_DB_NUM_INC(_item) dbCache->dbCacheNum[_item] += 1 +#define CTG_DB_NUM_DEC(_item) dbCache->dbCacheNum[_item] -= 1 +#define CTG_DB_NUM_SET(_item) dbCache->dbCacheNum[_item] = 1 +#define CTG_DB_NUM_RESET(_item) dbCache->dbCacheNum[_item] = 0 + +#define CTG_STAT_API_INC(item, n) (CTG_STAT_INC(gCtgMgmt.statInfo.api.item, n)) +#define CTG_STAT_RT_INC(item, n) (CTG_STAT_INC(gCtgMgmt.statInfo.runtime.item, n)) +#define CTG_STAT_NUM_INC(item, n) (CTG_STAT_INC(gCtgMgmt.statInfo.cache.cacheNum[item], n)) +#define CTG_STAT_NUM_DEC(item, n) (CTG_STAT_DEC(gCtgMgmt.statInfo.cache.cacheNum[item], n)) +#define CTG_STAT_HIT_INC(item, n) (CTG_STAT_INC(gCtgMgmt.statInfo.cache.cacheHit[item], n)) +#define CTG_STAT_HIT_DEC(item, n) (CTG_STAT_DEC(gCtgMgmt.statInfo.cache.cacheHit[item], n)) +#define CTG_STAT_NHIT_INC(item, n) (CTG_STAT_INC(gCtgMgmt.statInfo.cache.cacheNHit[item], n)) +#define CTG_STAT_NHIT_DEC(item, n) (CTG_STAT_DEC(gCtgMgmt.statInfo.cache.cacheNHit[item], n)) + +#define CTG_CACHE_NUM_INC(item, n) (CTG_STAT_INC(pCtg->cacheStat.cacheNum[item], n)) +#define CTG_CACHE_NUM_DEC(item, n) (CTG_STAT_DEC(pCtg->cacheStat.cacheNum[item], n)) +#define CTG_CACHE_HIT_INC(item, n) (CTG_STAT_INC(pCtg->cacheStat.cacheHit[item], n)) +#define CTG_CACHE_NHIT_INC(item, n) (CTG_STAT_INC(pCtg->cacheStat.cacheNHit[item], n)) + +#define CTG_META_NUM_INC(type) do { \ + switch (type) { \ + case TSDB_SUPER_TABLE: \ + CTG_DB_NUM_INC(CTG_CI_STABLE_META); \ + break; \ + case TSDB_CHILD_TABLE: \ + CTG_DB_NUM_INC(CTG_CI_CTABLE_META); \ + break; \ + case TSDB_NORMAL_TABLE: \ + CTG_DB_NUM_INC(CTG_CI_NTABLE_META); \ + break; \ + case TSDB_SYSTEM_TABLE: \ + CTG_DB_NUM_INC(CTG_CI_SYSTABLE_META); \ + break; \ + default: \ + CTG_DB_NUM_INC(CTG_CI_OTHERTABLE_META); \ + break; \ + } \ +} while (0) + +#define CTG_META_NUM_DEC(type) do { \ + switch (type) { \ + case TSDB_SUPER_TABLE: \ + CTG_DB_NUM_DEC(CTG_CI_STABLE_META); \ + break; \ + case TSDB_CHILD_TABLE: \ + CTG_DB_NUM_DEC(CTG_CI_CTABLE_META); \ + break; \ + case TSDB_NORMAL_TABLE: \ + CTG_DB_NUM_DEC(CTG_CI_NTABLE_META); \ + break; \ + case TSDB_SYSTEM_TABLE: \ + CTG_DB_NUM_DEC(CTG_CI_SYSTABLE_META); \ + break; \ + default: \ + CTG_DB_NUM_DEC(CTG_CI_OTHERTABLE_META); \ + break; \ + } \ +} while (0) + +#define CTG_META_HIT_INC(type) do { \ + switch (type) { \ + case TSDB_SUPER_TABLE: \ + CTG_CACHE_HIT_INC(CTG_CI_STABLE_META, 1); \ + break; \ + case TSDB_CHILD_TABLE: \ + CTG_CACHE_HIT_INC(CTG_CI_CTABLE_META, 1); \ + break; \ + case TSDB_NORMAL_TABLE: \ + CTG_CACHE_HIT_INC(CTG_CI_NTABLE_META, 1); \ + break; \ + case TSDB_SYSTEM_TABLE: \ + CTG_CACHE_HIT_INC(CTG_CI_SYSTABLE_META, 1); \ + break; \ + default: \ + CTG_CACHE_HIT_INC(CTG_CI_OTHERTABLE_META, 1); \ + break; \ + } \ +} while (0) + +#define CTG_META_NHIT_INC() CTG_CACHE_NHIT_INC(CTG_CI_OTHERTABLE_META, 1) + #define CTG_IS_META_NULL(type) ((type) == META_TYPE_NULL_TABLE) #define CTG_IS_META_CTABLE(type) ((type) == META_TYPE_CTABLE) @@ -682,6 +784,7 @@ typedef struct SCtgOperation { void ctgdShowTableMeta(SCatalog* pCtg, const char* tbName, STableMeta* p); void ctgdShowClusterCache(SCatalog* pCtg); int32_t ctgdShowCacheInfo(void); +int32_t ctgdShowStatInfo(void); int32_t ctgRemoveTbMetaFromCache(SCatalog* pCtg, SName* pTableName, bool syncReq); int32_t ctgGetTbMetaFromCache(SCatalog* pCtg, SCtgTbMetaCtx* ctx, STableMeta** pTableMeta); @@ -806,10 +909,12 @@ int32_t ctgAcquireVgMetaFromCache(SCatalog *pCtg, const char *dbFName, const cha int32_t ctgCopyTbMeta(SCatalog *pCtg, SCtgTbMetaCtx *ctx, SCtgDBCache **pDb, SCtgTbCache **pTb, STableMeta **pTableMeta, char* dbFName); void ctgReleaseVgMetaToCache(SCatalog *pCtg, SCtgDBCache *dbCache, SCtgTbCache *pCache); void ctgReleaseTbMetaToCache(SCatalog *pCtg, SCtgDBCache *dbCache, SCtgTbCache *pCache); +void ctgGetGlobalCacheStat(SCtgCacheStat *pStat); extern SCatalogMgmt gCtgMgmt; extern SCtgDebug gCTGDebug; extern SCtgAsyncFps gCtgAsyncFps[]; +extern SCtgCacheItemInfo gCtgStatItem[CTG_CI_MAX_VALUE]; #ifdef __cplusplus } diff --git a/source/libs/catalog/src/catalog.c b/source/libs/catalog/src/catalog.c index f9a218835ea77d4a20aa1b7ac8086187c995c561..8a56b0889b679b750e7077662dbbc4361e478310 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_STAT_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_STAT_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_STAT_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: @@ -1388,6 +1393,8 @@ int32_t catalogGetDBCfg(SCatalog* pCtg, SRequestConnInfo* pConn, const char* dbF CTG_API_LEAVE(TSDB_CODE_CTG_INVALID_INPUT); } + CTG_CACHE_NHIT_INC(CTG_CI_DB_CFG, 1); + CTG_API_LEAVE(ctgGetDBCfgFromMnode(pCtg, pConn, dbFName, pDbCfg, NULL)); } @@ -1440,6 +1447,8 @@ int32_t catalogGetUdfInfo(SCatalog* pCtg, SRequestConnInfo* pConn, const char* f CTG_API_LEAVE(TSDB_CODE_CTG_INVALID_INPUT); } + CTG_CACHE_NHIT_INC(CTG_CI_UDF, 1); + int32_t code = 0; CTG_ERR_JRET(ctgGetUdfInfoFromMnode(pCtg, pConn, funcName, pInfo, NULL)); @@ -1488,6 +1497,8 @@ int32_t catalogGetServerVersion(SCatalog* pCtg, SRequestConnInfo* pConn, char** CTG_API_LEAVE(TSDB_CODE_CTG_INVALID_INPUT); } + CTG_CACHE_NHIT_INC(CTG_CI_SVR_VER, 1); + int32_t code = 0; CTG_ERR_JRET(ctgGetSvrVerFromMnode(pCtg, pConn, pVersion, NULL)); diff --git a/source/libs/catalog/src/ctgAsync.c b/source/libs/catalog/src/ctgAsync.c index f62e93b82a9374ae751cb9e4b5bbde797d62e200..6c5666193753aea698559937c660022a5650bbbb 100644 --- a/source/libs/catalog/src/ctgAsync.c +++ b/source/libs/catalog/src/ctgAsync.c @@ -241,7 +241,7 @@ int32_t ctgInitGetIndexTask(SCtgJob* pJob, int32_t taskIdx, void* param) { char* name = (char*)param; SCtgTask task = {0}; - task.type = CTG_TASK_GET_INDEX; + task.type = CTG_TASK_GET_INDEX_INFO; task.taskId = taskIdx; task.pJob = pJob; @@ -330,7 +330,7 @@ int32_t ctgInitGetTbIndexTask(SCtgJob* pJob, int32_t taskIdx, void* param) { SName* name = (SName*)param; SCtgTask task = {0}; - task.type = CTG_TASK_GET_TB_INDEX; + task.type = CTG_TASK_GET_TB_SMA_INDEX; task.taskId = taskIdx; task.pJob = pJob; @@ -596,7 +596,7 @@ int32_t ctgInitJob(SCatalog* pCtg, SRequestConnInfo* pConn, SCtgJob** job, const for (int32_t i = 0; i < tbIndexNum; ++i) { SName* name = taosArrayGet(pReq->pTableIndex, i); - CTG_ERR_JRET(ctgInitTask(pJob, CTG_TASK_GET_TB_INDEX, name, NULL)); + CTG_ERR_JRET(ctgInitTask(pJob, CTG_TASK_GET_TB_SMA_INDEX, name, NULL)); } for (int32_t i = 0; i < tbCfgNum; ++i) { @@ -606,7 +606,7 @@ int32_t ctgInitJob(SCatalog* pCtg, SRequestConnInfo* pConn, SCtgJob** job, const for (int32_t i = 0; i < indexNum; ++i) { char* indexName = taosArrayGet(pReq->pIndex, i); - CTG_ERR_JRET(ctgInitTask(pJob, CTG_TASK_GET_INDEX, indexName, NULL)); + CTG_ERR_JRET(ctgInitTask(pJob, CTG_TASK_GET_INDEX_INFO, indexName, NULL)); } for (int32_t i = 0; i < udfNum; ++i) { @@ -1925,6 +1925,8 @@ int32_t ctgLaunchGetTbCfgTask(SCtgTask* pTask) { pMsgCtx->pBatchs = pJob->pBatchs; } + CTG_CACHE_NHIT_INC(CTG_CI_TBL_CFG, 1); + if (pCtx->tbType <= 0) { CTG_ERR_JRET(ctgReadTbTypeFromCache(pCtg, dbFName, pCtx->pName->tname, &pCtx->tbType)); if (pCtx->tbType <= 0) { @@ -1967,6 +1969,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 +1983,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; } @@ -1994,6 +1998,8 @@ int32_t ctgLaunchGetDbCfgTask(SCtgTask* pTask) { pMsgCtx->pBatchs = pJob->pBatchs; } + CTG_CACHE_NHIT_INC(CTG_CI_DB_CFG, 1); + CTG_ERR_RET(ctgGetDBCfgFromMnode(pCtg, pConn, pCtx->dbFName, NULL, pTask)); return TSDB_CODE_SUCCESS; @@ -2023,10 +2029,14 @@ int32_t ctgLaunchGetDbInfoTask(SCtgTask* pTask) { pInfo->tbNum = dbCache->vgCache.vgInfo->numOfTable; pInfo->stateTs = dbCache->vgCache.vgInfo->stateTs; + CTG_CACHE_HIT_INC(CTG_CI_DB_INFO, 1); + ctgReleaseVgInfoToCache(pCtg, dbCache); dbCache = NULL; } else { pInfo->vgVer = CTG_DEFAULT_INVALID_VERSION; + + CTG_CACHE_NHIT_INC(CTG_CI_DB_INFO, 1); } CTG_ERR_JRET(ctgHandleTaskEnd(pTask, 0)); @@ -2046,6 +2056,8 @@ int32_t ctgLaunchGetIndexTask(SCtgTask* pTask) { pMsgCtx->pBatchs = pJob->pBatchs; } + CTG_CACHE_NHIT_INC(CTG_CI_INDEX_INFO, 1); + CTG_ERR_RET(ctgGetIndexInfoFromMnode(pCtg, pConn, pCtx->indexFName, NULL, pTask)); return TSDB_CODE_SUCCESS; @@ -2061,6 +2073,8 @@ int32_t ctgLaunchGetUdfTask(SCtgTask* pTask) { pMsgCtx->pBatchs = pJob->pBatchs; } + CTG_CACHE_NHIT_INC(CTG_CI_UDF, 1); + CTG_ERR_RET(ctgGetUdfInfoFromMnode(pCtg, pConn, pCtx->udfName, NULL, pTask)); return TSDB_CODE_SUCCESS; @@ -2104,6 +2118,8 @@ int32_t ctgLaunchGetSvrVerTask(SCtgTask* pTask) { pMsgCtx->pBatchs = pJob->pBatchs; } + CTG_CACHE_NHIT_INC(CTG_CI_SVR_VER, 1); + CTG_ERR_RET(ctgGetSvrVerFromMnode(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 7ff8afd6a510f16c6a47df25550c9d2dbd0e3543..b0321588651a73da880fa062c9b4e87baa478955 100644 --- a/source/libs/catalog/src/ctgCache.c +++ b/source/libs/catalog/src/ctgCache.c @@ -31,6 +31,28 @@ SCtgOperation gCtgCacheOperation[CTG_OP_MAX] = {{CTG_OP_UPDATE_VGROUP, "update v {CTG_OP_DROP_TB_INDEX, "drop tbIndex", ctgOpDropTbIndex}, {CTG_OP_CLEAR_CACHE, "clear cache", ctgOpClearCache}}; +SCtgCacheItemInfo gCtgStatItem[CTG_CI_MAX_VALUE] = { + {"Cluster ", CTG_CI_FLAG_LEVEL_GLOBAL}, //CTG_CI_CLUSTER + {"Dnode ", CTG_CI_FLAG_LEVEL_CLUSTER}, //CTG_CI_DNODE, + {"Qnode ", CTG_CI_FLAG_LEVEL_CLUSTER}, //CTG_CI_QNODE, + {"DB ", CTG_CI_FLAG_LEVEL_CLUSTER}, //CTG_CI_DB, + {"DbVgroup ", CTG_CI_FLAG_LEVEL_DB}, //CTG_CI_DB_VGROUP, + {"DbCfg ", CTG_CI_FLAG_LEVEL_DB}, //CTG_CI_DB_CFG, + {"DbInfo ", CTG_CI_FLAG_LEVEL_DB}, //CTG_CI_DB_INFO, + {"StbMeta ", CTG_CI_FLAG_LEVEL_DB}, //CTG_CI_STABLE_META, + {"NtbMeta ", CTG_CI_FLAG_LEVEL_DB}, //CTG_CI_NTABLE_META, + {"CtbMeta ", CTG_CI_FLAG_LEVEL_DB}, //CTG_CI_CTABLE_META, + {"SysTblMeta", CTG_CI_FLAG_LEVEL_DB}, //CTG_CI_SYSTABLE_META, + {"OthTblMeta", CTG_CI_FLAG_LEVEL_DB}, //CTG_CI_OTHERTABLE_META, + {"TblSMA ", CTG_CI_FLAG_LEVEL_DB}, //CTG_CI_TBL_SMA, + {"TblCfg ", CTG_CI_FLAG_LEVEL_DB}, //CTG_CI_TBL_CFG, + {"IndexInfo ", CTG_CI_FLAG_LEVEL_DB}, //CTG_CI_INDEX_INFO, + {"User ", CTG_CI_FLAG_LEVEL_CLUSTER}, //CTG_CI_USER, + {"UDF ", CTG_CI_FLAG_LEVEL_CLUSTER}, //CTG_CI_UDF, + {"SvrVer ", CTG_CI_FLAG_LEVEL_CLUSTER} //CTG_CI_SVR_VER, +}; + + int32_t ctgRLockVgInfo(SCatalog *pCtg, SCtgDBCache *dbCache, bool *inCache) { CTG_LOCK(CTG_READ, &dbCache->vgCache.vgLock); @@ -93,6 +115,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 +130,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 +205,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 +219,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 +250,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); return TSDB_CODE_SUCCESS; @@ -233,7 +258,7 @@ _return: ctgReleaseTbMetaToCache(pCtg, dbCache, pCache); - CTG_CACHE_STAT_INC(numOfMetaMiss, 1); + CTG_META_NHIT_INC(); return TSDB_CODE_SUCCESS; } @@ -246,34 +271,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(); 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(); goto _return; } @@ -281,7 +306,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); return TSDB_CODE_SUCCESS; @@ -343,7 +368,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 +376,7 @@ _return: ctgReleaseTbMetaToCache(pCtg, dbCache, pCache); - CTG_CACHE_STAT_INC(numOfMetaMiss, 1); + CTG_META_NHIT_INC(1); *pDb = NULL; *pTb = NULL; @@ -387,7 +412,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); return TSDB_CODE_SUCCESS; @@ -395,7 +420,7 @@ _return: ctgReleaseTbMetaToCache(pCtg, dbCache, pCache); - CTG_CACHE_STAT_INC(numOfMetaMiss, 1); + CTG_META_NHIT_INC(); *pTb = NULL; @@ -429,7 +454,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_SMA, 1); return TSDB_CODE_SUCCESS; @@ -437,7 +462,7 @@ _return: ctgReleaseTbIndexToCache(pCtg, dbCache, pCache); - CTG_CACHE_STAT_INC(numOfIndexMiss, 1); + CTG_CACHE_NHIT_INC(CTG_CI_TBL_SMA, 1); return TSDB_CODE_SUCCESS; } @@ -702,7 +727,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; @@ -731,7 +756,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; } @@ -784,7 +809,7 @@ int32_t ctgEnqueue(SCatalog *pCtg, SCtgCacheOperation *operation) { ctgDebug("action [%s] added into queue", opName); CTG_QUEUE_INC(); - CTG_RT_STAT_INC(numOfOpEnqueue, 1); + CTG_STAT_RT_INC(numOfOpEnqueue, 1); tsem_post(&gCtgMgmt.queue.reqSem); @@ -1382,7 +1407,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)); @@ -1444,7 +1469,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; @@ -1542,7 +1567,6 @@ 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); ctgDebug("stb removed from stbCache, dbFName:%s, stb:%s, suid:0x%" PRIx64, dbFName, tbName, orig->suid); } } @@ -1560,14 +1584,15 @@ int32_t ctgWriteTbMetaToCache(SCatalog *pCtg, SCtgDBCache *dbCache, char *dbFNam pCache = taosHashGet(dbCache->tbCache, tbName, strlen(tbName)); } else { CTG_LOCK(CTG_WRITE, &pCache->metaLock); + if (orig) { + CTG_META_NUM_DEC(origType); + } taosMemoryFree(pCache->pMeta); pCache->pMeta = meta; CTG_UNLOCK(CTG_WRITE, &pCache->metaLock); } - if (NULL == orig) { - CTG_CACHE_STAT_INC(numOfTbl, 1); - } + CTG_META_NUM_INC(pCache->pMeta->tableType); ctgDebug("tbmeta updated to cache, dbFName:%s, tbName:%s, tbType:%d", dbFName, tbName, meta->tableType); ctgdShowTableMeta(pCtg, tbName, meta); @@ -1581,8 +1606,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); @@ -1615,6 +1638,8 @@ int32_t ctgWriteTbIndexToCache(SCatalog *pCtg, SCtgDBCache *dbCache, char *dbFNa CTG_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); } + CTG_DB_NUM_INC(CTG_CI_TBL_SMA); + *index = NULL; ctgDebug("table %s index updated to cache, ver:%d, num:%d", tbName, pIndex->version, (int32_t)taosArrayGetSize(pIndex->pIndex)); @@ -1766,10 +1791,12 @@ int32_t ctgOpUpdateVgroup(SCtgCacheOperation *operation) { } freeVgInfo(vgInfo); + CTG_DB_NUM_RESET(CTG_CI_DB_VGROUP); } vgCache->vgInfo = dbInfo; msg->dbInfo = NULL; + CTG_DB_NUM_SET(CTG_CI_DB_VGROUP); ctgDebug("db vgInfo updated, dbFName:%s, vgVer:%d, stateTs:%" PRId64 ", dbId:0x%" PRIx64, dbFName, vgVersion.vgVersion, vgVersion.stateTs, vgVersion.dbId); @@ -1842,6 +1869,7 @@ int32_t ctgOpDropDbVgroup(SCtgCacheOperation *operation) { freeVgInfo(dbCache->vgCache.vgInfo); dbCache->vgCache.vgInfo = NULL; + CTG_DB_NUM_RESET(CTG_CI_DB_VGROUP); ctgDebug("db vgInfo removed, dbFName:%s", msg->dbFName); ctgWUnlockVgInfo(dbCache); @@ -1911,6 +1939,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; @@ -1931,8 +1960,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)); @@ -1942,13 +1969,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); } ctgInfo("stb removed from cache, dbFName:%s, stbName:%s, suid:0x%" PRIx64, msg->dbFName, msg->stbName, msg->suid); @@ -1968,6 +1996,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; @@ -1992,6 +2021,7 @@ int32_t ctgOpDropTbMeta(SCtgCacheOperation *operation) { } CTG_LOCK(CTG_WRITE, &pTbCache->metaLock); + tblType = pTbCache->pMeta->tableType; ctgFreeTbCacheImpl(pTbCache); CTG_UNLOCK(CTG_WRITE, &pTbCache->metaLock); @@ -1999,7 +2029,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); } ctgDebug("table %s removed from cache, dbFName:%s", msg->tbName, msg->dbFName); @@ -2037,6 +2067,8 @@ int32_t ctgOpUpdateUser(SCtgCacheOperation *operation) { taosMemoryFreeClear(msg); + CTG_CACHE_NUM_INC(CTG_CI_USER, 1); + return TSDB_CODE_SUCCESS; } @@ -2290,10 +2322,10 @@ void ctgCleanupCacheQueue(void) { ctgDebug("process [%s] operation", gCtgCacheOperation[op->opId].name); (*gCtgCacheOperation[op->opId].func)(op); stopQueue = true; - CTG_RT_STAT_INC(numOfOpDequeue, 1); + CTG_STAT_RT_INC(numOfOpDequeue, 1); } else { ctgFreeCacheOperationData(op); - CTG_RT_STAT_INC(numOfOpAbort, 1); + CTG_STAT_RT_INC(numOfOpAbort, 1); } if (op->syncOp) { @@ -2349,9 +2381,10 @@ void *ctgUpdateThreadFunc(void *param) { taosMemoryFreeClear(operation); } - CTG_RT_STAT_INC(numOfOpDequeue, 1); + CTG_STAT_RT_INC(numOfOpDequeue, 1); ctgdShowCacheInfo(); + ctgdShowStatInfo(); } qInfo("catalog update thread stopped"); @@ -2492,7 +2525,8 @@ int32_t ctgGetTbMetasFromCache(SCatalog *pCtg, SRequestConnInfo *pConn, SCtgTbMe ctgDebug("tb %s not in cache, dbFName:%s", pName->tname, dbFName); ctgAddFetch(&ctx->pFetchs, dbIdx, i, fetchIdx, baseResIdx + i, flag); taosArrayPush(ctx->pResList, &(SMetaRes){0}); - + CTG_META_NHIT_INC(); + continue; } @@ -2502,12 +2536,15 @@ int32_t ctgGetTbMetasFromCache(SCatalog *pCtg, SRequestConnInfo *pConn, SCtgTbMe ctgDebug("tb %s meta not in cache, dbFName:%s", pName->tname, dbFName); ctgAddFetch(&ctx->pFetchs, dbIdx, i, fetchIdx, baseResIdx + i, flag); taosArrayPush(ctx->pResList, &(SMetaRes){0}); + CTG_META_NHIT_INC(); continue; } STableMeta *tbMeta = pCache->pMeta; + CTG_META_HIT_INC(tbMeta->tableType); + SCtgTbMetaCtx nctx = {0}; nctx.flag = flag; nctx.tbInfo.inCache = true; @@ -2575,8 +2612,9 @@ int32_t ctgGetTbMetasFromCache(SCatalog *pCtg, SRequestConnInfo *pConn, SCtgTbMe ctgDebug("stb 0x%" PRIx64 " not in cache, dbFName:%s", pTableMeta->suid, dbFName); ctgAddFetch(&ctx->pFetchs, dbIdx, i, fetchIdx, baseResIdx + i, flag); taosArrayPush(ctx->pResList, &(SMetaRes){0}); - taosMemoryFreeClear(pTableMeta); + + CTG_META_NHIT_INC(); continue; } @@ -2587,8 +2625,9 @@ int32_t ctgGetTbMetasFromCache(SCatalog *pCtg, SRequestConnInfo *pConn, SCtgTbMe ctgAddFetch(&ctx->pFetchs, dbIdx, i, fetchIdx, baseResIdx + i, flag); taosArrayPush(ctx->pResList, &(SMetaRes){0}); - taosMemoryFreeClear(pTableMeta); + + CTG_META_NHIT_INC(); continue; } @@ -2602,9 +2641,9 @@ int32_t ctgGetTbMetasFromCache(SCatalog *pCtg, SRequestConnInfo *pConn, SCtgTbMe ctgAddFetch(&ctx->pFetchs, dbIdx, i, fetchIdx, baseResIdx + i, flag); taosArrayPush(ctx->pResList, &(SMetaRes){0}); - taosMemoryFreeClear(pTableMeta); + CTG_META_NHIT_INC(); continue; } @@ -2618,9 +2657,9 @@ int32_t ctgGetTbMetasFromCache(SCatalog *pCtg, SRequestConnInfo *pConn, SCtgTbMe ctgAddFetch(&ctx->pFetchs, dbIdx, i, fetchIdx, baseResIdx + i, flag); taosArrayPush(ctx->pResList, &(SMetaRes){0}); - taosMemoryFreeClear(pTableMeta); + CTG_META_NHIT_INC(); continue; } @@ -2636,6 +2675,8 @@ int32_t ctgGetTbMetasFromCache(SCatalog *pCtg, SRequestConnInfo *pConn, SCtgTbMe CTG_UNLOCK(CTG_READ, &pCache->metaLock); taosHashRelease(dbCache->tbCache, pCache); + CTG_META_HIT_INC(pTableMeta->tableType); + res.pRes = pTableMeta; taosArrayPush(ctx->pResList, &res); diff --git a/source/libs/catalog/src/ctgDbg.c b/source/libs/catalog/src/ctgDbg.c index 6b870232c74bdb09dfd90bbb95a9cae8954f23da..b5d587d257a8d084246efa86ed72e77a723de98c 100644 --- a/source/libs/catalog/src/ctgDbg.c +++ b/source/libs/catalog/src/ctgDbg.c @@ -345,7 +345,7 @@ int32_t ctgdGetOneHandle(SCatalog **pHandle) { int32_t ctgdGetStatNum(char *option, void *res) { if (0 == strcasecmp(option, "runtime.numOfOpDequeue")) { - *(uint64_t *)res = atomic_load_64(&gCtgMgmt.stat.runtime.numOfOpDequeue); + *(uint64_t *)res = atomic_load_64(&gCtgMgmt.statInfo.runtime.numOfOpDequeue); return TSDB_CODE_SUCCESS; } @@ -517,6 +517,27 @@ void ctgdShowClusterCache(SCatalog *pCtg) { ctgDebug("## cluster 0x%" PRIx64 " %p cache Info END ##", pCtg->clusterId, pCtg); } +int32_t ctgdShowStatInfo(void) { + if (!gCTGDebug.statEnable) { + return TSDB_CODE_CTG_OUT_OF_SERVICE; + } + + CTG_API_ENTER(); + + SCtgCacheStat cache; + ctgGetGlobalCacheStat(&cache); + + qDebug("## Global Stat Info %s ##", "begin"); + qDebug("## \t%s \t%s \t%s ##", "Num", "Hit", "Nhit"); + for (int32_t i = 0; i < CTG_CI_MAX_VALUE; ++i) { + qDebug("# %s \t%" PRIu64 " \t%" PRIu64 " \t%" PRIu64 " #", gCtgStatItem[i].name, cache.cacheNum[i], cache.cacheHit[i], cache.cacheNHit[i]); + } + qDebug("## Global Stat Info %s ##", "end"); + + CTG_API_LEAVE(TSDB_CODE_SUCCESS); +} + + int32_t ctgdShowCacheInfo(void) { if (!gCTGDebug.cacheEnable) { return TSDB_CODE_CTG_OUT_OF_SERVICE; diff --git a/source/libs/catalog/src/ctgUtil.c b/source/libs/catalog/src/ctgUtil.c index cd9380778b598080405ca569672e0c7b27d5fc72..a2f2a3d556fea5049e643cdbd7be7e753a89e1db 100644 --- a/source/libs/catalog/src/ctgUtil.c +++ b/source/libs/catalog/src/ctgUtil.c @@ -77,12 +77,12 @@ char* ctgTaskTypeStr(CTG_TASK_TYPE type) { return "[get table meta]"; case CTG_TASK_GET_TB_HASH: return "[get table hash]"; - case CTG_TASK_GET_TB_INDEX: - return "[get table index]"; + case CTG_TASK_GET_TB_SMA_INDEX: + return "[get table sma]"; case CTG_TASK_GET_TB_CFG: return "[get table cfg]"; - case CTG_TASK_GET_INDEX: - return "[get index]"; + case CTG_TASK_GET_INDEX_INFO: + return "[get index info]"; case CTG_TASK_GET_UDF: return "[get udf]"; case CTG_TASK_GET_USER: @@ -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) { @@ -228,7 +227,6 @@ void ctgFreeTbCache(SCtgDBCache* dbCache) { } taosHashCleanup(dbCache->tbCache); dbCache->tbCache = NULL; - CTG_CACHE_STAT_DEC(numOfTbl, tblNum); } void ctgFreeVgInfoCache(SCtgDBCache* dbCache) { freeVgInfo(dbCache->vgCache.vgInfo); } @@ -260,8 +258,6 @@ void ctgFreeInstDbCache(SHashObj* pDbCache) { } taosHashCleanup(pDbCache); - - CTG_CACHE_STAT_DEC(numOfDb, dbNum); } void ctgFreeInstUserCache(SHashObj* pUserCache) { @@ -280,8 +276,6 @@ void ctgFreeInstUserCache(SHashObj* pUserCache) { } taosHashCleanup(pUserCache); - - CTG_CACHE_STAT_DEC(numOfUser, userNum); } void ctgFreeHandleImpl(SCatalog* pCtg) { @@ -307,7 +301,7 @@ void ctgFreeHandle(SCatalog* pCtg) { ctgFreeInstDbCache(pCtg->dbCache); ctgFreeInstUserCache(pCtg->userCache); - CTG_CACHE_STAT_DEC(numOfCluster, 1); + CTG_STAT_NUM_DEC(CTG_CI_CLUSTER, 1); taosMemoryFree(pCtg); @@ -342,7 +336,9 @@ void ctgClearHandle(SCatalog* pCtg) { ctgError("taosHashInit %d user cache failed", gCtgMgmt.cfg.maxUserCacheNum); } - CTG_CACHE_STAT_INC(numOfClear, 1); + memset(pCtg->cacheStat.cacheNum, 0, sizeof(pCtg->cacheStat.cacheNum)); + + CTG_STAT_RT_INC(numOfOpClearCache, 1); ctgInfo("handle cleared, clusterId:0x%" PRIx64, clusterId); } @@ -501,7 +497,7 @@ void ctgFreeTaskRes(CTG_TASK_TYPE type, void** pRes) { } break; } - case CTG_TASK_GET_TB_INDEX: { + case CTG_TASK_GET_TB_SMA_INDEX: { taosArrayDestroyEx(*pRes, tFreeSTableIndexInfo); *pRes = NULL; break; @@ -516,7 +512,7 @@ void ctgFreeTaskRes(CTG_TASK_TYPE type, void** pRes) { } case CTG_TASK_GET_TB_HASH: case CTG_TASK_GET_DB_INFO: - case CTG_TASK_GET_INDEX: + case CTG_TASK_GET_INDEX_INFO: case CTG_TASK_GET_UDF: case CTG_TASK_GET_USER: case CTG_TASK_GET_SVR_VER: @@ -571,7 +567,7 @@ void ctgFreeSubTaskRes(CTG_TASK_TYPE type, void** pRes) { } break; } - case CTG_TASK_GET_TB_INDEX: { + case CTG_TASK_GET_TB_SMA_INDEX: { taosArrayDestroyEx(*pRes, tFreeSTableIndexInfo); *pRes = NULL; break; @@ -587,7 +583,7 @@ void ctgFreeSubTaskRes(CTG_TASK_TYPE type, void** pRes) { case CTG_TASK_GET_TB_META: case CTG_TASK_GET_DB_INFO: case CTG_TASK_GET_TB_HASH: - case CTG_TASK_GET_INDEX: + case CTG_TASK_GET_INDEX_INFO: case CTG_TASK_GET_UDF: case CTG_TASK_GET_SVR_VER: case CTG_TASK_GET_USER: { @@ -664,7 +660,7 @@ void ctgFreeTaskCtx(SCtgTask* pTask) { taosMemoryFreeClear(pTask->taskCtx); break; } - case CTG_TASK_GET_TB_INDEX: { + case CTG_TASK_GET_TB_SMA_INDEX: { SCtgTbIndexCtx* taskCtx = (SCtgTbIndexCtx*)pTask->taskCtx; taosMemoryFreeClear(taskCtx->pName); taosMemoryFreeClear(pTask->taskCtx); @@ -680,7 +676,7 @@ void ctgFreeTaskCtx(SCtgTask* pTask) { case CTG_TASK_GET_DB_VGROUP: case CTG_TASK_GET_DB_CFG: case CTG_TASK_GET_DB_INFO: - case CTG_TASK_GET_INDEX: + case CTG_TASK_GET_INDEX_INFO: case CTG_TASK_GET_UDF: case CTG_TASK_GET_QNODE: case CTG_TASK_GET_USER: { @@ -1421,3 +1417,69 @@ void catalogFreeMetaData(SMetaData* pData) { taosMemoryFreeClear(pData->pSvrVer); taosMemoryFree(pData); } + +void ctgGetClusterCacheStat(SCatalog* pCtg) { + for (int32_t i = 0; i < CTG_CI_MAX_VALUE; ++i) { + if (0 == (gCtgStatItem[i].flag & CTG_CI_FLAG_LEVEL_DB)) { + continue; + } + + pCtg->cacheStat.cacheNum[i] = 0; + } + + SCtgDBCache *dbCache = NULL; + void *pIter = taosHashIterate(pCtg->dbCache, NULL); + while (pIter) { + dbCache = (SCtgDBCache *)pIter; + + for (int32_t i = 0; i < CTG_CI_MAX_VALUE; ++i) { + if (0 == (gCtgStatItem[i].flag & CTG_CI_FLAG_LEVEL_DB)) { + continue; + } + + pCtg->cacheStat.cacheNum[i] += dbCache->dbCacheNum[i]; + } + + pIter = taosHashIterate(pCtg->dbCache, pIter); + } +} + +void ctgSummaryClusterCacheStat(SCatalog *pCtg) { + for (int32_t i = 0; i < CTG_CI_MAX_VALUE; ++i) { + if (gCtgStatItem[i].flag & CTG_CI_FLAG_LEVEL_GLOBAL) { + continue; + } + + gCtgMgmt.statInfo.cache.cacheNum[i] += pCtg->cacheStat.cacheNum[i]; + gCtgMgmt.statInfo.cache.cacheHit[i] += pCtg->cacheStat.cacheHit[i]; + gCtgMgmt.statInfo.cache.cacheNHit[i] += pCtg->cacheStat.cacheNHit[i]; + } +} + +void ctgGetGlobalCacheStat(SCtgCacheStat *pStat) { + for (int32_t i = 0; i < CTG_CI_MAX_VALUE; ++i) { + if (gCtgStatItem[i].flag & CTG_CI_FLAG_LEVEL_GLOBAL) { + continue; + } + + gCtgMgmt.statInfo.cache.cacheNum[i] = 0; + gCtgMgmt.statInfo.cache.cacheHit[i] = 0; + gCtgMgmt.statInfo.cache.cacheNHit[i] = 0; + } + + SCatalog *pCtg = NULL; + void *pIter = taosHashIterate(gCtgMgmt.pCluster, NULL); + while (pIter) { + pCtg = *(SCatalog **)pIter; + + if (pCtg) { + ctgGetClusterCacheStat(pCtg); + ctgSummaryClusterCacheStat(pCtg); + } + + pIter = taosHashIterate(gCtgMgmt.pCluster, pIter); + } + + memcpy(pStat, &gCtgMgmt.statInfo.cache, sizeof(gCtgMgmt.statInfo.cache)); +} +