From 283a2f77e7562361b8e457cbbe4bd63da79bb354 Mon Sep 17 00:00:00 2001 From: Megvii Engine Team Date: Wed, 11 May 2022 18:03:28 +0800 Subject: [PATCH] feat(serialization): support test for new serialization format GitOrigin-RevId: 9a8047ec0ba53c273c83cc0608cee424d3816d36 --- src/opr/impl/loop/forward_sereg.cpp | 3 +- src/serialization/impl/opr_registry.cpp | 4 +- src/serialization/test/serializer_oss.cpp | 379 +++++++++++++++++++++--------- 3 files changed, 273 insertions(+), 113 deletions(-) diff --git a/src/opr/impl/loop/forward_sereg.cpp b/src/opr/impl/loop/forward_sereg.cpp index df5b2862..8eb1bccd 100644 --- a/src/opr/impl/loop/forward_sereg.cpp +++ b/src/opr/impl/loop/forward_sereg.cpp @@ -137,8 +137,7 @@ void LoopSerializer::reg_all() { CounterProvider, dump_counter_provider, load_counter_provider); MGB_SEREG_OPR_INTL_CALL_ADD_V2( - opr::Loop, dump_loop, load_loop, nullptr, 2, - CURRENT_VERSION); + opr::Loop, dump_loop, load_loop, nullptr, 2, CURRENT_VERSION); MGB_SEREG_OPR_INTL_CALL_ADD_V2( InputMaker, dump_input_maker, load_input_maker, nullptr, 2, CURRENT_VERSION); diff --git a/src/serialization/impl/opr_registry.cpp b/src/serialization/impl/opr_registry.cpp index c0ea45eb..11d65a03 100644 --- a/src/serialization/impl/opr_registry.cpp +++ b/src/serialization/impl/opr_registry.cpp @@ -184,9 +184,11 @@ void OprRegistryV2::versioned_add( auto id = record.type_id; uint64_t type_id = id; //! record.type->name is nullptr when MGB_VERBOSE_TYPEINFO_NAME==0 +#if MGB_VERBOSE_TYPEINFO_NAME if (record.type && record.type->name) { type_id = MGB_HASH_RUNTIME(std::string(record.type->name)); } +#endif for (uint8_t version = min_version; version <= max_version; version++) { auto&& registry_map = sd.version_id_reg_map[version]; auto versioned_record = record; @@ -206,7 +208,7 @@ void OprRegistryV2::versioned_add( if (id != type_id) { mgb_assert( registry_map.find(type_id) == registry_map.end(), - "dduplicated OprRegistryV2 of %s\n", record.name.c_str()); + "duplicated OprRegistryV2 of %s\n", record.name.c_str()); registry_map.emplace(type_id, versioned_record); } auto&& registry_type_map = sd.version_type_reg_map[version]; diff --git a/src/serialization/test/serializer_oss.cpp b/src/serialization/test/serializer_oss.cpp index ebbfa5ff..845afaaa 100644 --- a/src/serialization/test/serializer_oss.cpp +++ b/src/serialization/test/serializer_oss.cpp @@ -2,6 +2,7 @@ #include "megbrain/opr/basic_arith_wrapper.h" #include "megbrain/opr/dnn/convolution.h" +#include "megbrain/opr/dnn/softmax.h" #include "megbrain/opr/io.h" #include "megbrain/opr/tensor_manip.h" #include "megbrain/opr/utility.h" @@ -11,10 +12,12 @@ using namespace mgb; using namespace serialization; -#define GET_OUTPUT_FILE() output_file(ssprintf("TestSerializer2.%d", __LINE__)) +#define GET_OUTPUT_FILE(format) \ + output_file(ssprintf("TestSerializer2.line%d.V%d", __LINE__, (int)format)) -TEST(TestSerializer2, GraphDumpLoad) { - auto fname = GET_OUTPUT_FILE(); +namespace { +void test_graph_load_dump(GraphDumpFormat format) { + auto fname = GET_OUTPUT_FILE(format); auto orig_id = -1; auto dump = [&]() { @@ -22,8 +25,7 @@ TEST(TestSerializer2, GraphDumpLoad) { auto graph = ComputingGraph::make(); auto x = opr::ImmutableTensor::make(*graph, 1926.0817f, {cn}); x.rename("varz"); - auto dumper = GraphDumper::make( - OutputFile::make_fs(fname.c_str()), GraphDumpFormat::FLATBUFFERS); + auto dumper = GraphDumper::make(OutputFile::make_fs(fname.c_str()), format); auto rst = dumper->dump({x}); ASSERT_EQ(rst.nr_opr, 1); ASSERT_EQ(rst.inputs.size(), 0); @@ -33,8 +35,7 @@ TEST(TestSerializer2, GraphDumpLoad) { mgb_log("%zu of %zu", rst.tensor_value_bytes, rst.tot_bytes); }; auto load = [&]() { - auto loader = GraphLoader::make( - InputFile::make_fs(fname.c_str()), GraphDumpFormat::FLATBUFFERS); + auto loader = GraphLoader::make(InputFile::make_fs(fname.c_str()), format); auto rst = loader->load(); ASSERT_EQ(rst.tensor_map.size(), 0); ASSERT_EQ(rst.output_var_list.size(), 1); @@ -54,24 +55,22 @@ TEST(TestSerializer2, GraphDumpLoad) { load(); } -TEST(TestSerializer2, MultiGraphDumpLoad) { - auto fname = GET_OUTPUT_FILE(); +void test_multi_graph_dump_load(GraphDumpFormat format) { + auto fname = GET_OUTPUT_FILE(format); auto dump = [&]() { auto cn = CompNode::load("cpu0"); auto graph = ComputingGraph::make(); auto x = opr::ImmutableTensor::make(*graph, 1926.0817f, {cn}); x.rename("varz"); - auto dumper = GraphDumper::make( - OutputFile::make_fs(fname.c_str()), GraphDumpFormat::FLATBUFFERS); + auto dumper = GraphDumper::make(OutputFile::make_fs(fname.c_str()), format); // dump twice dumper->dump({x}); dumper->dump({x}); }; auto load = [&]() { GraphLoader::LoadConfig load_config = {}; - auto loader = GraphLoader::make( - InputFile::make_fs(fname.c_str()), GraphDumpFormat::FLATBUFFERS); + auto loader = GraphLoader::make(InputFile::make_fs(fname.c_str()), format); // load twice loader->load(load_config, false); loader = GraphLoader::make(loader->reset_file(), loader->format()); @@ -82,8 +81,8 @@ TEST(TestSerializer2, MultiGraphDumpLoad) { load(); } -TEST(TestSerializer2, Metadata) { - auto fname = GET_OUTPUT_FILE(); +void test_metadata(GraphDumpFormat format) { + auto fname = GET_OUTPUT_FILE(format); TensorShape shape{2, 3}; auto dump = [&]() { @@ -100,15 +99,13 @@ TEST(TestSerializer2, Metadata) { metadata.user_info = "TEST_METADATA"; metadata.has_user_info = true; - auto dumper = GraphDumper::make( - OutputFile::make_fs(fname.c_str()), GraphDumpFormat::FLATBUFFERS); + auto dumper = GraphDumper::make(OutputFile::make_fs(fname.c_str()), format); auto rst = dumper->dump({z.rename("z")}, {}, metadata); }; auto load = [&]() { HostTensorGenerator<> gen; - auto loader = GraphLoader::make( - InputFile::make_fs(fname.c_str()), GraphDumpFormat::FLATBUFFERS); + auto loader = GraphLoader::make(InputFile::make_fs(fname.c_str()), format); auto rst = loader->load(); auto metadata = rst.metadata; int cmp = strcmp(metadata.user_info.c_str(), "TEST_METADATA"); @@ -119,8 +116,8 @@ TEST(TestSerializer2, Metadata) { load(); } -TEST(TestSerializer2, APlusB) { - auto fname = GET_OUTPUT_FILE(); +void test_serializer_APlusB(GraphDumpFormat format) { + auto fname = GET_OUTPUT_FILE(format); TensorShape shape{2, 3}; auto dump = [&]() { @@ -131,8 +128,7 @@ TEST(TestSerializer2, APlusB) { auto x = opr::Host2DeviceCopy::make(*graph, host_x, {"x"}), y = opr::Host2DeviceCopy::make(*graph, host_y, {"y"}); - auto dumper = GraphDumper::make( - OutputFile::make_fs(fname.c_str()), GraphDumpFormat::FLATBUFFERS); + auto dumper = GraphDumper::make(OutputFile::make_fs(fname.c_str()), format); // test dump duplicated auto rst = dumper->dump({(x + y).rename("z"), x + y}); ASSERT_EQ(2u, rst.outputs.size()); @@ -140,8 +136,7 @@ TEST(TestSerializer2, APlusB) { auto load = [&]() { HostTensorGenerator<> gen; - auto loader = GraphLoader::make( - InputFile::make_fs(fname.c_str()), GraphDumpFormat::FLATBUFFERS); + auto loader = GraphLoader::make(InputFile::make_fs(fname.c_str()), format); auto rst = loader->load(); auto xv = rst.tensor_map.at("x"); auto yv = rst.tensor_map.at("y"); @@ -163,9 +158,9 @@ TEST(TestSerializer2, APlusB) { load(); } -TEST(TestSerializer2, APlusBParam) { +void test_serializer_APlusB_param(GraphDumpFormat format) { auto cns = load_multiple_xpus(2); - auto fname = GET_OUTPUT_FILE(); + auto fname = GET_OUTPUT_FILE(format); TensorShape shape{2, 3}; HostTensorGenerator<> gen; @@ -180,14 +175,12 @@ TEST(TestSerializer2, APlusBParam) { auto x = opr::Host2DeviceCopy::make(*graph, host_x, {"x"}), y = opr::SharedDeviceTensor::make(*graph, bias, {"y"}); - auto dumper = GraphDumper::make( - OutputFile::make_fs(fname.c_str()), GraphDumpFormat::FLATBUFFERS); + auto dumper = GraphDumper::make(OutputFile::make_fs(fname.c_str()), format); GraphDumper::DumpConfig config; config.keep_param_name = true; dumper->dump({(x + y).rename("z")}, config); } - auto loader = GraphLoader::make( - InputFile::make_fs(fname.c_str()), GraphDumpFormat::FLATBUFFERS); + auto loader = GraphLoader::make(InputFile::make_fs(fname.c_str()), format); auto load = [&](CompNode dest_cn) { auto dest_cn_loc = dest_cn.locator_logical(); @@ -215,8 +208,8 @@ TEST(TestSerializer2, APlusBParam) { ASSERT_EQ(1u + (cns[1].mem_node() != cns[0].mem_node()), shmap.at("y")->size()); } -TEST(TestSerializer2, Immutable) { - auto fname = GET_OUTPUT_FILE(); +void test_serializer_immutable(GraphDumpFormat format) { + auto fname = GET_OUTPUT_FILE(format); TensorShape shape{2, 3}; auto dump = [&]() { @@ -224,15 +217,13 @@ TEST(TestSerializer2, Immutable) { auto host_x = std::make_shared(cn, shape); auto graph = ComputingGraph::make(); auto x = opr::Host2DeviceCopy::make(*graph, host_x, {"x"}); - auto dumper = GraphDumper::make( - OutputFile::make_fs(fname.c_str()), GraphDumpFormat::FLATBUFFERS); + auto dumper = GraphDumper::make(OutputFile::make_fs(fname.c_str()), format); dumper->dump({(x + 1.f).rename("y")}); }; auto load = [&]() { HostTensorGenerator<> gen; - auto loader = GraphLoader::make( - InputFile::make_fs(fname.c_str()), GraphDumpFormat::FLATBUFFERS); + auto loader = GraphLoader::make(InputFile::make_fs(fname.c_str()), format); auto rst = loader->load(); auto xv = rst.tensor_map.at("x"); ASSERT_EQ(shape, xv->shape()); @@ -251,8 +242,8 @@ TEST(TestSerializer2, Immutable) { load(); } -TEST(TestSerializer2, CustomLoader) { - auto fname = GET_OUTPUT_FILE(); +void test_serializer_custom_loader(GraphDumpFormat format) { + auto fname = GET_OUTPUT_FILE(format); TensorShape shape{2, 3}; int load_nr_null_ptr = 0, load_nr_call = 0; @@ -292,8 +283,7 @@ TEST(TestSerializer2, CustomLoader) { auto x = opr::Host2DeviceCopy::make(*graph, host_x, {"x"}), y = opr::SharedDeviceTensor::make(*graph, y_val), z = ((x + 1.f) * y).rename("z"); - auto dumper = GraphDumper::make( - OutputFile::make_fs(fname.c_str()), GraphDumpFormat::FLATBUFFERS); + auto dumper = GraphDumper::make(OutputFile::make_fs(fname.c_str()), format); GraphDumpConfig config; config.tensor_value_dumper = tensor_value_dumper; dumper->dump({z}, config); @@ -302,8 +292,7 @@ TEST(TestSerializer2, CustomLoader) { GraphLoadConfig config; config.tensor_value_loader = tensor_value_loader; - auto loader = GraphLoader::make( - InputFile::make_fs(fname.c_str()), GraphDumpFormat::FLATBUFFERS); + auto loader = GraphLoader::make(InputFile::make_fs(fname.c_str()), format); auto load = [&]() { HostTensorGenerator<> gen; auto rst = loader->load(config); @@ -329,8 +318,8 @@ TEST(TestSerializer2, CustomLoader) { ASSERT_EQ(4, load_nr_call); } -TEST(TestSerializer2, ManyIOVars) { - auto fname = GET_OUTPUT_FILE(); +void test_serializer_many_io_var(GraphDumpFormat format) { + auto fname = GET_OUTPUT_FILE(format); constexpr size_t NR_VARS = 32; auto dump = [&]() { auto graph = ComputingGraph::make(); @@ -355,15 +344,13 @@ TEST(TestSerializer2, ManyIOVars) { con, 0, std::vector(NR_VARS, 1)), OperatorNodeConfig{}.comp_node_arr(y_comp_nodes)); - auto dumper = GraphDumper::make( - OutputFile::make_fs(fname.c_str()), GraphDumpFormat::FLATBUFFERS); + auto dumper = GraphDumper::make(OutputFile::make_fs(fname.c_str()), format); auto rst = dumper->dump(ys); }; auto load = [&]() { HostTensorGenerator<> gen; - auto loader = GraphLoader::make( - InputFile::make_fs(fname.c_str()), GraphDumpFormat::FLATBUFFERS); + auto loader = GraphLoader::make(InputFile::make_fs(fname.c_str()), format); auto rst = loader->load(); ASSERT_EQ(NR_VARS, rst.output_var_list.size()); ComputingGraph::OutputSpec out_spec(NR_VARS); @@ -391,8 +378,8 @@ TEST(TestSerializer2, ManyIOVars) { load(); } -TEST(TestSerializer2, RemoveSetGrad) { - auto fname = GET_OUTPUT_FILE(); +void test_serializer_remove_set_grad(GraphDumpFormat format) { + auto fname = GET_OUTPUT_FILE(format); TensorShape shape{2, 3}; auto dump = [&]() { @@ -412,15 +399,13 @@ TEST(TestSerializer2, RemoveSetGrad) { // SetGrad as internal auto z1 = sg(x) + sg(sg(y)); - auto dumper = GraphDumper::make( - OutputFile::make_fs(fname.c_str()), GraphDumpFormat::FLATBUFFERS); + auto dumper = GraphDumper::make(OutputFile::make_fs(fname.c_str()), format); dumper->dump({z0, z1}); }; auto load = [&]() { HostTensorGenerator<> gen; - auto loader = GraphLoader::make( - InputFile::make_fs(fname.c_str()), GraphDumpFormat::FLATBUFFERS); + auto loader = GraphLoader::make(InputFile::make_fs(fname.c_str()), format); auto rst = loader->load(); auto xv = rst.tensor_map.at("x"); auto yv = rst.tensor_map.at("y"); @@ -445,8 +430,8 @@ TEST(TestSerializer2, RemoveSetGrad) { load(); } -TEST(TestSerializer2, MultipleParamNDIMDTypeCompNode) { - auto fname = GET_OUTPUT_FILE(); +void test_serializer_multiple_param(GraphDumpFormat format) { + auto fname = GET_OUTPUT_FILE(format); std::vector> values; auto add_value = [&](int stream, int ndim, DType dtype) { CompNode::Locator loc; @@ -487,14 +472,12 @@ TEST(TestSerializer2, MultipleParamNDIMDTypeCompNode) { #undef cb } ASSERT_GT(values.size(), 8u); - auto dumper = GraphDumper::make( - OutputFile::make_fs(fname.c_str()), GraphDumpFormat::FLATBUFFERS); + auto dumper = GraphDumper::make(OutputFile::make_fs(fname.c_str()), format); dumper->dump({x}); }; auto load = [&]() { - auto loader = GraphLoader::make( - InputFile::make_fs(fname.c_str()), GraphDumpFormat::FLATBUFFERS); + auto loader = GraphLoader::make(InputFile::make_fs(fname.c_str()), format); ASSERT_THROW(loader->shared_tensor_id_map(), MegBrainError); loader->load(); auto&& got = loader->shared_tensor_id_map(); @@ -515,8 +498,8 @@ TEST(TestSerializer2, MultipleParamNDIMDTypeCompNode) { load(); } -TEST(TestSerializer2, ConstVarShape) { - auto fname = GET_OUTPUT_FILE(); +void test_serializer_const_var_shape(GraphDumpFormat format) { + auto fname = GET_OUTPUT_FILE(format); TensorShape shape{2, 3}; HostTensorGenerator<> gen; auto host_x = gen({2, 3}); @@ -525,14 +508,12 @@ TEST(TestSerializer2, ConstVarShape) { // dump auto graph = ComputingGraph::make(); auto x = opr::Host2DeviceCopy::make(*graph, host_x, {"x"}); - auto dumper = GraphDumper::make( - OutputFile::make_fs(fname.c_str()), GraphDumpFormat::FLATBUFFERS); + auto dumper = GraphDumper::make(OutputFile::make_fs(fname.c_str()), format); dumper->dump({x + 1.f}); } auto run_and_check = [&](const GraphLoadConfig& config) { - auto loader = GraphLoader::make( - InputFile::make_fs(fname.c_str()), GraphDumpFormat::FLATBUFFERS); + auto loader = GraphLoader::make(InputFile::make_fs(fname.c_str()), format); auto rst = loader->load(config); rst.tensor_map.at("x")->copy_from(*host_x); auto y = rst.output_var_list[0]; @@ -588,8 +569,8 @@ TEST(TestSerializer2, ConstVarShape) { } } -TEST(TestSerializer2, ConstVarShapeOutputName) { - auto fname = GET_OUTPUT_FILE(); +void test_serializer_const_var_shape_output_name(GraphDumpFormat format) { + auto fname = GET_OUTPUT_FILE(format); TensorShape shape{2, 3}; HostTensorGenerator<> gen; auto host_x = gen({2, 3}); @@ -600,15 +581,13 @@ TEST(TestSerializer2, ConstVarShapeOutputName) { auto x = opr::Host2DeviceCopy::make(*graph, host_x, {"x"}), y = opr::GetVarShape::make(x) + 1; y.rename("out"); - auto dumper = GraphDumper::make( - OutputFile::make_fs(fname.c_str()), GraphDumpFormat::FLATBUFFERS); + auto dumper = GraphDumper::make(OutputFile::make_fs(fname.c_str()), format); dumper->dump({y}); } { // load - auto loader = GraphLoader::make( - InputFile::make_fs(fname.c_str()), GraphDumpFormat::FLATBUFFERS); + auto loader = GraphLoader::make(InputFile::make_fs(fname.c_str()), format); GraphLoadConfig config; config.const_var_shape = true; auto rst = loader->load(config); @@ -618,8 +597,8 @@ TEST(TestSerializer2, ConstVarShapeOutputName) { } } -TEST(TestSerializer2, Priority) { - auto fname = GET_OUTPUT_FILE(); +void test_serializer_priority(GraphDumpFormat format) { + auto fname = GET_OUTPUT_FILE(format); TensorShape shape{2, 3}; auto dump = [&](bool keep_pri) { @@ -633,8 +612,7 @@ TEST(TestSerializer2, Priority) { set_priority(x, 1); set_priority(y, 2); - auto dumper = GraphDumper::make( - OutputFile::make_fs(fname.c_str()), GraphDumpFormat::FLATBUFFERS); + auto dumper = GraphDumper::make(OutputFile::make_fs(fname.c_str()), format); GraphDumper::DumpConfig config; if (keep_pri) { config.keep_opr_priority = true; @@ -643,8 +621,7 @@ TEST(TestSerializer2, Priority) { }; auto load = [&](bool has_pri) { - auto loader = GraphLoader::make( - InputFile::make_fs(fname.c_str()), GraphDumpFormat::FLATBUFFERS); + auto loader = GraphLoader::make(InputFile::make_fs(fname.c_str()), format); auto rst = loader->load(); VarNode *x, *y; unpack_vector(rst.output_var_list.front().node()->owner_opr()->input(), x, y); @@ -668,8 +645,8 @@ TEST(TestSerializer2, Priority) { load(true); } -TEST(TestSerializer2, MultipleParams) { - auto fname = GET_OUTPUT_FILE(); +void test_serializer_multiple_params(GraphDumpFormat format) { + auto fname = GET_OUTPUT_FILE(format); HostTensorGenerator<> gen; std::vector> tensors{ gen({2, 3}), gen({1}), gen({3, 2}), gen({1, 1})}; @@ -680,14 +657,11 @@ TEST(TestSerializer2, MultipleParams) { for (auto&& i : tensors) { outputs.push_back(opr::SharedDeviceTensor::make(*graph, *i)); } - GraphDumper::make( - OutputFile::make_fs(fname.c_str()), GraphDumpFormat::FLATBUFFERS) - ->dump(outputs); + GraphDumper::make(OutputFile::make_fs(fname.c_str()), format)->dump(outputs); }; auto load = [&]() { - auto loader = GraphLoader::make( - InputFile::make_fs(fname.c_str()), GraphDumpFormat::FLATBUFFERS); + auto loader = GraphLoader::make(InputFile::make_fs(fname.c_str()), format); auto rst = loader->load(); ASSERT_EQ(tensors.size(), rst.output_var_list.size()); for (size_t i = 0; i < tensors.size(); ++i) { @@ -706,8 +680,8 @@ TEST(TestSerializer2, MultipleParams) { load(); } -TEST(TestSerializer2, ParamerizedDType) { - auto fname = GET_OUTPUT_FILE(); +void test_serializer_paramerized_dtype(GraphDumpFormat format) { + auto fname = GET_OUTPUT_FILE(format); TensorShape shape{2, 3, 3}; dtype::Quantized8Asymm dtype(0.01f, (uint8_t)123); @@ -720,14 +694,12 @@ TEST(TestSerializer2, ParamerizedDType) { auto graph = ComputingGraph::make(); auto x = opr::Host2DeviceCopy::make(*graph, host_x, {"x"}); auto rst = opr::Dimshuffle::make(x, {1, 2, 0}); - auto dumper = GraphDumper::make( - OutputFile::make_fs(fname.c_str()), GraphDumpFormat::FLATBUFFERS); + auto dumper = GraphDumper::make(OutputFile::make_fs(fname.c_str()), format); dumper->dump({rst}); }; auto load = [&]() { - auto loader = GraphLoader::make( - InputFile::make_fs(fname.c_str()), GraphDumpFormat::FLATBUFFERS); + auto loader = GraphLoader::make(InputFile::make_fs(fname.c_str()), format); auto rst = loader->load(); ASSERT_EQ(rst.output_var_list.size(), 1u); EXPECT_EQ(rst.output_var_list.front().node()->dtype(), dtype); @@ -737,8 +709,8 @@ TEST(TestSerializer2, ParamerizedDType) { load(); } -TEST(TestSerializer2, OperatorName) { - auto fname = GET_OUTPUT_FILE(); +void test_serializer_operator_name(GraphDumpFormat format) { + auto fname = GET_OUTPUT_FILE(format); TensorShape shape{2, 3}; auto dump = [&]() { @@ -751,15 +723,13 @@ TEST(TestSerializer2, OperatorName) { using Mode = opr::Elemwise::Mode; auto z = opr::Elemwise::make({x, y}, Mode::ADD, {"add(x, y)"}); - auto dumper = GraphDumper::make( - OutputFile::make_fs(fname.c_str()), GraphDumpFormat::FLATBUFFERS); + auto dumper = GraphDumper::make(OutputFile::make_fs(fname.c_str()), format); auto rst = dumper->dump({z.rename("z")}); }; auto load = [&]() { HostTensorGenerator<> gen; - auto loader = GraphLoader::make( - InputFile::make_fs(fname.c_str()), GraphDumpFormat::FLATBUFFERS); + auto loader = GraphLoader::make(InputFile::make_fs(fname.c_str()), format); auto rst = loader->load(); auto z = rst.output_var_map.at("z"); auto op_name = z.node()->owner_opr()->cname(); @@ -771,8 +741,8 @@ TEST(TestSerializer2, OperatorName) { load(); } -TEST(TestSerializer2, HasOutputDtype) { - auto fname = GET_OUTPUT_FILE(); +void test_serializer_has_output_dtype(GraphDumpFormat format) { + auto fname = GET_OUTPUT_FILE(format); HostTensorGenerator<> gen; @@ -792,8 +762,7 @@ TEST(TestSerializer2, HasOutputDtype) { x, w, b, param, {}, OperatorNodeConfig{dtype::QuantizedS32(0.05f)}); auto y1 = opr::ConvBias::make( x, w, b, param, {}, OperatorNodeConfig{dtype::QuantizedS8(0.3f)}); - auto dumper = GraphDumper::make( - OutputFile::make_fs(fname.c_str()), GraphDumpFormat::FLATBUFFERS); + auto dumper = GraphDumper::make(OutputFile::make_fs(fname.c_str()), format); dumper->dump({y0, y1}); }; @@ -806,8 +775,7 @@ TEST(TestSerializer2, HasOutputDtype) { }; auto load = [&]() { - auto loader = GraphLoader::make( - InputFile::make_fs(fname.c_str()), GraphDumpFormat::FLATBUFFERS); + auto loader = GraphLoader::make(InputFile::make_fs(fname.c_str()), format); auto rst = loader->load(); ASSERT_EQ(rst.output_var_list.size(), 2u); check(rst, 0, dtype::QuantizedS32(0.05f)); @@ -818,8 +786,8 @@ TEST(TestSerializer2, HasOutputDtype) { load(); } -TEST(TestSerializer2, LOGEXP) { - auto fname = GET_OUTPUT_FILE(); +void test_serializer_log_exp(GraphDumpFormat format) { + auto fname = GET_OUTPUT_FILE(format); TensorShape shape{2, 3}; using Mode = opr::Elemwise::Mode; bool inplace_opt = true; @@ -835,16 +803,14 @@ TEST(TestSerializer2, LOGEXP) { auto y = opr::Elemwise::make({x}, Mode::EXP); auto z = opr::Elemwise::make({y}, Mode::LOG); - auto dumper = GraphDumper::make( - OutputFile::make_fs(fname.c_str()), GraphDumpFormat::FLATBUFFERS); + auto dumper = GraphDumper::make(OutputFile::make_fs(fname.c_str()), format); auto rst = dumper->dump({z.rename("z"), z}); size_t expected_nr_opr = inplace_opt ? 1 : 3; ASSERT_EQ(expected_nr_opr, rst.nr_opr); }; auto load = [&]() { - auto loader = GraphLoader::make( - InputFile::make_fs(fname.c_str()), GraphDumpFormat::FLATBUFFERS); + auto loader = GraphLoader::make(InputFile::make_fs(fname.c_str()), format); auto rst = loader->load(); }; @@ -855,4 +821,197 @@ TEST(TestSerializer2, LOGEXP) { dump(); load(); } + +} // namespace + +TEST(TestSerializer2, GraphDumpLoad) { + test_graph_load_dump(GraphDumpFormat::FLATBUFFERS); +} + +TEST(TestSerializer2, MultiGraphDumpLoad) { + test_multi_graph_dump_load(GraphDumpFormat::FLATBUFFERS); +} + +TEST(TestSerializer2, Metadata) { + test_metadata(GraphDumpFormat::FLATBUFFERS); +} + +TEST(TestSerializer2, APlusB) { + test_serializer_APlusB(GraphDumpFormat::FLATBUFFERS); +} + +TEST(TestSerializer2, APlusBParam) { + test_serializer_APlusB_param(GraphDumpFormat::FLATBUFFERS); +} + +TEST(TestSerializer2, Immutable) { + test_serializer_immutable(GraphDumpFormat::FLATBUFFERS); +} + +TEST(TestSerializer2, CustomLoader) { + test_serializer_custom_loader(GraphDumpFormat::FLATBUFFERS); +} + +TEST(TestSerializer2, ManyIOVars) { + test_serializer_many_io_var(GraphDumpFormat::FLATBUFFERS); +} + +TEST(TestSerializer2, RemoveSetGrad) { + test_serializer_remove_set_grad(GraphDumpFormat::FLATBUFFERS); +} + +TEST(TestSerializer2, MultipleParamNDIMDTypeCompNode) { + test_serializer_multiple_param(GraphDumpFormat::FLATBUFFERS); +} + +TEST(TestSerializer2, ConstVarShape) { + test_serializer_const_var_shape(GraphDumpFormat::FLATBUFFERS); +} + +TEST(TestSerializer2, ConstVarShapeOutputName) { + test_serializer_const_var_shape_output_name(GraphDumpFormat::FLATBUFFERS); +} + +TEST(TestSerializer2, Priority) { + test_serializer_priority(GraphDumpFormat::FLATBUFFERS); +} + +TEST(TestSerializer2, MultipleParams) { + test_serializer_multiple_params(GraphDumpFormat::FLATBUFFERS); +} + +TEST(TestSerializer2, ParamerizedDType) { + test_serializer_paramerized_dtype(GraphDumpFormat::FLATBUFFERS); +} + +TEST(TestSerializer2, OperatorName) { + test_serializer_operator_name(GraphDumpFormat::FLATBUFFERS); +} + +TEST(TestSerializer2, HasOutputDtype) { + test_serializer_has_output_dtype(GraphDumpFormat::FLATBUFFERS); +} + +TEST(TestSerializer2, LOGEXP) { + test_serializer_log_exp(GraphDumpFormat::FLATBUFFERS); +} + +/******************** Flatbuffer V2 Test **********************/ + +TEST(TestSerializer2, GraphDumpLoadV2) { + test_graph_load_dump(GraphDumpFormat::FLATBUFFERS_V2); +} + +TEST(TestSerializer2, MultiGraphDumpLoadV2) { + test_multi_graph_dump_load(GraphDumpFormat::FLATBUFFERS_V2); +} + +TEST(TestSerializer2, MetadataV2) { + test_metadata(GraphDumpFormat::FLATBUFFERS_V2); +} + +TEST(TestSerializer2, APlusBV2) { + test_serializer_APlusB(GraphDumpFormat::FLATBUFFERS_V2); +} + +TEST(TestSerializer2, APlusBParamV2) { + test_serializer_APlusB_param(GraphDumpFormat::FLATBUFFERS_V2); +} + +TEST(TestSerializer2, ImmutableV2) { + test_serializer_immutable(GraphDumpFormat::FLATBUFFERS_V2); +} + +TEST(TestSerializer2, ManyIOVarsV2) { + test_serializer_many_io_var(GraphDumpFormat::FLATBUFFERS_V2); +} + +TEST(TestSerializer2, RemoveSetGradV2) { + test_serializer_remove_set_grad(GraphDumpFormat::FLATBUFFERS_V2); +} + +TEST(TestSerializer2, MultipleParamNDIMDTypeCompNodeV2) { + test_serializer_multiple_param(GraphDumpFormat::FLATBUFFERS_V2); +} + +TEST(TestSerializer2, ConstVarShapeV2) { + test_serializer_const_var_shape(GraphDumpFormat::FLATBUFFERS_V2); +} + +TEST(TestSerializer2, ConstVarShapeOutputNameV2) { + test_serializer_const_var_shape_output_name(GraphDumpFormat::FLATBUFFERS_V2); +} + +TEST(TestSerializer2, MultipleParamsV2) { + test_serializer_multiple_params(GraphDumpFormat::FLATBUFFERS_V2); +} + +TEST(TestSerializer2, ParamerizedDTypeV2) { + test_serializer_paramerized_dtype(GraphDumpFormat::FLATBUFFERS_V2); +} + +TEST(TestSerializer2, PriorityV2) { + test_serializer_priority(GraphDumpFormat::FLATBUFFERS_V2); +} + +TEST(TestSerializer2, OperatorNameV2) { + test_serializer_operator_name(GraphDumpFormat::FLATBUFFERS_V2); +} + +TEST(TestSerializer2, HasOutputDtypeV2) { + test_serializer_has_output_dtype(GraphDumpFormat::FLATBUFFERS_V2); +} + +TEST(TestSerializer2, LOGEXPV2) { + test_serializer_log_exp(GraphDumpFormat::FLATBUFFERS_V2); +} + +TEST(TestSerializer2, TestSoftMaxLoadDump) { + auto fname = GET_OUTPUT_FILE(GraphDumpFormat::FLATBUFFERS_V2); + TensorShape shape{2, 3}; + + auto cn = CompNode::load("xpu0"); + std::shared_ptr host = + std::make_shared(cn, shape, dtype::Float32{}); + HostTensorND dst_truth; + for (int i = 0; i < 6; i++) { + host->ptr()[i] = i; + } + auto dump = [&]() { + auto graph = ComputingGraph::make(); + auto h2d = opr::Host2DeviceCopy::make(*graph, host); + auto x = opr::Softmax::make(h2d, {1}, {}); + x.rename("softmax_out"); + auto func = graph->compile({make_callback_copy(x, dst_truth)}); + auto dumper = GraphDumper::make( + OutputFile::make_fs(fname.c_str()), GraphDumpFormat::FLATBUFFERS_V2); + auto rst = dumper->dump({x}); + func->execute().wait(); + ASSERT_EQ(rst.nr_opr, 6); + ASSERT_EQ(rst.inputs.size(), 1); + ASSERT_EQ(rst.outputs.size(), 1); + ASSERT_EQ(rst.params.size(), 0); + }; + auto load = [&]() { + auto loader = GraphLoader::make( + InputFile::make_fs(fname.c_str()), GraphDumpFormat::FLATBUFFERS_V2); + auto rst = loader->load(); + ASSERT_EQ(rst.tensor_map.size(), 1); + ASSERT_EQ(rst.output_var_list.size(), 1); + ASSERT_EQ(rst.output_var_map.size(), 1); + ASSERT_EQ(rst.output_var_map.count("softmax_out"), 1); + + HostTensorND host_x; + auto func = + rst.graph_compile({make_callback_copy(rst.output_var_list[0], host_x)}); + rst.tensor_map.begin()->second->copy_from(*host).sync(); + func->execute().wait(); + for (int i = 0; i < 6; i++) { + EXPECT_NEAR(host_x.ptr()[i], dst_truth.ptr()[i], 1e-6); + } + }; + dump(); + load(); +} + #endif