Function _getSubModuleIO

tools/cpp/compilefornpu.cpp:781–832

    return attentionNames;
}
static SubModuleIO _getSubModuleIO(std::vector<MNN::Express::VARP> inputs, const SubModuleInfo& info, const void* buffer, size_t bufferSize, std::string srcpath) {
    // Deep clone output to let the module release
    SubModuleIO io;
    std::vector<std::string> inputNames(info.inputs.size());
    std::vector<std::string> outputNames(info.outputs.size());
    auto net = flatbuffers::GetRoot<Net>(buffer);
    for (int i=0; i<info.inputs.size(); ++i) {
        auto index = info.inputs[i];
        inputNames[i] = net->tensorName()->GetAsString(index)->str();
    }
    for (int i=0; i<info.outputs.size(); ++i) {
        auto index = info.outputs[i];
        outputNames[i] = net->tensorName()->GetAsString(index)->str();
    }
    auto attentionNames = _getAttentionName(buffer, bufferSize);
    MNN::ScheduleConfig config;
    config.numThread = 1;
    std::shared_ptr<MNN::Express::Executor::RuntimeManager> rtmgr(MNN::Express::Executor::RuntimeManager::createRuntimeManager(config));
    rtmgr->setExternalFile((srcpath + ".weight").c_str());
    rtmgr->setMode(MNN::Interpreter::Session_Debug);
    std::shared_ptr<MNN::Express::Module> m(MNN::Express::Module::load(inputNames, outputNames, (const uint8_t*)buffer, bufferSize, rtmgr), MNN::Express::Module::destroy);
    MNN::TensorCallBackWithInfo beforeCallBack = [&](const std::vector<MNN::Tensor*>& ntensors, const MNN::OperatorInfo* info) {
        auto opName = info->name();
        if (info->type() != "Attention") {
            return true;
        }
        if (attentionNames.find(opName) != attentionNames.end()) {
            auto query = ntensors[0];
            auto key = ntensors[1];
            auto value = ntensors[2];
            int seq_len = query->length(1);
            auto numHead = query->length(2);
            auto headDim = query->length(3);
            auto kvNumHead = key->length(2);
            std::vector<int> kvDims = {kvNumHead, 1, 1, headDim};
            io.kvcache.emplace_back(kvDims);
            io.seqLen = seq_len;
        }
        return true;
    };
    MNN::TensorCallBackWithInfo callBack = [&](const std::vector<MNN::Tensor*>& ntensors,  const MNN::OperatorInfo* info) {
        return true;
    };
    MNN::Express::ExecutorScope::Current()->setCallBack(std::move(beforeCallBack), std::move(callBack));
    auto outputs = m->onForward(inputs);
    io.inputs = inputs;
    io.outputs.resize(outputs.size());
    for (int i=0; i<outputs.size(); ++i) {
        io.outputs[i] = MNN::Express::_Clone(outputs[i], true);
    }
    return io;
}

static int _compileWholeModule(std::vector<std::string> inputNames, std::vector<std::string> outputNames,
                               std::vector<std::vector<MNN::Express::VARP>> inputs, const std::set<int>& inputIndexes,