Method prepare

src/gpu/cl/operators/ClGemmLowpMatrixMultiplyCore.cpp:877–943

}

void ClGemmLowpMatrixMultiplyCore::prepare(ITensorPack &tensors)
{
    if (!_is_prepared)
    {
        auto               b = tensors.get_const_tensor(TensorType::ACL_SRC_1);
        CLAuxTensorHandler tmp_b(offset_int_vec(RhsReshape), _tmp_b, tensors, true);
        CLAuxTensorHandler vec_sum_col(offset_int_vec(VecSumCol), _vector_sum_col, tensors, true);
        CLAuxTensorHandler rhs_qasymm8(offset_int_vec(RhsQAsymm8), _qasymm8_weights, tensors, false);

        ARM_COMPUTE_ERROR_ON_NULLPTR(b);

        if (_convert_to_qasymm8)
        {
            ITensorPack convert_to_qs8_pack = {{ACL_SRC, b}, {ACL_DST, rhs_qasymm8.get()}};
            CLScheduler::get().enqueue_op(*_weights_to_qasymm8, convert_to_qs8_pack, false);
            b->mark_as_unused();
        }

        if (is_gemm_reshaped(_gemm_kernel_type) && _reshape_b_only_on_first_run)
        {
            // Run reshape kernel and mark original weights tensor as unused
            ITensorPack mtx_b_pack = {{TensorType::ACL_SRC, _convert_to_qasymm8 ? rhs_qasymm8.get() : b},
                                      {TensorType::ACL_DST, tmp_b.get()}};
            CLScheduler::get().enqueue_op(*_mtx_b_reshape_kernel, mtx_b_pack, false);
            b->mark_as_unused();
        }

        // Run matrix B reduction kernel only if _a_offset is not equal to 0
        if (_a_offset != 0 && _reshape_b_only_on_first_run)
        {
            ITensorPack mtx_b_red_pack = {{TensorType::ACL_SRC, _convert_to_qasymm8 ? rhs_qasymm8.get() : b},
                                          {TensorType::ACL_DST, vec_sum_col.get()}};
            CLScheduler::get().enqueue_op(*_mtx_b_reduction_kernel, mtx_b_red_pack, false);
        }

        // Compute GEMM output multipliers and shifts for output stage
        {
            const size_t num_filters = (_gemm_info.gemmlowp_output_stage().is_quantized_per_channel)
                                           ? _gemm_info.gemmlowp_output_stage().gemmlowp_multipliers.size()
                                           : 1;

            CLAuxTensorHandler multipliers(offset_int_vec(Multipliers), _gemm_output_stage_multipliers, tensors, false);
            CLAuxTensorHandler shifts(offset_int_vec(Shifts), _gemm_output_stage_shifts, tensors, false);

            ICLTensor *multiplier_tensor = multipliers.get();
            if (multiplier_tensor != nullptr && multiplier_tensor->info()->total_size() > 0)
            {
                multiplier_tensor->map(CLScheduler::get().queue(), true);
                std::memcpy(multiplier_tensor->ptr_to_element(Coordinates(0)),
                            _gemm_info.gemmlowp_output_stage().gemmlowp_multipliers.data(),
                            num_filters * sizeof(int32_t));
                multiplier_tensor->unmap(CLScheduler::get().queue());
            }

            ICLTensor *shifts_tensor = shifts.get();
            if (shifts.get() != nullptr && shifts_tensor->info()->total_size() > 0)
            {
                shifts_tensor->map(CLScheduler::get().queue(), true);