diff --git a/model/init_callback_register.cpp b/model/init_callback_register.cpp index a136d8aece06a7c80ccfb577cb086dadb19d1aba..2c1bb89a95a5fca59a21e98586c296b3dc6e79bd 100644 --- a/model/init_callback_register.cpp +++ b/model/init_callback_register.cpp @@ -18,87 +18,11 @@ extern "C" { #endif extern __attribute__((weak, visibility("default"))) void conflicting_func_ascendcl(); - -typedef aclError (*aclDumpSetCallbackFunc)(const char *configStr); -typedef aclError (*aclDumpUnsetCallbackFunc)(); -extern ACL_FUNC_VISIBILITY aclError aclDumpSetCallbackRegister(aclDumpSetCallbackFunc cbFunc); -extern ACL_FUNC_VISIBILITY aclError aclDumpSetCallbackUnRegister(); -extern ACL_FUNC_VISIBILITY aclError aclDumpUnsetCallbackRegister(aclDumpUnsetCallbackFunc cbFunc); -extern ACL_FUNC_VISIBILITY aclError aclDumpUnsetCallbackUnRegister(); #ifdef __cplusplus } #endif namespace { -struct DumpBlacklist { - std::string name; - std::vector pos; -}; - -struct OpNameRange { - std::string begin; - std::string end; -}; - -struct ModelDumpConfig { - std::string modelName; - std::vector layer; - std::vector watcherNodes; - bool isLayer = false; // Whether the label of "layer" exists - bool isModelName = false; // Whether the label of "model_name" exists - std::vector optypeBlacklist; - std::vector opnameBlacklist; - std::vector dumpOpNameRanges; -}; - -struct aclDumpConfig { - std::string dumpPath; - std::string dumpMode; - std::vector dumpList; - std::string dumpOpSwitch; - std::string dumpDebug; - std::string dumpScene; - std::string dumpStep; - std::string dumpData; - std::string dumpLevel; - std::vector dumpStats; -}; -const std::string ACL_DUMP = "dump"; -const std::string ACL_DUMP_MODEL_NAME = "model_name"; -const std::string ACL_DUMP_LAYER = "layer"; -const std::string ACL_DUMP_WATCHER_NODES = "watcher_nodes"; -const std::string ACL_DUMP_OPNAME_RANGE = "opname_range"; -const std::string ACL_DUMP_OPNAME_RANGE_BEGIN = "begin"; -const std::string ACL_DUMP_OPNAME_RANGE_END = "end"; -const std::string ACL_DUMP_PATH = "dump_path"; -const std::string ACL_DUMP_LIST = "dump_list"; -const std::string ACL_DUMP_MODE = "dump_mode"; -const std::string ACL_DUMP_STEP = "dump_step"; -const std::string ACL_DUMP_OP_SWITCH = "dump_op_switch"; -const std::string ACL_DUMP_MODE_OUTPUT = "output"; -const std::string ACL_DUMP_DEBUG = "dump_debug"; -const std::string ACL_DUMP_DATA = "dump_data"; -const std::string ACL_DUMP_LEVEL = "dump_level"; -const std::string ACL_DUMP_SCENE = "dump_scene"; -const std::string ACL_DUMP_STATS = "dump_stats"; -const std::string ACL_DUMP_LEVEL_ALL = "all"; -const std::string ACL_DUMP_STATUS_SWITCH_ON = "on"; -const std::string ACL_DUMP_STATUS_SWITCH_OFF = "off"; -const std::string ACL_DUMP_LEVEL_OP = "op"; -const std::string ACL_DUMP_OPTYPE_BLACKLIST = "optype_blacklist"; -const std::string ACL_DUMP_OPNAME_BLACKLIST = "opname_blacklist"; -const std::string ACL_DUMP_BLACKLIST_NAME = "name"; -const std::string ACL_DUMP_BLACKLIST_POS = "pos"; - -const std::string ACL_DUMP_LITE_EXCEPTION = "lite_exception"; -const std::string ACL_DUMP_EXCEPTION_AIC_ERR_BRIEF = "aic_err_brief_dump"; // l0 exception dump -const std::string ACL_DUMP_EXCEPTION_AIC_ERR_NORM = "aic_err_norm_dump"; // l1 exception dump -const std::string ACL_DUMP_EXCEPTION_AIC_ERR_DETAIL = "aic_err_detail_dump"; // npu coredump -const std::set aclDumpSceneExceptions = { - ACL_DUMP_LITE_EXCEPTION, ACL_DUMP_EXCEPTION_AIC_ERR_BRIEF, - ACL_DUMP_EXCEPTION_AIC_ERR_NORM, ACL_DUMP_EXCEPTION_AIC_ERR_DETAIL, -}; - void HandleReleaseSourceByDevice(uint32_t devId, bool isReset) { acl::AclResourceManager::GetInstance().HandleReleaseSourceByDevice(devId, isReset); @@ -108,238 +32,6 @@ void HandleReleaseSourceByStream(aclrtStream stream, bool isCreate) { acl::AclResourceManager::GetInstance().HandleReleaseSourceByStream(stream, isCreate); } - -std::string GetCfgStrByKey(const nlohmann::json &js , const std::string &key) { - return js.at(key).get(); -} - -bool ContainKey(const nlohmann::json &js, const std::string &key) { - return (js.find(key) != js.end()); -} - -static void from_json(const nlohmann::json &js, OpNameRange &range) { - if (ContainKey(js, ACL_DUMP_OPNAME_RANGE_BEGIN)) { - range.begin = js.at(ACL_DUMP_OPNAME_RANGE_BEGIN).get(); - } - if (ContainKey(js, ACL_DUMP_OPNAME_RANGE_END)) { - range.end = js.at(ACL_DUMP_OPNAME_RANGE_END).get(); - } -} - -static void from_json(const nlohmann::json &js, DumpBlacklist &blacklist) -{ - if (ContainKey(js, ACL_DUMP_BLACKLIST_NAME)) { - blacklist.name = GetCfgStrByKey(js, ACL_DUMP_BLACKLIST_NAME); - } - if (ContainKey(js, ACL_DUMP_BLACKLIST_POS)) { - blacklist.pos = js.at(ACL_DUMP_BLACKLIST_POS).get>(); - } -} - -static void from_json(const nlohmann::json &js, ModelDumpConfig &info) -{ - info.isLayer = false; - if (ContainKey(js, ACL_DUMP_MODEL_NAME)) { - info.modelName = GetCfgStrByKey(js, ACL_DUMP_MODEL_NAME); - info.isModelName = true; - } - if (ContainKey(js, ACL_DUMP_LAYER)) { - info.layer = js.at(ACL_DUMP_LAYER).get>(); - info.isLayer = true; - } - if (ContainKey(js, ACL_DUMP_WATCHER_NODES)) { - info.watcherNodes = js.at(ACL_DUMP_WATCHER_NODES).get>(); - } - if (ContainKey(js, ACL_DUMP_OPTYPE_BLACKLIST)) { - info.optypeBlacklist = js.at(ACL_DUMP_OPTYPE_BLACKLIST).get>(); - } - if (ContainKey(js, ACL_DUMP_OPNAME_BLACKLIST)) { - info.opnameBlacklist = js.at(ACL_DUMP_OPNAME_BLACKLIST).get>(); - } - if (ContainKey(js, ACL_DUMP_OPNAME_RANGE)) { - info.dumpOpNameRanges = js.at(ACL_DUMP_OPNAME_RANGE).get>(); - } -} - -static void from_json(const nlohmann::json &js, aclDumpConfig &config) -{ - if (ContainKey(js, ACL_DUMP_PATH)) { - config.dumpPath = GetCfgStrByKey(js, ACL_DUMP_PATH); - } - if (ContainKey(js, ACL_DUMP_LIST)) { - config.dumpList = js.at(ACL_DUMP_LIST).get>(); - } - if (ContainKey(js, ACL_DUMP_MODE)) { - config.dumpMode = GetCfgStrByKey(js, ACL_DUMP_MODE); - ACL_LOG_DEBUG("dump_mode field parse successfully, value = %s.", config.dumpMode.c_str()); - } else { - // dump_mode is an optional field, valid values include input/output/all - // default value is output - config.dumpMode = ACL_DUMP_MODE_OUTPUT; - } - if (ContainKey(js, ACL_DUMP_OP_SWITCH)) { - config.dumpOpSwitch = GetCfgStrByKey(js, ACL_DUMP_OP_SWITCH); - ACL_LOG_DEBUG("dump_op_switch field parse successfully, value = %s.", config.dumpOpSwitch.c_str()); - } else { - // dump_op_switch is an optional field, valid values include on/off - // default value is off - config.dumpOpSwitch = ACL_DUMP_STATUS_SWITCH_OFF; - } - // dump_debug is an optional field, valid values include on/off - // default value is off - config.dumpDebug = ACL_DUMP_STATUS_SWITCH_OFF; - if (ContainKey(js, ACL_DUMP_DEBUG)) { - config.dumpDebug = GetCfgStrByKey(js, ACL_DUMP_DEBUG); - ACL_LOG_DEBUG("dump_debug field parse successfully, value = %s", config.dumpDebug.c_str()); - } - - // dump_scene is an optional field, valid values include lite_exception - // default value is empty - config.dumpScene.clear(); - if (ContainKey(js, ACL_DUMP_SCENE)) { - config.dumpScene = GetCfgStrByKey(js, ACL_DUMP_SCENE); - ACL_LOG_DEBUG("dump_scene field parse successfully, value = %s", config.dumpScene.c_str()); - } - if (ContainKey(js, ACL_DUMP_STEP)) { - config.dumpStep = GetCfgStrByKey(js, ACL_DUMP_STEP); - } - if (ContainKey(js, ACL_DUMP_DATA)) { - config.dumpData = GetCfgStrByKey(js, ACL_DUMP_DATA); - } - if (ContainKey(js, ACL_DUMP_LEVEL)) { - config.dumpLevel = GetCfgStrByKey(js, ACL_DUMP_LEVEL); - ACL_LOG_DEBUG("dump_level field parse successfully, value = %s.", config.dumpLevel.c_str()); - } else { - // dump_level is an optional field, valid values include op/kernel/all - // default value is all - config.dumpLevel = ACL_DUMP_LEVEL_ALL; - } - if (ContainKey(js, ACL_DUMP_STATS)) { - config.dumpStats = js.at(ACL_DUMP_STATS).get>(); - } -} - -static aclError HandleDumpExceptionConfig(ge::DumpConfig &dumpCfg, const aclDumpConfig &config) -{ - if (aclDumpSceneExceptions.find(config.dumpScene) == aclDumpSceneExceptions.end()) { - return ACL_ERROR_INVALID_PARAM; - } - - dumpCfg.dump_exception = config.dumpScene; - dumpCfg.dump_path = config.dumpPath; - dumpCfg.dump_status = ACL_DUMP_STATUS_SWITCH_ON; - - const char_t *ascendWorkPath = nullptr; - MM_SYS_GET_ENV(MM_ENV_ASCEND_WORK_PATH, ascendWorkPath); - if (ascendWorkPath != nullptr) { - dumpCfg.dump_path = ascendWorkPath; - ACL_LOG_INFO("get env ASCEND_WORK_PATH %s", ascendWorkPath); - } - - ACL_LOG_INFO("convert to ge dump config successfully, enable %s dump, path=%s", - config.dumpScene.c_str(), dumpCfg.dump_path.c_str()); - return ACL_SUCCESS; -} - -static aclError HandleDumpDebugConfig(ge::DumpConfig &dumpCfg, const aclDumpConfig &config) -{ - if (dumpCfg.dump_debug != ACL_DUMP_STATUS_SWITCH_ON) { - return ACL_ERROR_INVALID_PARAM; - } - - dumpCfg.dump_path = config.dumpPath; - dumpCfg.dump_status = ACL_DUMP_STATUS_SWITCH_OFF; - dumpCfg.dump_step = config.dumpStep; - - ACL_LOG_INFO("convert to ge dump config successfully, dump_path = %s, dump_debug = %s, dump_step = %s", - dumpCfg.dump_path.c_str(), dumpCfg.dump_debug.c_str(), dumpCfg.dump_step.c_str()); - return ACL_SUCCESS; -} - -static bool ProcessModelDumpConfig(ge::ModelDumpConfig &modelConfig, - const ModelDumpConfig &dumpModelConfig) -{ - if (dumpModelConfig.isModelName && dumpModelConfig.modelName.empty()) { - ACL_LOG_WARN("[Check][modelName]the modelName field is null"); - return false; - } - - if (dumpModelConfig.isLayer && dumpModelConfig.layer.empty()) { - ACL_LOG_WARN("[Check][Layer]layer field is null in model %s", - dumpModelConfig.modelName.c_str()); - return false; - } - - modelConfig.model_name = dumpModelConfig.modelName; - - // Process opname blacklist - for (const auto &item : dumpModelConfig.opnameBlacklist) { - modelConfig.opname_blacklist.emplace_back(ge::DumpBlacklist{item.name, item.pos}); - } - - // Process optype blacklist - for (const auto &item : dumpModelConfig.optypeBlacklist) { - modelConfig.optype_blacklist.emplace_back(ge::DumpBlacklist{item.name, item.pos}); - } - - // Process layers - modelConfig.layers.assign(dumpModelConfig.layer.begin(), dumpModelConfig.layer.end()); - - // Process watcher nodes - modelConfig.watcher_nodes.assign(dumpModelConfig.watcherNodes.begin(), - dumpModelConfig.watcherNodes.end()); - - // Process dump op ranges - for (const auto &range : dumpModelConfig.dumpOpNameRanges) { - modelConfig.dump_op_ranges.emplace_back(std::make_pair(range.begin, range.end)); - } - return true; -} - -static aclError SetUpDumpConfig(ge::DumpConfig &dumpCfg, const aclDumpConfig &config) -{ - // Handle exception dump config - if (aclDumpSceneExceptions.find(config.dumpScene) != aclDumpSceneExceptions.end()) { - return HandleDumpExceptionConfig(dumpCfg, config); - } - - // Handle debug dump config - dumpCfg.dump_debug = config.dumpDebug; - if (dumpCfg.dump_debug == ACL_DUMP_STATUS_SWITCH_ON) { - return HandleDumpDebugConfig(dumpCfg, config); - } - - // Set basic dump config - dumpCfg.dump_path = config.dumpPath; - dumpCfg.dump_mode = config.dumpMode; - dumpCfg.dump_step = config.dumpStep; - dumpCfg.dump_op_switch = config.dumpOpSwitch; - dumpCfg.dump_data = config.dumpData; - dumpCfg.dump_level = config.dumpLevel; - dumpCfg.dump_status = ((dumpCfg.dump_level == ACL_DUMP_LEVEL_OP) || - (dumpCfg.dump_level == ACL_DUMP_LEVEL_ALL)) - ? ACL_DUMP_STATUS_SWITCH_ON - : ACL_DUMP_STATUS_SWITCH_OFF; - - // Process dump list - for (const auto &item : config.dumpList) { - ge::ModelDumpConfig modelConfig; - if (ProcessModelDumpConfig(modelConfig, item)) { - dumpCfg.dump_list.emplace_back(std::move(modelConfig)); - } - } - - // Process dump stats - dumpCfg.dump_stats.assign(config.dumpStats.begin(), config.dumpStats.end()); - - ACL_LOG_INFO("convert to ge dump config successfully, dump_mode = %s, dump_path = %s, " - "dump_op_switch = %s, dump_step = %s, dump_data = %s, dumplist size is %zu", - dumpCfg.dump_mode.c_str(), dumpCfg.dump_path.c_str(), - dumpCfg.dump_op_switch.c_str(), dumpCfg.dump_step.c_str(), - dumpCfg.dump_data.c_str(), dumpCfg.dump_list.size()); - - return ACL_SUCCESS; -} } namespace acl { @@ -459,62 +151,4 @@ __attribute__((destructor)) aclError UnRegResourceFinalizeCallback() } return ACL_SUCCESS; } - -// ----------------------------------dump callback ------------------------------------------------- -aclError DumpSetCallbackFunc(const char *configBuffer) -{ - (void)configBuffer; - ACL_LOG_INFO("start to enter DumpCallbackFunc"); - nlohmann::json js; - aclError ret = acl::JsonParserUtils::ParseJson(configBuffer, js); - if (ret != ACL_SUCCESS) { - ACL_LOG_INNER_ERROR("Parse dump config from buffer failed, errorCode = %d", ret); - return ret; - } - if (!ContainKey(js, ACL_DUMP)) { - return ACL_SUCCESS; - } - aclDumpConfig aclCfg = js.at(ACL_DUMP); - ge::DumpConfig dumpCfg; - SetUpDumpConfig(dumpCfg, aclCfg); - ge::GeExecutor geExecutor; - const ge::Status geRet = geExecutor.SetDump(dumpCfg); - if (geRet != ge::SUCCESS) { - ACL_LOG_CALL_ERROR("[Set][Dump]set dump config for model failed, ge errorCode = %d", geRet); - return ACL_GET_ERRCODE_GE(static_cast(geRet)); - } - return ACL_SUCCESS; -} - -__attribute__((constructor)) aclError RegAclMdlSetDumpCallback() -{ - return aclDumpSetCallbackRegister(DumpSetCallbackFunc); -} -__attribute__((destructor)) aclError UnRegAclMdlSetDumpCallback() -{ - return aclDumpSetCallbackUnRegister(); -} - -aclError DumpSetCallbackFunc() -{ - ge::DumpConfig dumpCfg; - ge::GeExecutor geExecutor; - // clear dump config - dumpCfg.dump_status = ACL_DUMP_STATUS_SWITCH_OFF; - dumpCfg.dump_debug = ACL_DUMP_STATUS_SWITCH_OFF; - const ge::Status geRet = geExecutor.SetDump(dumpCfg); - if (geRet != ge::SUCCESS) { - ACL_LOG_CALL_ERROR("[Clear][DumpConfig]Clear dump config failed, ge errorCode = %d", geRet); - return ACL_GET_ERRCODE_GE(static_cast(geRet)); - } - return ACL_SUCCESS; -} -__attribute__((constructor)) aclError RegAclMdlUnsetDumpCallback() -{ - return aclDumpUnsetCallbackRegister(DumpSetCallbackFunc); -} -__attribute__((destructor)) aclError UnRegAclMdlUnsetDumpCallback() -{ - return aclDumpUnsetCallbackUnRegister(); -} } \ No newline at end of file diff --git a/tests/depends/acl_stub.h b/tests/depends/acl_stub.h index 7b803de4017eec16792c7ad2eb17785a1c4981aa..650c49e1d91ace4a09d29f15e734b540f825a87a 100755 --- a/tests/depends/acl_stub.h +++ b/tests/depends/acl_stub.h @@ -54,7 +54,7 @@ #include "runtime/rts/rts_snapshot.h" #include "adx_datadump_server.h" -#include "adump_api.h" +#include "adump_pub.h" #include "mmpa/mmpa_api.h" #include "./jpeg/src/jpeg_stub.h" @@ -566,8 +566,8 @@ public: // adx function virtual int AdxDataDumpServerInit(); virtual int AdxDataDumpServerUnInit(); - virtual int32_t AdumpSetDumpConfig(Adx::DumpType dumpType, const Adx::DumpConfig &dumpConfig); - virtual bool AdumpIsDumpEnable(Adx::DumpType dumpType); + virtual int32_t AdumpSetDump(const char *dumpConfigData, size_t dumpConfigSize); + virtual int32_t AdumpUnSetDump(); // slog function virtual int dlog_getlevel(int module_id, int *enable_event); @@ -1068,8 +1068,8 @@ public: // adx function stub MOCK_METHOD0(AdxDataDumpServerInit, int()); MOCK_METHOD0(AdxDataDumpServerUnInit, int()); - MOCK_METHOD2(AdumpSetDumpConfig, int(Adx::DumpType dumpType, const Adx::DumpConfig &dumpConfig)); - MOCK_METHOD1(AdumpIsDumpEnable, bool(Adx::DumpType dumpType)); + MOCK_METHOD2(AdumpSetDump, int32_t(const char *dumpConfigData, size_t dumpConfigSize)); + MOCK_METHOD0(AdumpUnSetDump, int32_t()); // slog function stub MOCK_METHOD2(dlog_getlevel, int(int module_id, int *enable_event)); diff --git a/tests/depends/toolchain/src/toolchain_stub.cpp b/tests/depends/toolchain/src/toolchain_stub.cpp index d1cf79eee94ae0343608f177ae42b1679a6bae46..df534dfe9cd59935770e81332b4420782697e93e 100755 --- a/tests/depends/toolchain/src/toolchain_stub.cpp +++ b/tests/depends/toolchain/src/toolchain_stub.cpp @@ -17,7 +17,7 @@ #include "toolchain/dump.h" #include "acl_stub.h" #include "adx_datadump_server.h" -#include "adump_api.h" +#include "adump_pub.h" #include "awatchdog.h" extern "C" int AdxDataDumpServerInit(); @@ -33,14 +33,16 @@ int aclStub::AdxDataDumpServerUnInit() return 0; } -int32_t aclStub::AdumpSetDumpConfig(Adx::DumpType dumpType, const Adx::DumpConfig &dumpConfig) +int32_t aclStub::AdumpSetDump(const char *dumpConfigData, size_t dumpConfigSize) { + (void)dumpConfigData; + (void)dumpConfigSize; return 0; } -bool aclStub::AdumpIsDumpEnable(Adx::DumpType dumpType) +int32_t aclStub::AdumpUnSetDump() { - return true; + return 1; } int AdxDataDumpServerInit() @@ -69,14 +71,14 @@ void AwdDestroyThreadWatchdog(AwdHandle handle) } namespace Adx { - int32_t AdumpSetDumpConfig(DumpType dumpType, const DumpConfig &dumpConfig) + int32_t AdumpSetDump(const char *dumpConfigData, size_t dumpConfigSize) { - return MockFunctionTest::aclStubInstance().AdumpSetDumpConfig(dumpType, dumpConfig); + return MockFunctionTest::aclStubInstance().AdumpSetDump(dumpConfigData, dumpConfigSize); } - bool AdumpIsDumpEnable(DumpType dumpType) + int32_t AdumpUnSetDump() { - return MockFunctionTest::aclStubInstance().AdumpIsDumpEnable(dumpType); + return MockFunctionTest::aclStubInstance().AdumpUnSetDump(); } } diff --git a/tests/ut/acl/testcase/acl_common_unittest.cpp b/tests/ut/acl/testcase/acl_common_unittest.cpp index 32a3158d331a9f040ab83624f128fda1ceb8c353..9ea1e8bb21e6b14b73530d32f8af5cbfdfc868cc 100755 --- a/tests/ut/acl/testcase/acl_common_unittest.cpp +++ b/tests/ut/acl/testcase/acl_common_unittest.cpp @@ -349,7 +349,7 @@ TEST_F(UTEST_ACL_Common, aclFinalizeReference_failed) TEST_F(UTEST_ACL_Common, finalize2) { - acl::AclDump::GetInstance().aclDumpFromAclInitFlag_ = true; + acl::AclDump::GetInstance().adxInitFromAclInitFlag_ = true; EXPECT_CALL(MockFunctionTest::aclStubInstance(), Finalize()) .WillRepeatedly(Return(SUCCESS)); EXPECT_CALL(MockFunctionTest::aclStubInstance(), AdxDataDumpServerInit()) diff --git a/tests/ut/acl/testcase/acl_toolchain_unittest.cpp b/tests/ut/acl/testcase/acl_toolchain_unittest.cpp index b99aa78eb64cdd95dd790396c803864e62aa4785..3a06e32eba1f569947ad1c5418372e1f58333f03 100755 --- a/tests/ut/acl/testcase/acl_toolchain_unittest.cpp +++ b/tests/ut/acl/testcase/acl_toolchain_unittest.cpp @@ -87,19 +87,6 @@ static int32_t MsprofRegTypeInfoStubForCnt(uint16_t level, uint32_t typeId, cons return 0; } -TEST_F(UTEST_ACL_toolchain, dumpApiNotSupportTest) -{ - acl::AclDump::GetInstance().aclDumpFromAclInitFlag_ = true; - aclError ret = aclmdlInitDump(); - EXPECT_NE(ret, ACL_SUCCESS); - - ret = aclmdlSetDump("llt/acl/ut/json/dumpConfig.json"); - EXPECT_NE(ret, ACL_SUCCESS); - - ret = aclmdlFinalizeDump(); - EXPECT_NE(ret, ACL_SUCCESS); -} - static int AdxDataDumpServerInitInvoke() { int initRet = 1; @@ -108,8 +95,7 @@ static int AdxDataDumpServerInitInvoke() TEST_F(UTEST_ACL_toolchain, dumpInitFailed) { - acl::AclDump::GetInstance().aclDumpFromAclInitFlag_ = true; - acl::AclDump::GetInstance().SetAclDumpFromAclInitFlag(false); + acl::AclDump::GetInstance().adxInitFromAclInitFlag_ = true; EXPECT_CALL(MockFunctionTest::aclStubInstance(), AdxDataDumpServerInit()) .WillRepeatedly(Invoke(AdxDataDumpServerInitInvoke)); aclError ret = aclmdlInitDump(); @@ -119,256 +105,14 @@ TEST_F(UTEST_ACL_toolchain, dumpInitFailed) TEST_F(UTEST_ACL_toolchain, dumpParamTest) { acl::AclDump aclDump; - acl::AclDump::GetInstance().aclDumpFromAclInitFlag_ = false; + acl::AclDump::GetInstance().adxInitFromAclInitFlag_ = false; aclError ret = aclmdlInitDump(); EXPECT_EQ(ret, ACL_SUCCESS); - acl::AclDump::GetInstance().aclDumpFromAclInitFlag_ = false; + acl::AclDump::GetInstance().adxInitFromAclInitFlag_ = false; ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDump1.json"); EXPECT_EQ(ret, ACL_SUCCESS); - acl::AclDump::GetInstance().aclDumpFromAclInitFlag_ = false; - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDump2.json"); - EXPECT_NE(ret, ACL_SUCCESS); - - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDump3.json"); - EXPECT_NE(ret, ACL_SUCCESS); - - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDump4.json"); - EXPECT_NE(ret, ACL_SUCCESS); - - // dump_list field illegal - ret = aclDump.HandleDumpConfig(ACL_BASE_DIR "/tests/ut/acl/json/testDump5.json"); - EXPECT_EQ(ret, ACL_ERROR_INVALID_DUMP_CONFIG); - - ret = aclDump.HandleDumpConfig(ACL_BASE_DIR "/tests/ut/acl/json/testDump6.json"); - EXPECT_EQ(ret, ACL_ERROR_INVALID_DUMP_CONFIG); - - // invalid dump_op_switch - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDump7.json"); - EXPECT_NE(ret, ACL_SUCCESS); - - // invalid dumppathIp - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDump8.json"); - EXPECT_NE(ret, ACL_SUCCESS); - - // model name is empty - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDump9.json"); - EXPECT_EQ(ret, ACL_SUCCESS); - - // dump_op_switch field is not exist - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDump10.json"); - EXPECT_EQ(ret, ACL_SUCCESS); - - // dump_op_switch field is off,dump_list is empty - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDump11.json"); - EXPECT_EQ(ret, ACL_SUCCESS); - - // dump_op_switch field is illegal - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDump12.json"); - EXPECT_NE(ret, ACL_SUCCESS); - - // dump_mode field is illegal - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDump13.json"); - EXPECT_NE(ret, ACL_SUCCESS); - - // dump_path is empty - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDump14.json"); - EXPECT_NE(ret, ACL_SUCCESS); - - // no dump item - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDump15.json"); - EXPECT_NE(ret, ACL_SUCCESS); - - // dump_list field is illegal - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDump16.json"); - EXPECT_NE(ret, ACL_SUCCESS); - - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDump17.json"); - EXPECT_NE(ret, ACL_SUCCESS); - - // ip is invalid - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDump18.json"); - EXPECT_NE(ret, ACL_SUCCESS); - - // dump_step field is illegal cuz of reverse range - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDump19.json"); - EXPECT_NE(ret, ACL_SUCCESS); - - // dump_step field is illegal cuz of wrong format - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDump20.json"); - EXPECT_NE(ret, ACL_SUCCESS); - - // dump_step field is illegal cuz of wrong format - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDump21.json"); - EXPECT_NE(ret, ACL_SUCCESS); - - // dump_step field is illegal cuz of wrong format - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDump22.json"); - EXPECT_NE(ret, ACL_SUCCESS); - - // dump_step field is illegal cuz of wrong format - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDump23.json"); - EXPECT_NE(ret, ACL_SUCCESS); - - // dump_step field is illegal cuz of wrong format - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDump24.json"); - EXPECT_NE(ret, ACL_SUCCESS); - - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDump25.json"); - EXPECT_EQ(ret, ACL_SUCCESS); - - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDump26.json"); - EXPECT_EQ(ret, ACL_SUCCESS); - - // dump_step field is illegal cuz of wrong format - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDump27.json"); - EXPECT_NE(ret, ACL_SUCCESS); - - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDump28.json"); - EXPECT_NE(ret, ACL_SUCCESS); - - // optype_blacklist and opname_blacklist dump test - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDump29.json"); - EXPECT_EQ(ret, ACL_SUCCESS); - - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDump30.json"); - EXPECT_EQ(ret, ACL_SUCCESS); - - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDump31.json"); - EXPECT_EQ(ret, ACL_SUCCESS); - - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDump32.json"); - EXPECT_NE(ret, ACL_SUCCESS); - - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDump33.json"); - EXPECT_NE(ret, ACL_SUCCESS); - - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDump34.json"); - EXPECT_NE(ret, ACL_SUCCESS); - - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDump35.json"); - EXPECT_EQ(ret, ACL_SUCCESS); - - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDump36.json"); - EXPECT_NE(ret, ACL_SUCCESS); - - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDump37.json"); - EXPECT_NE(ret, ACL_SUCCESS); - - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDumpWatcher1.json"); - EXPECT_EQ(ret, ACL_SUCCESS); - - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDumpWatcher2.json"); - EXPECT_NE(ret, ACL_SUCCESS); - - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDumpWatcher3.json"); - EXPECT_EQ(ret, ACL_SUCCESS); - - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDumpWatcher4.json"); - EXPECT_NE(ret, ACL_SUCCESS); - - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDumpWatcher5.json"); - EXPECT_NE(ret, ACL_SUCCESS); - - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDumpWatcher6.json"); - EXPECT_NE(ret, ACL_SUCCESS); - - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDumpWatcher7.json"); - EXPECT_NE(ret, ACL_SUCCESS); - - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDumpWatcher8.json"); - EXPECT_NE(ret, ACL_SUCCESS); - - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDumpWatcher9.json"); - EXPECT_NE(ret, ACL_SUCCESS); - - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDumpWatcher10.json"); - EXPECT_NE(ret, ACL_SUCCESS); - - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDumpWatcher11.json"); - EXPECT_NE(ret, ACL_SUCCESS); - - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDump_DumpDataCheck.json"); - EXPECT_EQ(ret, ACL_SUCCESS); - - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDump_DumpLevelOp.json"); - EXPECT_EQ(ret, ACL_SUCCESS); - - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDump_DumpLevelKernel.json"); - EXPECT_EQ(ret, ACL_SUCCESS); - - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDump_DumpLevelInvalid.json"); - EXPECT_NE(ret, ACL_SUCCESS); - - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDump_DumpStatsCheck1.json"); - EXPECT_NE(ret, ACL_SUCCESS); - - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDump_DumpStatsCheck2.json"); - EXPECT_NE(ret, ACL_SUCCESS); - - ret = aclDump.HandleDumpConfig(ACL_BASE_DIR "/tests/ut/acl/json/testDump_OpBlacklistInvalid.json"); - EXPECT_EQ(ret, ACL_ERROR_INVALID_DUMP_CONFIG); - - ret = aclDump.HandleDumpConfig(ACL_BASE_DIR "/tests/ut/acl/json/testDump_OpBlacklistWithInvalidDumpLevel.json"); - EXPECT_EQ(ret, ACL_ERROR_INVALID_DUMP_CONFIG); - - //dump_op_switch is on in dump overflow detection - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDebugDump1.json"); - EXPECT_NE(ret, ACL_SUCCESS); - - //dump_path is invalid in dump overflow detection - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDebugDump2.json"); - EXPECT_NE(ret, ACL_SUCCESS); - - //dump_list is valid in dump overflow detection - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDebugDump3.json"); - EXPECT_NE(ret, ACL_SUCCESS); - - //dump_list is invalid/dump_op_switch is "off"/dump_path is valid in dump overflow detection - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDebugDump4.json"); - EXPECT_NE(ret, ACL_SUCCESS); - - //dump_list is empty/dump_op_switch is "off"/dump_path is valid in dump overflow detection - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDebugDump5.json"); - EXPECT_EQ(ret, ACL_SUCCESS); - - //dump_op_switch is not in dump info - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDebugDump6.json"); - EXPECT_NE(ret, ACL_SUCCESS); - - //dump_path is not in dump info - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDebugDump7.json"); - EXPECT_NE(ret, ACL_SUCCESS); - - //only dump_path and dump_debug in dump info - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDebugDump8.json"); - EXPECT_EQ(ret, ACL_SUCCESS); - - //only dump_path and dump_op_switch in dump info - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDebugDump9.json"); - EXPECT_EQ(ret, ACL_SUCCESS); - - //only dump_path and dump_list in dump info - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDebugDump11.json"); - EXPECT_EQ(ret, ACL_SUCCESS); - - //only dump_path in dump info - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDebugDump10.json"); - EXPECT_EQ(ret, ACL_SUCCESS); - - //simple lite_exception_with_shape config is not support - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testLiteExceptionDump_with_shape.json"); - EXPECT_NE(ret, ACL_SUCCESS); - - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDumpOff1.json"); - EXPECT_EQ(ret, ACL_SUCCESS); - EXPECT_CALL(MockFunctionTest::aclStubInstance(), mmAccess2(_,_)) - .WillOnce(Return(-1)) - .WillRepeatedly(Return(0)); - ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testDumpOff1.json"); - EXPECT_EQ(ret, ACL_ERROR_INVALID_DUMP_CONFIG); - // aclInit dump ret = aclDump.HandleDumpConfig(ACL_BASE_DIR "/tests/ut/acl/json/dumpConfig.json"); EXPECT_EQ(ret, ACL_SUCCESS); @@ -379,14 +123,13 @@ TEST_F(UTEST_ACL_toolchain, dumpParamTest) ret = aclDump.HandleDumpConfig(ACL_BASE_DIR "/tests/ut/acl/json/testDump_DumpLevelKernel.json"); EXPECT_EQ(ret, ACL_SUCCESS); - EXPECT_CALL(MockFunctionTest::aclStubInstance(), SetDump(_)).WillOnce(Return(FAILED)); + EXPECT_CALL(MockFunctionTest::aclStubInstance(), AdumpSetDump(_, _)).WillOnce(Return(FAILED)); ret = aclDump.HandleDumpConfig(ACL_BASE_DIR "/tests/ut/acl/json/testDump_DumpLevelKernel.json"); EXPECT_NE(ret, ACL_SUCCESS); } TEST_F(UTEST_ACL_toolchain, dumpNotInitTest) { - acl::AclDump::GetInstance().SetAclDumpFromAclInitFlag(false); aclmdlFinalizeDump(); aclError ret = aclmdlSetDump("llt/acl/ut/json/dumpConfig.json"); EXPECT_NE(ret, ACL_SUCCESS); @@ -395,7 +138,7 @@ TEST_F(UTEST_ACL_toolchain, dumpNotInitTest) TEST_F(UTEST_ACL_toolchain, repeatExecuteAclmdlInitDumpTest) { - acl::AclDump::GetInstance().aclDumpFromAclInitFlag_ = false; + acl::AclDump::GetInstance().adxInitFromAclInitFlag_ = false; aclError ret = aclmdlInitDump(); EXPECT_EQ(ret, ACL_SUCCESS); EXPECT_NE(aclmdlInitDump(), ACL_SUCCESS); @@ -403,13 +146,13 @@ TEST_F(UTEST_ACL_toolchain, repeatExecuteAclmdlInitDumpTest) EXPECT_EQ(ret, ACL_SUCCESS); } -TEST_F(UTEST_ACL_toolchain, SetDumpConfigFailedTest) +TEST_F(UTEST_ACL_toolchain, AdumpSetDumpFailedTest) { - acl::AclDump::GetInstance().aclDumpFromAclInitFlag_ = false; + acl::AclDump::GetInstance().adxInitFromAclInitFlag_ = false; aclError ret = aclmdlInitDump(); EXPECT_EQ(ret, ACL_SUCCESS); - EXPECT_CALL(MockFunctionTest::aclStubInstance(), SetDump(_)).WillOnce(Return(FAILED)); + EXPECT_CALL(MockFunctionTest::aclStubInstance(), AdumpSetDump(_, _)).WillOnce(Return(FAILED)); ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/dumpConfig.json"); EXPECT_NE(ret, ACL_SUCCESS); @@ -420,12 +163,12 @@ TEST_F(UTEST_ACL_toolchain, SetDumpConfigFailedTest) TEST_F(UTEST_ACL_toolchain, dumpFinalizeFailedTest) { - acl::AclDump::GetInstance().aclDumpFromAclInitFlag_ = false; + acl::AclDump::GetInstance().adxInitFromAclInitFlag_ = false; aclError ret = aclmdlInitDump(); EXPECT_EQ(ret, ACL_SUCCESS); // Clear dump config failed in aclmdlFinalizeDump - EXPECT_CALL(MockFunctionTest::aclStubInstance(), SetDump(_)).WillOnce(Return((FAILED))); + EXPECT_CALL(MockFunctionTest::aclStubInstance(), AdumpUnSetDump()).WillOnce(Return((FAILED))); ret = aclmdlFinalizeDump(); EXPECT_NE(ret, ACL_SUCCESS); Mock::VerifyAndClear((void *) (&MockFunctionTest::aclStubInstance())); @@ -442,60 +185,22 @@ TEST_F(UTEST_ACL_toolchain, dumpFinalizeFailedTest) TEST_F(UTEST_ACL_toolchain, LiteExceptionDumpTest) { acl::AclDump aclDump; - acl::AclDump::GetInstance().aclDumpFromAclInitFlag_ = false; + acl::AclDump::GetInstance().adxInitFromAclInitFlag_ = false; auto ret = aclDump.HandleDumpConfig(ACL_BASE_DIR "/tests/ut/acl/json/testLiteExceptionDump.json"); EXPECT_EQ(ret, ACL_SUCCESS); ret = aclDump.HandleDumpConfig(ACL_BASE_DIR "/tests/ut/acl/json/testLiteException_debug_off.json"); EXPECT_EQ(ret, ACL_SUCCESS); - - ret = aclDump.HandleDumpConfig(ACL_BASE_DIR "/tests/ut/acl/json/testLiteExceptionDump_with_shape.json"); - EXPECT_NE(ret, ACL_SUCCESS); - - // dump_scene field illegal - ret = aclDump.HandleDumpConfig(ACL_BASE_DIR "/tests/ut/acl/json/testLiteException_empty.json"); - EXPECT_EQ(ret, ACL_ERROR_INVALID_DUMP_CONFIG); - - ret = aclDump.HandleDumpConfig(ACL_BASE_DIR "/tests/ut/acl/json/testLiteException_unspport.json"); - EXPECT_EQ(ret, ACL_ERROR_INVALID_DUMP_CONFIG); - - ret = aclDump.HandleDumpConfig(ACL_BASE_DIR "/tests/ut/acl/json/testLiteException_debug_on.json"); - EXPECT_EQ(ret, ACL_ERROR_INVALID_DUMP_CONFIG); - - ret = aclDump.HandleDumpConfig(ACL_BASE_DIR "/tests/ut/acl/json/testLiteException_op_on.json"); - EXPECT_EQ(ret, ACL_ERROR_INVALID_DUMP_CONFIG); } TEST_F(UTEST_ACL_toolchain, ExceptionDumpTest) { acl::AclDump aclDump; aclError ret; - acl::AclDump::GetInstance().aclDumpFromAclInitFlag_ = false; - ret = aclDump.HandleDumpConfig(ACL_BASE_DIR "/tests/ut/acl/json/testExceptionDump_brief.json"); - EXPECT_EQ(ret, ACL_SUCCESS); - EXPECT_EQ(acl::AclDump::GetInstance().aclDumpFromAclInitFlag_, false); - - acl::AclDump::GetInstance().aclDumpFromAclInitFlag_ = false; - ret = aclDump.HandleDumpConfig(ACL_BASE_DIR "/tests/ut/acl/json/testExceptionDump_norm.json"); - EXPECT_EQ(ret, ACL_SUCCESS); - EXPECT_EQ(acl::AclDump::GetInstance().aclDumpFromAclInitFlag_, true); - - acl::AclDump::GetInstance().aclDumpFromAclInitFlag_ = false; - ret = aclDump.HandleDumpConfig(ACL_BASE_DIR "/tests/ut/acl/json/testExceptionDump_detail.json"); - EXPECT_EQ(ret, ACL_SUCCESS); - EXPECT_EQ(acl::AclDump::GetInstance().aclDumpFromAclInitFlag_, false); - - ret = aclDump.HandleDumpConfig(ACL_BASE_DIR "/tests/ut/acl/json/testExceptionDump_invalid.json"); - EXPECT_NE(ret, ACL_SUCCESS); - - int32_t mmRet = 0; - MM_SYS_SET_ENV(MM_ENV_ASCEND_WORK_PATH, "/home", 1, mmRet); - (void)mmRet; - acl::AclDump::GetInstance().aclDumpFromAclInitFlag_ = false; + acl::AclDump::GetInstance().adxInitFromAclInitFlag_ = false; ret = aclDump.HandleDumpConfig(ACL_BASE_DIR "/tests/ut/acl/json/testExceptionDump_brief.json"); EXPECT_EQ(ret, ACL_SUCCESS); - EXPECT_EQ(acl::AclDump::GetInstance().aclDumpFromAclInitFlag_, false); - MM_SYS_UNSET_ENV(MM_ENV_ASCEND_WORK_PATH, mmRet); + EXPECT_EQ(acl::AclDump::GetInstance().adxInitFromAclInitFlag_, true); } TEST_F(UTEST_ACL_toolchain, FinalizeDumpTest) @@ -520,13 +225,11 @@ TEST_F(UTEST_ACL_toolchain, FinalizeDumpTest_AdumpSetDumpConfig_Failed) ret = aclmdlSetDump(ACL_BASE_DIR "/tests/ut/acl/json/testExceptionDump_brief.json"); EXPECT_EQ(ret, ACL_SUCCESS); - EXPECT_CALL(MockFunctionTest::aclStubInstance(), AdumpSetDumpConfig(_, _)).WillOnce(Return(-1)); - EXPECT_CALL(MockFunctionTest::aclStubInstance(), AdumpIsDumpEnable(_)).WillRepeatedly(Return(true)); + EXPECT_CALL(MockFunctionTest::aclStubInstance(), AdumpUnSetDump()).WillOnce(Return(1)); ret = aclmdlFinalizeDump(); EXPECT_NE(ret, ACL_SUCCESS); Mock::VerifyAndClear((void *) (&MockFunctionTest::aclStubInstance())); - EXPECT_CALL(MockFunctionTest::aclStubInstance(), AdumpIsDumpEnable(_)).WillRepeatedly(Return(true)); ret = aclmdlFinalizeDump(); EXPECT_EQ(ret, ACL_SUCCESS); } diff --git a/toolchain/dump.cpp b/toolchain/dump.cpp index c046defd242a1be7d09cee2f7174834c96383326..d0afc66a05ee0fa109d88be6adbe05ef2c237819 100755 --- a/toolchain/dump.cpp +++ b/toolchain/dump.cpp @@ -16,7 +16,7 @@ #include "mmpa/mmpa_api.h" #include "adx_datadump_server.h" -#include "adump_api.h" +#include "adump_pub.h" #include "json_parser.h" #include "error_codes_inner.h" @@ -28,931 +28,37 @@ namespace { bool aclmdlInitDumpFlag = false; - bool isCutDumpPathFlag = false; std::mutex aclDumpMutex; - const std::string ACL_DUMP_MODE_INPUT = "input"; - const std::string ACL_DUMP_MODE_OUTPUT = "output"; - const std::string ACL_DUMP_MODE_ALL = "all"; - const std::string ACL_DUMP_STATUS_SWITCH_ON = "on"; - const std::string ACL_DUMP_STATUS_SWITCH_OFF = "off"; - const std::string ACL_DUMP_MODEL_NAME = "model_name"; - const std::string ACL_DUMP_LAYER = "layer"; - const std::string ACL_DUMP_WATCHER_NODES = "watcher_nodes"; - const std::string ACL_DUMP_OPNAME_RANGE = "opname_range"; - const std::string ACL_DUMP_OPNAME_RANGE_BEGIN = "begin"; - const std::string ACL_DUMP_OPNAME_RANGE_END = "end"; - const std::string ACL_DUMP_PATH = "dump_path"; - const std::string ACL_DUMP_LIST = "dump_list"; - const std::string ACL_DUMP_MODE = "dump_mode"; - const std::string ACL_DUMP_STEP = "dump_step"; - const std::string ACL_DUMP_OPTYPE_BLACKLIST = "optype_blacklist"; - const std::string ACL_DUMP_OPNAME_BLACKLIST = "opname_blacklist"; - const std::string ACL_DUMP_BLACKLIST_NAME = "name"; - const std::string ACL_DUMP_BLACKLIST_POS = "pos"; - const std::string ACL_DUMP_OP_SWITCH = "dump_op_switch"; - const std::string ACL_DUMP_SCENE = "dump_scene"; - const std::string ACL_DUMP_LITE_EXCEPTION = "lite_exception"; - const std::string ACL_DUMP_WATCHER = "watcher"; - const std::string ACL_DUMP_DEBUG = "dump_debug"; - const std::string ACL_DUMP_DATA = "dump_data"; - const std::string ACL_DUMP_LEVEL = "dump_level"; - const std::string ACL_DUMP_STATS = "dump_stats"; - const std::string ACL_DUMP_LEVEL_OP = "op"; - const std::string ACL_DUMP_LEVEL_KERNEL = "kernel"; - const std::string ACL_DUMP_LEVEL_ALL = "all"; - const std::string ACL_DUMP = "dump"; constexpr int32_t ADX_ERROR_NONE = 0; - constexpr int32_t MAX_IPV4_ADDRESS_LENGTH = 4; - constexpr int32_t MAX_DUMP_PATH_LENGTH = 512; - constexpr int32_t MAX_IPV4_ADDRESS_VALUE = 255; - constexpr int32_t DECIMAL = 10; - constexpr uint64_t OPERATOR_OP_DUMP = 1U; - constexpr uint64_t OPERATOR_KERNEL_DUMP = 1U << 1U; - - const std::string ACL_DUMP_EXCEPTION_AIC_ERR_BRIEF = "aic_err_brief_dump"; // l0 exception dump - const std::string ACL_DUMP_EXCEPTION_AIC_ERR_NORM = "aic_err_norm_dump"; // l1 exception dump - const std::string ACL_DUMP_EXCEPTION_AIC_ERR_DETAIL = "aic_err_detail_dump"; // npu coredump - - const std::set aclDumpSceneExceptions = { - ACL_DUMP_LITE_EXCEPTION, ACL_DUMP_EXCEPTION_AIC_ERR_BRIEF, - ACL_DUMP_EXCEPTION_AIC_ERR_NORM, ACL_DUMP_EXCEPTION_AIC_ERR_DETAIL, - }; - - // adx dumps opened by aclmdlSetDump - std::set aclOpenedDump; - - typedef aclError (*aclDumpSetCallbackFunc)(const char *configStr); - typedef aclError (*aclDumpUnsetCallbackFunc)(); - std::mutex dumpCbMtx; - aclDumpSetCallbackFunc dumpSetCbFunc; - aclDumpUnsetCallbackFunc dumpUnsetCbFunc; } namespace acl { - // wrap json functions to reduce lib size - static const nlohmann::json& GetCfgJsonByKey(const nlohmann::json &js, const std::string &key) { - return js.at(key); - } - static std::string GetCfgStrByKey(const nlohmann::json &js , const std::string &key) { - return js.at(key).get(); - } - - static bool ContainKey(const nlohmann::json &js, const std::string &key) { - return (js.find(key) != js.end()); - } - - static void from_json(const nlohmann::json &js,OpNameRange &range) { - if (ContainKey(js, ACL_DUMP_OPNAME_RANGE_BEGIN)) { - range.begin = js.at(ACL_DUMP_OPNAME_RANGE_BEGIN).get(); - } - if (ContainKey(js, ACL_DUMP_OPNAME_RANGE_END)) { - range.end = js.at(ACL_DUMP_OPNAME_RANGE_END).get(); - } - } - - static void from_json(const nlohmann::json &js, AclDumpBlacklist &blacklist) - { - if (ContainKey(js, ACL_DUMP_BLACKLIST_NAME)) { - blacklist.name = GetCfgStrByKey(js, ACL_DUMP_BLACKLIST_NAME); - } - if (ContainKey(js, ACL_DUMP_BLACKLIST_POS)) { - blacklist.pos = js.at(ACL_DUMP_BLACKLIST_POS).get>(); - } - } - - static void from_json(const nlohmann::json &js, AclModelDumpConfig &info) - { - info.isLayer = false; - if (ContainKey(js, ACL_DUMP_MODEL_NAME)) { - info.modelName = GetCfgStrByKey(js, ACL_DUMP_MODEL_NAME); - info.isModelName = true; - } - if (ContainKey(js, ACL_DUMP_LAYER)) { - info.layer = js.at(ACL_DUMP_LAYER).get>(); - info.isLayer = true; - } - if (ContainKey(js, ACL_DUMP_WATCHER_NODES)) { - info.watcherNodes = js.at(ACL_DUMP_WATCHER_NODES).get>(); - } - if (ContainKey(js, ACL_DUMP_OPTYPE_BLACKLIST)) { - info.optypeBlacklist = js.at(ACL_DUMP_OPTYPE_BLACKLIST).get>(); - } - if (ContainKey(js, ACL_DUMP_OPNAME_BLACKLIST)) { - info.opnameBlacklist = js.at(ACL_DUMP_OPNAME_BLACKLIST).get>(); - } - if (ContainKey(js, ACL_DUMP_OPNAME_RANGE)) { - info.dumpOpNameRanges = js.at(ACL_DUMP_OPNAME_RANGE).get>(); - } - } - - static void from_json(const nlohmann::json &js, AclDumpConfig &config) - { - if (ContainKey(js, ACL_DUMP_PATH)) { - config.dumpPath = GetCfgStrByKey(js, ACL_DUMP_PATH); - } - if (ContainKey(js, ACL_DUMP_LIST)) { - config.dumpList = js.at(ACL_DUMP_LIST).get>(); - } - if (ContainKey(js, ACL_DUMP_MODE)) { - config.dumpMode = GetCfgStrByKey(js, ACL_DUMP_MODE); - ACL_LOG_DEBUG("dump_mode field parse successfully, value = %s.", config.dumpMode.c_str()); - } else { - // dump_mode is an optional field, valid values include input/output/all - // default value is output - config.dumpMode = ACL_DUMP_MODE_OUTPUT; - } - if (ContainKey(js, ACL_DUMP_OP_SWITCH)) { - config.dumpOpSwitch = GetCfgStrByKey(js, ACL_DUMP_OP_SWITCH); - ACL_LOG_DEBUG("dump_op_switch field parse successfully, value = %s.", config.dumpOpSwitch.c_str()); - } else { - // dump_op_switch is an optional field, valid values include on/off - // default value is off - config.dumpOpSwitch = ACL_DUMP_STATUS_SWITCH_OFF; - } - // dump_debug is an optional field, valid values include on/off - // default value is off - config.dumpDebug = ACL_DUMP_STATUS_SWITCH_OFF; - if (ContainKey(js, ACL_DUMP_DEBUG)) { - config.dumpDebug = GetCfgStrByKey(js, ACL_DUMP_DEBUG); - ACL_LOG_DEBUG("dump_debug field parse successfully, value = %s", config.dumpDebug.c_str()); - } - - // dump_scene is an optional field, valid values include lite_exception - // default value is empty - config.dumpScene.clear(); - if (ContainKey(js, ACL_DUMP_SCENE)) { - config.dumpScene = GetCfgStrByKey(js, ACL_DUMP_SCENE); - ACL_LOG_DEBUG("dump_scene field parse successfully, value = %s", config.dumpScene.c_str()); - } - if (ContainKey(js, ACL_DUMP_STEP)) { - config.dumpStep = GetCfgStrByKey(js, ACL_DUMP_STEP); - } - if (ContainKey(js, ACL_DUMP_DATA)) { - config.dumpData = GetCfgStrByKey(js, ACL_DUMP_DATA); - } - if (ContainKey(js, ACL_DUMP_LEVEL)) { - config.dumpLevel = GetCfgStrByKey(js, ACL_DUMP_LEVEL); - ACL_LOG_DEBUG("dump_level field parse successfully, value = %s.", config.dumpLevel.c_str()); - } else { - // dump_level is an optional field, valid values include op/kernel/all - // default value is all - config.dumpLevel = ACL_DUMP_LEVEL_ALL; - } - if (ContainKey(js, ACL_DUMP_STATS)) { - config.dumpStats = js.at(ACL_DUMP_STATS).get>(); - } - } - - static std::vector Split(const std::string &str, const char_t * const delimiter) - { - std::vector resVec; - if (str.empty()) { - ACL_LOG_ERROR("[Check][Str]input str is null"); - acl::AclErrorLogManager::ReportInputError(acl::INVALID_PARAM_MSG, - std::vector({"param", "value", "reason"}), - std::vector({"str", "", "Must not be empty"})); - return resVec; - } - - if (delimiter == nullptr) { - ACL_LOG_ERROR("[Check][delimiter]delimiter is nullptr"); - acl::AclErrorLogManager::ReportInputError(acl::INVALID_PARAM_MSG, - std::vector({"param", "value", "reason"}), - std::vector({"delimiter", "nullptr", "Must not be null"})); - return resVec; - } - - std::string token; - std::istringstream tokenStream(str); - while (std::getline(tokenStream, token, *delimiter)) { - resVec.emplace_back(token); - } - return resVec; - } - AclDump &AclDump::GetInstance() { static AclDump aclDumpProc; return aclDumpProc; } - Adx::DumpType GetDumpType(std::string &dumpExpection, std::string &dumpDebug) - { - // l0 exception - if (dumpExpection == ACL_DUMP_EXCEPTION_AIC_ERR_BRIEF || - dumpExpection == ACL_DUMP_LITE_EXCEPTION) { - return Adx::DumpType::ARGS_EXCEPTION; - } - - // l1 exception - if (dumpExpection == ACL_DUMP_EXCEPTION_AIC_ERR_NORM) { - return Adx::DumpType::EXCEPTION; - } - - // npu coredump - if (dumpExpection == ACL_DUMP_EXCEPTION_AIC_ERR_DETAIL) { - return Adx::DumpType::AIC_ERR_DETAIL_DUMP; - } - - if (dumpDebug == ACL_DUMP_STATUS_SWITCH_ON) { - // overflow detection - return Adx::DumpType::OP_OVERFLOW; - } - return Adx::DumpType::OPERATOR; - } - - static bool CheckDumpSceneSwitch(const nlohmann::json &js, std::string &dumpScene) - { - ACL_LOG_INFO("start to execute CheckDumpSceneSwitch."); - if (!ContainKey(js, ACL_DUMP)) { - ACL_LOG_DEBUG("no dump item, no need to do dump!"); - return false; - } - const nlohmann::json &jsDumpConfig = GetCfgJsonByKey(js, ACL_DUMP); - - if (!ContainKey(jsDumpConfig, ACL_DUMP_SCENE)) { - ACL_LOG_INFO("dump_scene does not exist, no need to check."); - return true; - } - - dumpScene = GetCfgStrByKey(jsDumpConfig, ACL_DUMP_SCENE); - if ((aclDumpSceneExceptions.find(dumpScene) == aclDumpSceneExceptions.end()) && - (dumpScene != ACL_DUMP_WATCHER)) { - ACL_LOG_ERROR("Invalid value of dump_scene[%s].", dumpScene.c_str()); - return false; - } - - if (ContainKey(jsDumpConfig, ACL_DUMP_DEBUG)) { - std::string dumpDebug = GetCfgStrByKey(jsDumpConfig, ACL_DUMP_DEBUG); - if (dumpDebug == ACL_DUMP_STATUS_SWITCH_ON) { - ACL_LOG_ERROR("dump_scene is %s when dump_debug is on is unsupported.", dumpScene.c_str()); - return false; - } - } - - if (ContainKey(jsDumpConfig, ACL_DUMP_OP_SWITCH)) { - std::string dumpOpSwitch = GetCfgStrByKey(jsDumpConfig, ACL_DUMP_OP_SWITCH); - if (dumpOpSwitch == ACL_DUMP_STATUS_SWITCH_ON) { - ACL_LOG_ERROR("dump_scene is %s when dump_op_switch is on is unsupported.", dumpScene.c_str()); - return false; - } - } - - if (ContainKey(jsDumpConfig, ACL_DUMP_MODE)) { - std::string dumpMode = GetCfgStrByKey(jsDumpConfig, ACL_DUMP_MODE); - if ((dumpMode != ACL_DUMP_MODE_OUTPUT) && (dumpScene == ACL_DUMP_WATCHER)) { - ACL_LOG_ERROR("dump_mode only supports output when dump_scene is %s.", dumpScene.c_str()); - return false; - } - } - - return true; - } - - static bool CheckDumpOpNameRange(const std::vector &dumpConfigList, - const std::string& dumpLevel) - { - ACL_LOG_INFO("start to execute CheckDumpOpNameRange"); - for (const auto &dumpConfig : dumpConfigList) { - if (!dumpConfig.dumpOpNameRanges.empty()) { - if (dumpLevel != "op") { - ACL_LOG_ERROR("[Check][ValidDumpList] dump level only support op when op name range is enable."); - acl::AclErrorLogManager::ReportInputError(acl::INVALID_PARAM_MSG, - std::vector({"param", "value", "reason"}), - std::vector({"dump_level", dumpLevel.c_str(), "Only support op when op name range is enabled"})); - return false; - } - - if (dumpConfig.modelName.empty()) { - ACL_LOG_ERROR("[Check][ValidDumpList] model name cannot be empty when op name range is enable."); - acl::AclErrorLogManager::ReportInputError(acl::INVALID_PARAM_MSG, - std::vector({"param", "value", "reason"}), - std::vector({"model_name", "", "Cannot be empty when op name range is enabled"})); - return false; - } - - for (const auto &range : dumpConfig.dumpOpNameRanges) { - if (range.begin.empty() || range.end.empty()) { - ACL_LOG_ERROR("[Check][ValidDumpList] op name range is imcomplete, op name range begin[%s] end[%s].", - range.begin.c_str(), range.end.c_str()); - acl::AclErrorLogManager::ReportInputError(acl::INVALID_PARAM_MSG, - std::vector({"param", "value", "reason"}), - std::vector({"op_name_range", ("begin:" + range.begin + " end:" + range.end).c_str(), "Op name range is incomplete"})); - return false; - } - - ACL_LOG_INFO("op name range begin[%s], op name range end[%s].", - range.begin.c_str(), range.end.c_str()); - } - } - } - - ACL_LOG_INFO("successfully execute CheckDumpOpNameRange."); - return true; - } - - static bool CheckDumpOpSwitch(const std::string& dumpOpSwitch) { - if ((dumpOpSwitch != ACL_DUMP_STATUS_SWITCH_ON) && - (dumpOpSwitch != ACL_DUMP_STATUS_SWITCH_OFF)) { - ACL_LOG_ERROR("[Check][DumpOpSwitch]dump_op_switch value[%s] is invalid in config, " - "only supports on/off", dumpOpSwitch.c_str()); - acl::AclErrorLogManager::ReportInputError(acl::INVALID_PARAM_MSG, - std::vector({"param", "value", "reason"}), - std::vector({"dump_op_switch value", dumpOpSwitch.c_str(), "only supports on/off"})); - return false; - } - return true; - } - - static bool CheckEmptyDumpList(const std::vector& dumpList, - const std::string& dumpOpSwitch) { - if (dumpList.empty() && dumpOpSwitch == ACL_DUMP_STATUS_SWITCH_OFF) { - ACL_LOG_INFO("dump list is empty and dumpOpSwitch is off"); - return true; - } - return false; - } - - static bool CheckDumpListWhenSwitchOff(const std::vector& dumpList) { - if (std::none_of(dumpList.begin(), dumpList.end(), [](const AclModelDumpConfig& info) { - return !(info.isModelName && info.modelName.empty()) && - !(info.isLayer && info.layer.empty()); - })) { - ACL_LOG_ERROR("[Check][ValidDumpList]dump_list is not null, but dump_list " - "field invalid, dump config is invalid"); - acl::AclErrorLogManager::ReportInputError(acl::INVALID_PARAM_MSG, - std::vector({"param", "value", "reason"}), - std::vector({"dump_list", "", "Field invalid when dump_op_switch is off"})); - return false; - } - return true; - } - - static bool CheckWatcherScene(const std::vector& dumpList, - const std::string& dumpScene) { - if (dumpScene == ACL_DUMP_WATCHER){ - for (const auto& item : dumpList) { - if (item.watcherNodes.empty()) { - ACL_LOG_ERROR("[Check][ValidDumpList]dump_list is not null, but watcher_nodes is empty " - "when dump_scene is %s, dump config is invalid", dumpScene.c_str()); - acl::AclErrorLogManager::ReportInputError(acl::INVALID_PARAM_MSG, - std::vector({"param", "value", "reason"}), - std::vector({"watcher_nodes", "", "Must not be empty when dump_scene is watcher"})); - return false; - } - - if (!item.modelName.empty()) { - ACL_LOG_ERROR("[Check][ValidDumpList]dump_list is not null, but model_name is not empty " - "when dump_scene is %s, dump config is invalid", dumpScene.c_str()); - acl::AclErrorLogManager::ReportInputError(acl::INVALID_PARAM_MSG, - std::vector({"param", "value", "reason"}), - std::vector({"model_name", item.modelName.c_str(), "Must be empty when dump_scene is watcher"})); - return false; - } - } - } - - for (size_t i = 0U; i < dumpList.size(); ++i) { - if ((!dumpList[i].watcherNodes.empty()) && (dumpScene != ACL_DUMP_WATCHER)) { - ACL_LOG_ERROR("[Check][ValidDumpList]dump_scene must be watcher when watcher_nodes is not null"); - acl::AclErrorLogManager::ReportInputError(acl::INVALID_PARAM_MSG, - std::vector({"param", "value", "reason"}), - std::vector({"dump_scene", dumpScene.c_str(), "Must be watcher when watcher_nodes is not null"})); - return false; - } - } - return true; - } - - static bool CheckOpBlacklistSize(const std::vector& dumpList) { - return std::all_of(dumpList.begin(), dumpList.end(), [](const AclModelDumpConfig& dumpModelConfig) { - if (dumpModelConfig.optypeBlacklist.size() > 100U || dumpModelConfig.opnameBlacklist.size() > 100U) { - ACL_LOG_ERROR("[Check][ValidDumpList] size of optype_blacklist or opname_blacklist is over 100."); - acl::AclErrorLogManager::ReportInputError(acl::INVALID_PARAM_MSG, - std::vector({"param", "value", "reason"}), - std::vector({"optype_blacklist/opname_blacklist size", std::to_string(std::max(dumpModelConfig.optypeBlacklist.size(), dumpModelConfig.opnameBlacklist.size())).c_str(), "Must not be over 100"})); - return false; - } - return true; - }); - } - - static bool CheckOpBlacklistWithDumpLevel(const std::vector& dumpList, - const std::string& dumpLevel) { - for (const auto& config : dumpList) { - bool hasBlacklist = !config.optypeBlacklist.empty() || - !config.opnameBlacklist.empty(); - if (hasBlacklist && dumpLevel != "op") { - ACL_LOG_ERROR("[Check][ValidDumpList] optype_blacklist or opname_blacklist is configured, " - "but dump_level is not 'op'"); - acl::AclErrorLogManager::ReportInputError(acl::INVALID_PARAM_MSG, - std::vector({"param", "value", "reason"}), - std::vector({"dump_level", dumpLevel.c_str(), "Must be 'op' when blacklist is configured"})); - return false; - } - } - return true; - } - - static bool CheckDumplist(const nlohmann::json &js, const std::string& dumpLevel) { - ACL_LOG_INFO("start to execute CheckDumpListValidity."); - const nlohmann::json &jsDumpConfig = GetCfgJsonByKey(js, ACL_DUMP); - - std::vector dumpList; - if (ContainKey(jsDumpConfig, ACL_DUMP_LIST)) { - dumpList = jsDumpConfig.at(ACL_DUMP_LIST).get>(); - } - - std::string dumpOpSwitch = jsDumpConfig.find(ACL_DUMP_OP_SWITCH) != jsDumpConfig.end() - ? GetCfgStrByKey(jsDumpConfig, ACL_DUMP_OP_SWITCH) : ACL_DUMP_STATUS_SWITCH_OFF; - if (!CheckDumpOpSwitch(dumpOpSwitch)) { - return false; - } - if (CheckEmptyDumpList(dumpList, dumpOpSwitch)) { - return true; - } - if (dumpOpSwitch == ACL_DUMP_STATUS_SWITCH_OFF && !CheckDumpListWhenSwitchOff(dumpList)) { - return false; - } - - std::string dumpScene = ContainKey(jsDumpConfig, ACL_DUMP_SCENE) - ? GetCfgStrByKey(jsDumpConfig, ACL_DUMP_SCENE) : ""; - if (!CheckWatcherScene(dumpList, dumpScene)) { - return false; - } - if (!CheckOpBlacklistSize(dumpList)) { - return false; - } - if (!CheckOpBlacklistWithDumpLevel(dumpList, dumpLevel)) { - return false; - } - if (!CheckDumpOpNameRange(dumpList, dumpLevel)) { - return false; - } - ACL_LOG_INFO("end to check the validity of dump_list and dump_op_switch field."); - return true; - } - - static bool IsValidDirStr(const std::string &dumpPath) - { - ACL_LOG_INFO("start to execute IsValidDirStr"); - const std::string pathWhiteList = "-=[];\\,./!@#$%^&*()_+{}:?"; - const size_t len = dumpPath.length(); - for (size_t i = 0U; i < len; ++i) { - const int32_t tmpChar = static_cast(dumpPath[i]); - if ((std::islower(tmpChar) == 0) && (std::isupper(tmpChar) == 0) && (std::isdigit(tmpChar) == 0) && - (pathWhiteList.find(dumpPath[i]) == std::string::npos)) { - ACL_LOG_ERROR("[Check][PathWhiteList]invalid dump_path [%s] in dump config at " - "location %zu", dumpPath.c_str(), i); - const std::string errMsg = acl::AclErrorLogManager::FormatStr("dump config at location %zu", i); - acl::AclErrorLogManager::ReportInputError(acl::INVALID_PARAM_MSG, - std::vector({"param", "value", "reason"}), - std::vector({"dump_path", dumpPath.c_str(), errMsg.c_str()})); - return false; - } - } - - ACL_LOG_INFO("successfully execute IsValidDirChar, the dump result path[%s] is valid.", dumpPath.c_str()); - return true; - } - - static bool CheckIpAddress(const AclDumpConfig &config) - { - // check the valid of ipAddress in dump_path - ACL_LOG_INFO("start to execute IsValidIpAddress."); - const size_t colonPos = config.dumpPath.find_first_of(":"); - if (colonPos != std::string::npos) { - ACL_LOG_INFO("dump_path field contains ip address."); - if ((colonPos + 1U) == config.dumpPath.size()) { - ACL_LOG_ERROR("[Check][colonPos]dump_path field is invalid"); - acl::AclErrorLogManager::ReportInputError(acl::INVALID_PARAM_MSG, - std::vector({"param", "value", "reason"}), - std::vector({"dump_path", config.dumpPath.c_str(), "format is illegal"})); - return false; - } - - const std::string ipAddress = config.dumpPath.substr(0U, colonPos); - const std::vector ipRet = Split(ipAddress, "."); - if (ipRet.size() == static_cast(MAX_IPV4_ADDRESS_LENGTH)) { - try { - for (const auto &ret : ipRet) { - const int32_t val = std::stoi(ret); - if ((val < 0) || (val > MAX_IPV4_ADDRESS_VALUE)) { - ACL_LOG_DEBUG("ip address[%s] is invalid in dump_path field", ipAddress.c_str()); - return false; - } - } - } catch (...) { - ACL_LOG_DEBUG("ip address[%s] can not convert to digital in dump_path field", ipAddress.c_str()); - return false; - } - ACL_LOG_INFO("ip address[%s] is valid in dump_path field.", ipAddress.c_str()); - return true; - } - } - - ACL_LOG_DEBUG("the dump_path field does not contain ip address or it does not comply with the ipv4 rule."); - return false; - } - - static bool IsDumpPathValid(const std::string& dumpPath) - { - char_t trustedPath[MMPA_MAX_PATH] = {}; - const int32_t ret = mmRealPath(dumpPath.c_str(), trustedPath, static_cast(sizeof(trustedPath))); - if (ret != EN_OK) - { - const auto formatErrMsg = acl::AclGetErrorFormatMessage(mmGetErrorCode()); - ACL_LOG_ERROR("[Get][RealPath]the dump_path %s is not like a real path, " - "mmRealPath return %d, errMessage is %s", dumpPath.c_str(), ret, formatErrMsg.c_str()); - std::string errMsg = std::string("cannot convert to realpath: ") + formatErrMsg; - acl::AclErrorLogManager::ReportInputError(acl::INVALID_PATH_MSG, - std::vector({ "path", "reason" }), - std::vector({ dumpPath.c_str(), errMsg.c_str()})); - return false; - } - constexpr uint32_t accessMode = static_cast(M_R_OK) | static_cast(M_W_OK); - if (mmAccess2(trustedPath, static_cast(accessMode)) != EN_OK) - { - ACL_LOG_ERROR("[Check][Permission]the dump result path[%s] does not have read and " - "write permission", trustedPath); - acl::AclErrorLogManager::ReportInputError(acl::INVALID_PATH_MSG, - std::vector({ "path", "reason" }), - std::vector({ trustedPath, "does not have read and write permission" })); - return false; - } - ACL_LOG_INFO("the dump result path is %s", trustedPath); - return true; - } - - static bool CheckDumpPath(const nlohmann::json &js) - { - ACL_LOG_INFO("start to execute CheckDumpPath."); - const nlohmann::json &jsDumpConfig = GetCfgJsonByKey(js, ACL_DUMP); - AclDumpConfig config = jsDumpConfig; - if (config.dumpPath.length() > static_cast(MAX_DUMP_PATH_LENGTH)) { - ACL_LOG_ERROR("[Check][dumpPath]the length[%zu] of dump_path is larger than " - "MAX_DUMP_PATH_LENGTH[%d]", config.dumpPath.length(), MAX_DUMP_PATH_LENGTH); - const std::string errMsg = acl::AclErrorLogManager::FormatStr( - "dump_path is larger than MAX_DUMP_PATH_LENGTH[%d]", MAX_DUMP_PATH_LENGTH); - acl::AclErrorLogManager::ReportInputError(acl::INVALID_PARAM_MSG, - std::vector({"param", "value", "reason"}), - std::vector({"dump_path", - std::to_string(config.dumpPath.length()).c_str(), errMsg.c_str()})); - return false; - } - - const size_t colonPos = config.dumpPath.find_first_of(":"); - isCutDumpPathFlag = CheckIpAddress(config); - if (isCutDumpPathFlag) { - config.dumpPath = config.dumpPath.substr(colonPos + 1U); - if (!IsValidDirStr(config.dumpPath)) { - ACL_LOG_ERROR("[Check][ValidDirStr]dump_path[%s] is invalid in dump config", - config.dumpPath.c_str()); - acl::AclErrorLogManager::ReportInputError(acl::INVALID_PATH_MSG, - std::vector({"path", "reason"}), - std::vector({"dump_path", "is invalid directory"})); - return false; - } - } else { - // check dump result path in dump_path field of existence and readability - if (!IsDumpPathValid(config.dumpPath)) { - return false; - } - } - - ACL_LOG_INFO("successfully execute CheckDumpPath to verify dump_path field, it's valid."); - return true; - } - - static bool CheckDumpStep(const nlohmann::json &js) - { - ACL_LOG_INFO("start to execute CheckDumpStep"); - const nlohmann::json &jsDumpConfig = GetCfgJsonByKey(js, ACL_DUMP); - std::string dumpStep = ""; - if (ContainKey(jsDumpConfig, ACL_DUMP_STEP)) { - dumpStep = GetCfgStrByKey(jsDumpConfig, ACL_DUMP_STEP); - } - - if (dumpStep.empty()) { - return true; - } - - std::vector matchVecs; - acl::StringUtils::Split(dumpStep, '|', matchVecs); - if (matchVecs.size() > 100U) { - ACL_LOG_ERROR("dump_step value:%s, only support dump <= 100 sets of data.", dumpStep.c_str()); - return false; - } - - for (const auto &it : matchVecs) { - std::vector steps; - acl::StringUtils::Split(it, '-', steps); - if (steps.size() > 2U) { - ACL_LOG_ERROR("dump_step value:%s, step is not a range or a digit, correct example:'3|5-10'.", - dumpStep.c_str()); - return false; - } - - for (const auto &step : steps) { - if (!acl::StringUtils::IsDigit(step)) { - ACL_LOG_ERROR("dump_step value:%s, step is not a digit, correct example:'3|5-10'.", - dumpStep.c_str()); - return false; - } - } - - if (std::strtol(steps[0U].c_str(), nullptr, DECIMAL) > - std::strtol(steps[steps.size() - 1U].c_str(), nullptr, DECIMAL)) { - ACL_LOG_ERROR("dump_step value:%s, for set of dump range, the first step > second step.", - dumpStep.c_str()); - return false; - } - } - - return true; - } - - static bool DumpDebugCheck(const nlohmann::json &js) - { - ACL_LOG_INFO("start to execute DumpDebugCheck"); - const nlohmann::json &jsDumpConfig = GetCfgJsonByKey(js, ACL_DUMP); - std::string dumpOpSwitch(ACL_DUMP_STATUS_SWITCH_OFF); - std::string dumpPath; - - if (ContainKey(jsDumpConfig, ACL_DUMP_OP_SWITCH)) { - dumpOpSwitch = GetCfgStrByKey(jsDumpConfig, ACL_DUMP_OP_SWITCH); - if (dumpOpSwitch == ACL_DUMP_STATUS_SWITCH_ON) { - ACL_LOG_ERROR("dump_op_switch is %s when dump_debug is on is unsupported.", dumpOpSwitch.c_str()); - return false; - } - } - - if (ContainKey(jsDumpConfig, ACL_DUMP_PATH)) { - dumpPath = GetCfgStrByKey(jsDumpConfig, ACL_DUMP_PATH); - } else { - ACL_LOG_ERROR("dump_path field does not exist in dump config"); - return false; - } - if (dumpPath.empty() || (!CheckDumpPath(js))) { - ACL_LOG_ERROR("dump path is invalid in dump config"); - return false; - } - - if (ContainKey(jsDumpConfig, ACL_DUMP_LIST)) { - std::vector dumpList; - dumpList = jsDumpConfig.at(ACL_DUMP_LIST).get>(); - if (!dumpList.empty()) { - ACL_LOG_ERROR("nonsupport dump model when open dump overflow detection"); - return false; - } - } - - ACL_LOG_INFO("successfully execute DumpDebugCheck"); - return true; - } - static bool DumpStatsCheck(const nlohmann::json &js) - { - ACL_LOG_INFO("start to execute DumpStatsCheck"); - const nlohmann::json &jsDumpConfig = GetCfgJsonByKey(js, ACL_DUMP); - - if (ContainKey(jsDumpConfig, ACL_DUMP_STATS)) { - std::vector dumpStats = jsDumpConfig.at(ACL_DUMP_STATS).get>(); - if (dumpStats.empty()) { - ACL_LOG_ERROR("dump_stats exists but is empty."); - return false; - } - if ((!ContainKey(jsDumpConfig, ACL_DUMP_DATA)) || - (GetCfgStrByKey(jsDumpConfig, ACL_DUMP_DATA) != "stats")) { - ACL_LOG_ERROR("nonsupport to enable dump_stats when dump_data is tensor."); - return false; - } - } - ACL_LOG_INFO("successfully execute DumpStatsCheck"); - return true; - } - - static bool IsValidDumpConfig(const nlohmann::json &js) - { - ACL_LOG_INFO("start to execute IsValidDumpConfig."); - std::string dumpScene; - if (!CheckDumpSceneSwitch(js, dumpScene)) { - return false; - } - - if (aclDumpSceneExceptions.find(dumpScene) != aclDumpSceneExceptions.end()) { - return true; - } - std::string dumpDebug(ACL_DUMP_STATUS_SWITCH_OFF); - const nlohmann::json &jsDumpConfig = GetCfgJsonByKey(js, ACL_DUMP); - if (ContainKey(jsDumpConfig, ACL_DUMP_DEBUG)) { - dumpDebug = GetCfgStrByKey(jsDumpConfig, ACL_DUMP_DEBUG); - } - // if dump_debug is on, check dump config for overflow detection - if (dumpDebug == ACL_DUMP_STATUS_SWITCH_ON) { - if (!DumpDebugCheck(js)) { - ACL_LOG_ERROR("The current dump config is not valid for overflow detection"); - return false; - } - ACL_LOG_INFO("when dump_debug = %s , is valid for overflow detection", - dumpDebug.c_str()); - return true; - } - - // if dump_path does not exist, can't send dump config - if (!ContainKey(jsDumpConfig, ACL_DUMP_PATH)) { - ACL_LOG_ERROR("[Check][jsDumpConfig]dump_path field in dump config file " - "does not exist"); - acl::AclErrorLogManager::ReportInputError(acl::INVALID_PARAM_MSG, - std::vector({"param", "value", "reason"}), - std::vector({"dump_path", "", "field does not exist"})); - return false; - } - - const std::string dumpPath = GetCfgStrByKey(jsDumpConfig, ACL_DUMP_PATH); - if (dumpPath.empty()) { - ACL_LOG_DEBUG("dump_path field is null in config"); - return false; - } - - if (!CheckDumpPath(js)) { - return false; - } - - std::string dumpMode; - if (ContainKey(jsDumpConfig, ACL_DUMP_MODE)) { - dumpMode = GetCfgStrByKey(jsDumpConfig, ACL_DUMP_MODE); - } else { - dumpMode = ACL_DUMP_MODE_OUTPUT; - } - - if ((dumpMode != ACL_DUMP_MODE_INPUT) && - (dumpMode != ACL_DUMP_MODE_OUTPUT) && - (dumpMode != ACL_DUMP_MODE_ALL)) { - ACL_LOG_ERROR("[Check][dumpMode]dump_mode value[%s] error in config, only supports " - "input/output/all", dumpMode.c_str()); - acl::AclErrorLogManager::ReportInputError(acl::INVALID_PARAM_MSG, - std::vector({"param", "value", "reason"}), - std::vector({"dump_mode", dumpMode.c_str(), "only supports input/output/all"})); - return false; - } - - std::string dumpLevel; - if (ContainKey(jsDumpConfig, ACL_DUMP_LEVEL)) { - dumpLevel = GetCfgStrByKey(jsDumpConfig, ACL_DUMP_LEVEL); - } else { - dumpLevel = ACL_DUMP_LEVEL_ALL; - } - - if ((dumpLevel != ACL_DUMP_LEVEL_OP) && - (dumpLevel != ACL_DUMP_LEVEL_KERNEL) && - (dumpLevel != ACL_DUMP_LEVEL_ALL)) { - ACL_LOG_ERROR("[Check][dumpLevel]dump_level value[%s] error in config, only supports " - "op/kernel/all", dumpLevel.c_str()); - acl::AclErrorLogManager::ReportInputError(acl::INVALID_PARAM_MSG, - std::vector({"param", "value", "reason"}), - std::vector({"dump_level", dumpLevel.c_str(), "only supports op/kernel/all"})); - return false; - } - - if (!CheckDumpStep(js)) { - return false; - } - - if (!CheckDumplist(js, dumpLevel)) { - return false; - } - - if (!DumpStatsCheck(js)) { - return false; - } - - ACL_LOG_INFO("successfully execute IsValidDumpConfig to verify dump config, it's valid."); - return true; - } - - static aclError SetUpDumpConfigForAdx(const AclDumpConfig &config, - Adx::DumpConfig &adxConfig, Adx::DumpType &dumpType) - { - std::string dumpExpection; - std::string dumpDebug; - adxConfig.dumpPath = config.dumpPath; - adxConfig.dumpStatus = ACL_DUMP_STATUS_SWITCH_ON; - adxConfig.dumpSwitch = OPERATOR_OP_DUMP | OPERATOR_KERNEL_DUMP; - if (aclDumpSceneExceptions.find(config.dumpScene) != aclDumpSceneExceptions.end()) { - dumpExpection = config.dumpScene; - const char_t *ascendWorkPath = nullptr; - MM_SYS_GET_ENV(MM_ENV_ASCEND_WORK_PATH, ascendWorkPath); - if (ascendWorkPath != nullptr) { - adxConfig.dumpPath = ascendWorkPath; - ACL_LOG_INFO("get env ASCEND_WORK_PATH %s", ascendWorkPath); - } - dumpType = GetDumpType(dumpExpection, dumpDebug); - ACL_LOG_INFO("convert to adx dump config successfully, enable %s dump, path=%s", - config.dumpScene.c_str(), adxConfig.dumpPath.c_str()); - return ACL_SUCCESS; - } - - dumpDebug = config.dumpDebug; - dumpType = GetDumpType(dumpExpection, dumpDebug); - // if dump_debug is on, convert to ge dump config of overflow detection - if (dumpDebug == ACL_DUMP_STATUS_SWITCH_ON) { - ACL_LOG_INFO("convert to adx dump config successfully, dump_path = %s, dump_debug = %s", - adxConfig.dumpPath.c_str(), dumpDebug.c_str()); - return ACL_SUCCESS; - } - - adxConfig.dumpMode = config.dumpMode; - adxConfig.dumpData = config.dumpData; - if (config.dumpLevel == ACL_DUMP_LEVEL_OP) { - adxConfig.dumpSwitch = OPERATOR_OP_DUMP; - } - if (config.dumpLevel == ACL_DUMP_LEVEL_KERNEL) { - adxConfig.dumpSwitch = OPERATOR_KERNEL_DUMP; - } - // Process dump stats - adxConfig.dumpStatsItem.assign(config.dumpStats.begin(), config.dumpStats.end()); - ACL_LOG_INFO("convert to adx dump config successfully, dump_mode = %s, dump_path = %s, " - "dump_data = %s", - adxConfig.dumpMode.c_str(), adxConfig.dumpPath.c_str(), adxConfig.dumpData.c_str()); - return ACL_SUCCESS; - } - - aclError AclDump::HandleDumpCommand(const char *configStr) + aclError AclDump::HandleDumpCommand(const char *configStr, size_t size) { ACL_LOG_INFO("start to execute HandleDumpCommand."); - nlohmann::json js; - auto ret = acl::JsonParser::ParseJson(configStr, js); - if (ret != ACL_SUCCESS) { - ACL_LOG_ERROR("Parse dump config from buffer failed, ret = %d", ret); - acl::AclErrorLogManager::ReportInputError(acl::INVALID_PARAM_MSG, - std::vector({"param", "value", "reason"}), - std::vector({"file", "invalid json format", "Json parse failed"})); - return ACL_ERROR_INVALID_DUMP_CONFIG; - } - if (!ContainKey(js, ACL_DUMP)) { - ACL_LOG_INFO("no dump item, no need to do dump!"); - return ACL_SUCCESS; - } - ACL_CHECK_WITH_MESSAGE_AND_RETURN( - acl::IsValidDumpConfig(js), ACL_ERROR_INVALID_DUMP_CONFIG, "[Check][DumpConfig]dump config is invalid"); - AclDumpConfig aclCfg = js.at(ACL_DUMP); - if (!NeedDump(aclCfg)) { - return ACL_SUCCESS; - } - int32_t adxRet = AdxDataDumpServerInit(); if (adxRet != ADX_ERROR_NONE) { ACL_LOG_INNER_ERROR("[AdxDataDumpServer][Init]dump server run failed, adx errorCode = %d", adxRet); return ACL_ERROR_INTERNAL_ERROR; } acl::AclDump::GetInstance().SetAdxInitFromAclInitFlag(true); - if ((aclCfg.dumpScene != ACL_DUMP_LITE_EXCEPTION) && - (aclCfg.dumpScene != ACL_DUMP_EXCEPTION_AIC_ERR_BRIEF) && - (aclCfg.dumpScene != ACL_DUMP_EXCEPTION_AIC_ERR_DETAIL)) { - // lite_exception do not set dump flag in torch process - acl::AclDump::GetInstance().SetAclDumpFromAclInitFlag(true); - } - - // ge dump callback - { - const std::unique_lock dumpLk(dumpCbMtx); - if (dumpSetCbFunc != nullptr) { - ret = dumpSetCbFunc(configStr); - if (ret != ACL_SUCCESS) { - ACL_LOG_INNER_ERROR("call ge set dump callback failed"); - return ACL_GET_ERRCODE_GE(static_cast(ret)); - } - } - } // base dump - Adx::DumpConfig config; - Adx::DumpType adumpType; - // Converting from a valid ACL config to Adx config shall never fail. - (void)SetUpDumpConfigForAdx(aclCfg, config, adumpType); - adxRet = Adx::AdumpSetDumpConfig(adumpType, config); + adxRet = Adx::AdumpSetDump(configStr, size); if (adxRet != ADX_ERROR_NONE) { ACL_LOG_INNER_ERROR("[Set][Dump]set dump config failed, adx errorCode = %d", adxRet); return ACL_ERROR_INTERNAL_ERROR; } - ACL_LOG_INFO("set dump config for adx successfully," - "adumpType = %d, dump_path = %s, dump_mode = %s, dump_data = %s.", - static_cast(adumpType), config.dumpPath.c_str(), config.dumpMode.c_str(), - config.dumpData.c_str()); return ACL_SUCCESS; } - bool NeedDump(const AclDumpConfig &cfg) - { - if ((!cfg.dumpList.empty()) || (cfg.dumpOpSwitch == ACL_DUMP_STATUS_SWITCH_ON) || - (cfg.dumpDebug == ACL_DUMP_STATUS_SWITCH_ON) || (!cfg.dumpScene.empty())) { - return true; - } - ACL_LOG_INFO("no need to dump anything after check dump config"); - return false; - } - aclError AclDump::HandleDumpConfig(const char_t *const configPath) { ACL_LOG_INFO("start to execute HandleDumpConfig."); @@ -968,7 +74,9 @@ namespace acl { return ret; } try { - return HandleDumpCommand(configStr.c_str()); + if (!configStr.empty()) { + return HandleDumpCommand(configStr.c_str(), configStr.size()); + } } catch (const nlohmann::json::exception &e) { ACL_LOG_ERROR("[Convert][DumpConfig]parse json for config failed, exception:%s.", e.what()); @@ -990,12 +98,6 @@ aclError aclmdlInitDump() return ACL_ERROR_UNINITIALIZE; } - if (acl::AclDump::GetInstance().GetAclDumpFromAclInitFlag()) { - ACL_LOG_INNER_ERROR("[Check][AclDumpFlag]aclmdlInitDump is not supported because already execute " - "aclInit init dump"); - return ACL_ERROR_DUMP_ALREADY_RUN; - } - const std::unique_lock lk(aclDumpMutex); if (aclmdlInitDumpFlag) { ACL_LOG_INNER_ERROR("[Check][InitDumpFlag]repeatedly initialized dump in aclmdlInitDump, " @@ -1022,11 +124,6 @@ aclError aclmdlSetDump(const char *dumpCfgPath) return ACL_ERROR_UNINITIALIZE; } - if (acl::AclDump::GetInstance().GetAclDumpFromAclInitFlag()) { - ACL_LOG_INNER_ERROR("[Check][AclDumpFlag]aclmdlSetDump is not supported because already execute aclInit"); - return ACL_ERROR_DUMP_ALREADY_RUN; - } - const std::unique_lock lk(aclDumpMutex); if (!aclmdlInitDumpFlag) { ACL_LOG_INNER_ERROR("[Check][aclmdlInitDumpFlag]dump is not initialized in aclmdlInitDump"); @@ -1034,8 +131,6 @@ aclError aclmdlSetDump(const char *dumpCfgPath) } ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(dumpCfgPath); - nlohmann::json js; - acl::AclDumpConfig aclCfg; std::string configStr; aclError ret = acl::JsonParser::GetConfigStrFromFile(dumpCfgPath, configStr); if (ret != ACL_SUCCESS) { @@ -1046,55 +141,17 @@ aclError aclmdlSetDump(const char *dumpCfgPath) std::vector({dumpCfgPath, "Failed to read config file"})); return ret; } - ret = acl::JsonParser::ParseJson(configStr.c_str(), js); - if (ret != ACL_SUCCESS) { - ACL_LOG_ERROR("[Parse][JsonFromFile]parse dump config from file[%s] failed, ret = %d", - dumpCfgPath, ret); - acl::AclErrorLogManager::ReportInputError(acl::INVALID_FILE_MSG, - std::vector({"path", "reason"}), - std::vector({dumpCfgPath, "Json parse failed from file"})); - return ACL_ERROR_INVALID_DUMP_CONFIG; - } - - try { - ACL_CHECK_WITH_MESSAGE_AND_RETURN( - acl::IsValidDumpConfig(js), ACL_ERROR_INVALID_DUMP_CONFIG, "[Check][DumpConfig]dump config is invalid"); - aclCfg = js.at(ACL_DUMP); - if (!acl::NeedDump(aclCfg)) { - return ACL_SUCCESS; - } - } catch (const nlohmann::json::exception &e) { - ACL_LOG_ERROR("[Convert][DumpConfig]invalid dump config, exception:%s", e.what()); - acl::AclErrorLogManager::ReportInputError(acl::INVALID_FILE_MSG, - std::vector({"path", "reason"}), - std::vector({dumpCfgPath, ("Json convert exception: " + std::string(e.what())).c_str()})); - return ACL_ERROR_INVALID_DUMP_CONFIG; - } - - // ge dump callback - { - const std::unique_lock dumpLk(dumpCbMtx); - if (dumpSetCbFunc != nullptr) { - ret = dumpSetCbFunc(configStr.c_str()); - if (ret != ACL_SUCCESS) { - ACL_LOG_INNER_ERROR("call ge set dump callback failed"); - return ACL_GET_ERRCODE_GE(static_cast(ret)); - } - } - } // base dump - Adx::DumpConfig config; - Adx::DumpType adumpType; - (void)SetUpDumpConfigForAdx(aclCfg, config, adumpType); - const auto adxRet = Adx::AdumpSetDumpConfig(adumpType, config); - if (adxRet != ADX_ERROR_NONE) { - ACL_LOG_INNER_ERROR("[Set][Dump]set dump config failed, adumpType:[%d] adx errorCode = %d", - static_cast(adumpType), adxRet); - return ACL_ERROR_INTERNAL_ERROR; + if (!configStr.empty()) { + ACL_LOG_INFO("Start to set dump."); + const auto adxRet = Adx::AdumpSetDump(configStr.c_str(), configStr.size()); + if (adxRet != ADX_ERROR_NONE) { + ACL_LOG_INNER_ERROR("[Set][Dump]set dump config failed, adx errorCode = %d", adxRet); + return ACL_ERROR_INTERNAL_ERROR; + } } - (void) aclOpenedDump.insert(adumpType); - ACL_LOG_INFO("set dump config successfully, adumpType:[%d].", static_cast(adumpType)); + ACL_LOG_INFO("set dump config successfully."); return ACL_SUCCESS; } @@ -1107,47 +164,22 @@ aclError aclmdlFinalizeDump() return ACL_ERROR_UNINITIALIZE; } - if (acl::AclDump::GetInstance().GetAclDumpFromAclInitFlag()) { - ACL_LOG_INNER_ERROR("[Check][AclDumpFlag]aclmdlFinalizeDump is not supported because already execute aclInit"); - return ACL_ERROR_DUMP_ALREADY_RUN; - } - const std::unique_lock lk(aclDumpMutex); if (!aclmdlInitDumpFlag) { ACL_LOG_INNER_ERROR("[Check][aclmdlInitDumpFlag]dump is not initialized in aclmdlInitDump"); return ACL_ERROR_DUMP_NOT_RUN; } - // call ge unset dump callback - { - const std::unique_lock dumpLk(dumpCbMtx); - if (dumpUnsetCbFunc != nullptr) { - auto ret = dumpUnsetCbFunc(); - if (ret != ACL_SUCCESS) { - ACL_LOG_INNER_ERROR("call ge unset dump callback failed"); - return ACL_GET_ERRCODE_GE(static_cast(ret)); - } - } - } - // close adump opened - Adx::DumpConfig config; - config.dumpStatus = ACL_DUMP_STATUS_SWITCH_OFF; - for (const auto adumpType : aclOpenedDump) { - if (Adx::AdumpIsDumpEnable(adumpType)) { - const auto adxRet = Adx::AdumpSetDumpConfig(adumpType, config); - if (adxRet != ADX_ERROR_NONE) { - ACL_LOG_INNER_ERROR("[Set][Dump]set dump off failed, adumpType:[%d], adx errorCode = %d", - static_cast(adumpType), adxRet); - return ACL_ERROR_INTERNAL_ERROR; - } - ACL_LOG_INFO("set dump off successfully, adumpType:[%d].", static_cast(adumpType)); - } + int32_t adxRet = Adx::AdumpUnSetDump(); + if (adxRet != ADX_ERROR_NONE) { + ACL_LOG_INNER_ERROR("[Set][Dump]set dump off failed, adx errorCode = %d", adxRet); + return ACL_ERROR_INTERNAL_ERROR; } - aclOpenedDump.clear(); + ACL_LOG_INFO("set dump off successfully."); // close dump server - const int32_t adxRet = AdxDataDumpServerUnInit(); + adxRet = AdxDataDumpServerUnInit(); if (adxRet != ADX_ERROR_NONE) { ACL_LOG_CALL_ERROR("[AdxDataDumpServer][UnInit]generate dump file failed in disk, adx errorCode = %d", adxRet); return ACL_ERROR_INTERNAL_ERROR; @@ -1157,38 +189,3 @@ aclError aclmdlFinalizeDump() ACL_LOG_INFO("successfully execute aclmdlFinalizeDump, the dump task completed!"); return ACL_SUCCESS; } - -// add interface for acl_model dump -#ifdef __cplusplus -extern "C" { -#endif -ACL_FUNC_VISIBILITY aclError aclDumpSetCallbackRegister(aclDumpSetCallbackFunc cbFunc) -{ - const std::unique_lock lk(dumpCbMtx); - dumpSetCbFunc = cbFunc; - return ACL_SUCCESS; -} - -ACL_FUNC_VISIBILITY aclError aclDumpSetCallbackUnRegister() -{ - const std::unique_lock lk(dumpCbMtx); - dumpSetCbFunc = nullptr; - return ACL_SUCCESS; -} - -ACL_FUNC_VISIBILITY aclError aclDumpUnsetCallbackRegister(aclDumpUnsetCallbackFunc cbFunc) -{ - const std::unique_lock lk(dumpCbMtx); - dumpUnsetCbFunc = cbFunc; - return ACL_SUCCESS; -} - -ACL_FUNC_VISIBILITY aclError aclDumpUnsetCallbackUnRegister() -{ - const std::unique_lock lk(dumpCbMtx); - dumpUnsetCbFunc = nullptr; - return ACL_SUCCESS; -} -#ifdef __cplusplus -} -#endif diff --git a/toolchain/dump.h b/toolchain/dump.h index 122315cdb5bee3c69d094f18815aa2dee05724aa..88ccd1909ec7e0b8752c99d1eae3e666f906603c 100755 --- a/toolchain/dump.h +++ b/toolchain/dump.h @@ -15,54 +15,10 @@ #include "common_inner.h" namespace acl { - struct AclDumpBlacklist { - std::string name; - std::vector pos; - }; - - struct OpNameRange { - std::string begin; - std::string end; - }; - - struct AclModelDumpConfig { - std::string modelName; - std::vector layer; - std::vector watcherNodes; - bool isLayer = false; // Whether the label of "layer" exists - bool isModelName = false; // Whether the label of "model_name" exists - std::vector optypeBlacklist; - std::vector opnameBlacklist; - std::vector dumpOpNameRanges; - }; - - struct AclDumpConfig { - std::string dumpPath; - std::string dumpMode; - std::vector dumpList; - std::string dumpOpSwitch; - std::string dumpDebug; - std::string dumpScene; - std::string dumpStep; - std::string dumpData; - std::string dumpLevel; - std::vector dumpStats; - }; - - bool NeedDump(const AclDumpConfig &cfg); - class AclDump { public: static aclError HandleDumpConfig(const char_t *const configPath); static AclDump &GetInstance(); - void SetAclDumpFromAclInitFlag(const bool flag) - { - aclDumpFromAclInitFlag_ = flag; - } - bool GetAclDumpFromAclInitFlag() const - { - return aclDumpFromAclInitFlag_; - } void SetAdxInitFromAclInitFlag(const bool flag) { adxInitFromAclInitFlag_ = flag; @@ -73,8 +29,7 @@ namespace acl { } private: - static aclError HandleDumpCommand(const char *configStr); - bool aclDumpFromAclInitFlag_ = false; + static aclError HandleDumpCommand(const char *configStr, size_t size); bool adxInitFromAclInitFlag_ = false; ~AclDump() = default; AclDump() = default;