Function test_free_memory_in_weight_preprocess

src/core/test/graph/misc.cpp:1914–1989

}

void test_free_memory_in_weight_preprocess(int record_level, CompNode cn) {
    HostTensorGenerator<> gen;
    auto graph = ComputingGraph::make();
#if MGB_ENABLE_JSON
    std::unique_ptr<GraphProfiler> profiler;
    if (!record_level) {
        profiler = std::make_unique<GraphProfiler>(graph.get());
    }
#endif
    graph->options().graph_opt.weight_preprocess = true;
    graph->options().comp_node_seq_record_level = record_level;
    auto mkvar = [&](const char* name, const TensorShape& shp) {
        return opr::Host2DeviceCopy::make(*graph, gen(shp, cn)).rename(name);
    };
    auto mkcvar = [&](const char* name, const TensorShape& shp) {
        return opr::SharedDeviceTensor::make_const(*graph, *gen(shp, cn)).rename(name);
    };
    auto x = mkvar("x", {1, 32, 16, 16});
    // ConvBias test dense
    opr::ConvBias::Param param_conv_bias;
    param_conv_bias.pad_h = param_conv_bias.pad_w = 0;
    param_conv_bias.sparse = opr::ConvBias::Param::Sparse::DENSE;
    auto w1 = mkcvar("w1", {32, 32, 1, 1}), b1 = mkcvar("b1", {1, 32, 1, 1});
    auto conv1 = opr::ConvBias::make(x, w1, b1, param_conv_bias);
    Maybe<bool> wp1, wp2;
    conv1.node()->owner_opr()->cast_final_safe<opr::ConvBias>().setup_algo_chooser(
            [&](const cg::OperatorNodeBase* opr) {
                return try_find_any_weight_preprocess_algo(
                        opr->cast_final_safe<opr::ConvBias>().megdnn_opr(),
                        opr->cname(), wp1, opr->input(0)->layout(),
                        opr->input(1)->layout(), opr->input(2)->layout(),
                        TensorLayout{}, opr->output(0)->layout());
            });
    // Convolution
    opr::Convolution::Param param_conv;
    param_conv.pad_h = param_conv.pad_w = 0;
    param_conv.sparse = opr::Convolution::Param::Sparse::DENSE;
    auto w2 = mkcvar("w2", {32, 32, 1, 1});
    auto y = opr::Convolution::make(conv1, w2, param_conv);
    y.node()->owner_opr()->cast_final_safe<opr::Convolution>().setup_algo_chooser(
            [&](const cg::OperatorNodeBase* opr) {
                return try_find_any_weight_preprocess_algo(
                        opr->cast_final_safe<opr::Convolution>().megdnn_opr(),
                        opr->cname(), wp2, opr->input(0)->layout(),
                        opr->input(1)->layout(), opr->output(0)->layout());
            });

    HostTensorND host_y;
    auto func = graph->compile({make_callback_copy(y, host_y)});
    //! flag the no need memory of var
    func->execute();
    //! free the no need memory of var
    func->execute();
    auto check = [&](SymbolVar v) {
        ASSERT_TRUE(v.node()->contain_flag(VarNode::Flag::MEMORY_NO_NEED));
        ASSERT_TRUE(v.node()->dev_tensor().empty());
        ASSERT_TRUE(v.node()->owner_opr()
                            ->cast_final_safe<opr::SharedDeviceTensor>()