Method load

source/core/ConvolutionCommon.cpp:559–825

    return 0;
}
std::shared_ptr<ConvolutionCommon::Int8Common> ConvolutionCommon::load(const Op* op, Backend* backend, bool forceFloat, bool forceInt8, void* weightPtr) {
    auto conv = op->main_as_Convolution2D();
    auto quan = conv->quanParameter();
    std::shared_ptr<ConvolutionCommon::Int8Common> result(new Int8Common);
    result->quan = quan;
    size_t buffer_size = 0, alpha_size = 0;
    const int8_t* buffer_ptr = nullptr;
    const float* alpha_ptr = nullptr;
    std::unique_ptr<int8_t[]> external_buffer;
    size_t weightLength = 0;
    int8_t *buffer        = nullptr;
    bool useCachedMmap = false;
    if (backend && backend->getRuntime()) {
        useCachedMmap = backend->getRuntime()->hint().useCachedMmap > 1;
    }
    if (USE_EXTERNAL_DATA(conv) && op->externalPath() && quan->type() == 8) {
        std::unique_ptr<FileLoader> external(new FileLoader(op->externalPath()->c_str()));
        auto param = op->main_as_Convolution2D();
        external->offset(param->external()->data()[0]);
        if(weightPtr != nullptr) {
            result->weightFloat.set((float *)weightPtr, false);
        } else {
            result->weightFloat.reset((int)(param->external()->data()[1] / sizeof(float)));
        }
        external->read((char*)(result->weightFloat.get()), param->external()->data()[1]);
        return result;
    }
    // scaleStorage scalar survives weight externalization, unlike the alphaFp16 vector.
    const bool alphaIsFp16 = (quan->scaleStorage() == ScaleStorageType_FP16);
    if (USE_EXTERNAL_DATA(conv) && (op->externalPath() || useCachedMmap) && quan->buffer() == nullptr) {
        auto external_info = conv->external()->data();
        buffer_size = external_info[1];
        const size_t alphaElemBytes = alphaIsFp16 ? sizeof(uint16_t) : sizeof(float);
        alpha_size = external_info[2] / alphaElemBytes;
        result->alphaSize = alpha_size;
        if (useCachedMmap) {
            weightLength = conv->common()->inputCount() * conv->common()->outputCount() * conv->common()->kernelX() * conv->common()->kernelY();
            result->originBits = getQuantBitFromExternalFile(op);
            result->canUseInt4 = result->originBits <= 4;
        } else {
            // external data
            std::unique_ptr<FileLoader> external_file(new FileLoader(op->externalPath()->c_str()));
            external_file->offset(external_info[0]);
            if (0 != buffer_size) {
                if (1 == quan->type() && !forceFloat) {
                    buffer = IDSTDecoder::ReadQuanData_c(external_file.get(), &weightLength, result.get(), quan, forceInt8, forceFloat, weightPtr);
                    if(weightLength == 0){
                        MNN_PRINT("ReadQuanData_c return weightLength is 0, maybe the weight data is invalid\n");
                        return nullptr;
                    }
                } else {
                    external_buffer.reset(new int8_t[buffer_size]);
                    buffer_ptr = external_buffer.get();
                    external_file->read((char*)buffer_ptr, buffer_size);
                }
            }
            if (0 != alpha_size) {
                if (alphaIsFp16) {