diff --git a/interfaces/kits/hyperaio/src/hyperaio.cpp b/interfaces/kits/hyperaio/src/hyperaio.cpp
index 9f5f44bc3802b50dea098c4a1c13f38b7ee2fa2f..bd4d38d2ada6c84c206e2219fffa284832a0f504 100644
--- a/interfaces/kits/hyperaio/src/hyperaio.cpp
+++ b/interfaces/kits/hyperaio/src/hyperaio.cpp
@@ -31,6 +31,10 @@ const uint32_t URING_QUEUE_SIZE = 512;
 const uint32_t DELAY = 20;
 const uint32_t BATCH_SIZE = 128;
 const uint32_t RETRIES = 3;
+std::atomic<uint32_t> openReqCount_{0};
+std::atomic<uint32_t> readReqCount_{0};
+std::atomic<uint32_t> cancelReqCount_{0};
+std::atomic<uint32_t> cqeCount_{0};
 class HyperAio::Impl {
 public:
     io_uring uring_;
@@ -110,16 +114,13 @@ int32_t HyperAio::StartOpenReqs(OpenReqs *req)
     if (pImpl_ == nullptr) {
         return -EINVAL;
     }
-
     if (req == nullptr || req->reqs == nullptr) {
         return -EINVAL;
     }
-
     if (!initialized_.load()) {
         HILOGE("HyperAio is not initialized");
         return -EPERM;
     }
-
     HyperaioTrace trace("StartOpenReqs" + std::to_string(req->reqNum));
     uint32_t totalReqs = req->reqNum;
     uint32_t count = 0;
@@ -133,14 +134,19 @@ int32_t HyperAio::StartOpenReqs(OpenReqs *req)
         io_uring_sqe_set_data(sqe, reinterpret_cast<void *>(openInfo->userData));
         io_uring_prep_openat(sqe, openInfo->dfd, static_cast<const char *>(openInfo->path),
             openInfo->flags, openInfo->mode);
+        HILOGD("open flags = %{public}d, mode = %{public}u, userData = %{public}lu",
+            openInfo->flags, openInfo->mode, openInfo->userData);
+        HyperaioTrace trace("open flags:" + std::to_string(openInfo->flags) + "mode:" + std::to_string(openInfo->mode)
+            + "userData:" + std::to_string(openInfo->userData));
         count++;
         if (count >= BATCH_SIZE) {
-            count = 0;
             int32_t ret = io_uring_submit(&pImpl_->uring_);
             if (ret < 0) {
                 HILOGE("submit open reqs failed, ret = %{public}d", ret);
                 return ret;
             }
+            openReqCount_ += count;
+            count = 0;
         }
     }
     if (count > 0 && count < BATCH_SIZE) {
@@ -149,6 +155,7 @@ int32_t HyperAio::StartOpenReqs(OpenReqs *req)
             HILOGE("submit open reqs failed, ret = %{public}d", ret);
             return ret;
         }
+        openReqCount_ += count;
     }
     return EOK;
 }
@@ -158,16 +165,13 @@ int32_t HyperAio::StartReadReqs(ReadReqs *req)
     if (pImpl_ == nullptr) {
         return -EINVAL;
     }
-
     if (req == nullptr || req->reqs == nullptr) {
         return -EINVAL;
     }
-
     if (!initialized_.load()) {
         HILOGE("HyperAio is not initialized");
         return -EPERM;
     }
-
     HyperaioTrace trace("StartReadReqs" + std::to_string(req->reqNum));
     uint32_t totalReqs = req->reqNum;
     uint32_t count = 0;
@@ -180,14 +184,19 @@ int32_t HyperAio::StartReadReqs(ReadReqs *req)
         struct ReadInfo *readInfo = &req->reqs[i];
         io_uring_sqe_set_data(sqe, reinterpret_cast<void *>(readInfo->userData));
         io_uring_prep_read(sqe, readInfo->fd, readInfo->buf, readInfo->len, readInfo->offset);
+        HILOGD("read len = %{public}u, offset = %{public}lu, userData = %{public}lu",
+            readInfo->len, readInfo->offset, readInfo->userData);
+        HyperaioTrace trace("read len:" + std::to_string(readInfo->len) + "offset:" + std::to_string(readInfo->offset)
+            + "userData:" + std::to_string(readInfo->userData));
         count++;
         if (count >= BATCH_SIZE) {
-            count = 0;
             int32_t ret = io_uring_submit(&pImpl_->uring_);
             if (ret < 0) {
                 HILOGE("submit read reqs failed, ret = %{public}d", ret);
                 return ret;
             }
+            readReqCount_ += count;
+            count = 0;
         }
     }
     if (count > 0 && count < BATCH_SIZE) {
@@ -196,6 +205,7 @@ int32_t HyperAio::StartReadReqs(ReadReqs *req)
             HILOGE("submit read reqs failed, ret = %{public}d", ret);
             return ret;
         }
+        readReqCount_ += count;
     }
 
     return EOK;
@@ -206,16 +216,13 @@ int32_t HyperAio::StartCancelReqs(CancelReqs *req)
     if (pImpl_ == nullptr) {
         return -EINVAL;
     }
-
     if (req == nullptr || req->reqs == nullptr) {
         return -EINVAL;
     }
-
     if (!initialized_.load()) {
         HILOGE("HyperAio is not initialized");
         return -EPERM;
     }
-
     HyperaioTrace trace("StartCancelReqs" + std::to_string(req->reqNum));
     uint32_t totalReqs = req->reqNum;
     uint32_t count = 0;
@@ -228,14 +235,19 @@ int32_t HyperAio::StartCancelReqs(CancelReqs *req)
         struct CancelInfo *cancelInfo = &req->reqs[i];
         io_uring_sqe_set_data(sqe, reinterpret_cast<void *>(cancelInfo->userData));
         io_uring_prep_cancel(sqe, reinterpret_cast<void *>(cancelInfo->targetUserData), 0);
+        HILOGD("cancel userData = %{public}lu,  targetUserData = %{public}lu",
+            cancelInfo->userData, cancelInfo->targetUserData);
+        HyperaioTrace trace("cancel userData:" + std::to_string(cancelInfo->userData)
+            + "targetUserData:" + std::to_string(cancelInfo->targetUserData));
         count++;
         if (count >= BATCH_SIZE) {
-            count = 0;
             int32_t ret = io_uring_submit(&pImpl_->uring_);
             if (ret < 0) {
                 HILOGE("submit cancel reqs failed, ret = %{public}d", ret);
                 return ret;
             }
+            cancelReqCount_ += count;
+            count = 0;
         }
     }
     if (count > 0 && count < BATCH_SIZE) {
@@ -244,6 +256,7 @@ int32_t HyperAio::StartCancelReqs(CancelReqs *req)
             HILOGE("submit cancel reqs failed, ret = %{public}d", ret);
             return ret;
         }
+        cancelReqCount_ += count;
     }
     return EOK;
 }
@@ -262,23 +275,34 @@ void HyperAio::HarvestRes()
             HILOGI("wait cqe failed, ret = %{public}d", ret);
             continue;
         }
+        cqeCount_++;
         auto response = std::make_unique<IoResponse>(cqe->user_data, cqe->res, cqe->flags);
+        HILOGI("get cqe, user_data = %{public}lld, res = %{public}d, flags = %{public}u",
+            cqe->user_data, cqe->res, cqe->flags);
+        HyperaioTrace trace("harvest: userdata " + std::to_string(cqe->user_data)
+            + " res " + std::to_string(cqe->res) + "flags " + std::to_string(cqe->flags));
         io_uring_cqe_seen(&pImpl_->uring_, cqe);
         if (ioResultCallBack_) {
             ioResultCallBack_(std::move(response));
         }
     }
+    HILOGI("exit harvest thread");
 }
 
 int32_t HyperAio::DestroyCtx()
 {
+    HILOGI("openReqCount = %{public}u, readReqCount = %{public}u, cancelReqCount = %{public}u, cqeCount = %{public}u",
+        openReqCount_.load(), readReqCount_.load(), cancelReqCount_.load(), cqeCount_.load());
     if (!initialized_.load()) {
+        HILOGI("not initialized");
         return EOK;
     }
 
     stopThread_.store(true);
     if (harvestThread_.joinable()) {
+        HILOGI("start harvest thread join");
         harvestThread_.join();
+        HILOGI("join success");
     }
 
     if (pImpl_ != nullptr) {
@@ -286,6 +310,7 @@ int32_t HyperAio::DestroyCtx()
     }
 
     initialized_.store(false);
+    HILOGI("destroy hyperaio success");
     return EOK;
 }
 #else