Function preRearrangeWeights

express/module/StaticModule.cpp:35–230

}

static std::vector<std::shared_ptr<BufferStorage>> preRearrangeWeights( // NOLINT
                                                                       Schedule::ScheduleInfo& scheduleInfo, Backend* firstbackend, Backend* backupBackend, const Module* base = nullptr) {
    std::map<const std::string, std::shared_ptr<Execution>> base_executions;
    if (base != nullptr) {
        // has base module
        auto static_module = getStaticModule(base);
        if (static_module) {
            auto session = static_module->getSession();
            std::vector<Schedule::OpCacheInfo> op_caches = session->getPipelineInfo(0).second;
            for (auto& op_cache : op_caches) {
                const auto& exe_cache = op_cache.executionCache;
                for (const auto& exe_item : exe_cache) {
                    if (exe_item.first->name()) {
                        base_executions.insert(std::make_pair(exe_item.first->name()->str(), exe_item.second));
                    }
                }
            }
        }
    }
    FileLoader loader(scheduleInfo.externalWeightPath.c_str());
    auto&& pipelineInfo = scheduleInfo.pipelineInfo[0].second;
    std::vector<std::shared_ptr<BufferStorage>> splitOps(pipelineInfo.size());
    // KV Cache sharing: registry of Attention executions by layer_index for clone-based reuse
    std::map<int, std::shared_ptr<Execution>> kvAttentionRegistry;
    for (int i = 0; i < pipelineInfo.size(); ++i) {
        auto& info = pipelineInfo[i];
        auto op    = pipelineInfo[i].op;
        std::unique_ptr<OpT> op_table(op->UnPack());
        std::shared_ptr<Execution> exe;
        Backend* backend = firstbackend;
        if (info.type == Schedule::CONSTANT) {
            backend = backupBackend;
        }
        switch (op->type()) {
            case MNN::OpType_DepthwiseConvInt8:
            case MNN::OpType_ConvInt8:
            case MNN::OpType_ConvolutionDepthwise:
            case MNN::OpType_Convolution: {
                if (!base_executions.empty() && op->name()) {
                    auto iter = base_executions.find(op->name()->str());
                    if (iter != base_executions.end()) {
                        auto base_exe = iter->second.get();
                        Execution* copyExecution = nullptr;
                        base_exe->onClone(backend, op, &copyExecution);
                        if (copyExecution == nullptr) {
                            base_exe->onClone(backupBackend, op, &copyExecution);
                        }
                        if (copyExecution != nullptr && copyExecution->onClone(nullptr, op, nullptr)) {
                            exe.reset(copyExecution);
                        }
                    }
                }
                if (exe == nullptr) {
                    DataType type = DataType_DT_FLOAT;
                    auto conv2d = op->main_as_Convolution2D();
                    // Create Default Inputs and Outputs
                    auto tempInput = info.inputs[0];
                    auto tempOutput = info.outputs[0];