Method _run

test/expr/ModuleTest.cpp:1326–1403

    }
    
    bool _run(int precision, bool shapeMultable) {
        BackendConfig bnConfig;
        auto exe = Executor::newExecutor(MNN_FORWARD_CPU, bnConfig, 1);
        ExecutorScope scope(exe);
        Module::Config config;
        config.shapeMutable = shapeMultable;
        config.rearrange = true;
        std::vector<int8_t> buffer;
        {
            // Make Buffer
            auto x0 = _Input({1, 3, -1, -1}, NCHW, halide_type_of<float>());
            x0->setName("x0");
            auto y0 = _mobileNetV1Expr(_Convert(x0, NC4HW4), false);
            y0->setName("y0");
            buffer = Variable::save({y0});
        }
        auto rtInfo = Express::ExecutorScope::Current()->getRuntime();
        auto rt = rtInfo.first.begin()->second;
        MNN::ScheduleConfig sconfig;
        std::vector<MNN::ScheduleConfig> sconfigs = {sconfig};
        std::shared_ptr<Executor::RuntimeManager> rtMgr(Executor::RuntimeManager::createRuntimeManager(sconfigs));
        rtMgr->setMode(Interpreter::Session_Memory_Collect);
        std::shared_ptr<MNN::Express::Module> m0(Module::load({"x0"}, {"y0"}, (const unsigned char*)buffer.data(), buffer.size(), rtMgr, &config), Module::destroy);
        std::shared_ptr<MNN::Express::Module> m1(Module::load({"x0"}, {"y0"}, (const unsigned char*)buffer.data(), buffer.size(), rtMgr, &config), Module::destroy);
        float memoryInit = 0.0f;
        rtMgr->getInfo(Interpreter::MEMORY, &memoryInit);
        FUNC_PRINT_ALL(memoryInit, f);
        auto x = _Input({1, 3, 96, 96}, NCHW, halide_type_of<float>());
        x->writeMap<float>();
        x->unMap();
        auto x1 = _Input({1, 3, 97, 97}, NCHW, halide_type_of<float>());
        x1->writeMap<float>();
        x1->unMap();
        auto x2 = _Input({1, 3, 95, 95}, NCHW, halide_type_of<float>());
        x2->writeMap<float>();
        x2->unMap();
        float memoryCurrent = 0.0f;
        auto compute = [&](){
            m0->onForward({x});
            rtMgr->getInfo(Interpreter::MEMORY, &memoryCurrent);
            auto dynamic0 = memoryCurrent - memoryInit;
            FUNC_PRINT_ALL(dynamic0, f);
            m1->onForward({x1});
            rtMgr->getInfo(Interpreter::MEMORY, &memoryCurrent);
            auto dynamic1 = memoryCurrent - memoryInit;

            FUNC_PRINT_ALL(dynamic1, f);
            m1->onForward({x2});
            rtMgr->getInfo(Interpreter::MEMORY, &memoryCurrent);
            auto dynamic2 = memoryCurrent - memoryInit;
            FUNC_PRINT_ALL(dynamic2, f);

            if (dynamic1 > dynamic0 * 1.1f || dynamic2 > dynamic1) {
                MNN_ERROR("Dynamic Memory reuse error\n");
                return false;
            }
            return true;
        };