Star687
459
代码
代码
Issues33
Pull Requests122
Actions
项目讨论
Wiki
分析
Star687
459
已合并
refactor(om2): 重构OM2序列化格式，优化存储结构 #4512
wuzheng创建于 16 天前
refactor(om2): 重构OM2序列化格式，优化存储结构 #4512
已合并
wuzheng创建于 16 天前
从wuzheng-hw/geom2_830合入到cann/gedevelop
共 18 个文件变更+722-356
Mapi/acl/acl_model/model/model_om2.cpp+1-1
@@ -1688,7 +1688,7 @@ const char *aclmdlGetOpAttrImplOm2(aclmdlDesc *modelDesc, const char *opName, co
1688 return itAttr->second.c_str();1688 return itAttr->second.c_str();
1689 }1689 }
1690 }1690 }
1691- return nullptr;1691+ return "";
1692}1692}
1693 1693 
1694const char *aclmdlGetInputNameByIndexImplOm2(const aclmdlDesc *modelDesc, size_t index) {1694const char *aclmdlGetInputNameByIndexImplOm2(const aclmdlDesc *modelDesc, size_t index) {
Mbase/common/helper/om2/om2_package_contants.h+3-3
@@ -18,7 +18,7 @@
18namespace ge {18namespace ge {
19#define FORALL_OM2_CONSTANTS(DO) \19#define FORALL_OM2_CONSTANTS(DO) \
20 DO(OM2_ARCHIVE_VERSION, "om2_version"); \20 DO(OM2_ARCHIVE_VERSION, "om2_version"); \
21- DO(OM2_ARCHIVE_VERSION_VALUE, "0"); \21+ DO(OM2_ARCHIVE_VERSION_VALUE, "1.0"); \
22 DO(OM2_MODEL_NUM, "model_num"); \22 DO(OM2_MODEL_NUM, "model_num"); \
23 DO(OM2_ATC_COMMAND, "atc_command"); \23 DO(OM2_ATC_COMMAND, "atc_command"); \
24 DO(OM2_MANIFEST_PATH, "manifest.json"); \24 DO(OM2_MANIFEST_PATH, "manifest.json"); \
@@ -27,9 +27,9 @@ namespace ge {
27 DO(OM2_MODEL_META_PATH_FORMAT, "data/model_%s/model_meta.json"); \27 DO(OM2_MODEL_META_PATH_FORMAT, "data/model_%s/model_meta.json"); \
28 DO(OM2_RUNTIME_DIR_FORMAT, "data/model_%s/runtime/"); \28 DO(OM2_RUNTIME_DIR_FORMAT, "data/model_%s/runtime/"); \
29 DO(OM2_DEBUG_DIR_FORMAT, "data/model_%s/debug/"); \29 DO(OM2_DEBUG_DIR_FORMAT, "data/model_%s/debug/"); \
30- DO(OM2_OP_ATTR_PATH_FORMAT, "data/model_%s/debug/op_attr.json"); \30+ DO(OM2_OP_ATTR_PATH_FORMAT, "data/model_%s/op_attr.json"); \
31 DO(OM2_CUSTOM_KERNELS_DIR_FORMAT, "data/custom_ops/%s/"); \31 DO(OM2_CUSTOM_KERNELS_DIR_FORMAT, "data/custom_ops/%s/"); \
32- DO(OM2_KERNELS_DIR_FORMAT, "data/kernels_%s/"); \32+ DO(OM2_KERNELS_DIR, "data/kernels/"); \
33 DO(OM2_CONSTANTS_DIR, "data/constants/"); \33 DO(OM2_CONSTANTS_DIR, "data/constants/"); \
34 DO(OM2_CONSTANTS_FILE_PREFIX, "constant_"); \34 DO(OM2_CONSTANTS_FILE_PREFIX, "constant_"); \
35 DO(OM2_CONSTANTS_CONFIG_PATH_FORMAT, "data/constants/model_%s_constants_config.json"); \35 DO(OM2_CONSTANTS_CONFIG_PATH_FORMAT, "data/constants/model_%s_constants_config.json"); \
Mbase/common/helper/om2/om2_zip_saver.cc+71-41
@@ -11,6 +11,7 @@
11#include "common/helper/om2/om2_zip_saver.h"11#include "common/helper/om2/om2_zip_saver.h"
12 12 
13#include <map>13#include <map>
14+#include <sstream>
14 15 
15#include "common/ge_common/ge_types.h"16#include "common/ge_common/ge_types.h"
16#include "common/helper/om2/json_file.h"17#include "common/helper/om2/json_file.h"
@@ -29,20 +30,6 @@ bool EndsWith(const std::string &str, const std::string &suffix) {
29 return (str.size() >= suffix.size()) && (str.compare(str.size() - suffix.size(), suffix.size(), suffix) == 0);30 return (str.size() >= suffix.size()) && (str.compare(str.size() - suffix.size(), suffix.size(), suffix) == 0);
30}31}
31 32 
32-std::string SerializeOpAttrMapToJson(const std::map<std::string, std::map<std::string, std::string>> &op_attr_map) {
33- nlohmann::json json_obj = nlohmann::json::object();
34- 
35- for (const auto &[op_name, attrs] : op_attr_map) {
36- nlohmann::json op_attrs = nlohmann::json::object();
37- for (const auto &[attr_name, value] : attrs) {
38- op_attrs[attr_name] = value;
39- }
40- json_obj[op_name] = op_attrs;
41- }
42- 
43- return json_obj.dump();
44-}
45- 
46JsonFile SerializeTensorDesc(const ge::Om2TensorDesc &desc) {33JsonFile SerializeTensorDesc(const ge::Om2TensorDesc &desc) {
47 JsonFile json;34 JsonFile json;
48 (void)json.Set("name", desc.GetName());35 (void)json.Set("name", desc.GetName());
@@ -94,10 +81,8 @@ Status SerializeConstantsConfig(const gert::Om2ModelData &model_data,
94 (void)json_file.Set("internal_weight_size", model_data.constants_data.internal_weight_size);81 (void)json_file.Set("internal_weight_size", model_data.constants_data.internal_weight_size);
95 auto const_json_object = JsonFile::json::object();82 auto const_json_object = JsonFile::json::object();
96 for (const auto &const_meta : model_data.constants_data.consts) {83 for (const auto &const_meta : model_data.constants_data.consts) {
97- std::string const_key = const_meta.op_name.empty() ? const_meta.file_name : const_meta.op_name;84+ const std::string const_key =
98- if (const_key.empty()) {85+ (const_meta.type == "INTERNAL") ? "constant_" + std::to_string(const_meta.index) : const_meta.op_name;
99- const_key = "constant_" + std::to_string(const_meta.index);
100- }
101 JsonFile const_info;86 JsonFile const_info;
102 (void)const_info.Set("index", const_meta.index);87 (void)const_info.Set("index", const_meta.index);
103 (void)const_info.Set("type", const_meta.type);88 (void)const_info.Set("type", const_meta.type);
@@ -107,7 +92,6 @@ Status SerializeConstantsConfig(const gert::Om2ModelData &model_data,
107 }92 }
108 (void)const_info.Set("offset", const_meta.offset);93 (void)const_info.Set("offset", const_meta.offset);
109 (void)const_info.Set("size", const_meta.size);94 (void)const_info.Set("size", const_meta.size);
110- (void)const_info.Set("op_name", const_meta.op_name);
111 const_json_object[const_key] = const_info.Raw();95 const_json_object[const_key] = const_info.Raw();
112 }96 }
113 (void)json_file.Set("consts", const_json_object);97 (void)json_file.Set("consts", const_json_object);
@@ -200,7 +184,7 @@ Status SerializeVarMetas(const gert::Om2ModelData &model_data, const std::shared
200 184 
201Status SerializeKernelBinaries(const gert::Om2ModelData &model_data,185Status SerializeKernelBinaries(const gert::Om2ModelData &model_data,
202 const std::shared_ptr<ZipArchiveWriter> &zip_writer) {186 const std::shared_ptr<ZipArchiveWriter> &zip_writer) {
203- const auto kernel_bin_dir = FormatOm2Path(OM2_KERNELS_DIR_FORMAT, "npu_arch");187+ const auto kernel_bin_dir = OM2_KERNELS_DIR;
204 for (const auto &kb : model_data.kernel_binaries) {188 for (const auto &kb : model_data.kernel_binaries) {
205 const auto entry_path = kernel_bin_dir + kb.name;189 const auto entry_path = kernel_bin_dir + kb.name;
206 GE_ASSERT_TRUE(zip_writer->WriteBytes(entry_path, kb.data.get(), kb.data_size, false));190 GE_ASSERT_TRUE(zip_writer->WriteBytes(entry_path, kb.data.get(), kb.data_size, false));
@@ -336,16 +320,19 @@ Status SerializeModelMeta(const gert::Om2ModelData &model_data, const std::share
336 JsonFile input_info;320 JsonFile input_info;
337 (void)input_info.Set("name", desc.GetName());321 (void)input_info.Set("name", desc.GetName());
338 (void)input_info.Set("index", i);322 (void)input_info.Set("index", i);
339- (void)input_info.Set("shape", desc.GetShape());323+ if (!model_data.model_meta.dynamic_batch_info.empty()) {
340- (void)input_info.Set("shape_v2", desc_v2.GetShape());324+ (void)input_info.Set("shape", model_data.model_meta.origin_input_dims[i]);
325+ (void)input_info.Set("max_gear_shape", desc.GetShape());
326+ } else {
327+ (void)input_info.Set("shape", desc.GetShape());
328+ }
329+ if (model_data.model_meta.has_aipp) {
330+ (void)input_info.Set("shape_aclmdlGetInputDimsV2", desc_v2.GetShape());
331+ }
341 (void)input_info.Set("data_type", TypeUtils::DataTypeToSerialString(desc.GetDataType()));332 (void)input_info.Set("data_type", TypeUtils::DataTypeToSerialString(desc.GetDataType()));
342 (void)input_info.Set("format", TypeUtils::FormatToSerialString(desc.GetFormat()));333 (void)input_info.Set("format", TypeUtils::FormatToSerialString(desc.GetFormat()));
343 (void)input_info.Set("size", desc.GetSize());334 (void)input_info.Set("size", desc.GetSize());
344 (void)input_info.Set("shape_range", desc.GetShapeRange());335 (void)input_info.Set("shape_range", desc.GetShapeRange());
345- const auto origin_dims = (i < model_data.model_meta.origin_input_dims.size())
346- ? model_data.model_meta.origin_input_dims[i]
347- : desc.GetShape();
348- (void)input_info.Set("origin_input_dims", origin_dims);
349 input_json_array.push_back(input_info.Raw());336 input_json_array.push_back(input_info.Raw());
350 }337 }
351 338 
@@ -365,14 +352,51 @@ Status SerializeModelMeta(const gert::Om2ModelData &model_data, const std::share
365 352 
366 (void)model_meta_info.Set("inputs", input_json_array);353 (void)model_meta_info.Set("inputs", input_json_array);
367 (void)model_meta_info.Set("outputs", output_json_array);354 (void)model_meta_info.Set("outputs", output_json_array);
368- (void)model_meta_info.Set("dynamic_output_shape", model_data.model_meta.dynamic_output_shape);355+ 
369- (void)model_meta_info.Set("dynamic_batch_info", model_data.model_meta.dynamic_batch_info);356+ if (!model_data.model_meta.dynamic_batch_info.empty()) {
370- (void)model_meta_info.Set("user_designate_shape_order", model_data.model_meta.user_designate_shape_order);357+ JsonFile dynamic_dims_json;
371- (void)model_meta_info.Set("dynamic_type", model_data.model_meta.dynamic_type);358+ (void)dynamic_dims_json.Set("dynamic_type", model_data.model_meta.dynamic_type);
359+ (void)dynamic_dims_json.Set("user_designate_shape_order", model_data.model_meta.user_designate_shape_order);
360+ 
361+ std::map<size_t, std::vector<JsonFile::json>> gear_outputs;
362+ for (const auto &shape_str : model_data.model_meta.dynamic_output_shape) {
363+ std::vector<int64_t> values;
364+ std::istringstream iss(shape_str);
365+ std::string token;
366+ while (std::getline(iss, token, ',')) {
367+ values.push_back(std::stoll(token));
368+ }
369+ if (values.size() >= 2UL && values[0] >= 0) {
370+ auto dims = JsonFile::json::array();
371+ for (size_t i = 2UL; i < values.size(); ++i) {
372+ dims.push_back(values[i]);
373+ }
374+ gear_outputs[static_cast<size_t>(values[0])].push_back(std::move(dims));
375+ }
376+ }
377+ 
378+ auto gears_array = JsonFile::json::array();
379+ for (size_t gear_idx = 0UL; gear_idx < model_data.model_meta.dynamic_batch_info.size(); ++gear_idx) {
380+ JsonFile gear_json;
381+ (void)gear_json.Set("inputs", model_data.model_meta.dynamic_batch_info[gear_idx]);
382+ 
383+ auto outputs_array = JsonFile::json::array();
384+ auto it = gear_outputs.find(gear_idx);
385+ if (it != gear_outputs.end()) {
386+ for (const auto &dims : it->second) {
387+ outputs_array.push_back(dims);
388+ }
389+ }
390+ (void)gear_json.Set("outputs", outputs_array);
391+ gears_array.push_back(gear_json.Raw());
392+ }
393+ (void)dynamic_dims_json.Set("gears", gears_array);
394+ (void)model_meta_info.Set("dynamic_dims", dynamic_dims_json);
395+ }
396+ 
372 (void)model_meta_info.Set("work_size", model_data.model_meta.work_size);397 (void)model_meta_info.Set("work_size", model_data.model_meta.work_size);
373 (void)model_meta_info.Set("zero_copy_size", model_data.model_meta.zero_copy_size);398 (void)model_meta_info.Set("zero_copy_size", model_data.model_meta.zero_copy_size);
374 (void)model_meta_info.Set("name", model_data.model_meta.model_name);399 (void)model_meta_info.Set("name", model_data.model_meta.model_name);
375- (void)model_meta_info.Set("root_graph_name", model_data.model_meta.root_graph_name);
376 400 
377 // 序列化 AIPP 元数据401 // 序列化 AIPP 元数据
378 SerializeAippMeta(model_data.model_meta, model_meta_info);402 SerializeAippMeta(model_data.model_meta, model_meta_info);
@@ -387,9 +411,8 @@ Status SerializeModelMeta(const gert::Om2ModelData &model_data, const std::share
387Status SerializeDebugInfo(const gert::Om2ModelData &model_data, const std::shared_ptr<ZipArchiveWriter> &zip_writer) {411Status SerializeDebugInfo(const gert::Om2ModelData &model_data, const std::shared_ptr<ZipArchiveWriter> &zip_writer) {
388 const size_t model_index = 0UL;412 const size_t model_index = 0UL;
389 // op_attr.json413 // op_attr.json
390- const auto op_attr_json_str = model_data.debug_info.op_attr_map.empty()414+ const auto &op_attr_json_str =
391- ? std::string("{}")415+ model_data.debug_info.op_attr_json.empty() ? std::string("{}") : model_data.debug_info.op_attr_json;
W
Wwuzheng10 天前

om2_model_data同步修改层级

likedislike
392- : SerializeOpAttrMapToJson(model_data.debug_info.op_attr_map);
393 const auto op_attr_entry_path = FormatOm2Path(OM2_OP_ATTR_PATH_FORMAT, std::to_string(model_index).c_str());416 const auto op_attr_entry_path = FormatOm2Path(OM2_OP_ATTR_PATH_FORMAT, std::to_string(model_index).c_str());
394 GE_ASSERT_TRUE(zip_writer->WriteBytes(op_attr_entry_path, op_attr_json_str.data(), op_attr_json_str.size(), false));417 GE_ASSERT_TRUE(zip_writer->WriteBytes(op_attr_entry_path, op_attr_json_str.data(), op_attr_json_str.size(), false));
395 418 
@@ -403,9 +426,17 @@ Status SerializeDebugInfo(const gert::Om2ModelData &model_data, const std::share
403Status SerializeManifest(const gert::Om2ModelData &model_data, const std::shared_ptr<ZipArchiveWriter> &zip_writer) {426Status SerializeManifest(const gert::Om2ModelData &model_data, const std::shared_ptr<ZipArchiveWriter> &zip_writer) {
404 nlohmann::json manifest_json = nlohmann::json::object();427 nlohmann::json manifest_json = nlohmann::json::object();
405 for (const auto &[key, value] : model_data.manifest) {428 for (const auto &[key, value] : model_data.manifest) {
406- manifest_json[key] = value;429+ if (key == OM2_MODEL_NUM) {
430+ try {
431+ manifest_json[key] = std::stoi(value);
W
Wwuzheng10 天前

stoi有线程API可以用

likedislike
W
wuzheng
10 天前 评论：
432+ } catch (const std::exception &) {
433+ manifest_json[key] = value;
434+ }
435+ } else {
436+ manifest_json[key] = value;
437+ }
407 }438 }
408- const auto manifest_str = manifest_json.dump();439+ const auto manifest_str = manifest_json.dump(4);
409 GE_ASSERT_TRUE(zip_writer->WriteBytes(OM2_MANIFEST_PATH, manifest_str.data(), manifest_str.size(), false));440 GE_ASSERT_TRUE(zip_writer->WriteBytes(OM2_MANIFEST_PATH, manifest_str.data(), manifest_str.size(), false));
410 return SUCCESS;441 return SUCCESS;
411}442}
@@ -415,12 +446,11 @@ Status SerializeManifest(const gert::Om2ModelData &model_data, const std::shared
415Status Om2ZipSaver::Save(const gert::Om2ModelData &model_data, ModelBufferData &model, const bool is_offline,446Status Om2ZipSaver::Save(const gert::Om2ModelData &model_data, ModelBufferData &model, const bool is_offline,
416 const std::string &writer_path) {447 const std::string &writer_path) {
417 GELOGI(448 GELOGI(
418- "[OM2] Begin to serialize Om2ModelData to ZIP, model_name:%s, root_graph:%s, "449+ "[OM2] Begin to serialize Om2ModelData to ZIP, model_name:%s, "
419 "inputs:%zu, outputs:%zu, kernels:%zu, custom kernels: %zu, weight_size:%zu",450 "inputs:%zu, outputs:%zu, kernels:%zu, custom kernels: %zu, weight_size:%zu",
420- model_data.model_meta.model_name.c_str(), model_data.model_meta.root_graph_name.c_str(),451+ model_data.model_meta.model_name.c_str(), model_data.model_meta.input_desc.size(),
421- model_data.model_meta.input_desc.size(), model_data.model_meta.output_desc.size(),452+ model_data.model_meta.output_desc.size(), model_data.kernel_binaries.size(),
422- model_data.kernel_binaries.size(), model_data.custom_kernel_binaries.size(),453+ model_data.custom_kernel_binaries.size(), model_data.constants_data.internal_weight_size);
423- model_data.constants_data.internal_weight_size);
424 const std::string path = writer_path.empty() ? "om2_model" : writer_path;454 const std::string path = writer_path.empty() ? "om2_model" : writer_path;
425 auto zip_writer = std::make_shared<ZipArchiveWriter>(path);455 auto zip_writer = std::make_shared<ZipArchiveWriter>(path);
426 GE_ASSERT_NOTNULL(zip_writer);456 GE_ASSERT_NOTNULL(zip_writer);
Mbase/common/helper/om2_package_helper.cc+15-25
@@ -248,17 +248,6 @@ Status CollectDynamicBatchInfo(const std::vector<OpDescPtr> &case_ops, ModelMeta
248 return SUCCESS;248 return SUCCESS;
249}249}
250 250 
251-std::string GetRootGraphName(const GeModelPtr &ge_model) {
252- if (ge_model == nullptr) {
253- return "";
254- }
255- auto graph = ge_model->GetGraph();
256- while ((graph != nullptr) && (graph->GetParentGraph() != nullptr)) {
257- graph = graph->GetParentGraph();
258- }
259- return (graph == nullptr) ? "" : graph->GetName();
260-}
261- 
262Status SetOm2CompatibleOmInfoList(const GeModelPtr &ge_model) {251Status SetOm2CompatibleOmInfoList(const GeModelPtr &ge_model) {
263 std::vector<int64_t> om_info;252 std::vector<int64_t> om_info;
264 om_info.push_back(static_cast<int64_t>(ge_model->GetWeightSize()));253 om_info.push_back(static_cast<int64_t>(ge_model->GetWeightSize()));
@@ -937,7 +926,6 @@ Status Om2PackageHelper::BuildModelMeta(const GeModelPtr &ge_model, gert::Om2Mod
937 GE_ASSERT_SUCCESS(CollectDynamicBatchInfo(io_nodes.case_ops, extra_info));926 GE_ASSERT_SUCCESS(CollectDynamicBatchInfo(io_nodes.case_ops, extra_info));
938 927 
939 model_meta.model_name = ge_model->GetName();928 model_meta.model_name = ge_model->GetName();
940- model_meta.root_graph_name = GetRootGraphName(ge_model);
941 int64_t work_size = 0;929 int64_t work_size = 0;
942 (void)AttrUtils::GetInt(ge_model, ATTR_MODEL_MEMORY_SIZE, work_size);930 (void)AttrUtils::GetInt(ge_model, ATTR_MODEL_MEMORY_SIZE, work_size);
943 model_meta.work_size = static_cast<size_t>(work_size);931 model_meta.work_size = static_cast<size_t>(work_size);
@@ -986,26 +974,28 @@ Status Om2PackageHelper::BuildDebugInfo(const GeModelPtr &ge_model, gert::Om2Mod
986 GE_ASSERT_NOTNULL(graph);974 GE_ASSERT_NOTNULL(graph);
987 gert::Om2DebugInfo &debug_info = model_data.debug_info;975 gert::Om2DebugInfo &debug_info = model_data.debug_info;
988 976 
989- // Build op_attr_map977+ auto op_attr_object = JsonFile::json::object();
978+ 
990 for (const auto &node : graph->GetNodes(graph->GetGraphUnknownFlag())) {979 for (const auto &node : graph->GetNodes(graph->GetGraphUnknownFlag())) {
991 const auto &op_desc = node->GetOpDesc();980 const auto &op_desc = node->GetOpDesc();
992 GE_ASSERT_NOTNULL(op_desc);981 GE_ASSERT_NOTNULL(op_desc);
993 std::vector<std::string> original_op_names;982 std::vector<std::string> original_op_names;
994- if (AttrUtils::GetListStr(op_desc, ATTR_NAME_DATA_DUMP_ORIGIN_OP_NAMES, original_op_names)) {983+ if (AttrUtils::GetListStr(op_desc, ATTR_NAME_DATA_DUMP_ORIGIN_OP_NAMES, original_op_names) &&
995- std::map<std::string, std::string> op_attrs;984+ !original_op_names.empty()) {
996- // Serialize the LIST_STRING value as "[N]value[N]value..." format985+ auto attr_value_object = JsonFile::json::object();
997- std::string serialized_value;986+ attr_value_object["type"] = "LIST_STRING";
998- for (const auto &op_name : original_op_names) {987+ attr_value_object["value"] = original_op_names;
999- serialized_value += "[" + std::to_string(op_name.size()) + "]" + op_name;988+ 
1000- }989+ auto op_attr_entry = JsonFile::json::object();
1001- if (!serialized_value.empty()) {990+ op_attr_entry[ATTR_NAME_DATA_DUMP_ORIGIN_OP_NAMES] = attr_value_object;
1002- op_attrs[ATTR_NAME_DATA_DUMP_ORIGIN_OP_NAMES] = serialized_value;991+ 
1003- debug_info.op_attr_map[op_desc->GetName()] = op_attrs;992+ op_attr_object[op_desc->GetName()] = op_attr_entry;
1004- }
1005 }993 }
1006 }994 }
1007 995 
1008- // Build visual json996+ JsonFile op_attr_json(op_attr_object);
997+ debug_info.op_attr_json = op_attr_json.Dump();
998+ 
1009 GE_ASSERT_SUCCESS(SetOm2CompatibleOmInfoList(ge_model));999 GE_ASSERT_SUCCESS(SetOm2CompatibleOmInfoList(ge_model));
1010 GE_ASSERT_SUCCESS(VisualJsonConverter::SerializeFromGeModel(ge_model, debug_info.visual_json));1000 GE_ASSERT_SUCCESS(VisualJsonConverter::SerializeFromGeModel(ge_model, debug_info.visual_json));
1011 GELOGI("[OM2] Successfully built debug info");1001 GELOGI("[OM2] Successfully built debug info");
Mbase/common/om2/codegen/om2_codegen_model_builder.cc+4-1
@@ -17,6 +17,7 @@
17 17 
18#include "common/file_constant_utils/file_constant_utils.h"18#include "common/file_constant_utils/file_constant_utils.h"
19#include "common/ge_common/string_util.h"19#include "common/ge_common/string_util.h"
20+#include "common/helper/om2/om2_package_contants.h"
20#include "common/om2/codegen/om2_codegen_utils.h"21#include "common/om2/codegen/om2_codegen_utils.h"
21#include "common/om2/codegen/om2_model_utils.h"22#include "common/om2/codegen/om2_model_utils.h"
22#include "graph/debug/ge_attr_define.h"23#include "graph/debug/ge_attr_define.h"
@@ -97,7 +98,9 @@ Status Om2CodegenModelBuilder::CollectConstInputsFromOp(const OpDescPtr &op_desc
97 GE_ASSERT_SUCCESS(Om2ModelUtils::BuildInputTensorInfo(tensor_desc, entry.tensor_info));98 GE_ASSERT_SUCCESS(Om2ModelUtils::BuildInputTensorInfo(tensor_desc, entry.tensor_info));
98 codegen_model.const_inputs.push_back(std::move(entry));99 codegen_model.const_inputs.push_back(std::move(entry));
99 (void)weight_offset_to_varname_.emplace(data_offset, var_name);100 (void)weight_offset_to_varname_.emplace(data_offset, var_name);
100- const_metas.push_back(Om2ConstMeta{const_index, "INTERNAL", "", "", data_offset, tensor_size, ""});101+ const size_t model_index = 0UL;
W
Wwuzheng10 天前

单模型固定写0，后续考虑多模型如何扩展

likedislike
102+ const auto file_name = FormatOm2Path("%s%zu", OM2_CONSTANTS_FILE_PREFIX, model_index);
103+ const_metas.push_back(Om2ConstMeta{const_index, "INTERNAL", file_name, "", data_offset, tensor_size, ""});
101 }104 }
102 return SUCCESS;105 return SUCCESS;
103}106}
Mbase/common/om2/om2_model_data.h+1-2
@@ -52,7 +52,6 @@ using Om2AippInfo = Om2AippMeta;
52/// 模型元数据52/// 模型元数据
53struct Om2ModelMeta {53struct Om2ModelMeta {
54 std::string model_name;54 std::string model_name;
55- std::string root_graph_name;
56 size_t work_size = 0U;55 size_t work_size = 0U;
57 int64_t zero_copy_size = 0;56 int64_t zero_copy_size = 0;
58 std::vector<ge::Om2TensorDesc> input_desc;57 std::vector<ge::Om2TensorDesc> input_desc;
@@ -76,7 +75,7 @@ struct Om2ConstantsData {
76 75 
77/// Debug 信息76/// Debug 信息
78struct Om2DebugInfo {77struct Om2DebugInfo {
79- std::map<std::string, std::map<std::string, std::string>> op_attr_map; // 使用 map 直接存储，避免 JSON 解析开销78+ std::string op_attr_json;
80 std::string visual_json;79 std::string visual_json;
81};80};
82 81 
Mruntime/om2/om2_model_executor.cc+131-59
@@ -13,6 +13,7 @@
13#include <string>13#include <string>
14#include <fstream>14#include <fstream>
15#include <regex>15#include <regex>
16+#include <sstream>
16#include <unordered_set>17#include <unordered_set>
17#include <sys/syscall.h>18#include <sys/syscall.h>
18#include <unistd.h>19#include <unistd.h>
@@ -117,7 +118,7 @@ struct CustSharedLibInfo {
117struct RunModelInfo {118struct RunModelInfo {
118 std::string so_file;119 std::string so_file;
119 int32_t so_fd = -1;120 int32_t so_fd = -1;
120- std::map<std::string, std::map<std::string, std::string>> op_attr_map; // 直接使用 map，避免 JSON 序列化开销121+ ge::JsonFile op_attr_json;
121 void *so_handle = nullptr;122 void *so_handle = nullptr;
122 std::string model_name;123 std::string model_name;
123 std::string root_graph_name;124 std::string root_graph_name;
@@ -228,34 +229,62 @@ ge::Status ParseTensorDescFromJson(const ge::JsonFile &json_file, ge::Om2TensorD
228 return ge::SUCCESS;229 return ge::SUCCESS;
229}230}
230 231 
231-ge::Status ParseOpAttrMapJson(const uint8_t *data, size_t data_size,232+void ParseOpAttrJsonToMapInternal(const ge::JsonFile &op_attr_json,
232- std::map<std::string, std::map<std::string, std::string>> &op_attr_map) {233+ std::map<std::string, std::map<std::string, std::string>> &attr_map) {
233- try {234+ attr_map.clear();
234- const auto json_obj = ge::JsonFile::json::parse(data, data + data_size);235+ if (!op_attr_json.IsValid()) {
235- if (!json_obj.is_object()) {236+ return;
236- GELOGW("[OM2] op_attr.json root is not an object");237+ }
237- return ge::FAILED;238+ 
239+ const auto &json_data = op_attr_json.Raw();
240+ if (!json_data.is_object()) {
241+ GELOGW("[OM2] op_attr.json root is not an object");
242+ return;
243+ }
244+ 
245+ for (auto it_op = json_data.begin(); it_op != json_data.end(); ++it_op) {
246+ const std::string op_name = it_op.key();
247+ if (!it_op.value().is_object()) {
248+ continue;
238 }249 }
239 250 
240- for (auto &[op_name, attrs] : json_obj.items()) {251+ for (auto it_attr = it_op.value().begin(); it_attr != it_op.value().end(); ++it_attr) {
241- if (!attrs.is_object()) {252+ const std::string attr_name = it_attr.key();
242- GELOGW("[OM2] op_attr for %s is not an object", op_name.c_str());253+ if (!it_attr.value().is_object()) {
243 continue;254 continue;
244 }255 }
245- std::map<std::string, std::string> op_attrs;256+ 
246- for (auto &[attr_name, value] : attrs.items()) {257+ ge::JsonFile attr_obj(it_attr.value());
247- if (value.is_string()) {258+ 
248- op_attrs[attr_name] = value.get<std::string>();259+ std::string type;
249- } else {260+ if (!attr_obj.Get("type", type)) {
250- op_attrs[attr_name] = value.dump();261+ continue;
251- }262+ }
263+ 
264+ if (!attr_obj.Raw().contains("value")) {
265+ continue;
266+ }
267+ 
268+ try {
269+ std::string value_str;
270+ if (type == "LIST_STRING") {
271+ const auto &value_array = attr_obj.Raw()["value"];
W
Wwuzheng10 天前

使用jsonfile包装的API

likedislike
272+ if (value_array.is_array()) {
273+ for (const auto &elem : value_array) {
274+ const std::string s = elem.get<std::string>();
275+ value_str += "[" + std::to_string(s.size()) + "]" + s;
276+ }
277+ }
278+ } else {
279+ value_str = attr_obj.Raw()["value"].dump();
280+ }
281+ 
282+ attr_map[op_name][attr_name] = value_str;
283+ } catch (const std::exception &e) {
284+ GELOGW("[OM2] Failed to serialize attr value for op[%s] attr[%s]: %s", op_name.c_str(), attr_name.c_str(),
285+ e.what());
252 }286 }
253- op_attr_map[op_name] = op_attrs;
254 }287 }
255- return ge::SUCCESS;
256- } catch (const ge::JsonFile::json::exception &e) {
257- GELOGE(ge::FAILED, "[OM2] Failed to parse op_attr.json: %s", e.what());
258- return ge::FAILED;
259 }288 }
260}289}
261 290 
@@ -305,7 +334,6 @@ ge::Status DeserializeConstantsConfigEntry(const ge::RAIIZipArchive &archive, co
305 (void)val_file.Get("file_path", meta.file_path);334 (void)val_file.Get("file_path", meta.file_path);
306 (void)val_file.Get("offset", meta.offset);335 (void)val_file.Get("offset", meta.offset);
307 (void)val_file.Get("size", meta.size);336 (void)val_file.Get("size", meta.size);
308- (void)val_file.Get("op_name", meta.op_name);
309 (void)model_data.constants_data.consts.emplace_back(std::move(meta));337 (void)model_data.constants_data.consts.emplace_back(std::move(meta));
310 }338 }
311 }339 }
@@ -479,22 +507,23 @@ ge::Status DeserializeModelMetaEntry(const ge::RAIIZipArchive &archive, const st
479 507 
480 ge::JsonFile::json inputs_json;508 ge::JsonFile::json inputs_json;
481 if (json_file.Get("inputs", inputs_json) && inputs_json.is_array()) {509 if (json_file.Get("inputs", inputs_json) && inputs_json.is_array()) {
482- for (const auto &input_json : inputs_json) {510+ for (size_t i = 0UL; i < inputs_json.size(); ++i) {
483- const ge::JsonFile input_file(input_json);511+ const ge::JsonFile input_file(inputs_json[i]);
484- std::vector<int64_t> shape_v2;
485- GE_ASSERT_TRUE(input_file.Get("shape_v2", shape_v2), "[OM2] input shape_v2 not found in model_meta.json");
486 ge::Om2TensorDesc desc;512 ge::Om2TensorDesc desc;
487 GE_ASSERT_SUCCESS(ParseTensorDescFromJson(input_file, desc));513 GE_ASSERT_SUCCESS(ParseTensorDescFromJson(input_file, desc));
514+ GE_ASSERT_TRUE(!desc.GetShape().empty(), "[OM2] Input tensor at index %zu is missing 'shape' field", i);
515+ std::vector<int64_t> max_gear_shape;
516+ if (input_file.Get("max_gear_shape", max_gear_shape)) {
517+ model_data.model_meta.origin_input_dims.emplace_back(desc.GetShape());
518+ desc.SetShape(max_gear_shape);
519+ }
488 model_data.model_meta.input_desc.emplace_back(desc);520 model_data.model_meta.input_desc.emplace_back(desc);
489 ge::Om2TensorDesc desc_v2 = desc;521 ge::Om2TensorDesc desc_v2 = desc;
490- desc_v2.SetShape(shape_v2);522+ std::vector<int64_t> shape_v2;
491- model_data.model_meta.input_desc_v2.emplace_back(desc_v2);523+ if (input_file.Get("shape_aclmdlGetInputDimsV2", shape_v2)) {
492- std::vector<int64_t> origin_input_dims;524+ desc_v2.SetShape(shape_v2);
493- if (input_file.Get("origin_input_dims", origin_input_dims)) {
494- model_data.model_meta.origin_input_dims.emplace_back(std::move(origin_input_dims));
495- } else {
496- (void)model_data.model_meta.origin_input_dims.emplace_back(desc.GetShape());
497 }525 }
526+ model_data.model_meta.input_desc_v2.emplace_back(desc_v2);
498 }527 }
499 }528 }
500 529 
@@ -509,14 +538,42 @@ ge::Status DeserializeModelMetaEntry(const ge::RAIIZipArchive &archive, const st
509 }538 }
510 }539 }
511 540 
512- (void)json_file.Get("dynamic_output_shape", model_data.model_meta.dynamic_output_shape);541+ ge::JsonFile dynamic_dims_file;
513- (void)json_file.Get("dynamic_batch_info", model_data.model_meta.dynamic_batch_info);542+ if (json_file.Get("dynamic_dims", dynamic_dims_file) && dynamic_dims_file.IsValid()) {
514- (void)json_file.Get("user_designate_shape_order", model_data.model_meta.user_designate_shape_order);543+ (void)dynamic_dims_file.Get("dynamic_type", model_data.model_meta.dynamic_type);
515- (void)json_file.Get("dynamic_type", model_data.model_meta.dynamic_type);544+ (void)dynamic_dims_file.Get("user_designate_shape_order", model_data.model_meta.user_designate_shape_order);
545+ 
546+ ge::JsonFile::json gears_json;
547+ if (dynamic_dims_file.Get("gears", gears_json) && gears_json.is_array()) {
W
Wwuzheng10 天前

超大函数

likedislike
548+ for (size_t gear_idx = 0UL; gear_idx < gears_json.size(); ++gear_idx) {
549+ const ge::JsonFile gear_file(gears_json[gear_idx]);
550+ 
551+ std::vector<int64_t> inputs;
552+ if (gear_file.Get("inputs", inputs)) {
553+ model_data.model_meta.dynamic_batch_info.push_back(std::move(inputs));
554+ }
555+ 
556+ ge::JsonFile::json outputs_json;
557+ if (gear_file.Get("outputs", outputs_json) && outputs_json.is_array()) {
558+ for (size_t out_idx = 0UL; out_idx < outputs_json.size(); ++out_idx) {
559+ const auto &dims = outputs_json[out_idx];
560+ if (dims.is_array()) {
561+ std::string shape_str = std::to_string(gear_idx) + "," + std::to_string(out_idx);
562+ for (size_t i = 0UL; i < dims.size(); ++i) {
563+ shape_str += ",";
564+ shape_str += std::to_string(dims[i].get<int64_t>());
565+ }
566+ model_data.model_meta.dynamic_output_shape.push_back(std::move(shape_str));
567+ }
568+ }
569+ }
570+ }
571+ }
572+ }
573+ 
516 (void)json_file.Get("work_size", model_data.model_meta.work_size);574 (void)json_file.Get("work_size", model_data.model_meta.work_size);
517 (void)json_file.Get("zero_copy_size", model_data.model_meta.zero_copy_size);575 (void)json_file.Get("zero_copy_size", model_data.model_meta.zero_copy_size);
518 (void)json_file.Get("name", model_data.model_meta.model_name);576 (void)json_file.Get("name", model_data.model_meta.model_name);
519- (void)json_file.Get("root_graph_name", model_data.model_meta.root_graph_name);
520 577 
521 // 读取 aipp 字段578 // 读取 aipp 字段
522 ge::JsonFile aipp_json;579 ge::JsonFile aipp_json;
@@ -536,10 +593,7 @@ ge::Status DeserializeOpAttrEntry(const ge::RAIIZipArchive &archive, const std::
536 auto buff_data = archive.ExtractToMem(entry, buff_size);593 auto buff_data = archive.ExtractToMem(entry, buff_size);
537 GE_ASSERT_NOTNULL(buff_data, "[OM2] Failed to extract %s", entry.c_str());594 GE_ASSERT_NOTNULL(buff_data, "[OM2] Failed to extract %s", entry.c_str());
538 GE_ASSERT_TRUE(buff_size > 0U);595 GE_ASSERT_TRUE(buff_size > 0U);
539- if (ParseOpAttrMapJson(buff_data.get(), buff_size, model_data.debug_info.op_attr_map) != ge::SUCCESS) {596+ model_data.debug_info.op_attr_json = std::string(reinterpret_cast<const char *>(buff_data.get()), buff_size);
540- GELOGW("[OM2] Failed to parse op_attr.json, using empty map");
541- model_data.debug_info.op_attr_map.clear();
542- }
543 return ge::SUCCESS;597 return ge::SUCCESS;
544}598}
545 599 
@@ -549,10 +603,8 @@ ge::Status HandleArchiveEntry(const ge::RAIIZipArchive &archive, const std::stri
549 GE_ASSERT_SUCCESS(DeserializeCodegenEntry(archive, entry, model_data));603 GE_ASSERT_SUCCESS(DeserializeCodegenEntry(archive, entry, model_data));
550 return ge::SUCCESS;604 return ge::SUCCESS;
551 }605 }
552- if (entry.find("/debug/") != std::string::npos) {606+ if (IsFileNameEndsWith(entry, "op_attr.json")) {
553- if (IsFileNameEndsWith(entry, "op_attr.json")) {607+ GE_ASSERT_SUCCESS(DeserializeOpAttrEntry(archive, entry, model_data));
554- GE_ASSERT_SUCCESS(DeserializeOpAttrEntry(archive, entry, model_data));
555- }
556 return ge::SUCCESS;608 return ge::SUCCESS;
557 }609 }
558 if (IsFileNameEndsWith(entry, "model_meta.json")) {610 if (IsFileNameEndsWith(entry, "model_meta.json")) {
@@ -575,7 +627,7 @@ ge::Status HandleArchiveEntry(const ge::RAIIZipArchive &archive, const std::stri
575 }627 }
576 return ge::SUCCESS;628 return ge::SUCCESS;
577 }629 }
578- if (entry.find("data/kernels_") != std::string::npos && IsFileNameEndsWith(entry, ".o")) {630+ if (entry.find("data/kernels/") != std::string::npos && IsFileNameEndsWith(entry, ".o")) {
579 GE_ASSERT_SUCCESS(DeserializeKernelEntry(archive, entry, model_data));631 GE_ASSERT_SUCCESS(DeserializeKernelEntry(archive, entry, model_data));
580 return ge::SUCCESS;632 return ge::SUCCESS;
581 }633 }
@@ -631,10 +683,24 @@ ge::Status SetTensorDesc(ge::JsonFile::json &tensor_array_json, std::vector<ge::
631 int64_t size;683 int64_t size;
632 GE_ASSERT_TRUE(tensor_obj.Get("size", size));684 GE_ASSERT_TRUE(tensor_obj.Get("size", size));
633 tensor_desc.SetSize(static_cast<size_t>(size));685 tensor_desc.SetSize(static_cast<size_t>(size));
634- std::string shape_key = new_model_desc ? "shape_v2" : "shape";
635 std::vector<int64_t> shape_dims;686 std::vector<int64_t> shape_dims;
636- GE_ASSERT_TRUE(tensor_obj.Get(shape_key, shape_dims));687+ if (new_model_desc) {
637- tensor_desc.SetShape(shape_dims);688+ if (tensor_obj.Get("shape_aclmdlGetInputDimsV2", shape_dims)) {
689+ tensor_desc.SetShape(shape_dims);
690+ } else if (tensor_obj.Get("max_gear_shape", shape_dims)) {
691+ tensor_desc.SetShape(shape_dims);
692+ } else {
693+ GE_ASSERT_TRUE(tensor_obj.Get("shape", shape_dims));
694+ tensor_desc.SetShape(shape_dims);
695+ }
696+ } else {
W
Wwuzheng10 天前

冗余代码

likedislike
697+ if (tensor_obj.Get("max_gear_shape", shape_dims)) {
698+ tensor_desc.SetShape(shape_dims);
699+ } else {
700+ GE_ASSERT_TRUE(tensor_obj.Get("shape", shape_dims));
701+ tensor_desc.SetShape(shape_dims);
702+ }
703+ }
638 std::vector<std::pair<int64_t, int64_t>> shape_range;704 std::vector<std::pair<int64_t, int64_t>> shape_range;
639 GE_ASSERT_TRUE(tensor_obj.Get("shape_range", shape_range));705 GE_ASSERT_TRUE(tensor_obj.Get("shape_range", shape_range));
640 tensor_desc.SetShapeRange(shape_range);706 tensor_desc.SetShapeRange(shape_range);
@@ -840,9 +906,15 @@ class Om2ModelExecutor::Impl {
840 GE_ASSERT_SUCCESS(LoadSoFromBuffer(om2_data.program_body.so_artifact));906 GE_ASSERT_SUCCESS(LoadSoFromBuffer(om2_data.program_body.so_artifact));
841 GE_ASSERT_TRUE(!run_model_info_.so_file.empty(), "[OM2] Om2 compiled so not found in Om2ModelData.");907 GE_ASSERT_TRUE(!run_model_info_.so_file.empty(), "[OM2] Om2 compiled so not found in Om2ModelData.");
842 908 
843- // Set up op_attr_map from debug_info909+ // Set up op_attr_json from debug_info
844- if (!om2_data.debug_info.op_attr_map.empty()) {910+ if (!om2_data.debug_info.op_attr_json.empty()) {
845- run_model_info_.op_attr_map = om2_data.debug_info.op_attr_map;911+ run_model_info_.op_attr_json =
912+ ge::JsonFile(reinterpret_cast<const uint8_t *>(om2_data.debug_info.op_attr_json.data()),
913+ om2_data.debug_info.op_attr_json.size());
914+ if (!run_model_info_.op_attr_json.IsValid()) {
915+ GELOGW("[OM2] op_attr.json is not valid, using empty json content.");
916+ run_model_info_.op_attr_json = ge::JsonFile(ge::JsonFile::json::object());
917+ }
846 }918 }
847 919 
848 if (om2_data.constants_data.weight_data != nullptr) {920 if (om2_data.constants_data.weight_data != nullptr) {
@@ -855,7 +927,7 @@ class Om2ModelExecutor::Impl {
855 private:927 private:
856 ge::Status LoadModelMetaFromStruct(const gert::Om2ModelMeta &meta) {928 ge::Status LoadModelMetaFromStruct(const gert::Om2ModelMeta &meta) {
857 run_model_info_.model_name = meta.model_name;929 run_model_info_.model_name = meta.model_name;
858- run_model_info_.root_graph_name = meta.root_graph_name.empty() ? meta.model_name : meta.root_graph_name;930+ run_model_info_.root_graph_name = meta.model_name;
859 model_meta_info_.work_size = meta.work_size;931 model_meta_info_.work_size = meta.work_size;
860 GE_ASSERT_TRUE(meta.zero_copy_size >= 0, "[OM2][Check] Invalid zero_copy_size=%ld.", meta.zero_copy_size);932 GE_ASSERT_TRUE(meta.zero_copy_size >= 0, "[OM2][Check] Invalid zero_copy_size=%ld.", meta.zero_copy_size);
861 const auto zero_copy_size = static_cast<size_t>(meta.zero_copy_size);933 const auto zero_copy_size = static_cast<size_t>(meta.zero_copy_size);
@@ -1209,11 +1281,11 @@ class Om2ModelExecutor::Impl {
1209 GE_ASSERT_TRUE(has_model_);1281 GE_ASSERT_TRUE(has_model_);
1210 op_attr_map.clear();1282 op_attr_map.clear();
1211 1283 
1212- if (run_model_info_.op_attr_map.empty()) {1284+ if (!run_model_info_.op_attr_json.IsValid()) {
1213- return ge::SUCCESS; // Empty map1285+ return ge::SUCCESS;
W
Wwuzheng10 天前

json文件不对，应该报错

likedislike
1214 }1286 }
1215 1287 
1216- op_attr_map = run_model_info_.op_attr_map;1288+ ParseOpAttrJsonToMapInternal(run_model_info_.op_attr_json, op_attr_map);
1217 return ge::SUCCESS;1289 return ge::SUCCESS;
1218 }1290 }
1219 1291 
Mtests/acl_ut/ut/acl/testcase/acl_model_unittest.cpp+20-0
@@ -17,6 +17,7 @@
17#define private public17#define private public
18#include "model/acl_resource_manager.h"18#include "model/acl_resource_manager.h"
19#include "model/acl_resource_manager_om2.h"19#include "model/acl_resource_manager_om2.h"
20+#include "model/acl_model_impl_om2.h"
20#undef private21#undef private
21#include "model/aipp_param_check.h"22#include "model/aipp_param_check.h"
22#include "framework/executor/ge_executor.h"23#include "framework/executor/ge_executor.h"
@@ -5148,6 +5149,25 @@ TEST_F(UTEST_ACL_Model, aclmdlGetOpAttr_NotInOpAttrValueMap_ReturnsNull) {
5148 aclmdlDestroyDesc(desc);5149 aclmdlDestroyDesc(desc);
5149}5150}
5150 5151 
5152+TEST_F(UTEST_ACL_Model, aclmdlGetOpAttrImplOm2_NotInOpAttrValueMap_ReturnsEmptyString) {
5153+ aclmdlDesc *desc = aclmdlCreateDesc();
5154+ EXPECT_NE(desc, nullptr);
5155+ 
5156+ const char *opName = "test_op";
5157+ const char *attr = "_datadump_original_op_names";
5158+ 
5159+ const char *result = aclmdlGetOpAttrImplOm2(desc, opName, attr);
5160+ EXPECT_NE(result, nullptr);
5161+ EXPECT_EQ(std::string(result), "");
5162+ 
5163+ desc->opAttrValueMap[opName]["other_attr"] = "some_value";
5164+ result = aclmdlGetOpAttrImplOm2(desc, opName, attr);
5165+ EXPECT_NE(result, nullptr);
5166+ EXPECT_EQ(std::string(result), "");
5167+ 
5168+ aclmdlDestroyDesc(desc);
5169+}
5170+ 
5151TEST_F(UTEST_ACL_Model, aclmdlGetDescFromFile_Om2Model_PopulatesDescAndMap) {5171TEST_F(UTEST_ACL_Model, aclmdlGetDescFromFile_Om2Model_PopulatesDescAndMap) {
5152 // Test that aclmdlGetDescFromFile detects OM2 and populates desc via lightweight GetOm2ModelMetadata5172 // Test that aclmdlGetDescFromFile detects OM2 and populates desc via lightweight GetOm2ModelMetadata
5153 aclmdlDesc *desc = aclmdlCreateDesc();5173 aclmdlDesc *desc = aclmdlCreateDesc();
Mtests/ge/st/testcase/test_om2.cc+196-78
@@ -764,20 +764,17 @@ std::string MakeFakeOm2ManifestJson() {
764 return R"({764 return R"({
765 "atc_command": "",765 "atc_command": "",
766 "model_num": 1,766 "model_num": 1,
767- "om2_version": "0"767+ "om2_version": "1.0"
768})";768})";
769}769}
770 770 
771std::string MakeFakeOm2ModelMetaJson() {771std::string MakeFakeOm2ModelMetaJson() {
772 return R"({772 return R"({
773- "dynamic_batch_info": [],
774- "dynamic_output_shape": [],
775- "dynamic_type": 0,
776 "inputs": [773 "inputs": [
777 {"data_type": "DT_FLOAT", "format": "NCHW", "index": 0, "name": "data1",774 {"data_type": "DT_FLOAT", "format": "NCHW", "index": 0, "name": "data1",
778- "shape": [1, 1, 224, 224], "shape_range": [], "shape_v2": [1, 1, 224, 224], "size": 0},775+ "shape": [1, 1, 224, 224], "shape_range": [], "size": 0},
779 {"data_type": "DT_FLOAT", "format": "NCHW", "index": 1, "name": "data2",776 {"data_type": "DT_FLOAT", "format": "NCHW", "index": 1, "name": "data2",
780- "shape": [1, 1, 224, 224], "shape_range": [], "shape_v2": [1, 1, 224, 224], "size": 0}777+ "shape": [1, 1, 224, 224], "shape_range": [], "size": 0}
781 ],778 ],
782 "name": "g1",779 "name": "g1",
783 "outputs": [780 "outputs": [
@@ -785,8 +782,7 @@ std::string MakeFakeOm2ModelMetaJson() {
785 "shape": [1, 1, 224, 224], "shape_range": [], "size": 0}782 "shape": [1, 1, 224, 224], "shape_range": [], "size": 0}
786 ],783 ],
787 "work_size": 2048,784 "work_size": 2048,
788- "zero_copy_size": 0,785+ "zero_copy_size": 0
789- "user_designate_shape_order": []
790})";786})";
791}787}
792 788 
@@ -797,10 +793,9 @@ std::string MakeFakeOm2ConstantsConfigJson() {
797 "const_0": {793 "const_0": {
798 "index": 0,794 "index": 0,
799 "type": "INTERNAL",795 "type": "INTERNAL",
800- "file_name": "",796+ "file_name": "constant_0",
801 "offset": 0,797 "offset": 0,
802- "size": 16,798+ "size": 16
803- "op_name": "const_0"
804 }799 }
805 }800 }
806})";801})";
@@ -996,7 +991,7 @@ void CreateFakeOm2File(const std::string &work_dir, const std::string &output_fi
996 const auto op_attr = MakeFakeOm2OpAttrJson();991 const auto op_attr = MakeFakeOm2OpAttrJson();
997 ASSERT_TRUE(zip_writer.WriteBytes("manifest.json", manifest.data(), manifest.size(), false));992 ASSERT_TRUE(zip_writer.WriteBytes("manifest.json", manifest.data(), manifest.size(), false));
998 ASSERT_TRUE(zip_writer.WriteBytes("data/model_0/model_meta.json", model_meta.data(), model_meta.size(), false));993 ASSERT_TRUE(zip_writer.WriteBytes("data/model_0/model_meta.json", model_meta.data(), model_meta.size(), false));
999- ASSERT_TRUE(zip_writer.WriteBytes("data/model_0/debug/op_attr.json", op_attr.data(), op_attr.size(), false));994+ ASSERT_TRUE(zip_writer.WriteBytes("data/model_0/op_attr.json", op_attr.data(), op_attr.size(), false));
1000 ASSERT_TRUE(zip_writer.WriteFile("data/model_0/runtime/libg1_om2.so", so_path, false));995 ASSERT_TRUE(zip_writer.WriteFile("data/model_0/runtime/libg1_om2.so", so_path, false));
1001 ASSERT_TRUE(zip_writer.WriteFile("data/constants/constant_0", constant_path, false));996 ASSERT_TRUE(zip_writer.WriteFile("data/constants/constant_0", constant_path, false));
1002 ASSERT_TRUE(zip_writer.WriteFile("data/constants/model_0_constants_config.json", constants_config_path, false));997 ASSERT_TRUE(zip_writer.WriteFile("data/constants/model_0_constants_config.json", constants_config_path, false));
@@ -1018,7 +1013,7 @@ std::string BuildValidOm2ProtoTxt() {
1018void CreateMinimalOm2File(const std::string &path, const std::string &proto_content) {1013void CreateMinimalOm2File(const std::string &path, const std::string &proto_content) {
1019 ZipArchiveWriter writer(path);1014 ZipArchiveWriter writer(path);
1020 ASSERT_TRUE(writer.IsMemFileOpened());1015 ASSERT_TRUE(writer.IsMemFileOpened());
1021- const std::string manifest = R"({"om2_version":"0","model_num":1})";1016+ const std::string manifest = R"({"om2_version":"1.0","model_num":1})";
1022 ASSERT_TRUE(writer.WriteBytes("manifest.json", manifest.data(), manifest.size(), false));1017 ASSERT_TRUE(writer.WriteBytes("manifest.json", manifest.data(), manifest.size(), false));
1023 ASSERT_TRUE(writer.WriteBytes("data/model_0/debug/ge_proto_00000000_graph_1_test.txt", proto_content.data(),1018 ASSERT_TRUE(writer.WriteBytes("data/model_0/debug/ge_proto_00000000_graph_1_test.txt", proto_content.data(),
1024 proto_content.size(), true));1019 proto_content.size(), true));
@@ -1029,7 +1024,7 @@ void CreateMinimalOm2File(const std::string &path, const std::string &proto_cont
1029void CreateMinimalOm2FileWithoutProto(const std::string &path) {1024void CreateMinimalOm2FileWithoutProto(const std::string &path) {
1030 ZipArchiveWriter writer(path);1025 ZipArchiveWriter writer(path);
1031 ASSERT_TRUE(writer.IsMemFileOpened());1026 ASSERT_TRUE(writer.IsMemFileOpened());
1032- const std::string manifest = R"({"om2_version":"0","model_num":1})";1027+ const std::string manifest = R"({"om2_version":"1.0","model_num":1})";
1033 ASSERT_TRUE(writer.WriteBytes("manifest.json", manifest.data(), manifest.size(), false));1028 ASSERT_TRUE(writer.WriteBytes("manifest.json", manifest.data(), manifest.size(), false));
1034 ASSERT_TRUE(writer.SaveModelDataToFile());1029 ASSERT_TRUE(writer.SaveModelDataToFile());
1035 ASSERT_EQ(mmAccess2(path.c_str(), M_F_OK), EOK);1030 ASSERT_EQ(mmAccess2(path.c_str(), M_F_OK), EOK);
@@ -1586,12 +1581,18 @@ TEST_F(Om2St, ConvertOm2Model_Ok_GenOm2WithAicoreNode) {
1586 RAIIZipArchive archive(reinterpret_cast<const uint8_t *>(model_buf.get()), model_buf_size);1581 RAIIZipArchive archive(reinterpret_cast<const uint8_t *>(model_buf.get()), model_buf_size);
1587 ASSERT_TRUE(archive.IsGood());1582 ASSERT_TRUE(archive.IsGood());
1588 const std::set<std::string> expect_files = {1583 const std::set<std::string> expect_files = {
1589- "fake_test/data/model_0/runtime/g1_kernel_reg.cpp", "fake_test/data/model_0/runtime/g1_resources.cpp",1584+ "fake_test/data/model_0/runtime/g1_kernel_reg.cpp",
1590- "fake_test/data/model_0/runtime/g1_args_manager.cpp", "fake_test/data/model_0/runtime/g1_load_and_run.cpp",1585+ "fake_test/data/model_0/runtime/g1_resources.cpp",
1591- "fake_test/data/model_0/runtime/g1_interface.h", "fake_test/data/model_0/runtime/Makefile",1586+ "fake_test/data/model_0/runtime/g1_args_manager.cpp",
1592- "fake_test/data/model_0/runtime/libg1_om2.so", "fake_test/data/constants/model_0_constants_config.json",1587+ "fake_test/data/model_0/runtime/g1_load_and_run.cpp",
1593- "fake_test/data/kernels_npu_arch/add1_faked_kernel.o", "fake_test/data/model_0/model_meta.json",1588+ "fake_test/data/model_0/runtime/g1_interface.h",
1594- "fake_test/data/model_0/debug/op_attr.json", "fake_test/manifest.json",1589+ "fake_test/data/model_0/runtime/Makefile",
1590+ "fake_test/data/model_0/runtime/libg1_om2.so",
1591+ "fake_test/data/constants/model_0_constants_config.json",
1592+ "fake_test/data/kernels/add1_faked_kernel.o",
1593+ "fake_test/data/model_0/model_meta.json",
1594+ "fake_test/data/model_0/op_attr.json",
1595+ "fake_test/manifest.json",
1595 };1596 };
1596 ExpectOm2ArchiveFiles(archive, expect_files);1597 ExpectOm2ArchiveFiles(archive, expect_files);
1597 ExpectGeneratedMakefileSupportsEnvCompiler(archive, kZipFileBaseName);1598 ExpectGeneratedMakefileSupportsEnvCompiler(archive, kZipFileBaseName);
@@ -1807,7 +1808,7 @@ TEST_F(Om2St, Om2PackageHelper_Ok_ExtractVisualJsonFromMinimalOm2) {
1807 {1808 {
1808 ZipArchiveWriter writer(output_file);1809 ZipArchiveWriter writer(output_file);
1809 ASSERT_TRUE(writer.IsMemFileOpened());1810 ASSERT_TRUE(writer.IsMemFileOpened());
1810- const std::string manifest = R"({"om2_version":"0","model_num":1})";1811+ const std::string manifest = R"({"om2_version":"1.0","model_num":1})";
1811 ASSERT_TRUE(writer.WriteBytes("manifest.json", manifest.data(), manifest.size(), false));1812 ASSERT_TRUE(writer.WriteBytes("manifest.json", manifest.data(), manifest.size(), false));
1812 ASSERT_TRUE(writer.WriteBytes("data/model_0/debug/ge_visual_00000000_graph_0.json", visual_json.data(),1813 ASSERT_TRUE(writer.WriteBytes("data/model_0/debug/ge_visual_00000000_graph_0.json", visual_json.data(),
1813 visual_json.size(), true));1814 visual_json.size(), true));
@@ -1839,7 +1840,7 @@ TEST_F(Om2St, Om2PackageHelper_Fail_ExtractVisualJsonWithoutVisualJson) {
1839 {1840 {
1840 ZipArchiveWriter writer(output_file);1841 ZipArchiveWriter writer(output_file);
1841 ASSERT_TRUE(writer.IsMemFileOpened());1842 ASSERT_TRUE(writer.IsMemFileOpened());
1842- const std::string manifest = R"({"om2_version":"0","model_num":1})";1843+ const std::string manifest = R"({"om2_version":"1.0","model_num":1})";
1843 ASSERT_TRUE(writer.WriteBytes("manifest.json", manifest.data(), manifest.size(), false));1844 ASSERT_TRUE(writer.WriteBytes("manifest.json", manifest.data(), manifest.size(), false));
1844 ASSERT_TRUE(writer.SaveModelData(model, false));1845 ASSERT_TRUE(writer.SaveModelData(model, false));
1845 }1846 }
@@ -1904,7 +1905,7 @@ TEST_F(Om2St, ConvertOm2Model_Ok_ConvertMinimalVisualOm2ToJson) {
1904 {1905 {
1905 ZipArchiveWriter writer(output_file);1906 ZipArchiveWriter writer(output_file);
1906 ASSERT_TRUE(writer.IsMemFileOpened());1907 ASSERT_TRUE(writer.IsMemFileOpened());
1907- const std::string manifest = R"({"om2_version":"0","model_num":1})";1908+ const std::string manifest = R"({"om2_version":"1.0","model_num":1})";
1908 ASSERT_TRUE(writer.WriteBytes("manifest.json", manifest.data(), manifest.size(), false));1909 ASSERT_TRUE(writer.WriteBytes("manifest.json", manifest.data(), manifest.size(), false));
1909 ASSERT_TRUE(writer.WriteBytes("data/model_0/debug/ge_visual_00000000_graph_0.json", visual_json.data(),1910 ASSERT_TRUE(writer.WriteBytes("data/model_0/debug/ge_visual_00000000_graph_0.json", visual_json.data(),
1910 visual_json.size(), true));1911 visual_json.size(), true));
@@ -1928,7 +1929,7 @@ TEST_F(Om2St, ConvertOm2Model_Ok_ConvertVisualOm2AddsGroupOpName) {
1928 {1929 {
1929 ZipArchiveWriter writer(output_file);1930 ZipArchiveWriter writer(output_file);
1930 ASSERT_TRUE(writer.IsMemFileOpened());1931 ASSERT_TRUE(writer.IsMemFileOpened());
1931- const std::string manifest = R"({"om2_version":"0","model_num":1})";1932+ const std::string manifest = R"({"om2_version":"1.0","model_num":1})";
1932 ASSERT_TRUE(writer.WriteBytes("manifest.json", manifest.data(), manifest.size(), false));1933 ASSERT_TRUE(writer.WriteBytes("manifest.json", manifest.data(), manifest.size(), false));
1933 ASSERT_TRUE(writer.WriteBytes("data/model_0/debug/ge_visual_00000000_graph_0.json", visual_json.data(),1934 ASSERT_TRUE(writer.WriteBytes("data/model_0/debug/ge_visual_00000000_graph_0.json", visual_json.data(),
1934 visual_json.size(), true));1935 visual_json.size(), true));
@@ -1959,7 +1960,7 @@ TEST_F(Om2St, ConvertOm2Model_Ok_ConvertLooseVisualOm2ToJson) {
1959 {1960 {
1960 ZipArchiveWriter writer(output_file);1961 ZipArchiveWriter writer(output_file);
1961 ASSERT_TRUE(writer.IsMemFileOpened());1962 ASSERT_TRUE(writer.IsMemFileOpened());
1962- const std::string manifest = R"({"om2_version":"0","model_num":1})";1963+ const std::string manifest = R"({"om2_version":"1.0","model_num":1})";
1963 ASSERT_TRUE(writer.WriteBytes("manifest.json", manifest.data(), manifest.size(), false));1964 ASSERT_TRUE(writer.WriteBytes("manifest.json", manifest.data(), manifest.size(), false));
1964 ASSERT_TRUE(writer.WriteBytes("data/model_0/debug/ge_visual_00000000_graph_0.json", visual_json.data(),1965 ASSERT_TRUE(writer.WriteBytes("data/model_0/debug/ge_visual_00000000_graph_0.json", visual_json.data(),
1965 visual_json.size(), true));1966 visual_json.size(), true));
@@ -2022,10 +2023,10 @@ TEST_F(Om2St, ConvertOm2Model_Ok_GenOm2WithAtomicAicoreNode) {
2022 "fake_test_atomic/data/model_0/runtime/Makefile",2023 "fake_test_atomic/data/model_0/runtime/Makefile",
2023 "fake_test_atomic/data/model_0/runtime/libg1_om2.so",2024 "fake_test_atomic/data/model_0/runtime/libg1_om2.so",
2024 "fake_test_atomic/data/constants/model_0_constants_config.json",2025 "fake_test_atomic/data/constants/model_0_constants_config.json",
2025- "fake_test_atomic/data/kernels_npu_arch/add1_faked_kernel.o",2026+ "fake_test_atomic/data/kernels/add1_faked_kernel.o",
2026- "fake_test_atomic/data/kernels_npu_arch/add1_faked_atomic_kernel.o",2027+ "fake_test_atomic/data/kernels/add1_faked_atomic_kernel.o",
2027 "fake_test_atomic/data/model_0/model_meta.json",2028 "fake_test_atomic/data/model_0/model_meta.json",
2028- "fake_test_atomic/data/model_0/debug/op_attr.json",2029+ "fake_test_atomic/data/model_0/op_attr.json",
2029 "fake_test_atomic/manifest.json",2030 "fake_test_atomic/manifest.json",
2030 };2031 };
2031 ExpectOm2ArchiveFiles(archive, expect_files);2032 ExpectOm2ArchiveFiles(archive, expect_files);
@@ -2062,9 +2063,9 @@ TEST_F(Om2St, ConvertOm2Model_Ok_GenOm2WithInternalConst) {
2062 "fake_test/data/model_0/runtime/libg1_om2.so",2063 "fake_test/data/model_0/runtime/libg1_om2.so",
2063 "fake_test/data/constants/constant_0",2064 "fake_test/data/constants/constant_0",
2064 "fake_test/data/constants/model_0_constants_config.json",2065 "fake_test/data/constants/model_0_constants_config.json",
2065- "fake_test/data/kernels_npu_arch/add1_faked_kernel.o",2066+ "fake_test/data/kernels/add1_faked_kernel.o",
2066 "fake_test/data/model_0/model_meta.json",2067 "fake_test/data/model_0/model_meta.json",
2067- "fake_test/data/model_0/debug/op_attr.json",2068+ "fake_test/data/model_0/op_attr.json",
2068 "fake_test/manifest.json",2069 "fake_test/manifest.json",
2069 };2070 };
2070 ExpectOm2ArchiveFiles(archive, expect_files);2071 ExpectOm2ArchiveFiles(archive, expect_files);
@@ -2108,9 +2109,9 @@ TEST_F(Om2St, ConvertOm2Model_Ok_GenOm2WithFileConstMeta) {
2108 "fake_test/data/model_0/runtime/libg1_om2.so",2109 "fake_test/data/model_0/runtime/libg1_om2.so",
2109 "fake_test/data/constants/constant_0",2110 "fake_test/data/constants/constant_0",
2110 "fake_test/data/constants/model_0_constants_config.json",2111 "fake_test/data/constants/model_0_constants_config.json",
2111- "fake_test/data/kernels_npu_arch/add1_faked_kernel.o",2112+ "fake_test/data/kernels/add1_faked_kernel.o",
2112 "fake_test/data/model_0/model_meta.json",2113 "fake_test/data/model_0/model_meta.json",
2113- "fake_test/data/model_0/debug/op_attr.json",2114+ "fake_test/data/model_0/op_attr.json",
2114 "fake_test/manifest.json",2115 "fake_test/manifest.json",
2115 };2116 };
2116 ExpectOm2ArchiveFiles(archive, expect_files);2117 ExpectOm2ArchiveFiles(archive, expect_files);
@@ -2175,8 +2176,7 @@ JsonFile::json BuildRelocateExternalWeightConsts(const std::string &old_weight_p
2175 .Set("file_name", "")2176 .Set("file_name", "")
2176 .Set("file_path", old_weight_path)2177 .Set("file_path", old_weight_path)
2177 .Set("offset", 0)2178 .Set("offset", 0)
2178- .Set("size", 5)2179+ .Set("size", 5);
2179- .Set("op_name", "file_const");
2180 consts["file_const"] = file_const.Raw();2180 consts["file_const"] = file_const.Raw();
2181 return consts;2181 return consts;
2182}2182}
@@ -2262,12 +2262,18 @@ TEST_F(Om2St, ConvertOm2Model_Ok_GenOm2WithAicoreOp2) {
2262 ASSERT_TRUE(archive.IsGood());2262 ASSERT_TRUE(archive.IsGood());
2263 const auto file_names = archive.ListFiles();2263 const auto file_names = archive.ListFiles();
2264 const std::set<std::string> expect_files = {2264 const std::set<std::string> expect_files = {
2265- "fake_test/data/model_0/runtime/g1_kernel_reg.cpp", "fake_test/data/model_0/runtime/g1_resources.cpp",2265+ "fake_test/data/model_0/runtime/g1_kernel_reg.cpp",
2266- "fake_test/data/model_0/runtime/g1_args_manager.cpp", "fake_test/data/model_0/runtime/g1_load_and_run.cpp",2266+ "fake_test/data/model_0/runtime/g1_resources.cpp",
2267- "fake_test/data/model_0/runtime/g1_interface.h", "fake_test/data/model_0/runtime/Makefile",2267+ "fake_test/data/model_0/runtime/g1_args_manager.cpp",
2268- "fake_test/data/model_0/runtime/libg1_om2.so", "fake_test/data/constants/model_0_constants_config.json",2268+ "fake_test/data/model_0/runtime/g1_load_and_run.cpp",
2269- "fake_test/data/kernels_npu_arch/add1_faked_kernel.o", "fake_test/data/model_0/model_meta.json",2269+ "fake_test/data/model_0/runtime/g1_interface.h",
2270- "fake_test/data/model_0/debug/op_attr.json", "fake_test/manifest.json",2270+ "fake_test/data/model_0/runtime/Makefile",
2271+ "fake_test/data/model_0/runtime/libg1_om2.so",
2272+ "fake_test/data/constants/model_0_constants_config.json",
2273+ "fake_test/data/kernels/add1_faked_kernel.o",
2274+ "fake_test/data/model_0/model_meta.json",
2275+ "fake_test/data/model_0/op_attr.json",
2276+ "fake_test/manifest.json",
2271 };2277 };
2272 ExpectOm2ArchiveFiles(archive, expect_files);2278 ExpectOm2ArchiveFiles(archive, expect_files);
2273}2279}
@@ -2288,12 +2294,18 @@ TEST_F(Om2St, ConvertOm2Model_Ok_GenOm2WithAicoreOpOfDynamicIo) {
2288 ASSERT_TRUE(archive.IsGood());2294 ASSERT_TRUE(archive.IsGood());
2289 const auto file_names = archive.ListFiles();2295 const auto file_names = archive.ListFiles();
2290 const std::set<std::string> expect_files = {2296 const std::set<std::string> expect_files = {
2291- "fake_test/data/model_0/runtime/g1_kernel_reg.cpp", "fake_test/data/model_0/runtime/g1_resources.cpp",2297+ "fake_test/data/model_0/runtime/g1_kernel_reg.cpp",
2292- "fake_test/data/model_0/runtime/g1_args_manager.cpp", "fake_test/data/model_0/runtime/g1_load_and_run.cpp",2298+ "fake_test/data/model_0/runtime/g1_resources.cpp",
2293- "fake_test/data/model_0/runtime/g1_interface.h", "fake_test/data/model_0/runtime/Makefile",2299+ "fake_test/data/model_0/runtime/g1_args_manager.cpp",
2294- "fake_test/data/model_0/runtime/libg1_om2.so", "fake_test/data/constants/model_0_constants_config.json",2300+ "fake_test/data/model_0/runtime/g1_load_and_run.cpp",
2295- "fake_test/data/kernels_npu_arch/add1_faked_kernel.o", "fake_test/data/model_0/model_meta.json",2301+ "fake_test/data/model_0/runtime/g1_interface.h",
2296- "fake_test/data/model_0/debug/op_attr.json", "fake_test/manifest.json",2302+ "fake_test/data/model_0/runtime/Makefile",
2303+ "fake_test/data/model_0/runtime/libg1_om2.so",
2304+ "fake_test/data/constants/model_0_constants_config.json",
2305+ "fake_test/data/kernels/add1_faked_kernel.o",
2306+ "fake_test/data/model_0/model_meta.json",
2307+ "fake_test/data/model_0/op_attr.json",
2308+ "fake_test/manifest.json",
2297 };2309 };
2298 ExpectOm2ArchiveFiles(archive, expect_files);2310 ExpectOm2ArchiveFiles(archive, expect_files);
2299}2311}
@@ -2323,7 +2335,7 @@ TEST_F(Om2St, ConvertOm2Model_Ok_GenOm2WithAicpuOp) {
2323 "fake_test/data/model_0/runtime/libg1_om2.so",2335 "fake_test/data/model_0/runtime/libg1_om2.so",
2324 "fake_test/data/constants/model_0_constants_config.json",2336 "fake_test/data/constants/model_0_constants_config.json",
2325 "fake_test/data/model_0/model_meta.json",2337 "fake_test/data/model_0/model_meta.json",
2326- "fake_test/data/model_0/debug/op_attr.json",2338+ "fake_test/data/model_0/op_attr.json",
2327 "fake_test/manifest.json",2339 "fake_test/manifest.json",
2328 };2340 };
2329 ExpectOm2ArchiveFiles(archive, expect_files);2341 ExpectOm2ArchiveFiles(archive, expect_files);
@@ -2354,7 +2366,7 @@ TEST_F(Om2St, ConvertOm2Model_Ok_GenOm2WithCustAicpuOp) {
2354 "fake_test/data/model_0/runtime/libg1_om2.so",2366 "fake_test/data/model_0/runtime/libg1_om2.so",
2355 "fake_test/data/constants/model_0_constants_config.json",2367 "fake_test/data/constants/model_0_constants_config.json",
2356 "fake_test/data/model_0/model_meta.json",2368 "fake_test/data/model_0/model_meta.json",
2357- "fake_test/data/model_0/debug/op_attr.json",2369+ "fake_test/data/model_0/op_attr.json",
2358 "fake_test/manifest.json",2370 "fake_test/manifest.json",
2359 };2371 };
2360 int visual_json_count = 0;2372 int visual_json_count = 0;
@@ -2369,7 +2381,7 @@ TEST_F(Om2St, ConvertOm2Model_Ok_GenOm2WithCustAicpuOp) {
2369 ++visual_json_count;2381 ++visual_json_count;
2370 continue;2382 continue;
2371 }2383 }
2372- if ((file_name.find("fake_test/data/kernels_npu_arch/") != std::string::npos) &&2384+ if ((file_name.find("fake_test/data/kernels/") != std::string::npos) &&
2373 (file_name.find("_CustAicpuKernel.o") != std::string::npos)) {2385 (file_name.find("_CustAicpuKernel.o") != std::string::npos)) {
2374 found_cust_kernel = true;2386 found_cust_kernel = true;
2375 continue;2387 continue;
@@ -2405,7 +2417,7 @@ TEST_F(Om2St, ConvertOm2Model_Ok_GenOm2WithTfAicpuOp) {
2405 "fake_test/data/model_0/runtime/libg1_om2.so",2417 "fake_test/data/model_0/runtime/libg1_om2.so",
2406 "fake_test/data/constants/model_0_constants_config.json",2418 "fake_test/data/constants/model_0_constants_config.json",
2407 "fake_test/data/model_0/model_meta.json",2419 "fake_test/data/model_0/model_meta.json",
2408- "fake_test/data/model_0/debug/op_attr.json",2420+ "fake_test/data/model_0/op_attr.json",
2409 "fake_test/manifest.json",2421 "fake_test/manifest.json",
2410 };2422 };
2411 ExpectOm2ArchiveFiles(archive, expect_files);2423 ExpectOm2ArchiveFiles(archive, expect_files);
@@ -2544,12 +2556,18 @@ TEST_F(Om2St, ConvertOm2Model_Ok_GenOm2WithCmoTask) {
2544 RAIIZipArchive archive(reinterpret_cast<const uint8_t *>(model_buf.get()), model_buf_size);2556 RAIIZipArchive archive(reinterpret_cast<const uint8_t *>(model_buf.get()), model_buf_size);
2545 ASSERT_TRUE(archive.IsGood());2557 ASSERT_TRUE(archive.IsGood());
2546 const std::set<std::string> expect_files = {2558 const std::set<std::string> expect_files = {
2547- "fake_test/data/model_0/runtime/g1_kernel_reg.cpp", "fake_test/data/model_0/runtime/g1_resources.cpp",2559+ "fake_test/data/model_0/runtime/g1_kernel_reg.cpp",
2548- "fake_test/data/model_0/runtime/g1_args_manager.cpp", "fake_test/data/model_0/runtime/g1_load_and_run.cpp",2560+ "fake_test/data/model_0/runtime/g1_resources.cpp",
2549- "fake_test/data/model_0/runtime/g1_interface.h", "fake_test/data/model_0/runtime/Makefile",2561+ "fake_test/data/model_0/runtime/g1_args_manager.cpp",
2550- "fake_test/data/model_0/runtime/libg1_om2.so", "fake_test/data/constants/model_0_constants_config.json",2562+ "fake_test/data/model_0/runtime/g1_load_and_run.cpp",
2551- "fake_test/data/kernels_npu_arch/add1_faked_kernel.o", "fake_test/data/model_0/model_meta.json",2563+ "fake_test/data/model_0/runtime/g1_interface.h",
2552- "fake_test/data/model_0/debug/op_attr.json", "fake_test/manifest.json",2564+ "fake_test/data/model_0/runtime/Makefile",
2565+ "fake_test/data/model_0/runtime/libg1_om2.so",
2566+ "fake_test/data/constants/model_0_constants_config.json",
2567+ "fake_test/data/kernels/add1_faked_kernel.o",
2568+ "fake_test/data/model_0/model_meta.json",
2569+ "fake_test/data/model_0/op_attr.json",
2570+ "fake_test/manifest.json",
2553 };2571 };
2554 ExpectOm2ArchiveFiles(archive, expect_files);2572 ExpectOm2ArchiveFiles(archive, expect_files);
2555 GELOGI("Om2St: CMO task packaging succeeded.");2573 GELOGI("Om2St: CMO task packaging succeeded.");
@@ -2570,12 +2588,18 @@ TEST_F(Om2St, ConvertOm2Model_Ok_GenOm2WithBarrierTask) {
2570 RAIIZipArchive archive(reinterpret_cast<const uint8_t *>(model_buf.get()), model_buf_size);2588 RAIIZipArchive archive(reinterpret_cast<const uint8_t *>(model_buf.get()), model_buf_size);
2571 ASSERT_TRUE(archive.IsGood());2589 ASSERT_TRUE(archive.IsGood());
2572 const std::set<std::string> expect_files = {2590 const std::set<std::string> expect_files = {
2573- "fake_test/data/model_0/runtime/g1_kernel_reg.cpp", "fake_test/data/model_0/runtime/g1_resources.cpp",2591+ "fake_test/data/model_0/runtime/g1_kernel_reg.cpp",
2574- "fake_test/data/model_0/runtime/g1_args_manager.cpp", "fake_test/data/model_0/runtime/g1_load_and_run.cpp",2592+ "fake_test/data/model_0/runtime/g1_resources.cpp",
2575- "fake_test/data/model_0/runtime/g1_interface.h", "fake_test/data/model_0/runtime/Makefile",2593+ "fake_test/data/model_0/runtime/g1_args_manager.cpp",
2576- "fake_test/data/model_0/runtime/libg1_om2.so", "fake_test/data/constants/model_0_constants_config.json",2594+ "fake_test/data/model_0/runtime/g1_load_and_run.cpp",
2577- "fake_test/data/kernels_npu_arch/add1_faked_kernel.o", "fake_test/data/model_0/model_meta.json",2595+ "fake_test/data/model_0/runtime/g1_interface.h",
2578- "fake_test/data/model_0/debug/op_attr.json", "fake_test/manifest.json",2596+ "fake_test/data/model_0/runtime/Makefile",
2597+ "fake_test/data/model_0/runtime/libg1_om2.so",
2598+ "fake_test/data/constants/model_0_constants_config.json",
2599+ "fake_test/data/kernels/add1_faked_kernel.o",
2600+ "fake_test/data/model_0/model_meta.json",
2601+ "fake_test/data/model_0/op_attr.json",
2602+ "fake_test/manifest.json",
2579 };2603 };
2580 ExpectOm2ArchiveFiles(archive, expect_files);2604 ExpectOm2ArchiveFiles(archive, expect_files);
2581 GELOGI("Om2St: Barrier task packaging succeeded.");2605 GELOGI("Om2St: Barrier task packaging succeeded.");
@@ -2600,6 +2624,21 @@ TEST_F(Om2St, SaveModelInfo_WithMbatchOriginInputDims_SerializesOriginDims) {
2600 }2624 }
2601 }2625 }
2602 2626 
2627+ // Add a CASE node to populate dynamic_batch_info so that max_gear_shape is serialized
2628+ auto case_desc = std::make_shared<OpDesc>("case1", CASE);
2629+ GeTensorDesc case_input_desc(GeShape({1}), FORMAT_ND, DT_INT32);
2630+ (void)case_desc->AddInputDesc(case_input_desc);
2631+ AttrUtils::SetInt(case_desc, ATTR_NAME_BATCH_NUM, 2U);
2632+ AttrUtils::SetInt(case_desc, ATTR_DYNAMIC_TYPE, static_cast<int32_t>(DYNAMIC_BATCH));
2633+ std::vector<int64_t> batch_shape_0 = {1, 1, 224, 224};
2634+ std::vector<int64_t> batch_shape_1 = {2, 1, 224, 224};
2635+ AttrUtils::SetListInt(case_desc, ATTR_NAME_PRED_VALUE + "_0", batch_shape_0);
2636+ AttrUtils::SetListInt(case_desc, ATTR_NAME_PRED_VALUE + "_1", batch_shape_1);
2637+ std::vector<std::string> shape_order = {"data1", "data2"};
2638+ AttrUtils::SetListStr(case_desc, ATTR_USER_DESIGNEATE_SHAPE_ORDER, shape_order);
2639+ auto case_node = compute_graph->AddNode(case_desc);
2640+ ASSERT_NE(case_node, nullptr);
2641+ 
2603 ModelBufferData model_data;2642 ModelBufferData model_data;
2604 const std::string output_file = PathUtils::Join({test_work_dir, "test_origin_dims.om2"});2643 const std::string output_file = PathUtils::Join({test_work_dir, "test_origin_dims.om2"});
2605 SyncKernelNameForAllModels(ge_root_model);2644 SyncKernelNameForAllModels(ge_root_model);
@@ -2618,14 +2657,15 @@ TEST_F(Om2St, SaveModelInfo_WithMbatchOriginInputDims_SerializesOriginDims) {
2618 const auto &inputs = model_meta_json.Raw().at("inputs");2657 const auto &inputs = model_meta_json.Raw().at("inputs");
2619 ASSERT_GE(inputs.size(), 1U);2658 ASSERT_GE(inputs.size(), 1U);
2620 for (const auto &input : inputs) {2659 for (const auto &input : inputs) {
2621- ASSERT_TRUE(input.contains("origin_input_dims"));2660+ ASSERT_TRUE(input.contains("shape"));
2622- const auto &origin_dims = input.at("origin_input_dims");2661+ ASSERT_TRUE(input.contains("max_gear_shape"));
2623 const auto &shape = input.at("shape");2662 const auto &shape = input.at("shape");
2624- ASSERT_TRUE(origin_dims.is_array());2663+ const auto &max_gear_shape = input.at("max_gear_shape");
2625 ASSERT_TRUE(shape.is_array());2664 ASSERT_TRUE(shape.is_array());
2626- if (!origin_dims.empty()) {2665+ ASSERT_TRUE(max_gear_shape.is_array());
2627- EXPECT_EQ(origin_dims[0], JsonFile::json(-1)) << "Dynamic batch axis should be -1 in origin_input_dims";2666+ if (!shape.empty()) {
2628- EXPECT_NE(origin_dims[0], shape[0]) << "origin_input_dims should differ from shape for dynamic batch";2667+ EXPECT_EQ(shape[0], JsonFile::json(-1)) << "Dynamic batch axis should be -1 in shape";
2668+ EXPECT_NE(shape[0], max_gear_shape[0]) << "shape should differ from max_gear_shape for dynamic batch";
2629 }2669 }
2630 }2670 }
2631}2671}
@@ -2668,13 +2708,91 @@ TEST_F(Om2St, SaveModelInfo_WithDynamicBatchCase_WritesDynamicBatchInfo) {
2668 ASSERT_TRUE(model_meta_json.IsValid());2708 ASSERT_TRUE(model_meta_json.IsValid());
2669 2709 
2670 const auto &raw = model_meta_json.Raw();2710 const auto &raw = model_meta_json.Raw();
2671- EXPECT_EQ(raw.at("dynamic_type"), JsonFile::json(static_cast<int32_t>(DYNAMIC_BATCH)));2711+ ASSERT_TRUE(raw.contains("dynamic_dims"));
2672- ASSERT_EQ(raw.at("dynamic_batch_info").size(), 2U);2712+ const auto &dynamic_dims = raw.at("dynamic_dims");
2673- EXPECT_EQ(raw.at("dynamic_batch_info")[0], JsonFile::json({1, 1, 224, 224}));2713+ EXPECT_EQ(dynamic_dims.at("dynamic_type"), JsonFile::json(static_cast<int32_t>(DYNAMIC_BATCH)));
2674- EXPECT_EQ(raw.at("dynamic_batch_info")[1], JsonFile::json({2, 1, 224, 224}));2714+ ASSERT_EQ(dynamic_dims.at("user_designate_shape_order").size(), 2U);
2675- ASSERT_EQ(raw.at("user_designate_shape_order").size(), 2U);2715+ EXPECT_EQ(dynamic_dims.at("user_designate_shape_order")[0], JsonFile::json("data1"));
2676- EXPECT_EQ(raw.at("user_designate_shape_order")[0], JsonFile::json("data1"));2716+ EXPECT_EQ(dynamic_dims.at("user_designate_shape_order")[1], JsonFile::json("data2"));
2677- EXPECT_EQ(raw.at("user_designate_shape_order")[1], JsonFile::json("data2"));2717+ const auto &gears = dynamic_dims.at("gears");
2718+ ASSERT_EQ(gears.size(), 2U);
2719+ EXPECT_EQ(gears[0].at("inputs"), JsonFile::json({1, 1, 224, 224}));
2720+ EXPECT_EQ(gears[1].at("inputs"), JsonFile::json({2, 1, 224, 224}));
2721+}
2722+ 
2723+TEST_F(Om2St, SaveModelInfo_WithDynamicOutputShape_WritesGearOutputs) {
2724+ Om2PackageHelper om2_packager;
2725+ const auto ge_root_model = CreateGeRootModelWithAicoreOp();
2726+ ASSERT_NE(ge_root_model, nullptr);
2727+ auto &compute_graph = ge_root_model->GetRootGraph();
2728+ 
2729+ auto case_desc = std::make_shared<OpDesc>("case1", CASE);
2730+ GeTensorDesc case_input_desc(GeShape({1}), FORMAT_ND, DT_INT32);
2731+ (void)case_desc->AddInputDesc(case_input_desc);
2732+ AttrUtils::SetInt(case_desc, ATTR_NAME_BATCH_NUM, 2U);
2733+ AttrUtils::SetInt(case_desc, ATTR_DYNAMIC_TYPE, static_cast<int32_t>(DYNAMIC_BATCH));
2734+ AttrUtils::SetListInt(case_desc, ATTR_NAME_PRED_VALUE + "_0", {1, 1, 224, 224});
2735+ AttrUtils::SetListInt(case_desc, ATTR_NAME_PRED_VALUE + "_1", {2, 1, 224, 224});
2736+ AttrUtils::SetListStr(case_desc, ATTR_USER_DESIGNEATE_SHAPE_ORDER, {"data"});
2737+ auto case_node = compute_graph->AddNode(case_desc);
2738+ ASSERT_NE(case_node, nullptr);
2739+ 
2740+ for (const auto &node : compute_graph->GetDirectNode()) {
2741+ if (node->GetType() == NETOUTPUT) {
2742+ (void)AttrUtils::SetListStr(node->GetOpDesc(), ATTR_NAME_DYNAMIC_OUTPUT_DIMS, {"0,0,1,1000", "1,0,2,1000"});
2743+ } else if (node->GetType() == "Add") {
2744+ (void)AttrUtils::SetListStr(node->GetOpDesc(), ATTR_NAME_DATA_DUMP_ORIGIN_OP_NAMES,
2745+ {"original_add_1", "original_add_2"});
2746+ }
2747+ }
2748+ 
2749+ ModelBufferData model_data;
2750+ const std::string output_file = PathUtils::Join({test_work_dir, "test_dynamic_output_shape.om2"});
2751+ SyncKernelNameForAllModels(ge_root_model);
2752+ ASSERT_EQ(om2_packager.SaveToOmRootModel(ge_root_model, output_file, model_data, false), SUCCESS);
2753+ 
2754+ uint32_t model_buf_size = 0;
2755+ const auto model_buf = GetBinDataFromFile(output_file, model_buf_size);
2756+ RAIIZipArchive archive(reinterpret_cast<const uint8_t *>(model_buf.get()), model_buf_size);
2757+ ASSERT_TRUE(archive.IsGood());
2758+ 
2759+ size_t model_meta_size = 0;
2760+ const auto model_meta_buf =
2761+ archive.ExtractToMem("test_dynamic_output_shape/data/model_0/model_meta.json", model_meta_size);
2762+ ASSERT_NE(model_meta_buf, nullptr);
2763+ const JsonFile model_meta_json(reinterpret_cast<const uint8_t *>(model_meta_buf.get()), model_meta_size);
2764+ ASSERT_TRUE(model_meta_json.IsValid());
2765+ 
2766+ const auto &gears = model_meta_json.Raw().at("dynamic_dims").at("gears");
2767+ ASSERT_EQ(gears.size(), 2U);
2768+ ASSERT_TRUE(gears[0].contains("outputs"));
2769+ const auto &gear0_outputs = gears[0].at("outputs");
2770+ ASSERT_TRUE(gear0_outputs.is_array());
2771+ ASSERT_GE(gear0_outputs.size(), 1U);
2772+ EXPECT_EQ(gear0_outputs[0], JsonFile::json::array({1, 1000}));
2773+ ASSERT_TRUE(gears[1].contains("outputs"));
2774+ const auto &gear1_outputs = gears[1].at("outputs");
2775+ ASSERT_GE(gear1_outputs.size(), 1U);
2776+ EXPECT_EQ(gear1_outputs[0], JsonFile::json::array({2, 1000}));
2777+ 
2778+ size_t op_attr_size = 0;
2779+ const auto op_attr_buf = archive.ExtractToMem("test_dynamic_output_shape/data/model_0/op_attr.json", op_attr_size);
2780+ ASSERT_NE(op_attr_buf, nullptr);
2781+ const JsonFile op_attr_json(reinterpret_cast<const uint8_t *>(op_attr_buf.get()), op_attr_size);
2782+ ASSERT_TRUE(op_attr_json.IsValid());
2783+ const auto &op_attr_raw = op_attr_json.Raw();
2784+ bool found_dump_attr = false;
2785+ for (auto it = op_attr_raw.begin(); it != op_attr_raw.end(); ++it) {
2786+ if (it.value().is_object() && it.value().contains(ATTR_NAME_DATA_DUMP_ORIGIN_OP_NAMES)) {
2787+ const auto &attr_obj = it.value().at(ATTR_NAME_DATA_DUMP_ORIGIN_OP_NAMES);
2788+ EXPECT_EQ(attr_obj.at("type"), "LIST_STRING");
2789+ EXPECT_TRUE(attr_obj.at("value").is_array());
2790+ EXPECT_EQ(attr_obj.at("value").size(), 2U);
2791+ found_dump_attr = true;
2792+ break;
2793+ }
2794+ }
2795+ EXPECT_TRUE(found_dump_attr);
2678}2796}
2679 2797 
2680TEST_F(Om2St, ConvertOm2Model_Ok_GenOm2WithSeparatelyCleanTask) {2798TEST_F(Om2St, ConvertOm2Model_Ok_GenOm2WithSeparatelyCleanTask) {
@@ -2705,10 +2823,10 @@ TEST_F(Om2St, ConvertOm2Model_Ok_GenOm2WithSeparatelyCleanTask) {
2705 "fake_test/data/model_0/runtime/Makefile",2823 "fake_test/data/model_0/runtime/Makefile",
2706 "fake_test/data/model_0/runtime/libg1_om2.so",2824 "fake_test/data/model_0/runtime/libg1_om2.so",
2707 "fake_test/data/constants/model_0_constants_config.json",2825 "fake_test/data/constants/model_0_constants_config.json",
2708- "fake_test/data/kernels_npu_arch/add1_faked_kernel.o",2826+ "fake_test/data/kernels/add1_faked_kernel.o",
2709- "fake_test/data/kernels_npu_arch/add1_faked_atomic_kernel.o",2827+ "fake_test/data/kernels/add1_faked_atomic_kernel.o",
2710 "fake_test/data/model_0/model_meta.json",2828 "fake_test/data/model_0/model_meta.json",
2711- "fake_test/data/model_0/debug/op_attr.json",2829+ "fake_test/data/model_0/op_attr.json",
2712 "fake_test/manifest.json",2830 "fake_test/manifest.json",
2713 };2831 };
2714 ExpectOm2ArchiveFiles(archive, expect_files);2832 ExpectOm2ArchiveFiles(archive, expect_files);
Mtests/ge/st/testcase/test_om2_online.cc+0-3
@@ -157,7 +157,6 @@ TEST_F(Om2OnlineSessionTest, Om2ModelData_StructureIntegrity) {
157 157 
158 // Populate model meta158 // Populate model meta
159 model_data.model_meta.model_name = "test_model";159 model_data.model_meta.model_name = "test_model";
160- model_data.model_meta.root_graph_name = "root_graph";
161 model_data.model_meta.work_size = 4096U;160 model_data.model_meta.work_size = 4096U;
162 161 
163 // Populate kernel binaries162 // Populate kernel binaries
@@ -352,7 +351,6 @@ std::vector<uint8_t> ReadFileBytes(const std::string &path) {
352gert::Om2ModelData MakeOm2ModelDataWithFakeSo(const std::string &so_path) {351gert::Om2ModelData MakeOm2ModelDataWithFakeSo(const std::string &so_path) {
353 gert::Om2ModelData model_data;352 gert::Om2ModelData model_data;
354 model_data.model_meta.model_name = "st_om2_test_model";353 model_data.model_meta.model_name = "st_om2_test_model";
355- model_data.model_meta.root_graph_name = "test_graph";
356 model_data.model_meta.work_size = 1024U;354 model_data.model_meta.work_size = 1024U;
357 355 
358 ge::Om2TensorDesc input_desc;356 ge::Om2TensorDesc input_desc;
@@ -828,7 +826,6 @@ TEST_F(Om2OnlineModelExecutorTest, GetCompiledModel_Om2Mode_Success) {
828 826 
829 const auto om2_model_data = std::make_shared<gert::Om2ModelData>();827 const auto om2_model_data = std::make_shared<gert::Om2ModelData>();
830 om2_model_data->model_meta.model_name = "om2_st_model";828 om2_model_data->model_meta.model_name = "om2_st_model";
831- om2_model_data->model_meta.root_graph_name = "test_graph";
832 om2_model_data->debug_info.visual_json = R"({"format":"ge_visual_json","format_version":1})";829 om2_model_data->debug_info.visual_json = R"({"format":"ge_visual_json","format_version":1})";
833 ge_root_model->SetOm2ModelData(om2_model_data);830 ge_root_model->SetOm2ModelData(om2_model_data);
834 831 
Mtests/ge/ut/ge/common/om2_model_data_unittest.cc+4-7
@@ -31,7 +31,6 @@ TEST_F(Om2ModelDataTest, DefaultConstruction) {
31 31 
32 // Verify default values for model_meta32 // Verify default values for model_meta
33 EXPECT_TRUE(model_data.model_meta.model_name.empty());33 EXPECT_TRUE(model_data.model_meta.model_name.empty());
34- EXPECT_TRUE(model_data.model_meta.root_graph_name.empty());
35 EXPECT_EQ(model_data.model_meta.work_size, 0U);34 EXPECT_EQ(model_data.model_meta.work_size, 0U);
36 EXPECT_EQ(model_data.model_meta.zero_copy_size, 0);35 EXPECT_EQ(model_data.model_meta.zero_copy_size, 0);
37 EXPECT_TRUE(model_data.model_meta.input_desc.empty());36 EXPECT_TRUE(model_data.model_meta.input_desc.empty());
@@ -51,7 +50,7 @@ TEST_F(Om2ModelDataTest, DefaultConstruction) {
51 EXPECT_TRUE(model_data.kernel_binaries.empty());50 EXPECT_TRUE(model_data.kernel_binaries.empty());
52 51 
53 // Verify debug_info52 // Verify debug_info
54- EXPECT_TRUE(model_data.debug_info.op_attr_map.empty());53+ EXPECT_TRUE(model_data.debug_info.op_attr_json.empty());
55 EXPECT_TRUE(model_data.debug_info.visual_json.empty());54 EXPECT_TRUE(model_data.debug_info.visual_json.empty());
56}55}
57 56 
@@ -84,7 +83,6 @@ TEST_F(Om2ModelDataTest, PopulateModelMeta) {
84 Om2ModelData model_data;83 Om2ModelData model_data;
85 84 
86 model_data.model_meta.model_name = "test_model";85 model_data.model_meta.model_name = "test_model";
87- model_data.model_meta.root_graph_name = "root_graph";
88 model_data.model_meta.work_size = 1024 * 1024;86 model_data.model_meta.work_size = 1024 * 1024;
89 87 
90 // Add input descriptors88 // Add input descriptors
@@ -113,7 +111,6 @@ TEST_F(Om2ModelDataTest, PopulateModelMeta) {
113 111 
114 // Verify112 // Verify
115 EXPECT_EQ(model_data.model_meta.model_name, "test_model");113 EXPECT_EQ(model_data.model_meta.model_name, "test_model");
116- EXPECT_EQ(model_data.model_meta.root_graph_name, "root_graph");
117 EXPECT_EQ(model_data.model_meta.work_size, 1024 * 1024);114 EXPECT_EQ(model_data.model_meta.work_size, 1024 * 1024);
118 EXPECT_EQ(model_data.model_meta.input_desc.size(), 1U);115 EXPECT_EQ(model_data.model_meta.input_desc.size(), 1U);
119 EXPECT_EQ(model_data.model_meta.input_desc[0].GetName(), "input");116 EXPECT_EQ(model_data.model_meta.input_desc[0].GetName(), "input");
@@ -205,12 +202,12 @@ TEST_F(Om2ModelDataTest, PopulateDebugInfo) {
205 Om2ModelData model_data;202 Om2ModelData model_data;
206 203 
207 model_data.debug_info.visual_json = R"({"format":"ge_visual_json","format_version":1})";204 model_data.debug_info.visual_json = R"({"format":"ge_visual_json","format_version":1})";
208- model_data.debug_info.op_attr_map["add"] = {{"alpha", "1.0"}, {"beta", "1.0"}};205+ model_data.debug_info.op_attr_json = R"({"add":{"alpha":{"type":"FLOAT","value":1.0}}})";
209 206 
210 // Verify207 // Verify
211 EXPECT_EQ(model_data.debug_info.visual_json, R"({"format":"ge_visual_json","format_version":1})");208 EXPECT_EQ(model_data.debug_info.visual_json, R"({"format":"ge_visual_json","format_version":1})");
212- ASSERT_EQ(model_data.debug_info.op_attr_map.size(), 1U);209+ EXPECT_FALSE(model_data.debug_info.op_attr_json.empty());
213- EXPECT_EQ(model_data.debug_info.op_attr_map["add"]["alpha"], "1.0");210+ EXPECT_NE(model_data.debug_info.op_attr_json.find("add"), std::string::npos);
214}211}
215 212 
216// Test populating manifest213// Test populating manifest
Mtests/ge/ut/ge/executor/om2_model_executor_unittest.cc+66-88
@@ -85,15 +85,22 @@ std::string MakeManifestJson() {
85 return R"({85 return R"({
86 "atc_command": "",86 "atc_command": "",
87 "model_num": 1,87 "model_num": 1,
88- "om2_version": "0"88+ "om2_version": "1.0"
89})";89})";
90}90}
91 91 
92std::string MakeModelMetaJsonWithDynamicBatch() {92std::string MakeModelMetaJsonWithDynamicBatch() {
93 return R"({93 return R"({
94- "dynamic_batch_info": [[1], [2], [4], [8]],94+ "dynamic_dims": {
95- "dynamic_output_shape": ["0:0:1,1000", "1:0:2,1000", "2:0:4,1000", "3:0:8,1000"],95+ "dynamic_type": 1,
96- "dynamic_type": 1,96+ "user_designate_shape_order": ["data"],
97+ "gears": [
98+ {"inputs": [1], "outputs": [[1, 1000]]},
99+ {"inputs": [2], "outputs": [[2, 1000]]},
100+ {"inputs": [4], "outputs": [[4, 1000]]},
101+ {"inputs": [8], "outputs": [[8, 1000]]}
102+ ]
103+ },
97 "inputs": [104 "inputs": [
98 {105 {
99 "data_type": "DT_FLOAT",106 "data_type": "DT_FLOAT",
@@ -101,13 +108,12 @@ std::string MakeModelMetaJsonWithDynamicBatch() {
101 "index": 0,108 "index": 0,
102 "name": "data",109 "name": "data",
103 "shape": [-1, 3, 224, 224],110 "shape": [-1, 3, 224, 224],
111+ "max_gear_shape": [8, 3, 224, 224],
104 "shape_range": [],112 "shape_range": [],
105- "shape_v2": [-1, 3, 224, 224],
106 "size": 0113 "size": 0
107 }114 }
108 ],115 ],
109 "name": "g1",116 "name": "g1",
110- "root_graph_name": "root_g1",
111 "outputs": [117 "outputs": [
112 {118 {
113 "data_type": "DT_FLOAT",119 "data_type": "DT_FLOAT",
@@ -120,16 +126,20 @@ std::string MakeModelMetaJsonWithDynamicBatch() {
120 }126 }
121 ],127 ],
122 "work_size": 2048,128 "work_size": 2048,
123- "zero_copy_size": 0,129+ "zero_copy_size": 0
124- "user_designate_shape_order": ["data"]
125})";130})";
126}131}
127 132 
128std::string MakeModelMetaJsonWithDynamicHW() {133std::string MakeModelMetaJsonWithDynamicHW() {
129 return R"({134 return R"({
130- "dynamic_batch_info": [[224, 224], [448, 448]],135+ "dynamic_dims": {
131- "dynamic_output_shape": ["0:0:1,1000", "1:0:1,1000"],136+ "dynamic_type": 2,
132- "dynamic_type": 2,137+ "user_designate_shape_order": ["data"],
138+ "gears": [
139+ {"inputs": [224, 224], "outputs": [[1, 1000]]},
140+ {"inputs": [448, 448], "outputs": [[1, 1000]]}
141+ ]
142+ },
133 "inputs": [143 "inputs": [
134 {144 {
135 "data_type": "DT_FLOAT",145 "data_type": "DT_FLOAT",
@@ -137,13 +147,12 @@ std::string MakeModelMetaJsonWithDynamicHW() {
137 "index": 0,147 "index": 0,
138 "name": "data",148 "name": "data",
139 "shape": [1, 3, -1, -1],149 "shape": [1, 3, -1, -1],
150+ "max_gear_shape": [1, 3, 448, 448],
140 "shape_range": [],151 "shape_range": [],
141- "shape_v2": [1, 3, -1, -1],
142 "size": 0152 "size": 0
143 }153 }
144 ],154 ],
145 "name": "g1",155 "name": "g1",
146- "root_graph_name": "root_g1",
147 "outputs": [156 "outputs": [
148 {157 {
149 "data_type": "DT_FLOAT",158 "data_type": "DT_FLOAT",
@@ -156,16 +165,21 @@ std::string MakeModelMetaJsonWithDynamicHW() {
156 }165 }
157 ],166 ],
158 "work_size": 2048,167 "work_size": 2048,
159- "zero_copy_size": 0,168+ "zero_copy_size": 0
160- "user_designate_shape_order": ["data"]
161})";169})";
162}170}
163 171 
164std::string MakeModelMetaJsonWithDynamicDims() {172std::string MakeModelMetaJsonWithDynamicDims() {
165 return R"({173 return R"({
166- "dynamic_batch_info": [[1, 128], [1, 256], [1, 512]],174+ "dynamic_dims": {
167- "dynamic_output_shape": ["0:0:1,128", "1:0:1,256", "2:0:1,512"],175+ "dynamic_type": 3,
168- "dynamic_type": 3,176+ "user_designate_shape_order": ["data"],
177+ "gears": [
178+ {"inputs": [1, 128], "outputs": [[1, 128]]},
179+ {"inputs": [1, 256], "outputs": [[1, 256]]},
180+ {"inputs": [1, 512], "outputs": [[1, 512]]}
181+ ]
182+ },
169 "inputs": [183 "inputs": [
170 {184 {
171 "data_type": "DT_FLOAT",185 "data_type": "DT_FLOAT",
@@ -173,13 +187,12 @@ std::string MakeModelMetaJsonWithDynamicDims() {
173 "index": 0,187 "index": 0,
174 "name": "data",188 "name": "data",
175 "shape": [-1, -1],189 "shape": [-1, -1],
190+ "max_gear_shape": [1, 512],
176 "shape_range": [],191 "shape_range": [],
177- "shape_v2": [-1, -1],
178 "size": 0192 "size": 0
179 }193 }
180 ],194 ],
181 "name": "g1",195 "name": "g1",
182- "root_graph_name": "root_g1",
183 "outputs": [196 "outputs": [
184 {197 {
185 "data_type": "DT_FLOAT",198 "data_type": "DT_FLOAT",
@@ -192,16 +205,12 @@ std::string MakeModelMetaJsonWithDynamicDims() {
192 }205 }
193 ],206 ],
194 "work_size": 2048,207 "work_size": 2048,
195- "zero_copy_size": 0,208+ "zero_copy_size": 0
196- "user_designate_shape_order": ["data"]
197})";209})";
198}210}
199 211 
200std::string MakeModelMetaJson() {212std::string MakeModelMetaJson() {
201 return R"({213 return R"({
202- "dynamic_batch_info": [],
203- "dynamic_output_shape": [],
204- "dynamic_type": 0,
205 "inputs": [214 "inputs": [
206 {215 {
207 "data_type": "DT_FLOAT",216 "data_type": "DT_FLOAT",
@@ -210,7 +219,6 @@ std::string MakeModelMetaJson() {
210 "name": "data1",219 "name": "data1",
211 "shape": [1, 2, 3, 4],220 "shape": [1, 2, 3, 4],
212 "shape_range": [],221 "shape_range": [],
213- "shape_v2": [1, 2, 3, 4],
214 "size": 0222 "size": 0
215 },223 },
216 {224 {
@@ -220,12 +228,10 @@ std::string MakeModelMetaJson() {
220 "name": "data2",228 "name": "data2",
221 "shape": [1, 1, 224, 224],229 "shape": [1, 1, 224, 224],
222 "shape_range": [],230 "shape_range": [],
223- "shape_v2": [1, 1, 224, 224],
224 "size": 0231 "size": 0
225 }232 }
226 ],233 ],
227 "name": "g1",234 "name": "g1",
228- "root_graph_name": "root_g1",
229 "outputs": [235 "outputs": [
230 {236 {
231 "data_type": "DT_FLOAT",237 "data_type": "DT_FLOAT",
@@ -238,26 +244,22 @@ std::string MakeModelMetaJson() {
238 }244 }
239 ],245 ],
240 "work_size": 2048,246 "work_size": 2048,
241- "zero_copy_size": 0,247+ "zero_copy_size": 0
242- "user_designate_shape_order": []
243})";248})";
244}249}
245 250 
246std::string MakeModelMetaJsonWithZeroCopySize() {251std::string MakeModelMetaJsonWithZeroCopySize() {
247 return R"({252 return R"({
248- "dynamic_batch_info": [],
249- "dynamic_output_shape": [],
250- "dynamic_type": 0,
251 "inputs": [253 "inputs": [
252 {254 {
253 "data_type": "DT_FLOAT",255 "data_type": "DT_FLOAT",
254 "format": "ND",256 "format": "ND",
255 "index": 0,257 "index": 0,
256 "name": "data1",258 "name": "data1",
257- "origin_input_dims": [1, -1, 3, 4],259+ "shape": [1, -1, 3, 4],
258- "shape": [1, 2, 3, 4],260+ "max_gear_shape": [1, 2, 3, 4],
261+ "shape_aclmdlGetInputDimsV2": [1, 8, 3, 4],
259 "shape_range": [],262 "shape_range": [],
260- "shape_v2": [1, 8, 3, 4],
261 "size": 0263 "size": 0
262 },264 },
263 {265 {
@@ -265,15 +267,14 @@ std::string MakeModelMetaJsonWithZeroCopySize() {
265 "format": "NCHW",267 "format": "NCHW",
266 "index": 1,268 "index": 1,
267 "name": "data2",269 "name": "data2",
268- "origin_input_dims": [1, 1, -1, 224],270+ "shape": [1, 1, -1, 224],
269- "shape": [1, 1, 224, 224],271+ "max_gear_shape": [1, 1, 224, 224],
272+ "shape_aclmdlGetInputDimsV2": [1, 1, 448, 224],
270 "shape_range": [],273 "shape_range": [],
271- "shape_v2": [1, 1, 448, 224],
272 "size": 0274 "size": 0
273 }275 }
274 ],276 ],
275 "name": "g1",277 "name": "g1",
276- "root_graph_name": "root_g1",
277 "outputs": [278 "outputs": [
278 {279 {
279 "data_type": "DT_FLOAT",280 "data_type": "DT_FLOAT",
@@ -286,37 +287,28 @@ std::string MakeModelMetaJsonWithZeroCopySize() {
286 }287 }
287 ],288 ],
288 "work_size": 2048,289 "work_size": 2048,
289- "zero_copy_size": 1024,290+ "zero_copy_size": 1024
290- "user_designate_shape_order": []
291})";291})";
292}292}
293 293 
294std::string MakeModelMetaJsonWithoutRootGraphName() {294std::string MakeModelMetaJsonWithoutRootGraphName() {
295 return R"({295 return R"({
296- "dynamic_batch_info": [],
297- "dynamic_output_shape": [],
298- "dynamic_type": 0,
299 "inputs": [],296 "inputs": [],
300 "name": "g1",297 "name": "g1",
301 "outputs": [],298 "outputs": [],
302 "work_size": 2048,299 "work_size": 2048,
303- "zero_copy_size": 0,300+ "zero_copy_size": 0
304- "user_designate_shape_order": []
305})";301})";
306}302}
307 303 
308-std::string MakeModelMetaJsonWithoutInputShapeV2() {304+std::string MakeModelMetaJsonWithoutInputShape() {
309 return R"({305 return R"({
310- "dynamic_batch_info": [],
311- "dynamic_output_shape": [],
312- "dynamic_type": 0,
313 "inputs": [306 "inputs": [
314 {307 {
315 "data_type": "DT_FLOAT",308 "data_type": "DT_FLOAT",
316 "format": "ND",309 "format": "ND",
317 "index": 0,310 "index": 0,
318 "name": "data1",311 "name": "data1",
319- "shape": [1, 2, 3, 4],
320 "shape_range": [],312 "shape_range": [],
321 "size": 0313 "size": 0
322 }314 }
@@ -672,12 +664,11 @@ std::string MakeConstantsConfigJson() {
672 "internal_weight_size": 16,664 "internal_weight_size": 16,
673 "consts": {665 "consts": {
674 "fc1_weight": {666 "fc1_weight": {
675- "file_name": "",667+ "file_name": "constant_0",
676 "index": 0,668 "index": 0,
677 "type": "INTERNAL",669 "type": "INTERNAL",
678 "offset": 0,670 "offset": 0,
679- "size": 16,671+ "size": 16
680- "op_name": "fc1_weight"
681 }672 }
682 }673 }
683 })";674 })";
@@ -692,8 +683,7 @@ std::string MakeIndividualConstantsConfigJson() {
692 "index": 0,683 "index": 0,
693 "type": "INDIVIDUAL",684 "type": "INDIVIDUAL",
694 "offset": 1,685 "offset": 1,
695- "size": 2,686+ "size": 2
696- "op_name": "fc1_weight"
697 }687 }
698 }688 }
699 })";689 })";
@@ -708,8 +698,7 @@ std::string MakeIndividualConstantsConfigJsonWithZeroInternalWeightSize() {
708 "index": 0,698 "index": 0,
709 "type": "INDIVIDUAL",699 "type": "INDIVIDUAL",
710 "offset": 1,700 "offset": 1,
711- "size": 2,701+ "size": 2
712- "op_name": "fc1_weight"
713 }702 }
714 }703 }
715 })";704 })";
@@ -724,8 +713,7 @@ std::string MakeCombinedConstantsConfigJson() {
724 "index": 0,713 "index": 0,
725 "type": "COMBINED",714 "type": "COMBINED",
726 "offset": 1,715 "offset": 1,
727- "size": 2,716+ "size": 2
728- "op_name": "fc1_weight"
729 }717 }
730 }718 }
731 })";719 })";
@@ -736,28 +724,25 @@ std::string MakeMixedConstantsConfigJson() {
736 "internal_weight_size": 16,724 "internal_weight_size": 16,
737 "consts": {725 "consts": {
738 "fc0_weight": {726 "fc0_weight": {
739- "file_name": "",727+ "file_name": "constant_0",
740 "index": 0,728 "index": 0,
741 "type": "INTERNAL",729 "type": "INTERNAL",
742 "offset": 0,730 "offset": 0,
743- "size": 16,731+ "size": 16
744- "op_name": "fc0_weight"
745 },732 },
746 "fc1_weight": {733 "fc1_weight": {
747 "file_name": "mixed_fc.bin",734 "file_name": "mixed_fc.bin",
748 "index": 1,735 "index": 1,
749 "type": "INDIVIDUAL",736 "type": "INDIVIDUAL",
750 "offset": 1,737 "offset": 1,
751- "size": 2,738+ "size": 2
752- "op_name": "fc1_weight"
753 },739 },
754 "fc2_weight": {740 "fc2_weight": {
755 "file_name": "mixed_combined.bin",741 "file_name": "mixed_combined.bin",
756 "index": 2,742 "index": 2,
757 "type": "COMBINED",743 "type": "COMBINED",
758 "offset": 1,744 "offset": 1,
759- "size": 2,745+ "size": 2
760- "op_name": "fc2_weight"
761 }746 }
762 }747 }
763 })";748 })";
@@ -772,16 +757,14 @@ std::string MakeDuplicateIndividualConstantsConfigJson() {
772 "index": 1,757 "index": 1,
773 "type": "INDIVIDUAL",758 "type": "INDIVIDUAL",
774 "offset": 1,759 "offset": 1,
775- "size": 2,760+ "size": 2
776- "op_name": "fc1_weight"
777 },761 },
778 "fc2_weight": {762 "fc2_weight": {
779 "file_name": "duplicate_fc.bin",763 "file_name": "duplicate_fc.bin",
780 "index": 2,764 "index": 2,
781 "type": "INDIVIDUAL",765 "type": "INDIVIDUAL",
782 "offset": 1,766 "offset": 1,
783- "size": 2,767+ "size": 2
784- "op_name": "fc2_weight"
785 }768 }
786 }769 }
787 })";770 })";
@@ -1596,8 +1579,8 @@ TEST_F(Om2ModelExecutorUt, load_failed_when_model_desc_is_invalid) {
1596 ZipArchiveWriter zip_writer(om2_file_path);1579 ZipArchiveWriter zip_writer(om2_file_path);
1597 ASSERT_TRUE(zip_writer.IsMemFileOpened());1580 ASSERT_TRUE(zip_writer.IsMemFileOpened());
1598 const auto manifest = MakeManifestJson();1581 const auto manifest = MakeManifestJson();
1599- // Missing input shape_v2 should fail while parsing the cached v2 model desc.1582+ // Missing input shape should fail while parsing the cached model desc.
1600- const auto model_meta = MakeModelMetaJsonWithoutInputShapeV2();1583+ const auto model_meta = MakeModelMetaJsonWithoutInputShape();
1601 ASSERT_TRUE(zip_writer.WriteBytes("manifest.json", manifest.data(), manifest.size(), false));1584 ASSERT_TRUE(zip_writer.WriteBytes("manifest.json", manifest.data(), manifest.size(), false));
1602 ASSERT_TRUE(zip_writer.WriteBytes("data/model_0/model_meta.json", model_meta.data(), model_meta.size(), false));1585 ASSERT_TRUE(zip_writer.WriteBytes("data/model_0/model_meta.json", model_meta.data(), model_meta.size(), false));
1603 ASSERT_TRUE(zip_writer.WriteFile("data/model_0/runtime/libg1_om2.so",1586 ASSERT_TRUE(zip_writer.WriteFile("data/model_0/runtime/libg1_om2.so",
@@ -1992,7 +1975,7 @@ TEST_F(Om2ModelExecutorUt, get_mem_and_weight_size_from_mem_ok) {
1992 1975 
1993// 辅助函数：生成带属性的op_attr.json1976// 辅助函数：生成带属性的op_attr.json
1994static std::string MakeOpAttrJson() {1977static std::string MakeOpAttrJson() {
1995- return R"({"test_op":{"_datadump_original_op_names":"[12]original_op1[12]original_op2"}})";1978+ return R"({"test_op":{"_datadump_original_op_names":{"type":"LIST_STRING","value":["original_op1","original_op2"]}}})";
1996}1979}
1997 1980 
1998// 辅助函数：生成空op_attr.json1981// 辅助函数：生成空op_attr.json
@@ -2007,7 +1990,7 @@ static std::string MakeInvalidOpAttrJson() {
2007 1990 
2008// 辅助函数：生成多个算子属性的op_attr.json1991// 辅助函数：生成多个算子属性的op_attr.json
2009static std::string MakeMultipleOpAttrJson() {1992static std::string MakeMultipleOpAttrJson() {
2010- return R"({"op1":{"_datadump_original_op_names":"[5]orig1[5]orig2","_another_attr":"test_value"},"op2":{"_datadump_original_op_names":"[5]orig3"}})";1993+ return R"({"op1":{"_datadump_original_op_names":{"type":"LIST_STRING","value":["orig1","orig2"]},"_another_attr":{"type":"STRING","value":"test_value"}},"op2":{"_datadump_original_op_names":{"type":"LIST_STRING","value":["orig3"]}}})";
2011}1994}
2012 1995 
2013TEST_F(Om2ModelExecutorUt, GetOpAttr_ValidOpAttrJson_ReturnsParsedMap) {1996TEST_F(Om2ModelExecutorUt, GetOpAttr_ValidOpAttrJson_ReturnsParsedMap) {
@@ -2039,7 +2022,7 @@ TEST_F(Om2ModelExecutorUt, GetOpAttr_ValidOpAttrJson_ReturnsParsedMap) {
2039 const auto op_attr = MakeOpAttrJson();2022 const auto op_attr = MakeOpAttrJson();
2040 ASSERT_TRUE(zip_writer.WriteBytes("manifest.json", manifest.data(), manifest.size(), false));2023 ASSERT_TRUE(zip_writer.WriteBytes("manifest.json", manifest.data(), manifest.size(), false));
2041 ASSERT_TRUE(zip_writer.WriteBytes("data/model_0/model_meta.json", model_meta.data(), model_meta.size(), false));2024 ASSERT_TRUE(zip_writer.WriteBytes("data/model_0/model_meta.json", model_meta.data(), model_meta.size(), false));
2042- ASSERT_TRUE(zip_writer.WriteBytes("data/model_0/debug/op_attr.json", op_attr.data(), op_attr.size(), false));2025+ ASSERT_TRUE(zip_writer.WriteBytes("data/model_0/op_attr.json", op_attr.data(), op_attr.size(), false));
2043 ASSERT_TRUE(zip_writer.WriteFile("data/model_0/runtime/CMakeLists.txt",2026 ASSERT_TRUE(zip_writer.WriteFile("data/model_0/runtime/CMakeLists.txt",
2044 PathUtils::Join({runtime_dir, "CMakeLists.txt"}), false));2027 PathUtils::Join({runtime_dir, "CMakeLists.txt"}), false));
2045 ASSERT_TRUE(zip_writer.WriteFile("data/model_0/runtime/g1_interface.h",2028 ASSERT_TRUE(zip_writer.WriteFile("data/model_0/runtime/g1_interface.h",
@@ -2114,7 +2097,7 @@ TEST_F(Om2ModelExecutorUt, GetOpAttr_EmptyOpAttrJson_ReturnsEmptyMap) {
2114 const auto op_attr = MakeEmptyOpAttrJson();2097 const auto op_attr = MakeEmptyOpAttrJson();
2115 ASSERT_TRUE(zip_writer.WriteBytes("manifest.json", manifest.data(), manifest.size(), false));2098 ASSERT_TRUE(zip_writer.WriteBytes("manifest.json", manifest.data(), manifest.size(), false));
2116 ASSERT_TRUE(zip_writer.WriteBytes("data/model_0/model_meta.json", model_meta.data(), model_meta.size(), false));2099 ASSERT_TRUE(zip_writer.WriteBytes("data/model_0/model_meta.json", model_meta.data(), model_meta.size(), false));
2117- ASSERT_TRUE(zip_writer.WriteBytes("data/model_0/debug/op_attr.json", op_attr.data(), op_attr.size(), false));2100+ ASSERT_TRUE(zip_writer.WriteBytes("data/model_0/op_attr.json", op_attr.data(), op_attr.size(), false));
2118 ASSERT_TRUE(zip_writer.WriteFile("data/model_0/runtime/CMakeLists.txt",2101 ASSERT_TRUE(zip_writer.WriteFile("data/model_0/runtime/CMakeLists.txt",
2119 PathUtils::Join({runtime_dir, "CMakeLists.txt"}), false));2102 PathUtils::Join({runtime_dir, "CMakeLists.txt"}), false));
2120 ASSERT_TRUE(zip_writer.WriteFile("data/model_0/runtime/g1_interface.h",2103 ASSERT_TRUE(zip_writer.WriteFile("data/model_0/runtime/g1_interface.h",
@@ -2199,7 +2182,7 @@ TEST_F(Om2ModelExecutorUt, GetOpAttr_InvalidOpAttrJson_ReturnsEmptyMap) {
2199 const auto op_attr = MakeInvalidOpAttrJson();2182 const auto op_attr = MakeInvalidOpAttrJson();
2200 ASSERT_TRUE(zip_writer.WriteBytes("manifest.json", manifest.data(), manifest.size(), false));2183 ASSERT_TRUE(zip_writer.WriteBytes("manifest.json", manifest.data(), manifest.size(), false));
2201 ASSERT_TRUE(zip_writer.WriteBytes("data/model_0/model_meta.json", model_meta.data(), model_meta.size(), false));2184 ASSERT_TRUE(zip_writer.WriteBytes("data/model_0/model_meta.json", model_meta.data(), model_meta.size(), false));
2202- ASSERT_TRUE(zip_writer.WriteBytes("data/model_0/debug/op_attr.json", op_attr.data(), op_attr.size(), false));2185+ ASSERT_TRUE(zip_writer.WriteBytes("data/model_0/op_attr.json", op_attr.data(), op_attr.size(), false));
2203 ASSERT_TRUE(zip_writer.WriteFile("data/model_0/runtime/CMakeLists.txt",2186 ASSERT_TRUE(zip_writer.WriteFile("data/model_0/runtime/CMakeLists.txt",
2204 PathUtils::Join({runtime_dir, "CMakeLists.txt"}), false));2187 PathUtils::Join({runtime_dir, "CMakeLists.txt"}), false));
2205 ASSERT_TRUE(zip_writer.WriteFile("data/model_0/runtime/g1_interface.h",2188 ASSERT_TRUE(zip_writer.WriteFile("data/model_0/runtime/g1_interface.h",
@@ -2267,7 +2250,7 @@ TEST_F(Om2ModelExecutorUt, ParseOpAttrJsonToMapInternal_MultipleAttrs_ParsesAllA
2267 const auto op_attr = MakeMultipleOpAttrJson();2250 const auto op_attr = MakeMultipleOpAttrJson();
2268 ASSERT_TRUE(zip_writer.WriteBytes("manifest.json", manifest.data(), manifest.size(), false));2251 ASSERT_TRUE(zip_writer.WriteBytes("manifest.json", manifest.data(), manifest.size(), false));
2269 ASSERT_TRUE(zip_writer.WriteBytes("data/model_0/model_meta.json", model_meta.data(), model_meta.size(), false));2252 ASSERT_TRUE(zip_writer.WriteBytes("data/model_0/model_meta.json", model_meta.data(), model_meta.size(), false));
2270- ASSERT_TRUE(zip_writer.WriteBytes("data/model_0/debug/op_attr.json", op_attr.data(), op_attr.size(), false));2253+ ASSERT_TRUE(zip_writer.WriteBytes("data/model_0/op_attr.json", op_attr.data(), op_attr.size(), false));
2271 ASSERT_TRUE(zip_writer.WriteFile("data/model_0/runtime/CMakeLists.txt",2254 ASSERT_TRUE(zip_writer.WriteFile("data/model_0/runtime/CMakeLists.txt",
2272 PathUtils::Join({runtime_dir, "CMakeLists.txt"}), false));2255 PathUtils::Join({runtime_dir, "CMakeLists.txt"}), false));
2273 ASSERT_TRUE(zip_writer.WriteFile("data/model_0/runtime/g1_interface.h",2256 ASSERT_TRUE(zip_writer.WriteFile("data/model_0/runtime/g1_interface.h",
@@ -2709,9 +2692,6 @@ TEST_F(Om2ModelExecutorUt, GetCurrentShape_AfterFailedSet_ReturnsEmpty) {
2709 2692 
2710namespace {2693namespace {
2711constexpr const char *kAippModelMetaJson = R"({2694constexpr const char *kAippModelMetaJson = R"({
2712- "dynamic_batch_info": [],
2713- "dynamic_output_shape": [],
2714- "dynamic_type": 0,
2715 "inputs": [2695 "inputs": [
2716 {2696 {
2717 "data_type": "DT_FLOAT",2697 "data_type": "DT_FLOAT",
@@ -2720,12 +2700,11 @@ constexpr const char *kAippModelMetaJson = R"({
2720 "name": "data1",2700 "name": "data1",
2721 "shape": [1, 3, 224, 224],2701 "shape": [1, 3, 224, 224],
2722 "shape_range": [],2702 "shape_range": [],
2723- "shape_v2": [1, 3, 224, 224],2703+ "shape_aclmdlGetInputDimsV2": [1, 3, 224, 224],
2724 "size": 02704 "size": 0
2725 }2705 }
2726 ],2706 ],
2727 "name": "g1",2707 "name": "g1",
2728- "root_graph_name": "root_g1",
2729 "outputs": [2708 "outputs": [
2730 {2709 {
2731 "data_type": "DT_FLOAT",2710 "data_type": "DT_FLOAT",
@@ -2734,13 +2713,12 @@ constexpr const char *kAippModelMetaJson = R"({
2734 "name": "output_0",2713 "name": "output_0",
2735 "shape": [1, 1000],2714 "shape": [1, 1000],
2736 "shape_range": [],2715 "shape_range": [],
2737- "shape_v2": [1, 1000],2716+ "shape_aclmdlGetInputDimsV2": [1, 1000],
2738 "size": 02717 "size": 0
2739 }2718 }
2740 ],2719 ],
2741 "work_size": 2048,2720 "work_size": 2048,
2742- "zero_copy_size": 0,2721+ "zero_copy_size": 0
2743- "user_designate_shape_order": []
2744})";2722})";
2745 2723 
2746constexpr const char *kAippJsonSectionStatic = R"("aipp": {2724constexpr const char *kAippJsonSectionStatic = R"("aipp": {
Mtests/ge/ut/ge/executor/om2_model_manager_unittest.cc+0-1
@@ -131,7 +131,6 @@ gert::Om2ModelLoadArg MakeLoadArg(uint32_t model_id) {
131gert::Om2ModelData MakeOm2ModelDataWithFakeSo(const std::string &so_bytes_path) {131gert::Om2ModelData MakeOm2ModelDataWithFakeSo(const std::string &so_bytes_path) {
132 gert::Om2ModelData model_data;132 gert::Om2ModelData model_data;
133 model_data.model_meta.model_name = "test_model";133 model_data.model_meta.model_name = "test_model";
134- model_data.model_meta.root_graph_name = "test_graph";
135 model_data.model_meta.work_size = 1024U;134 model_data.model_meta.work_size = 1024U;
136 135 
137 // Add a minimal input/output descriptor so model desc is valid136 // Add a minimal input/output descriptor so model desc is valid
Mtests/ge/ut/ge/graph/execute/model_executor_unittest.cc+0-2
@@ -154,7 +154,6 @@ std::vector<uint8_t> ReadFileBytes(const std::string &path) {
154gert::Om2ModelData MakeOm2ModelDataWithFakeSo(const std::string &so_path) {154gert::Om2ModelData MakeOm2ModelDataWithFakeSo(const std::string &so_path) {
155 gert::Om2ModelData model_data;155 gert::Om2ModelData model_data;
156 model_data.model_meta.model_name = "test_model";156 model_data.model_meta.model_name = "test_model";
157- model_data.model_meta.root_graph_name = "test_graph";
158 model_data.model_meta.work_size = 1024U;157 model_data.model_meta.work_size = 1024U;
159 158 
160 ge::Om2TensorDesc input_desc;159 ge::Om2TensorDesc input_desc;
@@ -183,7 +182,6 @@ gert::Om2ModelData MakeOm2ModelDataWithFakeSo(const std::string &so_path) {
183gert::Om2ModelData MakeMinimalOm2ModelData(size_t work_size = 1024U, size_t tensor_size = 16U) {182gert::Om2ModelData MakeMinimalOm2ModelData(size_t work_size = 1024U, size_t tensor_size = 16U) {
184 gert::Om2ModelData model_data;183 gert::Om2ModelData model_data;
185 model_data.model_meta.model_name = "om2_ut_model";184 model_data.model_meta.model_name = "om2_ut_model";
186- model_data.model_meta.root_graph_name = "test_graph";
187 model_data.model_meta.work_size = work_size;185 model_data.model_meta.work_size = work_size;
188 186 
189 ge::Om2TensorDesc input_desc;187 ge::Om2TensorDesc input_desc;
Mtests/ge/ut/ge/graph/load/om2_package_helper_unittest.cc+207-40
@@ -457,9 +457,9 @@ TEST_F(Om2PackageHelperUt, ConvertOm2Model_Ok_GenOm2WithAicoreNode) {
457 "fake_test/data/model_0/runtime/libg1_om2.so",457 "fake_test/data/model_0/runtime/libg1_om2.so",
458 "fake_test/data/constants/constant_0",458 "fake_test/data/constants/constant_0",
459 "fake_test/data/constants/model_0_constants_config.json",459 "fake_test/data/constants/model_0_constants_config.json",
460- "fake_test/data/kernels_npu_arch/add1_faked_kernel.o",460+ "fake_test/data/kernels/add1_faked_kernel.o",
461 "fake_test/data/model_0/model_meta.json",461 "fake_test/data/model_0/model_meta.json",
462- "fake_test/data/model_0/debug/op_attr.json",462+ "fake_test/data/model_0/op_attr.json",
463 "fake_test/data/model_0/debug/ge_visual_00000000_graph_0.json",463 "fake_test/data/model_0/debug/ge_visual_00000000_graph_0.json",
464 "fake_test/manifest.json",464 "fake_test/manifest.json",
465 };465 };
@@ -498,12 +498,12 @@ TEST_F(Om2PackageHelperUt, ConvertOm2Model_Ok_GenOm2WithAicoreNode) {
498 std::string atc_command;498 std::string atc_command;
499 ASSERT_TRUE(manifest_json.Get("atc_command", atc_command));499 ASSERT_TRUE(manifest_json.Get("atc_command", atc_command));
500 EXPECT_EQ(atc_command, "");500 EXPECT_EQ(atc_command, "");
501- std::string model_num;501+ int model_num;
502 ASSERT_TRUE(manifest_json.Get("model_num", model_num));502 ASSERT_TRUE(manifest_json.Get("model_num", model_num));
503- EXPECT_EQ(model_num, "1");503+ EXPECT_EQ(model_num, 1);
504 std::string om2_version;504 std::string om2_version;
505 ASSERT_TRUE(manifest_json.Get("om2_version", om2_version));505 ASSERT_TRUE(manifest_json.Get("om2_version", om2_version));
506- EXPECT_EQ(om2_version, "0");506+ EXPECT_EQ(om2_version, "1.0");
507 507 
508 size_t model_meta_size = 0;508 size_t model_meta_size = 0;
509 const auto model_meta_buf = archive.ExtractToMem("fake_test/data/model_0/model_meta.json", model_meta_size);509 const auto model_meta_buf = archive.ExtractToMem("fake_test/data/model_0/model_meta.json", model_meta_size);
@@ -511,13 +511,8 @@ TEST_F(Om2PackageHelperUt, ConvertOm2Model_Ok_GenOm2WithAicoreNode) {
511 const JsonFile model_meta_json(reinterpret_cast<const uint8_t *>(model_meta_buf.get()), model_meta_size);511 const JsonFile model_meta_json(reinterpret_cast<const uint8_t *>(model_meta_buf.get()), model_meta_size);
512 ASSERT_TRUE(model_meta_json.IsValid());512 ASSERT_TRUE(model_meta_json.IsValid());
513 EXPECT_EQ(model_meta_json.Raw().at("name"), JsonFile::json("g1"));513 EXPECT_EQ(model_meta_json.Raw().at("name"), JsonFile::json("g1"));
514- EXPECT_EQ(model_meta_json.Raw().at("root_graph_name"), JsonFile::json("root_g1"));
515- EXPECT_EQ(model_meta_json.Raw().at("dynamic_batch_info"), JsonFile::json::array());
516- EXPECT_EQ(model_meta_json.Raw().at("dynamic_output_shape"), JsonFile::json::array());
517- EXPECT_EQ(model_meta_json.Raw().at("dynamic_type"), JsonFile::json(0));
518 EXPECT_EQ(model_meta_json.Raw().at("work_size"), JsonFile::json(2048));514 EXPECT_EQ(model_meta_json.Raw().at("work_size"), JsonFile::json(2048));
519 EXPECT_EQ(model_meta_json.Raw().at("zero_copy_size"), JsonFile::json(0));515 EXPECT_EQ(model_meta_json.Raw().at("zero_copy_size"), JsonFile::json(0));
520- EXPECT_EQ(model_meta_json.Raw().at("user_designate_shape_order"), JsonFile::json::array());
521 516 
522 const JsonFile::json expected_inputs = JsonFile::json::array({517 const JsonFile::json expected_inputs = JsonFile::json::array({
523 {{"data_type", "DT_FLOAT"},518 {{"data_type", "DT_FLOAT"},
@@ -526,8 +521,6 @@ TEST_F(Om2PackageHelperUt, ConvertOm2Model_Ok_GenOm2WithAicoreNode) {
526 {"name", "data1"},521 {"name", "data1"},
527 {"shape", JsonFile::json::array({1, 2, 3, 4})},522 {"shape", JsonFile::json::array({1, 2, 3, 4})},
528 {"shape_range", JsonFile::json::array()},523 {"shape_range", JsonFile::json::array()},
529- {"shape_v2", JsonFile::json::array({1, 2, 3, 4})},
530- {"origin_input_dims", JsonFile::json::array({1, 2, 3, 4})},
531 {"size", 0}},524 {"size", 0}},
532 {{"data_type", "DT_FLOAT"},525 {{"data_type", "DT_FLOAT"},
533 {"format", "NCHW"},526 {"format", "NCHW"},
@@ -535,8 +528,6 @@ TEST_F(Om2PackageHelperUt, ConvertOm2Model_Ok_GenOm2WithAicoreNode) {
535 {"name", "data2"},528 {"name", "data2"},
536 {"shape", JsonFile::json::array({1, 1, 224, 224})},529 {"shape", JsonFile::json::array({1, 1, 224, 224})},
537 {"shape_range", JsonFile::json::array()},530 {"shape_range", JsonFile::json::array()},
538- {"shape_v2", JsonFile::json::array({1, 1, 224, 224})},
539- {"origin_input_dims", JsonFile::json::array({1, 1, 224, 224})},
540 {"size", 0}},531 {"size", 0}},
541 });532 });
542 EXPECT_EQ(model_meta_json.Raw().at("inputs"), expected_inputs);533 EXPECT_EQ(model_meta_json.Raw().at("inputs"), expected_inputs);
@@ -569,15 +560,13 @@ TEST_F(Om2PackageHelperUt, ConvertOm2Model_Ok_GenOm2WithAicoreNode) {
569 EXPECT_EQ(consts.at("constant_0").at("index"), JsonFile::json(0));560 EXPECT_EQ(consts.at("constant_0").at("index"), JsonFile::json(0));
570 EXPECT_EQ(consts.at("constant_0").at("type"), JsonFile::json("INTERNAL"));561 EXPECT_EQ(consts.at("constant_0").at("type"), JsonFile::json("INTERNAL"));
571 EXPECT_FALSE(consts.at("constant_0").contains("external"));562 EXPECT_FALSE(consts.at("constant_0").contains("external"));
572- EXPECT_EQ(consts.at("constant_0").at("file_name"), JsonFile::json(""));563+ EXPECT_EQ(consts.at("constant_0").at("file_name"), JsonFile::json("constant_0"));
573- EXPECT_EQ(consts.at("constant_0").at("op_name"), JsonFile::json(""));
574 EXPECT_EQ(consts.at("constant_0").at("offset"), JsonFile::json(0));564 EXPECT_EQ(consts.at("constant_0").at("offset"), JsonFile::json(0));
575 EXPECT_EQ(consts.at("constant_0").at("size"), JsonFile::json(200704));565 EXPECT_EQ(consts.at("constant_0").at("size"), JsonFile::json(200704));
576 EXPECT_EQ(consts.at("constant_1").at("index"), JsonFile::json(1));566 EXPECT_EQ(consts.at("constant_1").at("index"), JsonFile::json(1));
577 EXPECT_EQ(consts.at("constant_1").at("type"), JsonFile::json("INTERNAL"));567 EXPECT_EQ(consts.at("constant_1").at("type"), JsonFile::json("INTERNAL"));
578 EXPECT_FALSE(consts.at("constant_1").contains("external"));568 EXPECT_FALSE(consts.at("constant_1").contains("external"));
579- EXPECT_EQ(consts.at("constant_1").at("file_name"), JsonFile::json(""));569+ EXPECT_EQ(consts.at("constant_1").at("file_name"), JsonFile::json("constant_0"));
580- EXPECT_EQ(consts.at("constant_1").at("op_name"), JsonFile::json(""));
581 EXPECT_EQ(consts.at("constant_1").at("offset"), JsonFile::json(200704));570 EXPECT_EQ(consts.at("constant_1").at("offset"), JsonFile::json(200704));
582 EXPECT_EQ(consts.at("constant_1").at("size"), JsonFile::json(200704));571 EXPECT_EQ(consts.at("constant_1").at("size"), JsonFile::json(200704));
583}572}
@@ -647,9 +636,9 @@ TEST_F(Om2PackageHelperUt, SaveToOmModel_SaveModeFalse_ReturnsModelBuffer) {
647 "g1/data/model_0/runtime/libg1_om2.so",636 "g1/data/model_0/runtime/libg1_om2.so",
648 "g1/data/constants/constant_0",637 "g1/data/constants/constant_0",
649 "g1/data/constants/model_0_constants_config.json",638 "g1/data/constants/model_0_constants_config.json",
650- "g1/data/kernels_npu_arch/add1_faked_kernel.o",639+ "g1/data/kernels/add1_faked_kernel.o",
651 "g1/data/model_0/model_meta.json",640 "g1/data/model_0/model_meta.json",
652- "g1/data/model_0/debug/op_attr.json",641+ "g1/data/model_0/op_attr.json",
653 "g1/data/model_0/debug/ge_visual_00000000_graph_0.json",642 "g1/data/model_0/debug/ge_visual_00000000_graph_0.json",
654 "g1/manifest.json",643 "g1/manifest.json",
655 };644 };
@@ -798,14 +787,12 @@ TEST_F(Om2PackageHelperUt, ConvertOm2Model_Ok_GenOm2WithFileConstMeta) {
798 const auto &internal_const = consts.at("constant_1");787 const auto &internal_const = consts.at("constant_1");
799 EXPECT_EQ(internal_const.at("index"), JsonFile::json(1));788 EXPECT_EQ(internal_const.at("index"), JsonFile::json(1));
800 EXPECT_EQ(internal_const.at("type"), JsonFile::json("INTERNAL"));789 EXPECT_EQ(internal_const.at("type"), JsonFile::json("INTERNAL"));
801- EXPECT_EQ(internal_const.at("file_name"), JsonFile::json(""));790+ EXPECT_EQ(internal_const.at("file_name"), JsonFile::json("constant_0"));
802- EXPECT_EQ(internal_const.at("op_name"), JsonFile::json(""));
803 EXPECT_EQ(internal_const.at("offset"), JsonFile::json(0));791 EXPECT_EQ(internal_const.at("offset"), JsonFile::json(0));
804 EXPECT_EQ(internal_const.at("size"), JsonFile::json(200704));792 EXPECT_EQ(internal_const.at("size"), JsonFile::json(200704));
805 EXPECT_FALSE(internal_const.contains("file_path"));793 EXPECT_FALSE(internal_const.contains("file_path"));
806 794 
807 const auto &file_const = consts.at("data2");795 const auto &file_const = consts.at("data2");
808- EXPECT_EQ(file_const.at("op_name"), JsonFile::json("data2"));
809 EXPECT_EQ(file_const.at("index"), JsonFile::json(0));796 EXPECT_EQ(file_const.at("index"), JsonFile::json(0));
810 EXPECT_EQ(file_const.at("type"), JsonFile::json("COMBINED"));797 EXPECT_EQ(file_const.at("type"), JsonFile::json("COMBINED"));
811 EXPECT_EQ(file_const.at("file_name"), JsonFile::json("weight_combined.bin"));798 EXPECT_EQ(file_const.at("file_name"), JsonFile::json("weight_combined.bin"));
@@ -846,8 +833,7 @@ TEST_F(Om2PackageHelperUt, RelocateExternalWeights_SkipInvalidConstItemsAndCompr
846 .Set("file_name", "")833 .Set("file_name", "")
847 .Set("file_path", old_weight_path)834 .Set("file_path", old_weight_path)
848 .Set("offset", 0)835 .Set("offset", 0)
849- .Set("size", 6)836+ .Set("size", 6);
850- .Set("op_name", "basename_const");
851 consts["basename_const"] = basename_const.Raw();837 consts["basename_const"] = basename_const.Raw();
852 838 
853 JsonFile constants_config;839 JsonFile constants_config;
@@ -934,7 +920,7 @@ TEST_F(Om2PackageHelperUt, SaveOpAttrJson_WithAttr_GenValidOpAttrJson) {
934 ASSERT_TRUE(archive.IsGood());920 ASSERT_TRUE(archive.IsGood());
935 921 
936 size_t op_attr_size = 0;922 size_t op_attr_size = 0;
937- const auto op_attr_buf = archive.ExtractToMem("test_op_attr/data/model_0/debug/op_attr.json", op_attr_size);923+ const auto op_attr_buf = archive.ExtractToMem("test_op_attr/data/model_0/op_attr.json", op_attr_size);
938 ASSERT_NE(op_attr_buf, nullptr);924 ASSERT_NE(op_attr_buf, nullptr);
939 925 
940 const JsonFile op_attr_json(reinterpret_cast<const uint8_t *>(op_attr_buf.get()), op_attr_size);926 const JsonFile op_attr_json(reinterpret_cast<const uint8_t *>(op_attr_buf.get()), op_attr_size);
@@ -950,8 +936,12 @@ TEST_F(Om2PackageHelperUt, SaveOpAttrJson_WithAttr_GenValidOpAttrJson) {
950 EXPECT_TRUE(op_attr.contains("_datadump_original_op_names"));936 EXPECT_TRUE(op_attr.contains("_datadump_original_op_names"));
951 937 
952 const auto &attr_value = op_attr.at("_datadump_original_op_names");938 const auto &attr_value = op_attr.at("_datadump_original_op_names");
953- EXPECT_TRUE(attr_value.is_string());939+ EXPECT_TRUE(attr_value.is_object());
954- EXPECT_EQ(attr_value.get<std::string>(), "[12]original_op1[12]original_op2");940+ EXPECT_EQ(attr_value.at("type"), "LIST_STRING");
941+ EXPECT_TRUE(attr_value.at("value").is_array());
942+ EXPECT_EQ(attr_value.at("value").size(), 2U);
943+ EXPECT_EQ(attr_value.at("value")[0], "original_op1");
944+ EXPECT_EQ(attr_value.at("value")[1], "original_op2");
955}945}
956 946 
957TEST_F(Om2PackageHelperUt, SaveOpAttrJson_NoAttr_GenEmptyOpAttrJson) {947TEST_F(Om2PackageHelperUt, SaveOpAttrJson_NoAttr_GenEmptyOpAttrJson) {
@@ -972,7 +962,7 @@ TEST_F(Om2PackageHelperUt, SaveOpAttrJson_NoAttr_GenEmptyOpAttrJson) {
972 ASSERT_TRUE(archive.IsGood());962 ASSERT_TRUE(archive.IsGood());
973 963 
974 size_t op_attr_size = 0;964 size_t op_attr_size = 0;
975- const auto op_attr_buf = archive.ExtractToMem("test_empty_attr/data/model_0/debug/op_attr.json", op_attr_size);965+ const auto op_attr_buf = archive.ExtractToMem("test_empty_attr/data/model_0/op_attr.json", op_attr_size);
976 ASSERT_NE(op_attr_buf, nullptr);966 ASSERT_NE(op_attr_buf, nullptr);
977 967 
978 const JsonFile op_attr_json(reinterpret_cast<const uint8_t *>(op_attr_buf.get()), op_attr_size);968 const JsonFile op_attr_json(reinterpret_cast<const uint8_t *>(op_attr_buf.get()), op_attr_size);
@@ -1014,7 +1004,7 @@ TEST_F(Om2PackageHelperUt, SaveOpAttrJson_EmptyOriginalOpNames_GenValidOpAttrJso
1014 ASSERT_TRUE(archive.IsGood());1004 ASSERT_TRUE(archive.IsGood());
1015 1005 
1016 size_t op_attr_size = 0;1006 size_t op_attr_size = 0;
1017- const auto op_attr_buf = archive.ExtractToMem("test_empty_list_attr/data/model_0/debug/op_attr.json", op_attr_size);1007+ const auto op_attr_buf = archive.ExtractToMem("test_empty_list_attr/data/model_0/op_attr.json", op_attr_size);
1018 ASSERT_NE(op_attr_buf, nullptr);1008 ASSERT_NE(op_attr_buf, nullptr);
1019 1009 
1020 const JsonFile op_attr_json(reinterpret_cast<const uint8_t *>(op_attr_buf.get()), op_attr_size);1010 const JsonFile op_attr_json(reinterpret_cast<const uint8_t *>(op_attr_buf.get()), op_attr_size);
@@ -1096,7 +1086,7 @@ TEST_F(Om2PackageHelperUt, ExtractVisualJson_Fail_NoVisualJson) {
1096 {1086 {
1097 ZipArchiveWriter writer(zip_path);1087 ZipArchiveWriter writer(zip_path);
1098 ASSERT_TRUE(writer.IsMemFileOpened());1088 ASSERT_TRUE(writer.IsMemFileOpened());
1099- const std::string manifest = R"({"om2_version":"0","model_num":1})";1089+ const std::string manifest = R"({"om2_version":"1.0","model_num":1})";
1100 ASSERT_TRUE(writer.WriteBytes("manifest.json", manifest.data(), manifest.size(), false));1090 ASSERT_TRUE(writer.WriteBytes("manifest.json", manifest.data(), manifest.size(), false));
1101 ModelBufferData buf;1091 ModelBufferData buf;
1102 ASSERT_TRUE(writer.SaveModelData(buf, true));1092 ASSERT_TRUE(writer.SaveModelData(buf, true));
@@ -1263,15 +1253,25 @@ TEST_F(Om2PackageHelperUt, BuildDebugInfo_DumpOriginOpNames) {
1263 gert::Om2ModelData model_data;1253 gert::Om2ModelData model_data;
1264 gert::Om2DebugInfo &debug_info = model_data.debug_info;1254 gert::Om2DebugInfo &debug_info = model_data.debug_info;
1265 ASSERT_EQ(om2_packager.BuildDebugInfo(ge_model, model_data), SUCCESS);1255 ASSERT_EQ(om2_packager.BuildDebugInfo(ge_model, model_data), SUCCESS);
1266- ASSERT_FALSE(debug_info.op_attr_map.empty());1256+ ASSERT_FALSE(debug_info.op_attr_json.empty());
1257+ 
1258+ const JsonFile op_attr_json(reinterpret_cast<const uint8_t *>(debug_info.op_attr_json.data()),
1259+ debug_info.op_attr_json.size());
1260+ ASSERT_TRUE(op_attr_json.IsValid());
1261+ const auto &raw_json = op_attr_json.Raw();
1262+ EXPECT_TRUE(raw_json.is_object());
1267 1263 
1268 bool found = false;1264 bool found = false;
1269- for (const auto &[op_name, attrs] : debug_info.op_attr_map) {1265+ for (auto it = raw_json.begin(); it != raw_json.end(); ++it) {
1270- auto it = attrs.find(ATTR_NAME_DATA_DUMP_ORIGIN_OP_NAMES);1266+ if (it.value().is_object() && it.value().contains(ATTR_NAME_DATA_DUMP_ORIGIN_OP_NAMES)) {
1271- if (it != attrs.end()) {1267+ const auto &attr_obj = it.value().at(ATTR_NAME_DATA_DUMP_ORIGIN_OP_NAMES);
1268+ EXPECT_EQ(attr_obj.at("type"), "LIST_STRING");
1269+ EXPECT_TRUE(attr_obj.at("value").is_array());
1270+ const auto &value_array = attr_obj.at("value");
1271+ EXPECT_EQ(value_array.size(), 2U);
1272+ EXPECT_EQ(value_array[0], "original_add_1");
1273+ EXPECT_EQ(value_array[1], "original_add_2");
1272 found = true;1274 found = true;
1273- EXPECT_NE(it->second.find("[14]original_add_1"), std::string::npos);
1274- EXPECT_NE(it->second.find("[14]original_add_2"), std::string::npos);
1275 break;1275 break;
1276 }1276 }
1277 }1277 }
@@ -1291,7 +1291,6 @@ TEST_F(Om2PackageHelperUt, BuildManifest_NullRootModel) {
1291TEST_F(Om2PackageHelperUt, Serialize_OnlineMode_ExternalConst_HasFilePath) {1291TEST_F(Om2PackageHelperUt, Serialize_OnlineMode_ExternalConst_HasFilePath) {
1292 gert::Om2ModelData model_data;1292 gert::Om2ModelData model_data;
1293 model_data.model_meta.model_name = "test_model";1293 model_data.model_meta.model_name = "test_model";
1294- model_data.model_meta.root_graph_name = "test_graph";
1295 1294 
1296 Om2ConstMeta const_meta;1295 Om2ConstMeta const_meta;
1297 const_meta.index = 0U;1296 const_meta.index = 0U;
@@ -1607,7 +1606,6 @@ TEST_F(Om2PackageHelperUt, SetSaveMode_Ok) {
1607TEST_F(Om2PackageHelperUt, SerializeVarResource_WithEntriesAndInitData) {1606TEST_F(Om2PackageHelperUt, SerializeVarResource_WithEntriesAndInitData) {
1608 gert::Om2ModelData model_data;1607 gert::Om2ModelData model_data;
1609 model_data.model_meta.model_name = "var_test_model";1608 model_data.model_meta.model_name = "var_test_model";
1610- model_data.model_meta.root_graph_name = "var_test_graph";
1611 1609 
1612 auto rt_var_resource = std::make_unique<gert::RTVarResource>();1610 auto rt_var_resource = std::make_unique<gert::RTVarResource>();
1613 gert::RTVarEntry entry;1611 gert::RTVarEntry entry;
@@ -1694,7 +1692,6 @@ TEST_F(Om2PackageHelperUt, SerializeVarResource_WithEntriesAndInitData) {
1694TEST_F(Om2PackageHelperUt, SerializeVarResource_NullAndEmpty) {1692TEST_F(Om2PackageHelperUt, SerializeVarResource_NullAndEmpty) {
1695 gert::Om2ModelData model_data;1693 gert::Om2ModelData model_data;
1696 model_data.model_meta.model_name = "var_empty_model";1694 model_data.model_meta.model_name = "var_empty_model";
1697- model_data.model_meta.root_graph_name = "var_empty_graph";
1698 model_data.program_body.so_artifact.file_name = "libtest.so";1695 model_data.program_body.so_artifact.file_name = "libtest.so";
1699 model_data.program_body.so_artifact.data = "fake_so";1696 model_data.program_body.so_artifact.data = "fake_so";
1700 model_data.debug_info.visual_json = R"({"format":"ge_visual_json","format_version":1,"model":{"graph":[]}})";1697 model_data.debug_info.visual_json = R"({"format":"ge_visual_json","format_version":1,"model":{"graph":[]}})";
@@ -1890,6 +1887,176 @@ TEST_F(Om2PackageHelperUt, SaveToOmModel_WithCustomKernel) {
1890 CustomOpFactory::RemoveCustomOps({kOpType});1887 CustomOpFactory::RemoveCustomOps({kOpType});
1891}1888}
1892 1889 
1890+TEST_F(Om2PackageHelperUt, SerializeModelMeta_WithDynamicBatchInfo_WritesDynamicDims) {
1891+ gert::Om2ModelData model_data;
1892+ model_data.model_meta.model_name = "dynamic_batch_model";
1893+ model_data.model_meta.dynamic_type = 1;
1894+ model_data.model_meta.user_designate_shape_order = {"NCHW"};
1895+ model_data.model_meta.dynamic_batch_info = {{1, 2, 3, 4}, {2, 4, 6, 8}};
1896+ model_data.model_meta.origin_input_dims = {{1, 3, 224, 224}};
1897+ model_data.model_meta.dynamic_output_shape = {"0,1,2,3", "1,2,4,6"};
1898+ 
1899+ ge::Om2TensorDesc input_desc;
1900+ input_desc.SetName("input");
1901+ input_desc.SetShape({1, 3, 224, 224});
1902+ input_desc.SetDataType(ge::DT_FLOAT);
1903+ input_desc.SetFormat(ge::FORMAT_NCHW);
1904+ input_desc.SetSize(602112U);
1905+ model_data.model_meta.input_desc.push_back(input_desc);
1906+ 
1907+ ge::Om2TensorDesc output_desc;
1908+ output_desc.SetName("output");
1909+ output_desc.SetShape({1, 1000});
1910+ output_desc.SetDataType(ge::DT_FLOAT);
1911+ output_desc.SetFormat(ge::FORMAT_ND);
1912+ output_desc.SetSize(4000U);
1913+ model_data.model_meta.output_desc.push_back(output_desc);
1914+ 
1915+ model_data.program_body.so_artifact.file_name = "libtest.so";
1916+ model_data.program_body.so_artifact.data = "fake_so_content";
1917+ model_data.debug_info.visual_json = R"({"format":"ge_visual_json","format_version":1,"model":{"graph":[]}})";
1918+ 
1919+ const std::string writer_path = PathUtils::Join({test_work_dir, "dynamic_batch.om2"});
1920+ ModelBufferData model_buffer;
1921+ ASSERT_EQ(Om2ZipSaver::Save(model_data, model_buffer, false, writer_path), SUCCESS);
1922+ ASSERT_NE(model_buffer.data, nullptr);
1923+ ASSERT_GT(model_buffer.length, 0U);
1924+ 
1925+ SimpleZipArchiveReader archive(model_buffer.data.get(), model_buffer.length);
1926+ ASSERT_TRUE(archive.IsGood());
1927+ 
1928+ std::string model_meta_entry;
1929+ for (const auto &name : archive.ListFiles()) {
1930+ if (name.find("model_meta.json") != std::string::npos) {
1931+ model_meta_entry = name;
1932+ break;
1933+ }
1934+ }
1935+ ASSERT_FALSE(model_meta_entry.empty());
1936+ 
1937+ size_t buf_size = 0U;
1938+ const auto buf = archive.ExtractToMem(model_meta_entry, buf_size);
1939+ ASSERT_NE(buf, nullptr);
1940+ ASSERT_GT(buf_size, 0U);
1941+ 
1942+ const JsonFile model_meta_json(reinterpret_cast<const uint8_t *>(buf.get()), buf_size);
1943+ ASSERT_TRUE(model_meta_json.IsValid());
1944+ const auto &raw = model_meta_json.Raw();
1945+ ASSERT_TRUE(raw.contains("dynamic_dims"));
1946+ const auto &dynamic_dims = raw.at("dynamic_dims");
1947+ EXPECT_EQ(dynamic_dims.at("dynamic_type"), 1);
1948+ EXPECT_EQ(dynamic_dims.at("user_designate_shape_order"), JsonFile::json::array({"NCHW"}));
1949+ ASSERT_TRUE(dynamic_dims.contains("gears"));
1950+ const auto &gears = dynamic_dims.at("gears");
1951+ ASSERT_TRUE(gears.is_array());
1952+ EXPECT_EQ(gears.size(), 2U);
1953+ 
1954+ const auto &gear0 = gears[0];
1955+ ASSERT_TRUE(gear0.contains("inputs"));
1956+ EXPECT_EQ(gear0.at("inputs"), JsonFile::json::array({1, 2, 3, 4}));
1957+ ASSERT_TRUE(gear0.contains("outputs"));
1958+ const auto &gear0_outputs = gear0.at("outputs");
1959+ ASSERT_TRUE(gear0_outputs.is_array());
1960+ ASSERT_EQ(gear0_outputs.size(), 1U);
1961+ EXPECT_EQ(gear0_outputs[0], JsonFile::json::array({2, 3}));
1962+ 
1963+ const auto &gear1 = gears[1];
1964+ ASSERT_TRUE(gear1.contains("inputs"));
1965+ EXPECT_EQ(gear1.at("inputs"), JsonFile::json::array({2, 4, 6, 8}));
1966+ ASSERT_TRUE(gear1.contains("outputs"));
1967+ const auto &gear1_outputs = gear1.at("outputs");
1968+ ASSERT_TRUE(gear1_outputs.is_array());
1969+ ASSERT_EQ(gear1_outputs.size(), 1U);
1970+ EXPECT_EQ(gear1_outputs[0], JsonFile::json::array({4, 6}));
1971+}
1972+ 
1973+TEST_F(Om2PackageHelperUt, SerializeModelMeta_WithMultipleOutputsPerGear_WritesAllOutputs) {
1974+ gert::Om2ModelData model_data;
1975+ model_data.model_meta.model_name = "multi_output_model";
1976+ model_data.model_meta.dynamic_type = 1;
1977+ model_data.model_meta.user_designate_shape_order = {"data"};
1978+ model_data.model_meta.dynamic_batch_info = {{1}, {2}};
1979+ model_data.model_meta.origin_input_dims = {{1, 3}};
1980+ model_data.model_meta.dynamic_output_shape = {"0,0,100", "0,1,200", "1,0,100", "1,1,200"};
1981+ 
1982+ ge::Om2TensorDesc desc;
1983+ desc.SetName("input");
1984+ desc.SetShape({1, 3});
1985+ desc.SetDataType(ge::DT_FLOAT);
1986+ desc.SetFormat(ge::FORMAT_ND);
1987+ desc.SetSize(12U);
1988+ model_data.model_meta.input_desc.push_back(desc);
1989+ 
1990+ model_data.program_body.so_artifact.file_name = "libtest.so";
1991+ model_data.program_body.so_artifact.data = "fake";
1992+ model_data.debug_info.visual_json = R"({"format":"ge_visual_json"})";
1993+ 
1994+ const std::string writer_path = PathUtils::Join({test_work_dir, "multi_output.om2"});
1995+ ModelBufferData model_buffer;
1996+ ASSERT_EQ(Om2ZipSaver::Save(model_data, model_buffer, false, writer_path), SUCCESS);
1997+ 
1998+ SimpleZipArchiveReader archive(model_buffer.data.get(), model_buffer.length);
1999+ ASSERT_TRUE(archive.IsGood());
2000+ 
2001+ std::string entry;
2002+ for (const auto &name : archive.ListFiles()) {
2003+ if (name.find("model_meta.json") != std::string::npos) {
2004+ entry = name;
2005+ break;
2006+ }
2007+ }
2008+ ASSERT_FALSE(entry.empty());
2009+ 
2010+ size_t buf_size = 0U;
2011+ const auto buf = archive.ExtractToMem(entry, buf_size);
2012+ ASSERT_NE(buf, nullptr);
2013+ 
2014+ const JsonFile meta_json(reinterpret_cast<const uint8_t *>(buf.get()), buf_size);
2015+ ASSERT_TRUE(meta_json.IsValid());
2016+ const auto &gears = meta_json.Raw().at("dynamic_dims").at("gears");
2017+ ASSERT_EQ(gears.size(), 2U);
2018+ EXPECT_EQ(gears[0].at("outputs").size(), 2U);
2019+ EXPECT_EQ(gears[0].at("outputs")[0], JsonFile::json::array({100}));
2020+ EXPECT_EQ(gears[0].at("outputs")[1], JsonFile::json::array({200}));
2021+ EXPECT_EQ(gears[1].at("outputs").size(), 2U);
2022+}
2023+ 
2024+TEST_F(Om2PackageHelperUt, SerializeManifest_InvalidModelNum_FallsBackToString) {
2025+ gert::Om2ModelData model_data;
2026+ model_data.model_meta.model_name = "test_model";
2027+ model_data.manifest[OM2_ARCHIVE_VERSION] = OM2_ARCHIVE_VERSION_VALUE;
2028+ model_data.manifest[OM2_MODEL_NUM] = "not_a_number";
2029+ model_data.manifest[OM2_ATC_COMMAND] = "";
2030+ 
2031+ model_data.program_body.so_artifact.file_name = "libtest.so";
2032+ model_data.program_body.so_artifact.data = "fake";
2033+ model_data.debug_info.visual_json = R"({"format":"ge_visual_json"})";
2034+ 
2035+ const std::string writer_path = PathUtils::Join({test_work_dir, "invalid_manifest.om2"});
2036+ ModelBufferData model_buffer;
2037+ ASSERT_EQ(Om2ZipSaver::Save(model_data, model_buffer, false, writer_path), SUCCESS);
2038+ 
2039+ SimpleZipArchiveReader archive(model_buffer.data.get(), model_buffer.length);
2040+ ASSERT_TRUE(archive.IsGood());
2041+ 
2042+ std::string manifest_entry;
2043+ for (const auto &name : archive.ListFiles()) {
2044+ if (name.find("manifest.json") != std::string::npos) {
2045+ manifest_entry = name;
2046+ break;
2047+ }
2048+ }
2049+ ASSERT_FALSE(manifest_entry.empty());
2050+ 
2051+ size_t buf_size = 0U;
2052+ const auto buf = archive.ExtractToMem(manifest_entry, buf_size);
2053+ ASSERT_NE(buf, nullptr);
2054+ 
2055+ const JsonFile manifest_json(reinterpret_cast<const uint8_t *>(buf.get()), buf_size);
2056+ ASSERT_TRUE(manifest_json.IsValid());
2057+ EXPECT_EQ(manifest_json.Raw().at(OM2_MODEL_NUM), "not_a_number");
2058+}
2059+ 
1893TEST_F(Om2PackageHelperUt, ReadCustomOpSoFiles) {2060TEST_F(Om2PackageHelperUt, ReadCustomOpSoFiles) {
1894 std::string so_file = "/tmp/libcusom_op_" + std::to_string(getpid()) + ".so";2061 std::string so_file = "/tmp/libcusom_op_" + std::to_string(getpid()) + ".so";
1895 std::string text = "fake custom op so content";2062 std::string text = "fake custom op so content";
Mtests/ge/ut/ge/graph/manager/graph_manager_unittest.cc+0-1
@@ -5702,7 +5702,6 @@ TEST_F(UtestGraphManagerTest, GetCompiledModel_SerializesOm2ModelDataInOm2Mode)
5702 5702 
5703 const auto om2_data = MakeShared<gert::Om2ModelData>();5703 const auto om2_data = MakeShared<gert::Om2ModelData>();
5704 om2_data->model_meta.model_name = "om2_ut_model";5704 om2_data->model_meta.model_name = "om2_ut_model";
5705- om2_data->model_meta.root_graph_name = "graph";
5706 om2_data->debug_info.visual_json = R"({"format":"ge_visual_json","format_version":1,"model":{"graph":[]}})";5705 om2_data->debug_info.visual_json = R"({"format":"ge_visual_json","format_version":1,"model":{"graph":[]}})";
5707 graph_node->GetGeRootModel()->SetOm2ModelData(om2_data);5706 graph_node->GetGeRootModel()->SetOm2ModelData(om2_data);
5708 5707 
Mtests/ge/ut/ge/graph_ir/ge_ir_build_unittest.cc+1-2
@@ -1830,8 +1830,7 @@ TEST(UtestIrBuild, aclgrphSaveModelOm2ExternalWeightRelocateTest) {
1830 .Set("file_name", weight_file_name)1830 .Set("file_name", weight_file_name)
1831 .Set("file_path", old_weight_path)1831 .Set("file_path", old_weight_path)
1832 .Set("offset", 0)1832 .Set("offset", 0)
1833- .Set("size", 15)1833+ .Set("size", 15);
1834- .Set("op_name", "file_const");
1835 consts["file_const"] = file_const.Raw();1834 consts["file_const"] = file_const.Raw();
1836 JsonFile constants_config;1835 JsonFile constants_config;
1837 constants_config.Set("internal_weight_size", 0U).Set("consts", consts);1836 constants_config.Set("internal_weight_size", 0U).Set("consts", consts);
Mtests/ge/ut/ge/session/omg_omg_unittest.cc+2-2
@@ -835,7 +835,7 @@ std::string CreateMinimalOm2File(const std::string &path, const std::string &vis
835 if (!writer.IsMemFileOpened()) {835 if (!writer.IsMemFileOpened()) {
836 return "";836 return "";
837 }837 }
838- const std::string manifest = R"({"om2_version":"0","model_num":1})";838+ const std::string manifest = R"({"om2_version":"1.0","model_num":1})";
839 writer.WriteBytes("manifest.json", manifest.data(), manifest.size(), false);839 writer.WriteBytes("manifest.json", manifest.data(), manifest.size(), false);
840 writer.WriteBytes("data/model_0/debug/ge_visual_00000000_graph_0.json", visual_json.data(), visual_json.size(), true);840 writer.WriteBytes("data/model_0/debug/ge_visual_00000000_graph_0.json", visual_json.data(), visual_json.size(), true);
841 ModelBufferData buf;841 ModelBufferData buf;
@@ -1010,7 +1010,7 @@ TEST_F(UtestOmg, ConvertOm_Fail_Om2NoVisualJson) {
1010 {1010 {
1011 ZipArchiveWriter writer(om2_path);1011 ZipArchiveWriter writer(om2_path);
1012 ASSERT_TRUE(writer.IsMemFileOpened());1012 ASSERT_TRUE(writer.IsMemFileOpened());
1013- const std::string manifest = R"({"om2_version":"0","model_num":1})";1013+ const std::string manifest = R"({"om2_version":"1.0","model_num":1})";
1014 writer.WriteBytes("manifest.json", manifest.data(), manifest.size(), false);1014 writer.WriteBytes("manifest.json", manifest.data(), manifest.size(), false);
1015 ModelBufferData buf;1015 ModelBufferData buf;
1016 writer.SaveModelData(buf, true);1016 writer.SaveModelData(buf, true);