Function _getConstData

tools/cpp/compilefornpu.cpp:364–454

}

void _getConstData(const Net* net, std::vector<MNN::Express::VARP> inputs, const std::set<int>& inputIndexes,
                   const std::set<int>& outputIndexes,
                   std::map<int, std::tuple<int, int, std::vector<int>, std::vector<char>>>& constTensorData,
                   std::string srcpath) {
    // set a backend and context to run resize
    ScheduleConfig config;
    config.type = MNN_FORWARD_CPU;
    BackendConfig backendConfig;
    backendConfig.precision = BackendConfig::Precision_High;
    config.backendConfig = &backendConfig;
    Backend::Info compute;
    compute.type = config.type;
    compute.numThread = config.numThread;
    compute.user = config.backendConfig;
    const RuntimeCreator* runtimeCreator(MNNGetExtraRuntimeCreator(compute.type));
    std::unique_ptr<Runtime> runtime(runtimeCreator->onCreate(compute));
    std::shared_ptr<Backend> backend(runtime->onCreate());
    BackendConfig defaultConfig;
    defaultConfig.flags = 4;
    std::shared_ptr<Backend> defaultBackend(runtime->onCreate(&defaultConfig));
    std::vector<std::shared_ptr<Tensor>> allTensors;
    allTensors.resize(net->tensorName()->size());
    ErrorCode code = NO_ERROR;
    FileLoader loader((srcpath + ".weight").c_str());
    initConstTensors(allTensors, net, defaultBackend.get(), code, &loader);
    if (NO_ERROR != code) {
        MNN_ERROR("Init tensor error code = %d\n", code);
        return;
    }
    bool valid = initTensors(allTensors, net);
    // set tensors' shape by inputConfig
    std::map<std::string, MNN::Express::VARP> inputsMap;
    for (int i = 0; i < inputs.size(); i++) {
        auto name = inputs[i]->name();
        inputsMap[name] = inputs[i];
    }
    for (int i = 0; i < allTensors.size(); i++) {
        auto name = net->tensorName()->GetAsString(i)->str();
        if (inputsMap.find(name) != inputsMap.end()) {
            auto input = inputsMap[name];
            auto info = input->getInfo();
            auto& dims = info->dim;
            allTensors[i]->buffer().dimensions = dims.size();
            for (int j = 0; j < dims.size(); j++) {
                allTensors[i]->setLength(j, dims[j]);
            }
            allTensors[i]->buffer().host =
                (uint8_t*)MNNMemoryAllocAlign(info->size * sizeof(float), MNN_MEMORY_ALIGN_DEFAULT);
            auto ptr = input->readMap<float>();
            std::memcpy(allTensors[i]->buffer().host, ptr, info->size * sizeof(float));
        }
    }
    std::vector<Schedule::OpCacheInfo> infos;
    auto selectOps = _collectNeededOps(net, inputIndexes, outputIndexes);
    {
        std::vector<const Op*> ops;
        for (int i = 0; i < selectOps.size(); i++) {
            auto op = net->oplists()->GetAs<Op>(selectOps[i]);