Function genStaticModel

tools/converter/source/common/convertToStaticModel.cpp:118–225

}

static void genStaticModel(CommandBuffer buffer, const std::string& modelName, std::map<Tensor*, std::pair<std::string, int>>& tensorNames, std::vector<std::string>&& outputNames, const Net* originNetInfo) {
    MNN_PRINT("gen Static Model ... \n");
    std::unique_ptr<MNN::NetT> netT = std::unique_ptr<MNN::NetT>(new MNN::NetT());
    netT->outputName = std::move(outputNames);
    netT->usage = Usage_INFERENCE_STATIC;
    std::map<Tensor*, int> tensorMap;
    // Add tensorName to new netT
    netT->tensorName.resize(tensorNames.size());
    std::vector<std::unique_ptr<OpT>> inputOps;
    for (auto& iter : tensorNames) {
        netT->tensorName[iter.second.second] = iter.second.first;
        tensorMap.insert(std::make_pair(iter.first, iter.second.second));
        if (TensorUtils::getDescribe(iter.first)->usage == MNN::Tensor::InsideDescribe::INPUT) {
            std::unique_ptr<OpT> input(new OpT);
            input->type = OpType_Input;
            input->name = iter.second.first;
            input->outputIndexes = {iter.second.second};
            input->main.value = new InputT;
            input->main.type = OpParameter_Input;
            input->main.AsInput()->dims = iter.first->shape();
            input->main.AsInput()->dformat = TensorUtils::getDescribe(iter.first)->dimensionFormat;
            auto type = iter.first->getType();
            if (type.code == halide_type_float) {
                if (type.bits == 32) {
                    input->main.AsInput()->dtype = DataType_DT_FLOAT;
                } else if (type.bits == 16) {
                    input->main.AsInput()->dtype = DataType_DT_HALF;
                }
            } else if (type.code == halide_type_int) {
                if (type.bits == 32) {
                    input->main.AsInput()->dtype = DataType_DT_INT32;
                } else if (type.bits == 16) {
                    input->main.AsInput()->dtype = DataType_DT_INT16;
                } else if (type.bits == 8) {
                    input->main.AsInput()->dtype = DataType_DT_INT8;
                }
            } else if (type.code == halide_type_uint) {
                if (type.bits == 16) {
                    input->main.AsInput()->dtype = DataType_DT_UINT16;
                } else if (type.bits == 8) {
                    input->main.AsInput()->dtype = DataType_DT_UINT8;
                }
            }
            inputOps.emplace_back(std::move(input));
        }
    }
    // add Tensors to netT
    for (auto& iterP : buffer.command) {
        auto& iter = *iterP;
        std::function<void(Tensor*)> insertTensor = [&](Tensor* t) {
            if (tensorMap.find(t) == tensorMap.end()) {
                int index = static_cast<int>(tensorMap.size());
                tensorMap.insert(std::make_pair(t, index));
                std::string tensorName = "ExtraTensor_" + std::to_string(index);
                netT->tensorName.push_back(tensorName);
            }
        };
        for (auto& t : iter.inputs) {