Method validate_mm

src/cpu/operators/CpuGemmConv2d.cpp:353–438

}

Status CpuGemmConv2d::validate_mm(const ITensorInfo         *src,
                                  const ITensorInfo         *weights,
                                  const ITensorInfo         *biases,
                                  const ITensorInfo         *dst,
                                  const ActivationLayerInfo &act_info,
                                  bool                       enable_fast_math,
                                  int                        gemm_3d_depth,
                                  bool                       skip_im2col,
                                  bool                       fixed_format,
                                  arm_compute::WeightFormat  weight_format)
{
    const DataType data_type             = src->data_type();
    const bool     is_quantized          = is_data_type_quantized_asymmetric(data_type);
    const bool     is_activation_enabled = act_info.enabled();

    if (is_quantized)
    {
        // Since we need negative offsets for computing convolution, we need to change QuantizationInfo()
        // Extract and negate input and weights offset
        const QuantizationInfo       &iqinfo  = src->quantization_info();
        const QuantizationInfo       &wqinfo  = weights->quantization_info();
        const QuantizationInfo       &oqinfo  = (dst->total_size() == 0) ? iqinfo : dst->quantization_info();
        const UniformQuantizationInfo uoqinfo = oqinfo.uniform();

        // Merge activation with output stage
        PixelValue type_min{};
        PixelValue type_max{};
        std::tie(type_min, type_max) = get_min_max(data_type);
        int32_t min_activation       = type_min.get<int32_t>();
        int32_t max_activation       = type_max.get<int32_t>();

        const std::set<ActivationLayerInfo::ActivationFunction> supported_acts = {
            ActivationLayerInfo::ActivationFunction::RELU, ActivationLayerInfo::ActivationFunction::BOUNDED_RELU,
            ActivationLayerInfo::ActivationFunction::LU_BOUNDED_RELU};
        if (is_activation_enabled && supported_acts.count(act_info.activation()) != 0)
        {
            std::tie(min_activation, max_activation) = get_quantized_activation_min_max(act_info, data_type, uoqinfo);
        }
        // F32 dequant path? (input quantized, output float)
        GEMMLowpOutputStageInfo output_info;
        if (int8_dequantize_f32_path(data_type, dst->data_type()))
        {
            // No requant stage; offsets are handled via offset-contribution on int32
            output_info.type                     = GEMMLowpOutputStageType::NONE;
            output_info.gemmlowp_offset          = 0;
            output_info.gemmlowp_min_bound       = 0;
            output_info.gemmlowp_max_bound       = 0;
            output_info.is_quantized_per_channel = false; // irrelevant when NONE
        }
        else
        {
            // Existing Q->Q path
            output_info.type                     = GEMMLowpOutputStageType::QUANTIZE_DOWN_FIXEDPOINT;
            output_info.gemmlowp_offset          = uoqinfo.offset;
            output_info.gemmlowp_min_bound       = min_activation;
            output_info.gemmlowp_max_bound       = max_activation;
            output_info.is_quantized_per_channel = (weights->data_type() == DataType::QSYMM8_PER_CHANNEL);
            ARM_COMPUTE_RETURN_ON_ERROR(