Method _init

source/backend/vulkan/image/execution/VulkanConvolution.cpp:111–152

    return NO_ERROR;
}
bool VulkanConvolutionDepthwise::_init(const float* weightData, size_t weightSize, const Op* convOp, Backend* bn) {
    auto extra      = static_cast<VulkanBackend*>(bn);
    auto common    = convOp->main_as_Convolution2D()->common();
    mSampler        = extra->getCommonSampler();
    // Create Pipeline
    std::vector<VkDescriptorType> convTypes{VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
                                            VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
                                            VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
                                            VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER};
    MNN_ASSERT(OpType_ConvolutionDepthwise == convOp->type());
    auto macroRelu = getPostTreatMacro(common);
    bool useFP16 = (extra->gpuType() == VulkanRuntime::ADRENO || extra->gpuType() == VulkanRuntime::MALI) && extra->getMemoryPool().permitFp16();
    std::string macroPrecision = (useFP16) ? "FP16_" : "FP32_";
    std::string macro = macroRelu + macroPrecision;
    if (common->strideX() == 1 && common->strideY() == 1 && common->dilateX() == 1 && common->dilateY() == 1 ) {
        mConvPipeline = extra->getPrivatePipeline("glsl_convolutionDepthwise_s1d1_w2_" + macro + "comp", convTypes);
        mUseS1D1W2 = true;
    } else {
        mConvPipeline = extra->getPrivatePipeline("glsl_convolutionDepthwise_" + macro + "comp", convTypes);
    }

    auto c4 = UP_DIV(common->outputCount(), 4);
    mKernel = std::make_shared<VulkanImage>(extra->getMemoryPool(), false, common->kernelX() * common->kernelY(), c4);
    if (nullptr != weightData){
        auto tempBuffer = _createBufferForConvDepthwise(extra, common, weightData, weightSize);
        extra->copyBufferToImage(tempBuffer.get(), mKernel.get());
    }
    auto convReal = convOp->main_as_Convolution2D();
    mBias.reset(new VulkanImage(extra->getMemoryPool(), false, {c4, 1}));
    auto biasBuffer = std::make_shared<VulkanBuffer>(extra->getMemoryPool(), false,
                                                     sizeof(float) * ALIGN_UP4(common->outputCount()));

    auto bias = biasBuffer->map();
    ::memset(bias, 0, ALIGN_UP4(common->outputCount()) * sizeof(float));
    if (nullptr != convReal->bias()) {
        // Create Buffer
        ::memcpy(bias, convReal->bias()->data(), common->outputCount() * sizeof(float));
    }
    biasBuffer->unmap();
    extra->copyBufferToImage(biasBuffer.get(), mBias.get());
    return true;
}


VulkanConvolutionDepthwise::VulkanConvolutionDepthwise(const float* weightData, size_t weightSize, const Op* convOp, Backend* bn)