Method run

test/expr/ModuleTest.cpp:1131–1225

class ResizeOptimizationTest : public MNNTestCase {
public:
    virtual bool run(int precision) {
        std::vector<int8_t> buffer;
        {
            // Make Buffer
            auto x0 = _Input({1, 3, 32, 32}, NCHW, halide_type_of<float>());
            x0->setName("x0");
            {
                auto x1s = _Shape(x0);
                auto ss = _Unstack(x1s);
                auto w = ss[2];
                auto h = ss[3];
                int batchNumber = 1;
                int channelNumber = 3;
                auto batch = _Const(&batchNumber, {}, NCHW, halide_type_of<int32_t>());
                auto channel = _Const(&channelNumber, {}, NCHW, halide_type_of<int32_t>());
                x0 = _Reshape(x0, _Stack({batch * channel, w * h}));
                x0 = _Reshape(x0, x1s);
            }
            auto y0 = _mobileNetV1Expr(_Convert(x0, NC4HW4), false);
            y0->setName("y0");
            auto x1 = _Input({1, 3, 64, 64}, NCHW, halide_type_of<float>());
            x1->setName("x1");
            auto y1 = _mobileNetV1Expr(_Convert(x1, NC4HW4), false);
            y1->setName("y1");
            auto z = y0 + y1;
            z->setName("z");
            buffer = Variable::save({z});
        }
        std::vector<std::pair<std::vector<int>, std::vector<int>>> inputShapes {
            {{1, 3, 32, 32}, {1, 3, 24, 24}},
            {{1, 3, 16, 16}, {1, 3, 24, 24}},
            {{1, 3, 48, 48}, {1, 3, 24, 24}},
        };
        {
            // Test For Interpreter API
            std::shared_ptr<Interpreter> net(Interpreter::createFromBuffer((void*)buffer.data(), buffer.size()), Interpreter::destroy);
            ScheduleConfig config;
            config.numThread = 1;
            net->setSessionMode(Interpreter::Session_Debug);
            auto session = net->createSession(config);
            auto getResult = [session, net, &inputShapes] {
                std::vector<float> resultSummer(inputShapes.size());
                auto x0 = net->getSessionInput(session, "x0");
                auto x1 = net->getSessionInput(session, "x1");
                auto z = net->getSessionOutput(session, "z");
                auto fillInput = [](MNN::Tensor* t, float v) {
                    std::shared_ptr<MNN::Tensor> tensor(new MNN::Tensor(t, t->getDimensionType()));
                    auto size = tensor->elementSize();
                    auto ptr = tensor->host<float>();
                    float cv = v;
                    for (int i=0; i<size; ++i) {
                        ptr[i] = cv;
                        cv = cv * -1.0f;
                    }
                    t->copyFromHostTensor(tensor.get());
                };
                for (int u=0; u<inputShapes.size(); ++u) {
                    net->resizeTensor(x0, inputShapes[u].first);