Method configure

src/cpu/operators/CpuGemmLowpMatrixMultiplyCore.cpp:116–360

CpuGemmLowpMatrixMultiplyCore::~CpuGemmLowpMatrixMultiplyCore() = default;

void CpuGemmLowpMatrixMultiplyCore::configure(
    const ITensorInfo *a, const ITensorInfo *b, const ITensorInfo *c, ITensorInfo *dst, const GEMMInfo &gemm_info)
{
    ARM_COMPUTE_TRACE_EVENT(ARM_COMPUTE_PROF_CAT_CPU, ARM_COMPUTE_PROF_LVL_CPU,
                            "CpuGemmLowpMatrixMultiplyCore::configure");
    ARM_COMPUTE_ERROR_ON_NULLPTR(a, b, dst);
    ARM_COMPUTE_ERROR_THROW_ON(CpuGemmLowpMatrixMultiplyCore::validate(a, b, c, dst, gemm_info));
    ARM_COMPUTE_LOG_PARAMS(a, b, c, dst, gemm_info);

    const ITensorInfo *matrix_a = a;
    const ITensorInfo *matrix_b = b;
    GEMMInfo           info     = gemm_info;

    // Set internal variables
    _a_offset                         = a->quantization_info().uniform().offset;
    _b_offset                         = b->quantization_info().uniform().offset;
    _run_vector_matrix_multiplication = a->dimension(1) < 2;
    _reshape_b_only_on_first_run      = b->are_values_constant();
    _is_prepared                      = false;
    _fused_assembly_path              = false;
    _flip_signedness = is_data_type_quantized_per_channel(b->data_type()) && (a->data_type() == DataType::QASYMM8) &&
                       _reshape_b_only_on_first_run;
    _gemm_info = gemm_info;

    // F32 dequant path? (input quantized, output float)
    const bool dequantize_f32 = int8_dequantize_f32_path(a->data_type(), dst->data_type());

    const ITensorInfo *a_to_use = a;
    // Initialize assembly kernel meta-data
    cpu::AsmGemmInfo asm_info = init_assembly_metadata(gemm_info);
    if (dequantize_f32)
    {
        // We don't want arm_gemm to compute the activations because bias and offsets are added in ACL at a later step
        // so we disable activation in arm_gemm and run it as a post op in ACL
        asm_info.activation_info = arm_compute::ActivationLayerInfo();
    }

    const int32_t                 offset_correction = 128;
    const DataType                dt                = DataType::QASYMM8_SIGNED;
    const UniformQuantizationInfo iqinfo            = a_to_use->quantization_info().uniform();

    _signed_a = a_to_use->clone()->set_data_type(dt).set_quantization_info(
        QuantizationInfo(iqinfo.scale, iqinfo.offset + offset_correction));

    // If inputs are mixed-sign but this machine does not support mixed sign kernels,
    // flip the sign so matched-sign kernels can be used.
    if (!_flip_signedness && a->data_type() == DataType::QASYMM8 && b->data_type() == DataType::QASYMM8_SIGNED &&
        !bool(CpuGemmAssemblyDispatch::validate(a_to_use, b, c, dst, asm_info)))
    {
        _flip_signedness = true;
    }
    _asm_glue = std::make_unique<cpu::CpuGemmAssemblyDispatch>();

    // Convert to QASYMM8 -> QASYMM8_SIGNED and back
    if (_flip_signedness)
    {
        _convert_to_signed_asymm = std::make_unique<kernels::CpuConvertQuantizedSignednessKernel>();
        _convert_to_signed_asymm->configure(a_to_use, &_signed_a);