tests/RawTensor.h

   1 /*
   2  * Copyright (c) 2017-2018 ARM Limited.
   3  *
   4  * SPDX-License-Identifier: MIT
   5  *
   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:
  12  *
  13  * The above copyright notice and this permission notice shall be included in all
  14  * copies or substantial portions of the Software.
  15  *
  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
  22  * SOFTWARE.
  23  */
  24 #ifndef __ARM_COMPUTE_TEST_RAW_TENSOR_H__
  25 #define __ARM_COMPUTE_TEST_RAW_TENSOR_H__
  26
  27 #include "tests/SimpleTensor.h"
  28
  29 namespace arm_compute
  30 {
  31 namespace test
  32 {
  33 /** Subclass of SimpleTensor using uint8_t as value type.
  34  *
  35  * Access operations (except for operator[]) will be based on the data type to
  36  * copy the right number of elements.
  37  */
  38 class RawTensor : public SimpleTensor<uint8_t>
  39 {
  40 public:
  41     /** Create an uninitialised tensor of the given @p shape and @p format.
  42      *
  43      * @param[in] shape                Shape of the new raw tensor.
  44      * @param[in] format               Format of the new raw tensor.
  45      * @param[in] fixed_point_position (Optional) Number of bits for the fractional part of the fixed point numbers
  46      */
  47     RawTensor(TensorShape shape, Format format, int fixed_point_position = 0);
  48
  49     /** Create an uninitialised tensor of the given @p shape and @p data type.
  50      *
  51      * @param[in] shape                Shape of the new raw tensor.
  52      * @param[in] data_type            Data type of the new raw tensor.
  53      * @param[in] num_channels         (Optional) Number of channels (default = 1).
  54      * @param[in] fixed_point_position (Optional) Number of bits for the fractional part of the fixed point numbers (default = 0).
  55      */
  56     RawTensor(TensorShape shape, DataType data_type, int num_channels = 1, int fixed_point_position = 0);
  57
  58     /** Conversion constructor from SimpleTensor.
  59      *
  60      * The passed SimpleTensor will be destroyed after it has been converted to
  61      * a RawTensor.
  62      *
  63      * @param[in,out] tensor SimpleTensor to be converted to a RawTensor.
  64      */
  65     template <typename T>
  66     RawTensor(SimpleTensor<T> &&tensor)
  67     {
  68         _buffer               = std::unique_ptr<uint8_t[]>(reinterpret_cast<uint8_t *>(tensor._buffer.release()));
  69         _shape                = std::move(tensor._shape);
  70         _format               = tensor._format;
  71         _data_type            = tensor._data_type;
  72         _num_channels         = tensor._num_channels;
  73         _fixed_point_position = tensor._fixed_point_position;
  74         _data_layout          = tensor._data_layout;
  75     }
  76
  77     /** Conversion operator to SimpleTensor.
  78      *
  79      * The current RawTensor must not be used after the conversion.
  80      *
  81      * @return SimpleTensor of the given type.
  82      */
  83     template <typename T>
  84     operator SimpleTensor<T>()
  85     {
  86         SimpleTensor<T> cast;
  87         cast._buffer               = std::unique_ptr<T[]>(reinterpret_cast<T *>(_buffer.release()));
  88         cast._shape                = std::move(_shape);
  89         cast._format               = _format;
  90         cast._data_type            = _data_type;
  91         cast._num_channels         = _num_channels;
  92         cast._fixed_point_position = _fixed_point_position;
  93         cast._data_layout          = _data_layout;
  94
  95         return cast;
  96     }
  97
  98     /** Create a deep copy of the given @p tensor.
  99      *
 100      * @param[in] tensor To be copied tensor.
 101      */
 102     RawTensor(const RawTensor &tensor);
 103
 104     /** Copy the given @p tensor.
 105      *
 106      * @param[in] tensor To be copied tensor.
 107      *
 108      * @return a copy of the given tensor.
 109      */
 110     RawTensor &operator=(RawTensor tensor);
 111     /** Allow instances of this class to be move constructed */
 112     RawTensor(RawTensor &&) = default;
 113     /** Default destructor. */
 114     ~RawTensor() = default;
 115
 116     /** Read only access to the specified element.
 117      *
 118      * @param[in] coord Coordinates of the desired element.
 119      *
 120      * @return A pointer to the desired element.
 121      */
 122     const void *operator()(const Coordinates &coord) const override;
 123
 124     /** Access to the specified element.
 125      *
 126      * @param[in] coord Coordinates of the desired element.
 127      *
 128      * @return A pointer to the desired element.
 129      */
 130     void *operator()(const Coordinates &coord) override;
 131 };
 132 } // namespace test
 133 } // namespace arm_compute
 134 #endif /* __ARM_COMPUTE_TEST_RAW_TENSOR_H__ */