diff --git a/source/libs/sync/inc/syncIndexMgr.h b/source/libs/sync/inc/syncIndexMgr.h
index 79b4fa0fbf06be6d1c16e783ebc59638fff1a5b5..4e6ab284f8cf9b10a06f5880abd8f14e7c13de81 100644
--- a/source/libs/sync/inc/syncIndexMgr.h
+++ b/source/libs/sync/inc/syncIndexMgr.h
@@ -25,29 +25,27 @@ extern "C" {
 // SIndexMgr -----------------------------
 typedef struct SSyncIndexMgr {
   SRaftId (*replicas)[TSDB_MAX_REPLICA];
-  SyncIndex index[TSDB_MAX_REPLICA];
-  SyncTerm  privateTerm[TSDB_MAX_REPLICA];  // for advanced function
-
-  int64_t startTimeArr[TSDB_MAX_REPLICA];
-  int64_t recvTimeArr[TSDB_MAX_REPLICA];
-
+  SyncIndex  index[TSDB_MAX_REPLICA];
+  SyncTerm   privateTerm[TSDB_MAX_REPLICA];  // for advanced function
+  int64_t    startTimeArr[TSDB_MAX_REPLICA];
+  int64_t    recvTimeArr[TSDB_MAX_REPLICA];
   int32_t    replicaNum;
-  SSyncNode *pSyncNode;
+  SSyncNode *pNode;
 } SSyncIndexMgr;
 
-SSyncIndexMgr *syncIndexMgrCreate(SSyncNode *pSyncNode);
-void           syncIndexMgrUpdate(SSyncIndexMgr *pSyncIndexMgr, SSyncNode *pSyncNode);
-void           syncIndexMgrDestroy(SSyncIndexMgr *pSyncIndexMgr);
-void           syncIndexMgrClear(SSyncIndexMgr *pSyncIndexMgr);
-void           syncIndexMgrSetIndex(SSyncIndexMgr *pSyncIndexMgr, const SRaftId *pRaftId, SyncIndex index);
-SyncIndex      syncIndexMgrGetIndex(SSyncIndexMgr *pSyncIndexMgr, const SRaftId *pRaftId);
-
-void     syncIndexMgrSetStartTime(SSyncIndexMgr *pSyncIndexMgr, const SRaftId *pRaftId, int64_t startTime);
-int64_t  syncIndexMgrGetStartTime(SSyncIndexMgr *pSyncIndexMgr, const SRaftId *pRaftId);
-void     syncIndexMgrSetRecvTime(SSyncIndexMgr *pSyncIndexMgr, const SRaftId *pRaftId, int64_t recvTime);
-int64_t  syncIndexMgrGetRecvTime(SSyncIndexMgr *pSyncIndexMgr, const SRaftId *pRaftId);
-void     syncIndexMgrSetTerm(SSyncIndexMgr *pSyncIndexMgr, const SRaftId *pRaftId, SyncTerm term);
-SyncTerm syncIndexMgrGetTerm(SSyncIndexMgr *pSyncIndexMgr, const SRaftId *pRaftId);
+SSyncIndexMgr *syncIndexMgrCreate(SSyncNode *pNode);
+void           syncIndexMgrUpdate(SSyncIndexMgr *pIndexMgr, SSyncNode *pNode);
+void           syncIndexMgrDestroy(SSyncIndexMgr *pIndexMgr);
+void           syncIndexMgrClear(SSyncIndexMgr *pIndexMgr);
+void           syncIndexMgrSetIndex(SSyncIndexMgr *pIndexMgr, const SRaftId *pRaftId, SyncIndex index);
+SyncIndex      syncIndexMgrGetIndex(SSyncIndexMgr *pIndexMgr, const SRaftId *pRaftId);
+
+void     syncIndexMgrSetStartTime(SSyncIndexMgr *pIndexMgr, const SRaftId *pRaftId, int64_t startTime);
+int64_t  syncIndexMgrGetStartTime(SSyncIndexMgr *pIndexMgr, const SRaftId *pRaftId);
+void     syncIndexMgrSetRecvTime(SSyncIndexMgr *pIndexMgr, const SRaftId *pRaftId, int64_t recvTime);
+int64_t  syncIndexMgrGetRecvTime(SSyncIndexMgr *pIndexMgr, const SRaftId *pRaftId);
+void     syncIndexMgrSetTerm(SSyncIndexMgr *pIndexMgr, const SRaftId *pRaftId, SyncTerm term);
+SyncTerm syncIndexMgrGetTerm(SSyncIndexMgr *pIndexMgr, const SRaftId *pRaftId);
 
 #ifdef __cplusplus
 }
diff --git a/source/libs/sync/src/syncIndexMgr.c b/source/libs/sync/src/syncIndexMgr.c
index 7933258e53f477795726d0ee5dcc286a35ccaa43..8ea5d782b76d3e170dd2dda7732fc18236ac06c2 100644
--- a/source/libs/sync/src/syncIndexMgr.c
+++ b/source/libs/sync/src/syncIndexMgr.c
@@ -17,56 +17,56 @@
 #include "syncIndexMgr.h"
 #include "syncUtil.h"
 
-SSyncIndexMgr *syncIndexMgrCreate(SSyncNode *pSyncNode) {
-  SSyncIndexMgr *pSyncIndexMgr = taosMemoryCalloc(1, sizeof(SSyncIndexMgr));
-  if (pSyncIndexMgr == NULL) {
+SSyncIndexMgr *syncIndexMgrCreate(SSyncNode *pNode) {
+  SSyncIndexMgr *pIndexMgr = taosMemoryCalloc(1, sizeof(SSyncIndexMgr));
+  if (pIndexMgr == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return NULL;
   }
 
-  pSyncIndexMgr->replicas = &(pSyncNode->replicasId);
-  pSyncIndexMgr->replicaNum = pSyncNode->replicaNum;
-  pSyncIndexMgr->pSyncNode = pSyncNode;
-  syncIndexMgrClear(pSyncIndexMgr);
+  pIndexMgr->replicas = &(pNode->replicasId);
+  pIndexMgr->replicaNum = pNode->replicaNum;
+  pIndexMgr->pNode = pNode;
+  syncIndexMgrClear(pIndexMgr);
 
-  return pSyncIndexMgr;
+  return pIndexMgr;
 }
 
-void syncIndexMgrUpdate(SSyncIndexMgr *pSyncIndexMgr, SSyncNode *pSyncNode) {
-  pSyncIndexMgr->replicas = &(pSyncNode->replicasId);
-  pSyncIndexMgr->replicaNum = pSyncNode->replicaNum;
-  pSyncIndexMgr->pSyncNode = pSyncNode;
-  syncIndexMgrClear(pSyncIndexMgr);
+void syncIndexMgrUpdate(SSyncIndexMgr *pIndexMgr, SSyncNode *pNode) {
+  pIndexMgr->replicas = &(pNode->replicasId);
+  pIndexMgr->replicaNum = pNode->replicaNum;
+  pIndexMgr->pNode = pNode;
+  syncIndexMgrClear(pIndexMgr);
 }
 
-void syncIndexMgrDestroy(SSyncIndexMgr *pSyncIndexMgr) {
-  if (pSyncIndexMgr != NULL) {
-    taosMemoryFree(pSyncIndexMgr);
+void syncIndexMgrDestroy(SSyncIndexMgr *pIndexMgr) {
+  if (pIndexMgr != NULL) {
+    taosMemoryFree(pIndexMgr);
   }
 }
 
-void syncIndexMgrClear(SSyncIndexMgr *pSyncIndexMgr) {
-  memset(pSyncIndexMgr->index, 0, sizeof(pSyncIndexMgr->index));
-  memset(pSyncIndexMgr->privateTerm, 0, sizeof(pSyncIndexMgr->privateTerm));
+void syncIndexMgrClear(SSyncIndexMgr *pIndexMgr) {
+  memset(pIndexMgr->index, 0, sizeof(pIndexMgr->index));
+  memset(pIndexMgr->privateTerm, 0, sizeof(pIndexMgr->privateTerm));
 
   // int64_t timeNow = taosGetMonotonicMs();
   int64_t timeNow = taosGetTimestampMs();
-  for (int i = 0; i < pSyncIndexMgr->replicaNum; ++i) {
-    pSyncIndexMgr->startTimeArr[i] = 0;
-    pSyncIndexMgr->recvTimeArr[i] = timeNow;
+  for (int i = 0; i < pIndexMgr->replicaNum; ++i) {
+    pIndexMgr->startTimeArr[i] = 0;
+    pIndexMgr->recvTimeArr[i] = timeNow;
   }
 
   /*
-  for (int i = 0; i < pSyncIndexMgr->replicaNum; ++i) {
-    pSyncIndexMgr->index[i] = 0;
+  for (int i = 0; i < pIndexMgr->replicaNum; ++i) {
+    pIndexMgr->index[i] = 0;
   }
   */
 }
 
-void syncIndexMgrSetIndex(SSyncIndexMgr *pSyncIndexMgr, const SRaftId *pRaftId, SyncIndex index) {
-  for (int i = 0; i < pSyncIndexMgr->replicaNum; ++i) {
-    if (syncUtilSameId(&((*(pSyncIndexMgr->replicas))[i]), pRaftId)) {
-      (pSyncIndexMgr->index)[i] = index;
+void syncIndexMgrSetIndex(SSyncIndexMgr *pIndexMgr, const SRaftId *pRaftId, SyncIndex index) {
+  for (int i = 0; i < pIndexMgr->replicaNum; ++i) {
+    if (syncUtilSameId(&((*(pIndexMgr->replicas))[i]), pRaftId)) {
+      (pIndexMgr->index)[i] = index;
       return;
     }
   }
@@ -77,8 +77,7 @@ void syncIndexMgrSetIndex(SSyncIndexMgr *pSyncIndexMgr, const SRaftId *pRaftId,
   char     host[128];
   uint16_t port;
   syncUtilU642Addr(pRaftId->addr, host, sizeof(host), &port);
-  sError("vgId:%d, index mgr set for %s:%d, index:%" PRId64 " error", pSyncIndexMgr->pSyncNode->vgId, host, port,
-         index);
+  sError("vgId:%d, index mgr set for %s:%d, index:%" PRId64 " error", pIndexMgr->pNode->vgId, host, port, index);
 }
 
 SSyncLogReplMgr *syncNodeGetLogReplMgr(SSyncNode *pNode, SRaftId *pDestId) {
@@ -90,14 +89,14 @@ SSyncLogReplMgr *syncNodeGetLogReplMgr(SSyncNode *pNode, SRaftId *pDestId) {
   return NULL;
 }
 
-SyncIndex syncIndexMgrGetIndex(SSyncIndexMgr *pSyncIndexMgr, const SRaftId *pRaftId) {
-  if (pSyncIndexMgr == NULL) {
+SyncIndex syncIndexMgrGetIndex(SSyncIndexMgr *pIndexMgr, const SRaftId *pRaftId) {
+  if (pIndexMgr == NULL) {
     return SYNC_INDEX_INVALID;
   }
 
-  for (int i = 0; i < pSyncIndexMgr->replicaNum; ++i) {
-    if (syncUtilSameId(&((*(pSyncIndexMgr->replicas))[i]), pRaftId)) {
-      SyncIndex idx = (pSyncIndexMgr->index)[i];
+  for (int i = 0; i < pIndexMgr->replicaNum; ++i) {
+    if (syncUtilSameId(&((*(pIndexMgr->replicas))[i]), pRaftId)) {
+      SyncIndex idx = (pIndexMgr->index)[i];
       return idx;
     }
   }
@@ -105,10 +104,10 @@ SyncIndex syncIndexMgrGetIndex(SSyncIndexMgr *pSyncIndexMgr, const SRaftId *pRaf
   return SYNC_INDEX_INVALID;
 }
 
-void syncIndexMgrSetStartTime(SSyncIndexMgr *pSyncIndexMgr, const SRaftId *pRaftId, int64_t startTime) {
-  for (int i = 0; i < pSyncIndexMgr->replicaNum; ++i) {
-    if (syncUtilSameId(&((*(pSyncIndexMgr->replicas))[i]), pRaftId)) {
-      (pSyncIndexMgr->startTimeArr)[i] = startTime;
+void syncIndexMgrSetStartTime(SSyncIndexMgr *pIndexMgr, const SRaftId *pRaftId, int64_t startTime) {
+  for (int i = 0; i < pIndexMgr->replicaNum; ++i) {
+    if (syncUtilSameId(&((*(pIndexMgr->replicas))[i]), pRaftId)) {
+      (pIndexMgr->startTimeArr)[i] = startTime;
       return;
     }
   }
@@ -118,14 +117,14 @@ void syncIndexMgrSetStartTime(SSyncIndexMgr *pSyncIndexMgr, const SRaftId *pRaft
   char     host[128];
   uint16_t port;
   syncUtilU642Addr(pRaftId->addr, host, sizeof(host), &port);
-  sError("vgId:%d, index mgr set for %s:%d, start-time:%" PRId64 " error", pSyncIndexMgr->pSyncNode->vgId, host, port,
+  sError("vgId:%d, index mgr set for %s:%d, start-time:%" PRId64 " error", pIndexMgr->pNode->vgId, host, port,
          startTime);
 }
 
-int64_t syncIndexMgrGetStartTime(SSyncIndexMgr *pSyncIndexMgr, const SRaftId *pRaftId) {
-  for (int i = 0; i < pSyncIndexMgr->replicaNum; ++i) {
-    if (syncUtilSameId(&((*(pSyncIndexMgr->replicas))[i]), pRaftId)) {
-      int64_t startTime = (pSyncIndexMgr->startTimeArr)[i];
+int64_t syncIndexMgrGetStartTime(SSyncIndexMgr *pIndexMgr, const SRaftId *pRaftId) {
+  for (int i = 0; i < pIndexMgr->replicaNum; ++i) {
+    if (syncUtilSameId(&((*(pIndexMgr->replicas))[i]), pRaftId)) {
+      int64_t startTime = (pIndexMgr->startTimeArr)[i];
       return startTime;
     }
   }
@@ -133,10 +132,10 @@ int64_t syncIndexMgrGetStartTime(SSyncIndexMgr *pSyncIndexMgr, const SRaftId *pR
   return -1;
 }
 
-void syncIndexMgrSetRecvTime(SSyncIndexMgr *pSyncIndexMgr, const SRaftId *pRaftId, int64_t recvTime) {
-  for (int i = 0; i < pSyncIndexMgr->replicaNum; ++i) {
-    if (syncUtilSameId(&((*(pSyncIndexMgr->replicas))[i]), pRaftId)) {
-      (pSyncIndexMgr->recvTimeArr)[i] = recvTime;
+void syncIndexMgrSetRecvTime(SSyncIndexMgr *pIndexMgr, const SRaftId *pRaftId, int64_t recvTime) {
+  for (int i = 0; i < pIndexMgr->replicaNum; ++i) {
+    if (syncUtilSameId(&((*(pIndexMgr->replicas))[i]), pRaftId)) {
+      (pIndexMgr->recvTimeArr)[i] = recvTime;
       return;
     }
   }
@@ -146,14 +145,13 @@ void syncIndexMgrSetRecvTime(SSyncIndexMgr *pSyncIndexMgr, const SRaftId *pRaftI
   char     host[128];
   uint16_t port;
   syncUtilU642Addr(pRaftId->addr, host, sizeof(host), &port);
-  sError("vgId:%d, index mgr set for %s:%d, recv-time:%" PRId64 " error", pSyncIndexMgr->pSyncNode->vgId, host, port,
-         recvTime);
+  sError("vgId:%d, index mgr set for %s:%d, recv-time:%" PRId64 " error", pIndexMgr->pNode->vgId, host, port, recvTime);
 }
 
-int64_t syncIndexMgrGetRecvTime(SSyncIndexMgr *pSyncIndexMgr, const SRaftId *pRaftId) {
-  for (int i = 0; i < pSyncIndexMgr->replicaNum; ++i) {
-    if (syncUtilSameId(&((*(pSyncIndexMgr->replicas))[i]), pRaftId)) {
-      int64_t recvTime = (pSyncIndexMgr->recvTimeArr)[i];
+int64_t syncIndexMgrGetRecvTime(SSyncIndexMgr *pIndexMgr, const SRaftId *pRaftId) {
+  for (int i = 0; i < pIndexMgr->replicaNum; ++i) {
+    if (syncUtilSameId(&((*(pIndexMgr->replicas))[i]), pRaftId)) {
+      int64_t recvTime = (pIndexMgr->recvTimeArr)[i];
       return recvTime;
     }
   }
@@ -161,10 +159,10 @@ int64_t syncIndexMgrGetRecvTime(SSyncIndexMgr *pSyncIndexMgr, const SRaftId *pRa
   return -1;
 }
 
-void syncIndexMgrSetTerm(SSyncIndexMgr *pSyncIndexMgr, const SRaftId *pRaftId, SyncTerm term) {
-  for (int i = 0; i < pSyncIndexMgr->replicaNum; ++i) {
-    if (syncUtilSameId(&((*(pSyncIndexMgr->replicas))[i]), pRaftId)) {
-      (pSyncIndexMgr->privateTerm)[i] = term;
+void syncIndexMgrSetTerm(SSyncIndexMgr *pIndexMgr, const SRaftId *pRaftId, SyncTerm term) {
+  for (int i = 0; i < pIndexMgr->replicaNum; ++i) {
+    if (syncUtilSameId(&((*(pIndexMgr->replicas))[i]), pRaftId)) {
+      (pIndexMgr->privateTerm)[i] = term;
       return;
     }
   }
@@ -174,13 +172,13 @@ void syncIndexMgrSetTerm(SSyncIndexMgr *pSyncIndexMgr, const SRaftId *pRaftId, S
   char     host[128];
   uint16_t port;
   syncUtilU642Addr(pRaftId->addr, host, sizeof(host), &port);
-  sError("vgId:%d, index mgr set for %s:%d, term:%" PRIu64 " error", pSyncIndexMgr->pSyncNode->vgId, host, port, term);
+  sError("vgId:%d, index mgr set for %s:%d, term:%" PRIu64 " error", pIndexMgr->pNode->vgId, host, port, term);
 }
 
-SyncTerm syncIndexMgrGetTerm(SSyncIndexMgr *pSyncIndexMgr, const SRaftId *pRaftId) {
-  for (int i = 0; i < pSyncIndexMgr->replicaNum; ++i) {
-    if (syncUtilSameId(&((*(pSyncIndexMgr->replicas))[i]), pRaftId)) {
-      SyncTerm term = (pSyncIndexMgr->privateTerm)[i];
+SyncTerm syncIndexMgrGetTerm(SSyncIndexMgr *pIndexMgr, const SRaftId *pRaftId) {
+  for (int i = 0; i < pIndexMgr->replicaNum; ++i) {
+    if (syncUtilSameId(&((*(pIndexMgr->replicas))[i]), pRaftId)) {
+      SyncTerm term = (pIndexMgr->privateTerm)[i];
       return term;
     }
   }