Compute Library
 21.05
ClConcatenate Class Reference

Basic function to execute concatenate tensors along a given axis. More...

#include <ClConcatenate.h>

Collaboration diagram for ClConcatenate:
[legend]

Public Member Functions

 ClConcatenate ()
 Default constructor. More...
 
void configure (const ClCompileContext &compile_context, const std::vector< ITensorInfo * > &src_vector, ITensorInfo *dst, size_t axis)
 Initialise the kernel's inputs vector and dst. More...
 
void run (ITensorPack &tensors) override
 Run the kernels contained in the function. 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...
 
ICLOperatoroperator= (const ICLOperator &)=delete
 Prevent instances of this class from being copied (As this class contains pointers) More...
 
ICLOperatoroperator= (ICLOperator &&)=default
 Default move assignment operator. More...
 
void prepare (ITensorPack &constants) override
 Prepare the function for executing. More...
 
MemoryRequirements workspace () const override
 Return the memory requirements required by the workspace. More...
 
- Public Member Functions inherited from IOperator
virtual ~IOperator ()=default
 Destructor. More...
 

Static Public Member Functions

static Status validate (const std::vector< const ITensorInfo * > &src_vector, const ITensorInfo *dst, size_t axis)
 Static function to check if given info will lead to a valid configuration of ClConcatenate. More...
 

Detailed Description

Basic function to execute concatenate tensors along a given axis.

This function calls the following kernels:

  1. kernels::ClWidthConcatenateKernel (if underlying concatenation axis is 0).
  2. kernels::ClHeightConcatenateKernel (if underlying concatenation axis is 1).
  3. kernels::ClDepthConcatenateKernel (if underlying concatenation axis is 2).
  4. kernels::ClBatchConcatenateKernel (if underlying concatenation axis is 3).

Definition at line 44 of file ClConcatenate.h.

Constructor & Destructor Documentation

◆ ClConcatenate()

Default constructor.

Definition at line 45 of file ClConcatenate.cpp.

46  : _concat_kernels(),
47  _num_inputs(0),
48  _axis(Window::DimX)
49 {
50 }
static constexpr size_t DimX
Alias for dimension 0 also known as X dimension.
Definition: Window.h:43

Member Function Documentation

◆ configure()

void configure ( const ClCompileContext compile_context,
const std::vector< ITensorInfo * > &  src_vector,
ITensorInfo dst,
size_t  axis 
)

Initialise the kernel's inputs vector and dst.

Note
Input and dst tensor dimensions preconditions defer depending on the concatenation axis.
Preconditions can be found respectively at kernels::ClWidthConcatenateKernel, kernels::ClHeightConcatenateKernel and kernels::ClDepthConcatenateKernel.
Parameters
[in]compile_contextThe compile context to be used.
[in,out]src_vectorThe vectors containing all the tensors info to concatenate. Data types supported: All
[out]dstDestination tensor info. Data types supported: same as src_vector.
[in]axisConcatenation axis. Supported underlying concatenation axis are 0, 1, 2 and 3.

Definition at line 52 of file ClConcatenate.cpp.

53 {
54  ARM_COMPUTE_ERROR_ON(dst == nullptr);
55  _axis = axis;
56  _num_inputs = src_vector.size();
57 
59  std::vector<const ITensorInfo *> const_src_vector(src_vector.size());
60  std::transform(src_vector.begin(), src_vector.end(), const_src_vector.begin(), [](ITensorInfo * t)
61  {
63  return t;
64  });
65 
66  // dst auto inizialitation if not yet initialized
67  auto_init_if_empty(*dst, dst_shape, 1, src_vector[0]->data_type());
68  ARM_COMPUTE_ERROR_THROW_ON(ClConcatenate::validate(const_src_vector, dst, axis));
69 
70  unsigned int offset = 0;
71  switch(_axis)
72  {
73  case Window::DimX:
74  {
75  switch(_num_inputs)
76  {
77  case 2:
78  {
79  // Configure WidthConcatenate2Tensors kernel
80  auto kernel = std::make_unique<kernels::ClWidthConcatenate2TensorsKernel>();
81  kernel->configure(compile_context, src_vector.at(0), src_vector.at(1), dst);
82  _concat_kernels.emplace_back(std::move(kernel));
83  break;
84  }
85  case 4:
86  {
87  // Configure WidthConcatenate4Tensors kernel
88  auto kernel = std::make_unique<kernels::ClWidthConcatenate4TensorsKernel>();
89  kernel->configure(compile_context, src_vector.at(0), src_vector.at(1), src_vector.at(2), src_vector.at(3), dst);
90  _concat_kernels.emplace_back(std::move(kernel));
91  break;
92  }
93  default:
94  {
95  // Configure generic case WidthConcatenate kernels
96  for(unsigned int i = 0; i < _num_inputs; ++i)
97  {
98  auto kernel = std::make_unique<kernels::ClWidthConcatenateKernel>();
99  kernel->configure(compile_context, src_vector.at(i), offset, dst);
100  offset += src_vector.at(i)->dimension(_axis);
101  _concat_kernels.emplace_back(std::move(kernel));
102  }
103  break;
104  }
105  }
106  break;
107  }
108  case Window::DimY:
109  {
110  for(unsigned int i = 0; i < _num_inputs; ++i)
111  {
112  auto kernel = std::make_unique<kernels::ClHeightConcatenateKernel>();
113  kernel->configure(compile_context, src_vector.at(i), offset, dst);
114  offset += src_vector.at(i)->dimension(_axis);
115  _concat_kernels.emplace_back(std::move(kernel));
116  }
117  break;
118  }
119  case Window::DimZ:
120  {
121  for(unsigned int i = 0; i < _num_inputs; ++i)
122  {
123  auto kernel = std::make_unique<kernels::ClDepthConcatenateKernel>();
124  kernel->configure(compile_context, src_vector.at(i), offset, dst);
125  offset += src_vector.at(i)->dimension(_axis);
126  _concat_kernels.emplace_back(std::move(kernel));
127  }
128  break;
129  }
130  case 3:
131  {
132  for(unsigned int i = 0; i < _num_inputs; ++i)
133  {
134  auto kernel = std::make_unique<kernels::ClBatchConcatenateKernel>();
135  kernel->configure(compile_context, src_vector.at(i), offset, dst);
136  offset += src_vector.at(i)->dimension(_axis);
137  _concat_kernels.emplace_back(std::move(kernel));
138  }
139  break;
140  }
141  default:
142  ARM_COMPUTE_ERROR("Axis not supported");
143  }
144 }
__global uchar * offset(const Image *img, int x, int y)
Get the pointer position of a Image.
Definition: helpers.h:861
TensorShape calculate_concatenate_shape(const std::vector< T * > &input, size_t axis)
Calculate the concatenate output shape of the concatenate operation along a single axis.
#define ARM_COMPUTE_ERROR(msg)
Print the given message then throw an std::runtime_error.
Definition: Error.h:352
#define ARM_COMPUTE_ERROR_ON(cond)
If the condition is true then an error message is printed and an exception thrown.
Definition: Error.h:466
#define ARM_COMPUTE_ERROR_THROW_ON(status)
Definition: Error.h:455
const DataType data_type
Definition: Im2Col.cpp:150
static constexpr size_t DimX
Alias for dimension 0 also known as X dimension.
Definition: Window.h:43
bool auto_init_if_empty(ITensorInfo &info, const TensorShape &shape, int num_channels, DataType data_type, QuantizationInfo quantization_info=QuantizationInfo())
Auto initialize the tensor info (shape, number of channels and data type) if the current assignment i...
static constexpr size_t DimY
Alias for dimension 1 also known as Y dimension.
Definition: Window.h:45
static constexpr size_t DimZ
Alias for dimension 2 also known as Z dimension.
Definition: Window.h:47
#define ARM_COMPUTE_ERROR_ON_NULLPTR(...)
Definition: Validate.h:157
static Status validate(const std::vector< const ITensorInfo * > &src_vector, const ITensorInfo *dst, size_t axis)
Static function to check if given info will lead to a valid configuration of ClConcatenate.

References ARM_COMPUTE_ERROR, ARM_COMPUTE_ERROR_ON, ARM_COMPUTE_ERROR_ON_NULLPTR, ARM_COMPUTE_ERROR_THROW_ON, arm_compute::auto_init_if_empty(), arm_compute::misc::shape_calculator::calculate_concatenate_shape(), arm_compute::test::validation::data_type, Window::DimX, Window::DimY, Window::DimZ, arm_compute::test::validation::dst, arm_compute::test::validation::dst_shape, offset(), tf_frozen_model_extractor::t, and ClConcatenate::validate().

◆ run()

void run ( ITensorPack tensors)
overridevirtual

Run the kernels contained in the function.

Parameters
[in]tensorsVector that contains the tensors to operate on.

Reimplemented from ICLOperator.

Definition at line 223 of file ClConcatenate.cpp.

224 {
225  if(tensors.empty())
226  {
227  ARM_COMPUTE_ERROR("No inputs provided");
228  }
229 
230  if(static_cast<int>(tensors.size()) - 1 != static_cast<int>(_num_inputs))
231  {
232  ARM_COMPUTE_ERROR("Configured with different number of inputs");
233  }
234 
235  if(_axis == Window::DimX && (_num_inputs == 2 || _num_inputs == 4))
236  {
237  ARM_COMPUTE_ERROR_ON(_concat_kernels.empty());
238  CLScheduler::get().enqueue_op(*_concat_kernels.at(0), tensors, true);
239  }
240  else
241  {
242  int i = 0;
243  for(auto &k : _concat_kernels)
244  {
245  ITensorPack pack;
246  pack.add_tensor(TensorType::ACL_SRC, tensors.get_const_tensor(ACL_SRC_VEC + i));
247  pack.add_tensor(TensorType::ACL_DST, tensors.get_tensor(ACL_DST));
248  CLScheduler::get().enqueue_op(*k, pack, true);
249  ++i;
250  }
251  }
252 }
static CLScheduler & get()
Access the scheduler singleton.
#define ARM_COMPUTE_ERROR(msg)
Print the given message then throw an std::runtime_error.
Definition: Error.h:352
#define ARM_COMPUTE_ERROR_ON(cond)
If the condition is true then an error message is printed and an exception thrown.
Definition: Error.h:466
static constexpr size_t DimX
Alias for dimension 0 also known as X dimension.
Definition: Window.h:43
void enqueue_op(ICLKernel &kernel, ITensorPack &tensors, bool flush=true)
Schedule the execution of the passed kernel if possible.

References arm_compute::ACL_DST, arm_compute::ACL_SRC, arm_compute::ACL_SRC_VEC, ITensorPack::add_tensor(), ARM_COMPUTE_ERROR, ARM_COMPUTE_ERROR_ON, Window::DimX, ITensorPack::empty(), CLScheduler::enqueue_op(), CLScheduler::get(), ITensorPack::get_const_tensor(), ITensorPack::get_tensor(), and ITensorPack::size().

◆ validate()

Status validate ( const std::vector< const ITensorInfo * > &  src_vector,
const ITensorInfo dst,
size_t  axis 
)
static

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

Note
Input and dst tensor dimensions preconditions defer depending on the concatenation axis.
Preconditions can be found respectively at kernels::ClWidthConcatenateKernel, kernels::ClHeightConcatenateKernel and kernels::ClDepthConcatenateKernel.
Parameters
[in]src_vectorThe vectors containing all the tensors info to concatenate. Data types supported: All
[in]dstDestination tensor info. Data types supported: same as src_vector.
[in]axisConcatenation axis. Supported underlying concatenation axis are 0, 1, 2 and 3.
Returns
a status

Definition at line 146 of file ClConcatenate.cpp.

147 {
148  ARM_COMPUTE_RETURN_ERROR_ON(dst == nullptr);
149  const unsigned int num_inputs = src_vector.size();
150 
152  ARM_COMPUTE_RETURN_ERROR_ON(num_inputs < 2);
153 
154  unsigned int offset = 0;
155  switch(axis)
156  {
157  case Window::DimX:
158  {
159  switch(num_inputs)
160  {
161  case 2:
162  // Validate WidthConcatenate2Tensors kernels if there are 2 inputs
163  ARM_COMPUTE_RETURN_ERROR_ON_NULLPTR(src_vector[0], src_vector[1]);
165  break;
166  case 4:
167  // Validate WidthConcatenate4Tensors kernels if there are 4 inputs
168  ARM_COMPUTE_RETURN_ERROR_ON_NULLPTR(src_vector[0], src_vector[1], src_vector[2], src_vector[3]);
169  ARM_COMPUTE_RETURN_ON_ERROR(kernels::ClWidthConcatenate4TensorsKernel::validate(src_vector[0], src_vector[1], src_vector[2], src_vector[3], dst));
170  break;
171  default:
172  // Validate generic case of WidthConcatenate kernel
173  for(const auto &src : src_vector)
174  {
177  offset += src->dimension(axis);
178  }
179  break;
180  }
181  break;
182  }
183  case Window::DimY:
184  {
185  for(const auto &src : src_vector)
186  {
188  offset += src->dimension(axis);
189  }
190  break;
191  }
192  case Window::DimZ:
193  {
194  for(const auto &src : src_vector)
195  {
197  offset += src->dimension(axis);
198  }
199  break;
200  }
201  case 3:
202  {
203  for(const auto &src : src_vector)
204  {
206  offset += src->dimension(axis);
207  }
208  break;
209  }
210  default:
211  ARM_COMPUTE_ERROR("Axis not supported");
212  }
213 
214  if(dst->total_size() != 0)
215  {
217  ARM_COMPUTE_RETURN_ERROR_ON(dst_shape.total_size() != dst->tensor_shape().total_size());
218  }
219 
220  return Status{};
221 }
__global uchar * offset(const Image *img, int x, int y)
Get the pointer position of a Image.
Definition: helpers.h:861
TensorShape calculate_concatenate_shape(const std::vector< T * > &input, size_t axis)
Calculate the concatenate output shape of the concatenate operation along a single axis.
static Status validate(const ITensorInfo *src, unsigned int depth_offset, const ITensorInfo *dst)
Static function to check if given info will lead to a valid configuration of ClDepthConcatenateKernel...
#define ARM_COMPUTE_ERROR(msg)
Print the given message then throw an std::runtime_error.
Definition: Error.h:352
#define ARM_COMPUTE_RETURN_ON_ERROR(status)
Checks if a status contains an error and returns it.
Definition: Error.h:204
static Status validate(const ITensorInfo *src, unsigned int batch_offset, const ITensorInfo *dst)
Static function to check if given info will lead to a valid configuration of ClBatchConcatenateKernel...
static Status validate(const ITensorInfo *src, unsigned int width_offset, const ITensorInfo *dst)
Static function to check if given info will lead to a valid configuration of ClWidthConcatenateKernel...
#define ARM_COMPUTE_RETURN_ERROR_ON(cond)
If the condition is true, an error is returned.
Definition: Error.h:296
SimpleTensor< float > src
Definition: DFT.cpp:155
#define ARM_COMPUTE_RETURN_ERROR_ON_NULLPTR(...)
Definition: Validate.h:159
static constexpr size_t DimX
Alias for dimension 0 also known as X dimension.
Definition: Window.h:43
static Status validate(const ITensorInfo *src1, const ITensorInfo *src2, const ITensorInfo *src3, const ITensorInfo *src4, const ITensorInfo *dst)
Static function to check if given info will lead to a valid configuration of ClWidthConcatenate4Tenso...
size_t total_size() const
Collapses all dimensions to a single linear total size.
Definition: TensorShape.h:172
static constexpr size_t DimY
Alias for dimension 1 also known as Y dimension.
Definition: Window.h:45
static constexpr size_t DimZ
Alias for dimension 2 also known as Z dimension.
Definition: Window.h:47
static Status validate(const ITensorInfo *src, unsigned int height_offset, const ITensorInfo *dst)
Static function to check if given info will lead to a valid configuration of ClHeightConcatenateKerne...
static Status validate(const ITensorInfo *src1, const ITensorInfo *src2, const ITensorInfo *dst)
Static function to check if given info will lead to a valid configuration of ClWidthConcatenate2Tenso...

References ARM_COMPUTE_ERROR, ARM_COMPUTE_RETURN_ERROR_ON, ARM_COMPUTE_RETURN_ERROR_ON_NULLPTR, ARM_COMPUTE_RETURN_ON_ERROR, arm_compute::misc::shape_calculator::calculate_concatenate_shape(), Window::DimX, Window::DimY, Window::DimZ, arm_compute::test::validation::dst, arm_compute::test::validation::dst_shape, offset(), arm_compute::test::validation::src, TensorShape::total_size(), ClWidthConcatenate2TensorsKernel::validate(), ClHeightConcatenateKernel::validate(), ClWidthConcatenateKernel::validate(), ClBatchConcatenateKernel::validate(), ClDepthConcatenateKernel::validate(), and ClWidthConcatenate4TensorsKernel::validate().

Referenced by ClConcatenate::configure(), and CLConcatenateLayer::validate().


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