2 * Copyright (c) 2016-2018 ARM Limited.
4 * SPDX-License-Identifier: MIT
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to
8 * deal in the Software without restriction, including without limitation the
9 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
10 * sell copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in all
14 * copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
24 #include "arm_compute/core/TensorInfo.h"
26 #include "arm_compute/core/Error.h"
27 #include "arm_compute/core/HOGInfo.h"
28 #include "arm_compute/core/Helpers.h"
29 #include "arm_compute/core/TensorInfo.h"
30 #include "arm_compute/core/Validate.h"
31 #include "support/ToolchainSupport.h"
33 using namespace arm_compute;
35 TensorInfo::TensorInfo()
36 : _total_size(0), _fixed_point_position(0), _offset_first_element_in_bytes(0), _strides_in_bytes(), _num_channels(0), _tensor_shape(), _data_type(DataType::UNKNOWN), _format(Format::UNKNOWN),
37 _is_resizable{ true }, _valid_region{ Coordinates(), _tensor_shape }, _padding{ 0 }, _quantization_info(), _data_layout(DataLayout::NCHW)
41 TensorInfo::TensorInfo(const ITensorInfo &info)
44 _total_size = info.total_size();
45 _fixed_point_position = info.fixed_point_position();
46 _offset_first_element_in_bytes = info.offset_first_element_in_bytes();
47 _strides_in_bytes = info.strides_in_bytes();
48 _num_channels = info.num_channels();
49 _tensor_shape = info.tensor_shape();
50 _data_type = info.data_type();
51 _format = info.format();
52 _is_resizable = info.is_resizable();
53 _valid_region = info.valid_region();
54 _padding = info.padding();
55 _quantization_info = info.quantization_info();
56 _data_layout = info.data_layout();
59 TensorInfo::TensorInfo(Format format)
60 : TensorInfo(TensorShape(), format)
64 TensorInfo::TensorInfo(unsigned int width, unsigned int height, Format format)
65 : TensorInfo(TensorShape(width, height), format)
69 TensorInfo::TensorInfo(const TensorShape &tensor_shape, Format format)
72 init(tensor_shape, format);
75 TensorInfo::TensorInfo(size_t num_channels, DataType data_type, size_t fixed_point_position)
78 init(TensorShape(), num_channels, data_type, fixed_point_position);
81 TensorInfo::TensorInfo(const TensorShape &tensor_shape, size_t num_channels, DataType data_type, int fixed_point_position)
84 init(tensor_shape, num_channels, data_type, fixed_point_position);
87 TensorInfo::TensorInfo(const TensorShape &tensor_shape, size_t num_channels, DataType data_type, QuantizationInfo quantization_info)
90 init(tensor_shape, num_channels, data_type, 0);
91 _quantization_info = quantization_info;
94 TensorInfo::TensorInfo(const HOGInfo &hog_info, unsigned int width, unsigned int height)
97 init(hog_info, width, height);
100 void TensorInfo::init(Format format)
102 init(TensorShape(), format);
105 void TensorInfo::init(const TensorShape &tensor_shape, Format format)
107 size_t num_channels = num_channels_from_format(format);
108 const DataType type = data_type_from_format(format);
110 init(tensor_shape, num_channels, type);
115 void TensorInfo::init(const TensorShape &tensor_shape, Format format,
116 const Strides &strides_in_bytes, size_t offset_first_element_in_bytes,
117 size_t total_size_in_bytes)
119 size_t num_channels = num_channels_from_format(format);
120 const DataType type = data_type_from_format(format);
122 init(tensor_shape, num_channels, type, strides_in_bytes, offset_first_element_in_bytes, total_size_in_bytes);
127 void TensorInfo::init(size_t num_channels, DataType data_type, size_t fixed_point_position)
129 init(TensorShape(), num_channels, data_type, fixed_point_position);
132 void TensorInfo::init(const TensorShape &tensor_shape, size_t num_channels, DataType data_type, int fixed_point_position)
134 ARM_COMPUTE_ERROR_ON(num_channels == 0);
135 ARM_COMPUTE_ERROR_ON(data_type == DataType::QS8 && (fixed_point_position < 1 || fixed_point_position > 6));
136 ARM_COMPUTE_ERROR_ON(data_type == DataType::QS16 && (fixed_point_position < 1 || fixed_point_position > 14));
138 _fixed_point_position = fixed_point_position;
139 _data_type = data_type;
140 _num_channels = num_channels;
141 _format = Format::UNKNOWN;
143 set_tensor_shape(tensor_shape);
146 void TensorInfo::init(const TensorShape &tensor_shape, size_t num_channels, DataType data_type,
147 const Strides &strides_in_bytes, size_t offset_first_element_in_bytes,
148 size_t total_size_in_bytes, int fixed_point_position)
150 ARM_COMPUTE_ERROR_ON(num_channels == 0);
151 ARM_COMPUTE_ERROR_ON(data_type == DataType::QS8 && (fixed_point_position < 1 || fixed_point_position > 6));
152 ARM_COMPUTE_ERROR_ON(data_type == DataType::QS16 && (fixed_point_position < 1 || fixed_point_position > 14));
154 _fixed_point_position = fixed_point_position;
155 _data_type = data_type;
156 _num_channels = num_channels;
157 _format = Format::UNKNOWN;
158 _tensor_shape = tensor_shape;
159 _offset_first_element_in_bytes = offset_first_element_in_bytes;
160 _strides_in_bytes = strides_in_bytes;
161 _total_size = total_size_in_bytes;
163 _valid_region = ValidRegion{ Coordinates(), _tensor_shape };
166 void TensorInfo::init(const HOGInfo &hog_info, unsigned int width, unsigned int height)
168 // Number of cells for each block
169 const Size2D num_cells_per_block = hog_info.num_cells_per_block();
171 // Tensor Size = (Number of horizontal block positions) * (Number of vertical block positions)
172 const Size2D num_block_positions_per_img = hog_info.num_block_positions_per_image(Size2D(width, height));
174 // Number of tensor channels = (Number of cells per block) * (Number of bins per cell)
175 const size_t num_channels = num_cells_per_block.area() * hog_info.num_bins();
177 init(TensorShape(num_block_positions_per_img.width, num_block_positions_per_img.height), num_channels, DataType::F32);
180 size_t TensorInfo::init_auto_padding(const TensorShape &tensor_shape, Format format)
182 const size_t num_channels = num_channels_from_format(format);
183 const DataType type = data_type_from_format(format);
184 size_t total_size = init_auto_padding(tensor_shape, num_channels, type);
191 size_t TensorInfo::init_auto_padding(const TensorShape &tensor_shape, size_t num_channels, DataType data_type, int fixed_point_position)
193 ARM_COMPUTE_ERROR_ON(num_channels == 0);
194 ARM_COMPUTE_ERROR_ON(data_type == DataType::QS8 && (fixed_point_position < 1 || fixed_point_position > 6));
195 ARM_COMPUTE_ERROR_ON(data_type == DataType::QS16 && (fixed_point_position < 1 || fixed_point_position > 14));
197 _fixed_point_position = fixed_point_position;
198 _data_type = data_type;
199 _num_channels = num_channels;
200 _format = Format::UNKNOWN;
201 _tensor_shape = tensor_shape;
203 _valid_region = ValidRegion{ Coordinates(), _tensor_shape };
210 size_t TensorInfo::init_auto_padding(const HOGInfo &hog_info, unsigned int width, unsigned int height)
212 // Number of cells for each block
213 const Size2D num_cells_per_block = hog_info.num_cells_per_block();
215 // Tensor Size = (Number of horizontal block positions) * (Number of vertical block positions)
216 const Size2D num_block_positions_per_img = hog_info.num_block_positions_per_image(Size2D(width, height));
218 // Number of tensor channels = (Number of cells per block) * (Number of bins per cell)
219 const size_t num_channels = num_cells_per_block.area() * hog_info.num_bins();
221 return init_auto_padding(TensorShape(num_block_positions_per_img.width, num_block_positions_per_img.height), num_channels, DataType::F32);
224 bool TensorInfo::auto_padding()
226 ARM_COMPUTE_ERROR_ON(!_is_resizable);
228 // Some kernels compute 32 elements at the time, worst case scenario they
229 // will read 32 values after the last element
230 const size_t extra_pad_x = _tensor_shape.num_dimensions() < 1 ? 0 : 32;
231 const size_t pad_x = _tensor_shape.num_dimensions() < 1 ? 0 : 4;
232 const size_t pad_y = _tensor_shape.num_dimensions() < 2 ? 0 : 4;
234 return extend_padding(PaddingSize(pad_y, pad_x + extra_pad_x, pad_y, pad_x));
237 std::tuple<Strides, size_t, size_t> TensorInfo::calculate_padding_requirements(const PaddingSize &padding)
239 // Calculate resulting stride for the X, Y and Z dimension
240 const size_t stride_x = element_size();
241 const size_t stride_y = (padding.left + _tensor_shape[0] + padding.right) * stride_x;
242 const size_t stride_z = (padding.top + _tensor_shape[1] + padding.bottom) * stride_y;
244 Strides required_strides;
245 size_t required_total_size = 0;
246 const size_t required_offset_first_element = padding.left * stride_x + padding.top * stride_y;
248 switch(_tensor_shape.num_dimensions())
252 if(_tensor_shape.total_size() > 0)
254 required_strides = Strides(stride_x, stride_x);
255 required_total_size = stride_z;
260 required_strides = compute_strides(*this, stride_x, stride_y);
261 required_total_size = stride_z;
264 required_strides = compute_strides(*this, stride_x, stride_y);
265 required_total_size = stride_z;
269 required_strides = compute_strides(*this, stride_x, stride_y, stride_z);
271 const unsigned int idx_last_dimension = _tensor_shape.num_dimensions() - 1;
273 required_total_size = _tensor_shape[idx_last_dimension] * required_strides[idx_last_dimension];
278 return std::make_tuple(required_strides, required_offset_first_element, required_total_size);
281 bool TensorInfo::extend_padding(const PaddingSize &padding)
283 ARM_COMPUTE_ERROR_ON(!_is_resizable);
285 bool updated = false;
287 if(padding.top > _padding.top)
289 _padding.top = padding.top;
293 if(padding.right > _padding.right)
295 _padding.right = padding.right;
299 if(padding.bottom > _padding.bottom)
301 _padding.bottom = padding.bottom;
305 if(padding.left > _padding.left)
307 _padding.left = padding.left;
311 std::tie(_strides_in_bytes, _offset_first_element_in_bytes, _total_size) = calculate_padding_requirements(_padding);
316 std::unique_ptr<ITensorInfo> TensorInfo::clone() const
318 return support::cpp14::make_unique<TensorInfo>(*this);
321 ITensorInfo &TensorInfo::set_data_type(DataType data_type)
323 _data_type = data_type;
324 _format = Format::UNKNOWN;
325 return set_tensor_shape(tensor_shape()); // Force total size and strides to update
328 ITensorInfo &TensorInfo::set_num_channels(int num_channels)
330 _num_channels = num_channels;
331 _format = Format::UNKNOWN;
335 ITensorInfo &TensorInfo::set_format(Format format)
339 if(_data_type == DataType::UNKNOWN)
341 _num_channels = num_channels_from_format(format);
342 _data_type = data_type_from_format(format);
346 ARM_COMPUTE_ERROR_ON(num_channels_from_format(format) != _num_channels);
347 ARM_COMPUTE_ERROR_ON(data_type_from_format(format) != _data_type);
352 ITensorInfo &TensorInfo::set_tensor_shape(const TensorShape &shape)
354 _tensor_shape = shape;
355 _offset_first_element_in_bytes = 0;
356 _strides_in_bytes = compute_strides(*this);
358 if(_tensor_shape.num_dimensions() == 0)
360 _total_size = _strides_in_bytes[0];
364 const unsigned int idx_last_dimension = _tensor_shape.num_dimensions() - 1;
365 _total_size = _tensor_shape[idx_last_dimension] * _strides_in_bytes[idx_last_dimension];
368 std::tie(_strides_in_bytes, _offset_first_element_in_bytes, _total_size) = calculate_padding_requirements(_padding);
370 _valid_region = ValidRegion{ Coordinates(), _tensor_shape };
374 ITensorInfo &TensorInfo::set_fixed_point_position(int fixed_point_position)
376 ARM_COMPUTE_ERROR_ON(_data_type == DataType::QS8 && (fixed_point_position < 1 || fixed_point_position > 6));
377 ARM_COMPUTE_ERROR_ON(_data_type == DataType::QS16 && (fixed_point_position < 1 || fixed_point_position > 14));
378 _fixed_point_position = fixed_point_position;
382 ITensorInfo &TensorInfo::set_quantization_info(const QuantizationInfo &quantization_info)
384 _quantization_info = quantization_info;
388 ITensorInfo &TensorInfo::set_data_layout(const DataLayout &data_layout)
390 _data_layout = data_layout;
394 ITensorInfo &TensorInfo::reset_padding()
396 _padding = PaddingSize();
397 if(((_format != Format::UNKNOWN) || (_data_type != DataType::UNKNOWN)) && _total_size != 0)
399 std::tie(_strides_in_bytes, _offset_first_element_in_bytes, _total_size) = calculate_padding_requirements(_padding);
404 size_t TensorInfo::offset_element_in_bytes(const Coordinates &pos) const
406 ARM_COMPUTE_ERROR_ON_COORDINATES_DIMENSIONS_GTE(pos, _tensor_shape.num_dimensions());
408 size_t offset = _offset_first_element_in_bytes;
410 for(size_t i = 0; i < _tensor_shape.num_dimensions(); ++i)
412 offset += pos[i] * _strides_in_bytes[i];