Method run

test/expr/StaticModuleOutputReuseTest.cpp:66–244

class StaticModuleOutputReuseTest : public MNNTestCase {
public:
    bool run(int precision) override {
        auto executor = cloneCurrentExecutor();
        ExecutorScope scope(executor);

        std::vector<int8_t> buffer;
        {
            auto x = _Input({1, 4, 32, 32}, NCHW, halide_type_of<float>());
            x->setName("Input");
            auto outputs = makeComplexGraph(x);
            buffer       = Variable::save(outputs);
        }

        Module::Config config;
        config.shapeMutable = true;

        std::shared_ptr<Module> module(
            Module::load({"Input"}, {"Aux", "Output", "Shape"}, (const uint8_t*)buffer.data(), buffer.size(), &config),
            Module::destroy);
        if (nullptr == module) {
            return false;
        }
        {
            auto x   = _Input({1, 4, 320, 320}, NCHW, halide_type_of<float>());
            auto ptr = x->writeMap<float>();
            module->onForward({x});
        }

        auto input0   = makeInput(0.0f);
        auto outputs0 = module->onForward({input0});
        if (outputs0.size() != 3) {
            return false;
        }

        auto aux0Info   = outputs0[0]->getInfo();
        auto output0Info = outputs0[1]->getInfo();
        auto shape0Info = outputs0[2]->getInfo();
        if (nullptr == aux0Info || nullptr == output0Info || nullptr == shape0Info) {
            return false;
        }
        if (aux0Info->dim != std::vector<int>({1, 16, 16, 16})) {
            return false;
        }
        if (output0Info->dim != std::vector<int>({1, 4, 1, 16})) {
            return false;
        }
        if (shape0Info->dim != std::vector<int>({4})) {
            return false;
        }

        int expectedShape[4] = {1, 4, 1, 16};
        auto shapeResult0    = outputs0[2]->readMap<int>();
        if (!checkVector(shapeResult0, expectedShape, 4, 0)) {
            return false;
        }

        // Snapshot first inference results. We'll verify they remain unchanged after
        // the next inference (to catch output buffer reuse issues).
        std::vector<float> aux0Snapshot(aux0Info->size);