arm_compute::CLReduceOperation Class Reference

Class to perform ReduceOperation. More...

#include <CLReduceOperation.h>

Collaboration diagram for arm_compute::CLReduceOperation:

Public Member Functions
	CLReduceOperation (std::shared_ptr< IMemoryManager > memory_manager)
	Construct a new ReduceOperation object.
void	configure (ICLTensor *input, ICLTensor *output, const std::set< uint32_t > &axis, bool keep_dims, ReductionOperation op)
	Set the input and output tensors.
void	run () override
	Run the OpenCL kernel for this operation.

Static Public Member Functions
static Status	validate (const ITensorInfo *input, const ITensorInfo *output, const std::set< uint32_t > &axis, bool keep_dims, const ReductionOperation &op)
	Static function to check if given info will lead to a valid configuration of CLReduceOperation.

Detailed Description

Class to perform ReduceOperation.

Definition at line 66 of file CLReduceOperation.h.

Constructor & Destructor Documentation

CLReduceOperation()

CLReduceOperation::CLReduceOperation

(

std::shared_ptr< IMemoryManager >

memory_manager

)

Construct a new ReduceOperation object.

Definition at line 48 of file CLReduceOperation.cpp.

  : _memory_group(std::move(memory_manager)), _input(nullptr), _output(nullptr), _axis(),
    _keep_dims(false), _interm_tensors(), _reduce_kernels(), _reshape()
{
}

Member Function Documentation

configure()

void CLReduceOperation::configure	(	ICLTensor *	input,
		ICLTensor *	output,
		const std::set< uint32_t > &	axis,
		bool	keep_dims,
		ReductionOperation	op
	)

Set the input and output tensors.

Parameters

[in]	input	Source tensor. Data types supported: U8/S32/F32
[out]	output	Destination tensor. Data types and data layouts supported: Same as input.
[in]	axis	Axis along which to reduce. It must be sorted and no duplicates.
[in]	keep_dims	If positive, retains reduced dimensions with length 1.
[in]	op	Reduce operation to perform.

Returns

N/A

Definition at line 106 of file CLReduceOperation.cpp.

{
  ARM_COMPUTE_ERROR_THROW_ON(validate(input->info(), output->info(), axis, keep_dims, op));
 
  _axis = axis;
 
  _input = input;
  _output = output;
  _keep_dims = keep_dims;
 
  // NOTE The axis must have no duplication.
  const size_t num_of_kernels = axis.size();
  const size_t num_of_interm_tensors = num_of_kernels - (keep_dims ? 1 : 0);
 
  if (num_of_kernels < 1)
  {
    throw std::runtime_error("CLReduceOperation: there is no axis to reduce");
  }
 
  _interm_tensors = std::make_unique<CLTensor[]>(num_of_interm_tensors);
  _reduce_kernels = std::make_unique<CLReduceOperationKernel[]>(num_of_kernels);
 
  // Set a vector that is ordered ICLTensors sequentially.
  std::vector<ICLTensor *> tensors;
  tensors.emplace_back(input);
  for (size_t i = 0; i < num_of_interm_tensors; ++i)
  {
    tensors.emplace_back(_interm_tensors.get() + i);
  }
  tensors.emplace_back(output);
 
  // Apply ReductionOperation on all kernels
  TensorShape shape{input->info()->tensor_shape()};
  auto it = axis.begin();
  for (size_t i = 0; i < num_of_kernels; ++i, ++it)
  {
    shape.set(*it, 1, false);
    if (!keep_dims || i != (num_of_kernels - 1))
    {
      _interm_tensors[i].allocator()->init(input->info()->clone()->set_tensor_shape(shape));
      _memory_group.manage(&_interm_tensors[i]);
    }
    _reduce_kernels[i].configure(tensors[i], tensors[i + 1], *it, op);
    if (i != 0)
    {
      _interm_tensors[i - 1].allocator()->allocate();
    }
  }
 
  // Configure reshape layer if we want to drop the dimensions
  if (!keep_dims)
  {
    _reshape.configure(&_interm_tensors[num_of_interm_tensors - 1], output);
    _interm_tensors[num_of_interm_tensors - 1].allocator()->allocate();
  }
}

References validate().

run()

void CLReduceOperation::run ( )

override

Run the OpenCL kernel for this operation.

Returns

N/A

Definition at line 165 of file CLReduceOperation.cpp.

{
  MemoryGroupResourceScope scope_mg(_memory_group);
 
  const size_t num_of_kernels = _axis.size();
  for (size_t i = 0; i < num_of_kernels; ++i)
  {
    CLScheduler::get().enqueue(_reduce_kernels[i]);
  }
 
  if (!_keep_dims)
  {
    _reshape.run();
  }
}

validate()

Status CLReduceOperation::validate ( const ITensorInfo *  input, const ITensorInfo *  output, const std::set< uint32_t > &  axis, bool  keep_dims, const ReductionOperation &  op  )

static

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

Parameters

[in]	input	Source tensor info. Data types supported: U8/S32/F32
[in]	output	Destination tensor info. Data types and data layouts supported: Same as input.
[in]	axis	Axis along which to reduce. It must be sorted and no duplicates.
[in]	keep_dims	If positive, retains reduced dimensions with length 1.
[in]	op	Reduce operation to perform.

Returns

a status

Definition at line 54 of file CLReduceOperation.cpp.

{
  const size_t num_of_kernels = axis.size();
  const size_t num_of_interm_tensors = num_of_kernels - (keep_dims ? 1 : 0);
 
  ARM_COMPUTE_RETURN_ERROR_ON(num_of_kernels < 1);
 
  // Create temporary tensor infos
  auto interm_tensors = std::make_unique<TensorInfo[]>(num_of_interm_tensors);
 
  // Create intermediate tensor info
  TensorShape shape{input->tensor_shape()};
 
  auto it = axis.begin();
  for (size_t i = 0; i < num_of_interm_tensors; ++i, ++it)
  {
    shape.set(*it, 1, false);
    interm_tensors[i].set_data_type(input->data_type());
    interm_tensors[i].set_tensor_shape(shape);
    interm_tensors[i].set_num_channels(input->num_channels());
    interm_tensors[i].set_data_layout(input->data_layout());
    interm_tensors[i].set_quantization_info(input->quantization_info());
  }
 
  // Set a vector that is ordered ITensorInfo sequentially.
  std::vector<const ITensorInfo *> tensors;
  tensors.emplace_back(input);
  for (size_t i = 0; i < num_of_interm_tensors; ++i)
  {
    tensors.emplace_back(interm_tensors.get() + i);
  }
  tensors.emplace_back(output);
 
  // Validate ReduceOperation only on all kernels
  it = axis.begin();
  for (size_t i = 0; i < num_of_kernels; ++i, ++it)
  {
    ARM_COMPUTE_RETURN_ON_ERROR(
      CLReduceOperationKernel::validate(tensors[i], tensors[i + 1], *it, op));
  }
 
  if (!keep_dims)
  {
    ARM_COMPUTE_RETURN_ON_ERROR(
      CLReshapeLayer::validate(&interm_tensors[num_of_interm_tensors - 1], output));
  }
 
  return Status{};
}

References arm_compute::CLReduceOperationKernel::validate().

Referenced by configure().

---

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

• runtime/compute/ARMComputeEx/arm_compute/runtime/CL/functions/CLReduceOperation.h
• runtime/compute/ARMComputeEx/src/runtime/CL/functions/CLReduceOperation.cpp