Function test_serializer_memshare

src/serialization/test/serializer_oss.cpp:828–897

}

void test_serializer_memshare(GraphDumpFormat format) {
    std::vector<uint8_t> buf;
    HostTensorGenerator<> gen;
    constexpr size_t SIZE = 127;
    auto xval = gen({SIZE}, "cpu0"), bval = gen({1}, "cpu0");

    auto dump = [&]() {
        auto graph = ComputingGraph::make();
        auto x0 = opr::SharedDeviceTensor::make(*graph, *xval).rename("x0");
        auto x1 = opr::SharedDeviceTensor::make(*graph, *xval).rename("x1");
        auto x2 = opr::SharedDeviceTensor::make(*graph, *xval).rename("x2");
        auto x3 = opr::SharedDeviceTensor::make(*graph, *xval).rename("x3");
        auto i4 = opr::ImmutableTensor::make(*graph, *xval).rename("i4");
        auto i5 = opr::ImmutableTensor::make(*graph, *xval).rename("i5");
        auto b = opr::SharedDeviceTensor::make(*graph, *bval).rename("b");
        auto dumper = GraphDumper::make(OutputFile::make_vector_proxy(&buf), format);
        dumper->dump({((x0 + x1) + b) + (x2 + x3) + i4 + i5, x0, i4});
    };

    HostTensorND expected;
    expected.copy_from(*xval);
    for (size_t i = 0; i < SIZE; ++i) {
        auto&& v = expected.ptr<float>()[i];
        v = v * 6 + bval->ptr<float>()[0];
    }

    std::vector<uint8_t> buf_al;
    auto load = [&](bool share) {
        std::unique_ptr<InputFile> fin;
        if (share) {
            buf_al.resize(buf.size());
            memcpy(buf_al.data(), buf.data(), buf.size());

            fin = InputFile::make_mem_proxy(
                    std::shared_ptr<void>{std::shared_ptr<void>{}, buf_al.data()},
                    buf.size());
        } else {
            fin = InputFile::make_mem_proxy(buf.data(), buf.size());
        }
        auto loader = GraphLoader::make(std::move(fin), format);
        auto rst = loader->load();
        auto x = rst.output_var_map.at("x0");
        auto i4 = rst.output_var_map.at("i4");
        auto&& opr = x.node()->owner_opr()->cast_final_safe<opr::SharedDeviceTensor>();
        auto&& opr_imm =
                i4.node()->owner_opr()->cast_final_safe<opr::ImmutableTensor>();
        HostTensorND val;
        auto func =
                rst.graph_compile({make_callback_copy(rst.output_var_list[0], val)});
        func->execute();
        return std::make_pair(
                val, std::vector<DeviceTensorND>{*opr.dev_data(), opr_imm.value()});
    };

    auto in_range = [](const std::vector<uint8_t>& buf, DeviceTensorND& dv) {
        auto p0 = reinterpret_cast<uint8_t*>(dv.raw_ptr()),
             p1 = reinterpret_cast<uint8_t*>(p0 + dv.layout().span().high_byte);
        return buf.data() <= p0 && p1 <= buf.data() + buf.size();