Method configure_mm

src/gpu/cl/operators/ClFullyConnected.cpp:202–285

ClFullyConnected::~ClFullyConnected() = default;

void ClFullyConnected::configure_mm(const CLCompileContext        &compile_context,
                                    ITensorInfo                   *src,
                                    ITensorInfo                   *weights,
                                    ITensorInfo                   *bias,
                                    ITensorInfo                   *dst,
                                    const FullyConnectedLayerInfo &fc_info)
{
    // If weights are dynamic and matmul is supported use matmul, else use gemm
    if (_use_matmul)
    {
        // Specify whether transpose weights is necessary in matmul info
        const MatMulInfo mat_info = MatMulInfo().adj_rhs(_transpose_weights);

        // Note: MatMul does not need offset negation unlike gemm
        // 1. Change shape when calling matmul to fit batch expectations.
        _lhs_to_use = src->clone()->set_tensor_shape(get_reshaped_matmul_tensor(_lhs_to_use.tensor_shape()));

        // 2. Use heuristics to get kernel info object
        const GPUTarget                                         gpu_target = CLScheduler::get().target();
        std::unique_ptr<cl_matmul::IClMatMulNativeKernelConfig> kernel_config =
            cl_matmul::ClMatMulNativeKernelConfigurationFactory::create(gpu_target);
        MatMulKernelInfo kernel_info = kernel_config->configure(src, weights, mat_info);

        // 3. Configure relevant matmul kernel
        if (_is_quantized)
        {
            _matmul_lowp_native_kernel = std::make_unique<kernels::ClMatMulLowpNativeKernel>();
            _matmul_lowp_native_kernel->set_target(gpu_target);
            _matmul_lowp_native_kernel->configure(compile_context, src, weights, bias, dst, kernel_info,
                                                  fc_info.activation_info);
        }
        else
        {
            _matmul_native_kernel = std::make_unique<kernels::ClMatMulNativeKernel>();
            _matmul_native_kernel->set_target(gpu_target);
            _matmul_native_kernel->configure(compile_context, src, weights, bias, dst, kernel_info,
                                             fc_info.activation_info);
        }
    }
    else
    {
        // Configure GEMM
        GEMMLowpOutputStageInfo gemmlowp_output_stage;
        construct_gemmlowp_output_stage(*src, *weights, *dst, gemmlowp_output_stage, fc_info.activation_info);

        const GEMMInfo &gemm_info = GEMMInfo(false,                           // is_a_reshaped
                                             false,                           // is_b_reshaped
                                             !_dynamic_gemm,                  // reshape_b_only_on_first_run
                                             0,                               // depth_output_gemm3d
                                             false,                           // reinterpret_input_as_3d
                                             fc_info.retain_internal_weights, // retain_internal_weights
                                             gemmlowp_output_stage,           // gemmlowp_output_stage
                                             fc_info.fp_mixed_precision,      // fp_mixed_precision
                                             false,                           // fast_math
                                             true,                            // broadcast_bias
                                             fc_info.activation_info);        // activation_info

        if (_is_quantized)