ClWinogradConv2d Class Reference

Basic function to execute Winograd-based convolution on OpenCL. More...

#include <ClWinogradConv2d.h>

Collaboration diagram for ClWinogradConv2d:

Public Member Functions
	ClWinogradConv2d ()
	Default constructor. More...
	~ClWinogradConv2d ()
	Default destructor. More...
	ClWinogradConv2d (const ClWinogradConv2d &)=delete
	Prevent instances of this class from being copied (As this class contains pointers) More...
	ClWinogradConv2d (ClWinogradConv2d &&)=default
	Default move constructor. More...
ClWinogradConv2d &	operator= (const ClWinogradConv2d &)=delete
	Prevent instances of this class from being copied (As this class contains pointers) More...
ClWinogradConv2d &	operator= (ClWinogradConv2d &&)=default
	Default move assignment operator. More...
void	configure (const ClCompileContext &compile_context, ITensorInfo *src, ITensorInfo *weights, ITensorInfo *biases, ITensorInfo *dst, const PadStrideInfo &conv_info, const ActivationLayerInfo &act_info=ActivationLayerInfo(), bool enable_fast_math=false)
	Set the input and output tensors. More...
void	run (ITensorPack &tensors) override
	Run the kernels contained in the function. More...
void	prepare (ITensorPack &tensors) override
	Prepare the function for executing. More...
experimental::MemoryRequirements	workspace () const override
	Return the memory requirements required by the workspace. More...
Public Member Functions inherited from ICLOperator
	ICLOperator (IRuntimeContext *ctx=nullptr)
	Constructor. More...
	ICLOperator (const ICLOperator &)=delete
	Prevent instances of this class from being copied (As this class contains pointers) More...
	ICLOperator (ICLOperator &&)=default
	Default move constructor. More...
ICLOperator &	operator= (const ICLOperator &)=delete
	Prevent instances of this class from being copied (As this class contains pointers) More...
ICLOperator &	operator= (ICLOperator &&)=default
	Default move assignment operator. More...
Public Member Functions inherited from IOperator
virtual	~IOperator ()=default
	Destructor. More...

Static Public Member Functions
static Status	validate (const ITensorInfo *src, const ITensorInfo *weights, const ITensorInfo *biases, const ITensorInfo *dst, const PadStrideInfo &conv_info, const ActivationLayerInfo &act_info=ActivationLayerInfo(), bool enable_fast_math=false)
	Static function to check if given info will lead to a valid configuration. More...

Detailed Description

Basic function to execute Winograd-based convolution on OpenCL.

This function calls the following OpenCL functions/kernels:

1. kernels::ClWinogradInputTransformKernel
2. kernels::ClWinogradFilterTransformKernel (only once)
3. ClGemm
4. kernels::ClWinogradOutputTransformKernel

Definition at line 53 of file ClWinogradConv2d.h.

Constructor & Destructor Documentation

ClWinogradConv2d() [1/3]

ClWinogradConv2d

(

)

Default constructor.

Definition at line 158 of file ClWinogradConv2d.cpp.

    : _batched_mm(),
      _input_transform(std::make_unique<kernels::ClWinogradInputTransformKernel>()),
      _filter_transform(std::make_unique<kernels::ClWinogradFilterTransformKernel>()),
      _output_transform(std::make_unique<kernels::ClWinogradOutputTransformKernel>()),
      _border_handler(),
      _input0(),
      _input1(),
      _batched_mm_output(),
      _is_prepared(false),
      _aux_mem()
{
}

~ClWinogradConv2d()

~ClWinogradConv2d ( )

default

Default destructor.

ClWinogradConv2d() [2/3]

ClWinogradConv2d ( const ClWinogradConv2d &  )

delete

Prevent instances of this class from being copied (As this class contains pointers)

ClWinogradConv2d() [3/3]

ClWinogradConv2d ( ClWinogradConv2d &&  )

default

Default move constructor.

Member Function Documentation

configure()

void configure	(	const ClCompileContext &	compile_context,
		ITensorInfo *	src,
		ITensorInfo *	weights,
		ITensorInfo *	biases,
		ITensorInfo *	dst,
		const PadStrideInfo &	conv_info,
		const ActivationLayerInfo &	act_info = ActivationLayerInfo(),
		bool	enable_fast_math = false
	)

Set the input and output tensors.

Valid data layouts:

• NHWC
• NCHW

Valid data type configurations:

src0	src1	src2	dst
F16	F16	F16	F16
F32	F32	F32	F32

Note

: This function only works with 3x3,3x1,1x3,5x5,5x1,1x5,7x1 and 1x7 kernels along with unit strides for both NCHW and NHWC data layout

Some Winograd configurations (i.e. F(4x4, 5x5)) are supported only with enable_fast_math = true

Parameters

[in]	compile_context	The compile context to be used.
[in]	src	Source tensor info. 3 lower dimensions represent a single input [width, height, IFM], while every optional dimension from 4 and above represent a batch of inputs. Data types supported: F16/F32.
[in]	weights	Weights tensor info. Weights are 4D tensor with dimensions [kernel_x, kernel_y, IFM, OFM]. Data type supported:Same as src.
[in]	biases	Biases tensor info. Shared biases supported. Biases are 1D tensor with dimensions [OFM].Data type supported: Same as src
[out]	dst	Destination tensor info. 3 lower dimensions represent a single output [width, height, OFM], while the rest represent batch of outputs. Data types supported: Same as src.
[in]	conv_info	Contains padding and stride information described in PadStrideInfo.
[in]	act_info	(Optional) Activation layer information in case of a fused activation.
[in]	enable_fast_math	(Optional) Enable fast math computation. In case this flag were set, the function could dispatch the fastest implementation available which may introduce a drop of accuracy as well. Default is false

Definition at line 174 of file ClWinogradConv2d.cpp.

{
    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()));
    _aux_mem.push_back(MemoryInfo(offset_int_vec(3), wino_wei_lifetm, _input1.total_size()));
    _aux_mem.push_back(MemoryInfo(offset_int_vec(4), MemoryLifetime::Temporary, _batched_mm_output.total_size()));
}

References arm_compute::test::validation::act_info, ARM_COMPUTE_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN, ARM_COMPUTE_ERROR_ON_MSG, ARM_COMPUTE_ERROR_THROW_ON, ARM_COMPUTE_LOG_PARAMS, CLFillBorderKernel::configure(), ClGemm::configure(), arm_compute::CONSTANT, arm_compute::test::validation::conv_info, arm_compute::test::validation::dst, arm_compute::mlgo::parser::end(), arm_compute::F16, arm_compute::F32, CLScheduler::get(), arm_compute::get_data_layout_dimension_index(), arm_compute::HEIGHT, arm_compute::test::validation::idx_height, arm_compute::test::validation::idx_width, arm_compute::offset_int_vec(), arm_compute::experimental::Prepare, arm_compute::test::validation::src, ITensorInfo::tensor_shape(), TensorInfo::total_size(), arm_compute::cpu::kernels::validate_arguments(), arm_compute::WIDTH, and ClGemm::workspace().

operator=() [1/2]

ClWinogradConv2d& operator= ( ClWinogradConv2d &&  )

default

Default move assignment operator.

operator=() [2/2]

ClWinogradConv2d& operator= ( const ClWinogradConv2d &  )

delete

Prevent instances of this class from being copied (As this class contains pointers)

prepare()

void prepare ( ITensorPack &  constants )

overridevirtual

Prepare the function for executing.

Any one off pre-processing step required by the function is handled here

Parameters

[in]

constants

Vector that contains the constants tensors.

Note

Prepare stage might not need all the function's buffers' backing memory to be available in order to execute

Reimplemented from ICLOperator.

Definition at line 279 of file ClWinogradConv2d.cpp.

{
    if(!_is_prepared)
    {
        auto       weights = utils::cast::polymorphic_downcast<const ICLTensor *>(tensors.get_const_tensor(TensorType::ACL_SRC_1));
        ICLTensor *in1_aux = utils::cast::polymorphic_downcast<ICLTensor *>(tensors.get_tensor(offset_int_vec(3)));
 
        CLAuxTensorHandler input1(_input1, *in1_aux);
        ITensorPack        pack_ft
        {
            { TensorType::ACL_SRC, weights },
            { TensorType::ACL_DST, input1.get() },
        };
        // Run filter transform and mark original weights as unused
        CLScheduler::get().enqueue_op(*_filter_transform, pack_ft, false);
        weights->mark_as_unused();
 
        // Prepare GEMM and release reshaped weights if marked unused by ClGemm
        ITensorPack mm_prepare_pack = tensors;
        mm_prepare_pack.add_tensor(ACL_SRC_1, input1.get());
        _batched_mm.prepare(mm_prepare_pack);
 
        CLScheduler::get().queue().finish();
        _is_prepared = true;
    }
}

References arm_compute::ACL_DST, arm_compute::ACL_SRC, arm_compute::ACL_SRC_1, ITensorPack::add_tensor(), CLScheduler::enqueue_op(), CLScheduler::get(), CLAuxTensorHandler::get(), ITensorPack::get_const_tensor(), ITensorPack::get_tensor(), arm_compute::offset_int_vec(), ClGemm::prepare(), and CLScheduler::queue().

Referenced by ClWinogradConv2d::run().

run()

void run ( ITensorPack &  tensors )

overridevirtual

Run the kernels contained in the function.

Parameters

[in]

tensors

Vector that contains the tensors to operate on.

Reimplemented from ICLOperator.

Definition at line 239 of file ClWinogradConv2d.cpp.

{
    const bool is_gemm_reshaped = _aux_mem[3].lifetime == MemoryLifetime::Prepare;
 
    auto src    = utils::cast::polymorphic_downcast<const ICLTensor *>(tensors.get_const_tensor(TensorType::ACL_SRC_0));
    auto biases = utils::cast::polymorphic_downcast<const ICLTensor *>(tensors.get_const_tensor(TensorType::ACL_SRC_2));
    auto dst    = utils::cast::polymorphic_downcast<ICLTensor *>(tensors.get_tensor(TensorType::ACL_DST));
 
    CLAuxTensorHandler input0(offset_int_vec(2), _input0, tensors, true);
    CLAuxTensorHandler input1(offset_int_vec(3), _input1, tensors, true, is_gemm_reshaped);
    CLAuxTensorHandler batched_mm_output(offset_int_vec(4), _batched_mm_output, tensors, true);
 
    prepare(tensors);
 
    // Run input transform
    ITensorPack pack_it
    {
        { TensorType::ACL_SRC, src },
        { TensorType::ACL_DST, input0.get() },
    };
    CLScheduler::get().enqueue_op(_border_handler, pack_it, false);
    CLScheduler::get().enqueue_op(*_input_transform, pack_it, false);
 
    // Run batched matrix multiplication
    ITensorPack pack_mm = tensors;
    pack_mm.add_const_tensor(TensorType::ACL_SRC_0, input0.get());
    pack_mm.add_tensor(TensorType::ACL_DST, batched_mm_output.get());
    is_gemm_reshaped ? pack_mm.remove_tensor(TensorType::ACL_SRC_1) : pack_mm.add_const_tensor(TensorType::ACL_SRC_1, input1.get());
    _batched_mm.run(pack_mm);
 
    // Run output transform
    ITensorPack pack_ot
    {
        { TensorType::ACL_SRC_0, batched_mm_output.get() },
        { TensorType::ACL_SRC_1, biases },
        { TensorType::ACL_DST, dst },
    };
    CLScheduler::get().enqueue_op(*_output_transform, pack_ot);
}

References arm_compute::ACL_DST, arm_compute::ACL_SRC, arm_compute::ACL_SRC_0, arm_compute::ACL_SRC_1, arm_compute::ACL_SRC_2, ITensorPack::add_const_tensor(), ITensorPack::add_tensor(), arm_compute::test::validation::dst, CLScheduler::enqueue_op(), CLScheduler::get(), CLAuxTensorHandler::get(), ITensorPack::get_const_tensor(), ITensorPack::get_tensor(), arm_compute::offset_int_vec(), arm_compute::experimental::Prepare, ClWinogradConv2d::prepare(), ITensorPack::remove_tensor(), ClGemm::run(), and arm_compute::test::validation::src.

validate()

Status validate ( const ITensorInfo *  src, const ITensorInfo *  weights, const ITensorInfo *  biases, const ITensorInfo *  dst, const PadStrideInfo &  conv_info, const ActivationLayerInfo &  act_info = ActivationLayerInfo(), bool  enable_fast_math = false  )

static

Static function to check if given info will lead to a valid configuration.

Similar to ClWinogradConv2d::configure()

Returns

a status

Definition at line 232 of file ClWinogradConv2d.cpp.

{
    ARM_COMPUTE_RETURN_ON_ERROR(validate_arguments(src, weights, biases, dst, conv_info, act_info, enable_fast_math));
    return Status{};
}

References arm_compute::test::validation::act_info, ARM_COMPUTE_RETURN_ON_ERROR, arm_compute::test::validation::conv_info, arm_compute::test::validation::dst, arm_compute::test::validation::src, and arm_compute::cpu::kernels::validate_arguments().

Referenced by ClConv2d::get_convolution_method(), ClConv2d::validate(), and CLWinogradConvolutionLayer::validate().

workspace()

experimental::MemoryRequirements workspace ( ) const

overridevirtual

Return the memory requirements required by the workspace.

Reimplemented from ICLOperator.

Definition at line 306 of file ClWinogradConv2d.cpp.

{
    return _aux_mem;
}

---

The documentation for this class was generated from the following files:

• src/gpu/cl/operators/ClWinogradConv2d.h
• src/gpu/cl/operators/ClWinogradConv2d.cpp