Method configure

src/gpu/cl/operators/ClWinogradConv2d.cpp:183–243

ClWinogradConv2d::~ClWinogradConv2d() = default;

void ClWinogradConv2d::configure(const ClCompileContext    &compile_context,
                                 ITensorInfo               *src,
                                 ITensorInfo               *weights,
                                 ITensorInfo               *biases,
                                 ITensorInfo               *dst,
                                 const PadStrideInfo       &conv_info,
                                 const ActivationLayerInfo &act_info,
                                 bool                       enable_fast_math)
{
    ARM_COMPUTE_ERROR_THROW_ON(validate_arguments(src, weights, biases, dst, conv_info, act_info, enable_fast_math));
    ARM_COMPUTE_LOG_PARAMS(src, weights, biases, dst, conv_info, act_info, enable_fast_math);

    // Get indices for the width and height
    const size_t idx_width  = get_data_layout_dimension_index(src->data_layout(), DataLayoutDimension::WIDTH);
    const size_t idx_height = get_data_layout_dimension_index(src->data_layout(), DataLayoutDimension::HEIGHT);

    // Input shape, kernel size and output tile
    const Size2D input_dims  = Size2D(src->tensor_shape()[idx_width], src->tensor_shape()[idx_height]);
    const Size2D kernel_size = Size2D(weights->tensor_shape()[idx_width], weights->tensor_shape()[idx_height]);
    const Size2D output_tile = winograd_output_tile(input_dims, kernel_size, src->data_layout());

    // Check if the Winograd configuration requires fast math
    if (!enable_fast_math)
    {
        ARM_COMPUTE_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(src, 1,
                                                      DataType::F32); //disable winograd for fp16 if fast math is false.
        ARM_COMPUTE_ERROR_ON_MSG(check_support_fast_math(output_tile, kernel_size),
                                 "This Winograd configuration requires enable_fast_math=true");
    }
    const WinogradInfo winograd_info =
        WinogradInfo(output_tile, kernel_size, input_dims, conv_info, src->data_layout());

    _is_prepared = false;

    // Configure input transform
    _input_transform->configure(compile_context, src, &_input0, winograd_info);
    _border_handler.configure(compile_context, src, _input_transform->border_size(), BorderMode::CONSTANT,
                              PixelValue());

    // Configure filter transform
    _filter_transform->configure(compile_context, weights, &_input1, winograd_info);

    // Configure batched matrix multiply
    _batched_mm.configure(compile_context, &_input0, &_input1, nullptr, &_batched_mm_output, 1.0f, 0.0f,
                          GEMMInfo(false, false, true /* Reshape weights only for the first run*/, 0, false, false,
                                   GEMMLowpOutputStageInfo(), (src->data_type() == DataType::F16)));

    // Configure output transform
    _output_transform->set_target(CLScheduler::get().target());
    _output_transform->configure(compile_context, &_batched_mm_output, biases, dst, winograd_info, act_info);

    _aux_mem = _batched_mm.workspace();
    const MemoryLifetime wino_wei_lifetm =
        std::any_of(std::begin(_aux_mem), std::end(_aux_mem),
                    [](const auto &r) { return (r.lifetime == MemoryLifetime::Persistent) && (r.size > 0); })
            ? MemoryLifetime::Prepare
            : MemoryLifetime::Persistent;
    _aux_mem.push_back(MemoryInfo(offset_int_vec(2), MemoryLifetime::Temporary, _input0.total_size()));