diff --git a/debug/accuracy_tools/msprobe/ccsrc/base/DebuggerConfig.cpp b/debug/accuracy_tools/msprobe/ccsrc/base/DebuggerConfig.cpp
index 15d17cab98ee4bde6f4fbefd7c3777fb04253fc3..e12119b1d0b724e7cba99f40bc4df6188001d23d 100644
--- a/debug/accuracy_tools/msprobe/ccsrc/base/DebuggerConfig.cpp
+++ b/debug/accuracy_tools/msprobe/ccsrc/base/DebuggerConfig.cpp
@@ -105,7 +105,7 @@ static bool DebuggerCfgParseUIntRangeGetBorder(const std::string& exp, uint32_t&
     }
     if (left >= right) {
         LOG_ERROR(DebuggerErrno::ERROR_INVALID_FORMAT,
-                    "When using a range expression, the left border should be smaller than the right.");
+                  "When using a range expression, the left border should be smaller than the right.");
         return false;
     }
     return true;
@@ -153,7 +153,7 @@ void DebuggerCfgParseUIntRange(const nlohmann::json& content, const std::string&
     constexpr uint32_t maxEleNum = 65536;
     if (realLen > maxEleNum) {
         LOG_ERROR(DebuggerErrno::ERROR_INVALID_FORMAT,
-                    "When using a range expression in " + name + ", maximum of 65536 elements can be expressed.");
+                  "When using a range expression in " + name + ", maximum of 65536 elements can be expressed.");
         return;
     }
 
@@ -356,7 +356,7 @@ void StatisticsCfg::Parse(const nlohmann::json& content)
     PARSE_OPTIONAL_FIELD_CHECK_RET(content, kList, filter);
     filter.erase(std::remove_if(filter.begin(), filter.end(),
                                 [](const std::string& s) { return s.find_first_not_of(' ') == std::string::npos; }),
-                                filter.end());
+                 filter.end());
     list = std::move(filter);
     if (DebuggerConfig::GetInstance().GetDebugLevel() == DebuggerLevel::L2) {
         matcher.Parse(list);
@@ -372,7 +372,7 @@ void DumpTensorCfg::Parse(const nlohmann::json& content)
     PARSE_OPTIONAL_FIELD_CHECK_RET(content, kList, filter);
     filter.erase(std::remove_if(filter.begin(), filter.end(),
                                 [](const std::string& s) { return s.find_first_not_of(' ') == std::string::npos; }),
-                                filter.end());
+                 filter.end());
     list = std::move(filter);
     if (DebuggerConfig::GetInstance().GetDebugLevel() == DebuggerLevel::L2) {
         matcher.Parse(list);
@@ -424,7 +424,7 @@ void DebuggerConfig::Parse()
             iter = content.find(name);                            \
             if (iter != content.end()) {                          \
                 member = std::make_shared<basetype>();            \
-                member->Parse(*(iter));                             \
+                ((member)->Parse(*(iter)));                             \
             }                                                     \
         }                                                         \
     } while (0)
diff --git a/debug/accuracy_tools/msprobe/ccsrc/core/AclDumpDataProcessor.cpp b/debug/accuracy_tools/msprobe/ccsrc/core/AclDumpDataProcessor.cpp
index 59f32903712c06c5c78c2715d3d46b93625a75db..caf7f5ba5573c2925d495eef8135410553b2d906 100644
--- a/debug/accuracy_tools/msprobe/ccsrc/core/AclDumpDataProcessor.cpp
+++ b/debug/accuracy_tools/msprobe/ccsrc/core/AclDumpDataProcessor.cpp
@@ -441,7 +441,7 @@ static DebuggerErrno DumpOpDebugDataToDisk(const std::string& dumpPath, AclDumpM
 {
     DEBUG_FUNC_TRACE();
     std::string outPath = dumpPath + ".output.";
-    uint32_t num = dumpData.output().size();
+    uint32_t num = static_cast<uint32_t>(dumpData.output().size());
     for (uint32_t slot = 0; slot < num; slot++) {
         uint32_t offset = 0;
         // parse DHA Atomic Add info
diff --git a/debug/accuracy_tools/msprobe/ccsrc/core/AclTensor.cpp b/debug/accuracy_tools/msprobe/ccsrc/core/AclTensor.cpp
index e2fc4a62da8e24b5a0ae1fd272c0fabf2c8022de..2858852353ebe3bd37c6146ddf56fe406003993a 100644
--- a/debug/accuracy_tools/msprobe/ccsrc/core/AclTensor.cpp
+++ b/debug/accuracy_tools/msprobe/ccsrc/core/AclTensor.cpp
@@ -94,7 +94,7 @@ const static std::unordered_set<AclFormat> kSupportedFormat = {
     AclFormat::FORMAT_DHWNC,
     AclFormat::FORMAT_NDC1HWC0,
     AclFormat::FORMAT_FRACTAL_Z_3D,
-    AclFormat::FORMAT_C1HWNCoC0,
+    AclFormat::FORMAT_C1HWNCOC0,
     AclFormat::FORMAT_FRACTAL_NZ,
     AclFormat::FORMAT_FRACTAL_ZN_LSTM,
     AclFormat::FORMAT_NCL,
@@ -108,7 +108,7 @@ const static std::map<std::pair<AclFormat, AclFormat>, TensorTransFunc> formatTr
     {{AclFormat::FORMAT_FRACTAL_NZ, AclFormat::FORMAT_NCHW}, FRAC_NZ_TO_NCHW},
     {{AclFormat::FORMAT_NC1HWC0, AclFormat::FORMAT_NCHW}, NC1HWC0_TO_NCHW},
     {{AclFormat::FORMAT_NDC1HWC0, AclFormat::FORMAT_NCHW}, NDC1HWC0_TO_NCDHW},
-    {{AclFormat::FORMAT_C1HWNCoC0, AclFormat::FORMAT_NCHW}, C1HWNCoC0_TO_NCHW},
+    {{AclFormat::FORMAT_C1HWNCOC0, AclFormat::FORMAT_NCHW}, C1HWNCoC0_TO_NCHW},
     {{AclFormat::FORMAT_NC1HWC0_C04, AclFormat::FORMAT_NCHW}, NC1HWC0_C04_TO_NCHW},
     {{AclFormat::FORMAT_FRACTAL_Z_3D, AclFormat::FORMAT_NCHW}, FRAC_Z3D_TO_NCDHW},
 };
@@ -174,7 +174,7 @@ const static std::unordered_map<AclDumpMsg::OutputFormat, AclFormat> formatTrans
     {AclDumpMsg::OutputFormat::FORMAT_HASHTABLE_LOOKUP_VALUE, AclFormat::FORMAT_HASHTABLE_LOOKUP_VALUE},
     {AclDumpMsg::OutputFormat::FORMAT_HASHTABLE_LOOKUP_OUTPUT, AclFormat::FORMAT_HASHTABLE_LOOKUP_OUTPUT},
     {AclDumpMsg::OutputFormat::FORMAT_HASHTABLE_LOOKUP_HITS, AclFormat::FORMAT_HASHTABLE_LOOKUP_HITS},
-    {AclDumpMsg::OutputFormat::FORMAT_C1HWNCoC0, AclFormat::FORMAT_C1HWNCoC0},
+    {AclDumpMsg::OutputFormat::FORMAT_C1HWNCoC0, AclFormat::FORMAT_C1HWNCOC0},
     {AclDumpMsg::OutputFormat::FORMAT_MD, AclFormat::FORMAT_MD},
     {AclDumpMsg::OutputFormat::FORMAT_NDHWC, AclFormat::FORMAT_NDHWC},
     {AclDumpMsg::OutputFormat::FORMAT_FRACTAL_ZZ, AclFormat::FORMAT_FRACTAL_ZZ},
@@ -244,7 +244,7 @@ static size_t EleNumOfTensor(const AclTensorInfo& tensor, bool host = true) {
             return 0;
         }
 
-        if (SIZE_MAX / dim < num) {
+        if (SIZE_MAX / dim < static_cast<unsigned long>(num)) {
             throw std::out_of_range(tensor + ": Count of element over size_t.");
         }
         num *= static_cast<size_t>(dim);
@@ -325,8 +325,8 @@ AclTensorInfo ParseAttrsFromDumpData(const std::string& dumpPath, const uint8_t*
     for (auto d : tensor.original_shape().dim()) {
         if (d > INT64_MAX) {
             LOG_WARNING(DebuggerErrno::ERROR_VALUE_OVERFLOW,
-                    "The value(" + std::to_string(d) + ") exceeds the max value of int64_t, " +
-                    "this maybe caused by the unfixed shape operaters.");
+                        "The value(" + std::to_string(d) + ") exceeds the max value of int64_t, " +
+                        "this maybe caused by the unfixed shape operaters.");
             hShape.clear();
             break;
         }
@@ -395,8 +395,8 @@ static DebuggerErrno FRAC_Z_TO_NCHW_WITH_GROUPS(AclTensorInfo& tensor)
     auto c1Dim = cinOpt / cubeK;
     const uint8_t* src = tensor.aclData;
     auto dst = tensor.transBuf.begin();
-    auto dtypeSize = SizeOfAclDType(tensor);
-    auto dstSize = tensor.transBuf.size();
+    int64_t dtypeSize = static_cast<int64_t>(SizeOfAclDType(tensor));
+    int64_t dstSize = static_cast<int64_t>(tensor.transBuf.size());
 
     for (int64_t g = 0; g < groups; ++g) {
         for (int64_t c = 0; c < cDim; ++c) {
@@ -457,8 +457,8 @@ static DebuggerErrno FRAC_Z_TO_NCHW(AclTensorInfo& tensor)
 
     const uint8_t* src = tensor.aclData;
     auto dst = tensor.transBuf.begin();
-    auto dtypeSize = SizeOfAclDType(tensor);
-    auto dstSize = tensor.transBuf.size();
+    int64_t dtypeSize = static_cast<int64_t>(SizeOfAclDType(tensor));
+    int64_t dstSize = static_cast<int64_t>(tensor.transBuf.size());
     for (int64_t nIdx = 0; nIdx < n; nIdx++) {
         int64_t nHeadAddr = nIdx * chw;
         for (int64_t cIdx = 0; cIdx < c; cIdx++) {
@@ -535,8 +535,8 @@ static DebuggerErrno FRAC_NZ_TO_NCHW(AclTensorInfo& tensor)
 
     const uint8_t* src = tensor.aclData;
     auto dst = tensor.transBuf.begin();
-    auto dtypeSize = SizeOfAclDType(tensor);
-    auto dstSize = tensor.transBuf.size();
+    int64_t dtypeSize = static_cast<int64_t>(SizeOfAclDType(tensor));
+    int64_t dstSize = static_cast<int64_t>(tensor.transBuf.size());
 
     for (int64_t timesIdx = 0; timesIdx < times; timesIdx++) {
         auto timesHead = timesIdx * w1h1h0w0;
@@ -599,8 +599,8 @@ static DebuggerErrno NC1HWC0_TO_NCHW(AclTensorInfo& tensor)
 
     const uint8_t* src = tensor.aclData;
     auto dst = tensor.transBuf.begin();
-    auto dtypeSize = SizeOfAclDType(tensor);
-    auto dstSize = tensor.transBuf.size();
+    int64_t dtypeSize = static_cast<int64_t>(SizeOfAclDType(tensor));
+    int64_t dstSize = static_cast<int64_t>(tensor.transBuf.size());
     for (int64_t nIndex = 0; nIndex < n; nIndex++) {
         int64_t nHeadAddr = nIndex * chw;
         for (int64_t cIndex = 0; cIndex < c; cIndex++) {
@@ -654,8 +654,8 @@ static DebuggerErrno NDC1HWC0_TO_NCDHW(AclTensorInfo& tensor)
 
     const uint8_t* src = tensor.aclData;
     auto dst = tensor.transBuf.begin();
-    auto dtypeSize = SizeOfAclDType(tensor);
-    auto dstSize = tensor.transBuf.size();
+    int64_t dtypeSize = static_cast<int64_t>(SizeOfAclDType(tensor));
+    int64_t dstSize = static_cast<int64_t>(tensor.transBuf.size());
     for (int64_t nIndex = 0; nIndex < n; nIndex++) {
         int64_t nHead = nIndex * cdhw;
         for (int64_t cIndex = 0; cIndex < c; cIndex++) {
@@ -703,8 +703,8 @@ static DebuggerErrno C1HWNCoC0_TO_NCHW(AclTensorInfo& tensor)
 
     const uint8_t* src = tensor.aclData;
     auto dst = tensor.transBuf.begin();
-    auto dtypeSize = SizeOfAclDType(tensor);
-    auto dstSize = tensor.transBuf.size();
+    int64_t dtypeSize = static_cast<int64_t>(SizeOfAclDType(tensor));
+    int64_t dstSize = static_cast<int64_t>(tensor.transBuf.size());
     for (int64_t nIndex = 0; nIndex < n; nIndex++) {
         for (int64_t cIndex = 0; cIndex < c; cIndex++) {
             for (int64_t hIndex = 0; hIndex < h; hIndex++) {
@@ -765,8 +765,8 @@ static DebuggerErrno FRAC_Z3D_TO_NCDHW(AclTensorInfo& tensor)
 
     const uint8_t* src = tensor.aclData;
     auto dst = tensor.transBuf.begin();
-    auto dtypeSize = SizeOfAclDType(tensor);
-    auto dstSize = tensor.transBuf.size();
+    int64_t dtypeSize = static_cast<int64_t>(SizeOfAclDType(tensor));
+    int64_t dstSize = static_cast<int64_t>(tensor.transBuf.size());
     for (int64_t nIdx = 0; nIdx < n; nIdx++) {
         int64_t nHead = nIdx * cdhw;
         for (int64_t cIdx = 0; cIdx < c; cIdx++) {
diff --git a/debug/accuracy_tools/msprobe/ccsrc/if/mindspore/MindSporeDbgHook.cpp b/debug/accuracy_tools/msprobe/ccsrc/if/mindspore/MindSporeDbgHook.cpp
index db279a33f17311a7c3681e7d899c2fa85a6fdcc8..7edf4cf5ca2e1a4a6dc8a11a8ed5503d79c79886 100644
--- a/debug/accuracy_tools/msprobe/ccsrc/if/mindspore/MindSporeDbgHook.cpp
+++ b/debug/accuracy_tools/msprobe/ccsrc/if/mindspore/MindSporeDbgHook.cpp
@@ -38,7 +38,7 @@ EXPORT_SYMBOL void MS_DbgOnStepBegin(uint32_t device, int32_t curStep,
                 continue;
             }
             std::vector<std::string>* ss = reinterpret_cast<std::vector<std::string>*>(ext.second);
-            strBuf = new const char*[(*ss).size() + 1];
+            strBuf = new const char* [(*ss).size() + 1];
             strBuf[(*ss).size()] = nullptr;
             size_t i = 0;
             for (std::string& s : *ss) {
diff --git a/debug/accuracy_tools/msprobe/ccsrc/utils/CPythonUtils.cpp b/debug/accuracy_tools/msprobe/ccsrc/utils/CPythonUtils.cpp
index 7a6b7b36bff9983b7262d5919e95b15ed4ed4d04..e9308414fafcf0ef214059b55035198fc88746bd 100644
--- a/debug/accuracy_tools/msprobe/ccsrc/utils/CPythonUtils.cpp
+++ b/debug/accuracy_tools/msprobe/ccsrc/utils/CPythonUtils.cpp
@@ -483,7 +483,7 @@ PythonTupleObject::PythonTupleObject() : PythonObject()
 
 PythonTupleObject::PythonTupleObject(PyObject* o) : PythonObject()
 {
-    if (!PyTuple_Check(o)) {
+    if (!o || !PyTuple_Check(o)) {
         return;
     }
 
diff --git a/debug/accuracy_tools/msprobe/ccsrc/utils/DataUtils.cpp b/debug/accuracy_tools/msprobe/ccsrc/utils/DataUtils.cpp
index 23088d48e31a15af69bdc19939e490b27c4a50a6..eb465cd311420d6355dfa6d1dbecd3168cba7637 100644
--- a/debug/accuracy_tools/msprobe/ccsrc/utils/DataUtils.cpp
+++ b/debug/accuracy_tools/msprobe/ccsrc/utils/DataUtils.cpp
@@ -26,14 +26,16 @@
 namespace MindStudioDebugger {
 namespace  DataUtils {
 
-int64_t SizeToS64(size_t v) {
+int64_t SizeToS64(size_t v)
+{
     if (v > static_cast<size_t>(INT64_MAX)) {
         throw std::runtime_error("Value " + std::to_string(v) + "exceeds the maximum value of int64.");
     }
     return static_cast<int64_t>(v);
 }
 
-std::string U64ToHexString(uint64_t v) {
+std::string U64ToHexString(uint64_t v)
+{
     std::stringstream ss;
     ss << "0x" << std::hex << std::uppercase << v;
     return std::move(ss.str());
@@ -42,33 +44,33 @@ std::string U64ToHexString(uint64_t v) {
 BFloat16::BFloat16(float f32)
 {
     if (std::isnan(f32)) {
-      value_ = BFloat16::nan_value;
+        value_ = BFloat16::NAN_VALUE;
     } else {
+        constexpr uint8_t offsetSize = 16;
         union {
-            uint32_t U32;
-            float F32;
+            uint32_t u32Value;
+            float f32Value;
         };
-        F32 = f32;
-        uint32_t rounding_bias = ((U32 >> 16) & 1) + UINT32_C(0x7FFF);
-        value_ = static_cast<uint16_t>((U32 + rounding_bias) >> 16);
+        f32Value = f32;
+        uint32_t rounding_bias = ((u32Value >> offsetSize) & 1) + UINT32_C(0x7FFF);
+        value_ = static_cast<uint16_t>((u32Value + rounding_bias) >> offsetSize);
     }
 }
 
 BFloat16::operator float() const
 {
     /* 为了兼容性，不要用c++20的bit_cast */
-    union
-    {
+    constexpr uint8_t offsetSize = 16;
+    union {
         float f32;
         uint32_t ui32;
     };
-    
     ui32 = static_cast<uint32_t>(value_);
-    ui32 <<= 16; // 将ui32左移16位
+    ui32 <<= offsetSize; // 将ui32左移16位
     return f32;
 }
 
-const static std::unordered_map<DataType, size_t> kTypeSizeMap = {
+constexpr std::pair<DataType, size_t> TYPE_SIZE_ARRAY[] = {
     {DataType::DT_BOOL, 1},
     {DataType::DT_INT8, 1},
     {DataType::DT_UINT8, 1},
@@ -88,15 +90,16 @@ const static std::unordered_map<DataType, size_t> kTypeSizeMap = {
 
 size_t SizeOfDType(DataType type)
 {
-    auto it = kTypeSizeMap.find(type);
-    if (it == kTypeSizeMap.end()) {
-        return 0;
+    for (const auto& pair : TYPE_SIZE_ARRAY) {
+        if (pair.first == type) {
+            return pair.second;
+        }
     }
-    return it->second;
+    return 0;
 }
 
-constexpr auto kOpDType_UNKNOWN = "UNKNOWN";
-const static std::unordered_map<DataType, std::string> kDDTypeToStringMap = {
+constexpr auto OP_DTYPE_UNKNOWN = "UNKNOWN";
+const std::pair<DataType, std::string_view> DTYPE_TO_STRING_ARRAY[] = {
     {DataType::DT_UNDEFINED, "UNDEFINED"},
     {DataType::DT_FLOAT, "FLOAT"},
     {DataType::DT_FLOAT16, "FLOAT16"},
@@ -133,15 +136,16 @@ const static std::unordered_map<DataType, std::string> kDDTypeToStringMap = {
 
 std::string GetDTypeString(DataType dtype)
 {
-    auto it = kDDTypeToStringMap.find(dtype);
-    if (it != kDDTypeToStringMap.end()) {
-        return it->second;
+    for (const auto& pair : DTYPE_TO_STRING_ARRAY) {
+        if (pair.first == dtype) {
+            return std::string(pair.second);
+        }
     }
-    return kOpDType_UNKNOWN;
+    return OP_DTYPE_UNKNOWN;
 }
 
-constexpr auto kOpFormat_UNKNOWN = "UNKNOWN";
-const static std::unordered_map<TensorFormat, std::string> kFormatToStringMap = {
+constexpr auto OP_FORMAT_UNKNOWN = "UNKNOWN";
+const std::pair<TensorFormat, std::string_view> FORMAT_TO_STRING_ARRAY[] = {
     {TensorFormat::FORMAT_NCHW, "NCHW"},
     {TensorFormat::FORMAT_NHWC, "NHWC"},
     {TensorFormat::FORMAT_ND, "ND"},
@@ -167,7 +171,7 @@ const static std::unordered_map<TensorFormat, std::string> kFormatToStringMap =
     {TensorFormat::FORMAT_HASHTABLE_LOOKUP_VALUE, "HASHTABLE_LOOKUP_VALUE"},
     {TensorFormat::FORMAT_HASHTABLE_LOOKUP_OUTPUT, "HASHTABLE_LOOKUP_OUTPUT"},
     {TensorFormat::FORMAT_HASHTABLE_LOOKUP_HITS, "HASHTABLE_LOOKUP_HITS"},
-    {TensorFormat::FORMAT_C1HWNCoC0, "C1HWNCoC0"},
+    {TensorFormat::FORMAT_C1HWNCOC0, "C1HWNCoC0"},
     {TensorFormat::FORMAT_MD, "MD"},
     {TensorFormat::FORMAT_NDHWC, "NDHWC"},
     {TensorFormat::FORMAT_FRACTAL_ZZ, "FRACTAL_ZZ"},
@@ -196,11 +200,12 @@ const static std::unordered_map<TensorFormat, std::string> kFormatToStringMap =
 
 std::string GetFormatString(TensorFormat fmt)
 {
-    auto it = kFormatToStringMap.find(fmt);
-    if (it != kFormatToStringMap.end()) {
-        return it->second;
+    for (const auto& pair : FORMAT_TO_STRING_ARRAY) {
+        if (pair.first == fmt) {
+            return std::string(pair.second);
+        }
     }
-    return kOpFormat_UNKNOWN;
+    return OP_FORMAT_UNKNOWN;
 }
 
 std::string GetShapeString(const TensorShape& shape)
diff --git a/debug/accuracy_tools/msprobe/ccsrc/utils/DataUtils.hpp b/debug/accuracy_tools/msprobe/ccsrc/utils/DataUtils.hpp
index f58e15a8c77719f62ddeef8ebbcd25a5b5ebf624..cbe5f8e150bd1dbbf399b083cc1ba1a9ac32a6f9 100644
--- a/debug/accuracy_tools/msprobe/ccsrc/utils/DataUtils.hpp
+++ b/debug/accuracy_tools/msprobe/ccsrc/utils/DataUtils.hpp
@@ -40,7 +40,7 @@ class BFloat16 {
 public:
     static constexpr uint16_t value_mask = 0x7fff;
     static constexpr uint16_t inf_value = 0x7f80;
-    static constexpr uint16_t nan_value = 0x7fc0;
+    static constexpr uint16_t NAN_VALUE = 0x7fc0;
     static constexpr uint16_t true_value = 0x3c00;
     static constexpr uint32_t f32_inf_value = 0x7f800000;
 
@@ -51,7 +51,7 @@ public:
     BFloat16 &operator=(const BFloat16 &other) noexcept = default;
     BFloat16 &operator=(BFloat16 &&other) noexcept = default;
 
-    explicit BFloat16(float f);
+    explicit BFloat16(float f32);
     explicit operator float() const;
     BFloat16 operator+(const BFloat16& other) const
         { return BFloat16(static_cast<float>(*this) + static_cast<float>(other)); }
@@ -131,7 +131,7 @@ enum TensorFormat : int {
     FORMAT_HASHTABLE_LOOKUP_VALUE = 22,
     FORMAT_HASHTABLE_LOOKUP_OUTPUT = 23,
     FORMAT_HASHTABLE_LOOKUP_HITS = 24,
-    FORMAT_C1HWNCoC0 = 25,
+    FORMAT_C1HWNCOC0 = 25,
     FORMAT_MD = 26,
     FORMAT_NDHWC = 27,
     FORMAT_FRACTAL_ZZ = 28,
diff --git a/debug/accuracy_tools/msprobe/ccsrc/utils/FileUtils.cpp b/debug/accuracy_tools/msprobe/ccsrc/utils/FileUtils.cpp
index 8c3cd20883d26d68a5e3504bec47a9c3d76d3023..f5383f8e66b88266a76c1b84a73b195d099c9298 100644
--- a/debug/accuracy_tools/msprobe/ccsrc/utils/FileUtils.cpp
+++ b/debug/accuracy_tools/msprobe/ccsrc/utils/FileUtils.cpp
@@ -60,7 +60,7 @@ static std::string GetFullPath(const std::string &originPath)
     }
 
     cwd = cwdBuf;
-    std::string fullPath = std::move(cwd + pathSeparator + originPath);
+    std::string fullPath = std::move(cwd + PATH_SEPARATOR + originPath);
 
     return fullPath;
 }
@@ -243,7 +243,7 @@ bool IsPathLengthLegal(const std::string& path)
 
 bool IsPathDepthValid(const std::string& path)
 {
-    return std::count(path.begin(), path.end(), pathSeparator) <= PATH_DEPTH_MAX;
+    return std::count(path.begin(), path.end(), PATH_SEPARATOR) <= PATH_DEPTH_MAX;
 }
 
 bool IsFileOwner(const std::string& path)
diff --git a/debug/accuracy_tools/msprobe/ccsrc/utils/FileUtils.hpp b/debug/accuracy_tools/msprobe/ccsrc/utils/FileUtils.hpp
index f1defd092c9630a4e32878b520a26242bae0116d..8606ea6f973f0cd40a571becd073f9ac3534786c 100644
--- a/debug/accuracy_tools/msprobe/ccsrc/utils/FileUtils.hpp
+++ b/debug/accuracy_tools/msprobe/ccsrc/utils/FileUtils.hpp
@@ -27,7 +27,7 @@
 
 namespace MindStudioDebugger {
 
-constexpr const char pathSeparator = '/';
+constexpr const char PATH_SEPARATOR = '/';
 constexpr const uint32_t FULL_PATH_LENGTH_MAX = 4096;
 constexpr const uint32_t FILE_NAME_LENGTH_MAX = 255;
 constexpr const uint32_t PATH_DEPTH_MAX = 32;
@@ -64,8 +64,8 @@ constexpr const uint32_t FILE_NAME_MAX = 255;
 
 /* 基础检查函数库，不做过多校验，路径有效性由调用者保证 */
 bool IsPathExist(const std::string& path);
-std::vector<std::string> SplitPath(const std::string &path, char separator=pathSeparator);
-std::string GetAbsPath(const std::string &path);
+std::vector<std::string> SplitPath(const std::string &path, char separator=PATH_SEPARATOR);
+std::string GetAbsPath(const std::string &originpath);
 bool IsDir(const std::string& path);
 bool IsRegularFile(const std::string& path);
 bool IsFileSymbolLink(const std::string& path);
diff --git a/debug/accuracy_tools/msprobe/mindspore/dym_loader/hook_dynamic_loader.h b/debug/accuracy_tools/msprobe/mindspore/dym_loader/hook_dynamic_loader.h
index 6309e60b662a03d7f77cb450986ded5329fd8960..f1bcd84e70bc4a1e3bf4e164eb3da6374a60b3b6 100644
--- a/debug/accuracy_tools/msprobe/mindspore/dym_loader/hook_dynamic_loader.h
+++ b/debug/accuracy_tools/msprobe/mindspore/dym_loader/hook_dynamic_loader.h
@@ -27,27 +27,26 @@ constexpr auto kHookBegin = "MS_DbgOnStepBegin";
 constexpr auto kHookEnd = "MS_DbgOnStepEnd";
 
 class HookDynamicLoader {
- public:
-  static HookDynamicLoader &GetInstance();
+public:
+    static HookDynamicLoader &GetInstance();
 
-  HookDynamicLoader(const HookDynamicLoader &) = delete;
-  HookDynamicLoader &operator=(const HookDynamicLoader &) = delete;
+    HookDynamicLoader(const HookDynamicLoader &) = delete;
+    HookDynamicLoader &operator=(const HookDynamicLoader &) = delete;
 
-  bool LoadLibrary();
-  bool UnloadLibrary();
-  void *GetHooker(const std::string &funcName);
+    bool LoadLibrary();
+    bool UnloadLibrary();
+    void *GetHooker(const std::string &funcName);
 
- private:
-  // Helper functions
-  bool loadFunction(void *handle, const std::string &functionName);
-  bool validateLibraryPath(const std::string &libPath);
+private:
+    // Helper functions
+    bool LoadFunction(void *handle, const std::string &functionName);
 
-  HookDynamicLoader() = default;
+    HookDynamicLoader() = default;
 
-  void *handle_ = nullptr;
-  std::vector<std::string> functionList_ = {kHookBegin, kHookEnd};
-  std::map<std::string, void *> funcMap_;
-  std::mutex mutex_;
+    void *handle_ = nullptr;
+    std::vector<std::string> functionList_ = {kHookBegin, kHookEnd};
+    std::map<std::string, void *> funcMap_;
+    std::mutex mutex_;
 };
 
 #endif  // HOOK_DYNAMIC_LOADER_H