src/runtime/TensorAllocator.cpp

   1 /*
   2  * Copyright (c) 2016, 2017 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 #include "arm_compute/runtime/TensorAllocator.h"
  25
  26 #include "arm_compute/core/Coordinates.h"
  27 #include "arm_compute/core/Error.h"
  28 #include "arm_compute/core/TensorInfo.h"
  29 #include "arm_compute/runtime/MemoryGroup.h"
  30
  31 #include <cstddef>
  32
  33 using namespace arm_compute;
  34
  35 namespace
  36 {
  37 bool validate_subtensor_shape(const TensorInfo &parent_info, const TensorInfo &child_info, const Coordinates &coords)
  38 {
  39     bool               is_valid     = true;
  40     const TensorShape &parent_shape = parent_info.tensor_shape();
  41     const TensorShape &child_shape  = child_info.tensor_shape();
  42     const size_t       parent_dims  = parent_info.num_dimensions();
  43     const size_t       child_dims   = child_info.num_dimensions();
  44
  45     if(child_dims <= parent_dims)
  46     {
  47         for(size_t num_dimensions = child_dims; num_dimensions > 0; --num_dimensions)
  48         {
  49             const size_t child_dim_size = coords[num_dimensions - 1] + child_shape[num_dimensions - 1];
  50
  51             if((coords[num_dimensions - 1] < 0) || (child_dim_size > parent_shape[num_dimensions - 1]))
  52             {
  53                 is_valid = false;
  54                 break;
  55             }
  56         }
  57     }
  58     else
  59     {
  60         is_valid = false;
  61     }
  62
  63     return is_valid;
  64 }
  65 } // namespace
  66
  67 TensorAllocator::TensorAllocator(Tensor *owner)
  68     : _associated_memory_group(nullptr), _buffer(nullptr), _owner(owner)
  69 {
  70 }
  71
  72 TensorAllocator::~TensorAllocator()
  73 {
  74     if((_associated_memory_group == nullptr) && (_buffer != nullptr))
  75     {
  76         delete[] _buffer;
  77         _buffer = nullptr;
  78         info().set_is_resizable(true);
  79     }
  80 }
  81
  82 TensorAllocator::TensorAllocator(TensorAllocator &&o) noexcept
  83     : ITensorAllocator(std::move(o)),
  84       _associated_memory_group(o._associated_memory_group),
  85       _buffer(o._buffer),
  86       _owner(o._owner)
  87 {
  88     o._associated_memory_group = nullptr;
  89     o._buffer                  = nullptr;
  90     o._owner                   = nullptr;
  91 }
  92
  93 TensorAllocator &TensorAllocator::operator=(TensorAllocator &&o) noexcept
  94 {
  95     if(&o != this)
  96     {
  97         _associated_memory_group   = o._associated_memory_group;
  98         o._associated_memory_group = nullptr;
  99
 100         _buffer   = o._buffer;
 101         o._buffer = nullptr;
 102
 103         _owner   = o._owner;
 104         o._owner = nullptr;
 105
 106         ITensorAllocator::operator=(std::move(o));
 107     }
 108     return *this;
 109 }
 110
 111 void TensorAllocator::init(const TensorAllocator &allocator, const Coordinates &coords, TensorInfo sub_info)
 112 {
 113     // Get parent info
 114     const TensorInfo parent_info = allocator.info();
 115
 116     // Check if coordinates and new shape are within the parent tensor
 117     ARM_COMPUTE_ERROR_ON(!validate_subtensor_shape(parent_info, sub_info, coords));
 118     ARM_COMPUTE_UNUSED(validate_subtensor_shape);
 119
 120     // Copy pointer to buffer
 121     _buffer = allocator._buffer;
 122
 123     // Init tensor info with new dimensions
 124     size_t total_size = parent_info.offset_element_in_bytes(coords) + sub_info.total_size() - sub_info.offset_first_element_in_bytes();
 125     sub_info.init(sub_info.tensor_shape(), sub_info.format(), parent_info.strides_in_bytes(), parent_info.offset_element_in_bytes(coords), total_size);
 126
 127     // Set TensorInfo
 128     init(sub_info);
 129 }
 130
 131 uint8_t *TensorAllocator::data() const
 132 {
 133     return _buffer;
 134 }
 135
 136 void TensorAllocator::allocate()
 137 {
 138     ARM_COMPUTE_ERROR_ON(_buffer != nullptr);
 139     if(_associated_memory_group == nullptr)
 140     {
 141         _buffer = new uint8_t[info().total_size()]();
 142     }
 143     else
 144     {
 145         _associated_memory_group->finalize_memory(_owner, reinterpret_cast<void **>(&_buffer), info().total_size());
 146     }
 147     info().set_is_resizable(false);
 148 }
 149
 150 void TensorAllocator::free()
 151 {
 152     if((_associated_memory_group == nullptr) && (_buffer != nullptr))
 153     {
 154         delete[] _buffer;
 155         _buffer = nullptr;
 156         info().set_is_resizable(true);
 157     }
 158 }
 159
 160 void TensorAllocator::set_associated_memory_group(MemoryGroup *associated_memory_group)
 161 {
 162     ARM_COMPUTE_ERROR_ON(associated_memory_group == nullptr);
 163     ARM_COMPUTE_ERROR_ON(_associated_memory_group != nullptr);
 164     ARM_COMPUTE_ERROR_ON(_buffer != nullptr);
 165     _associated_memory_group = associated_memory_group;
 166 }
 167
 168 uint8_t *TensorAllocator::lock()
 169 {
 170     return _buffer;
 171 }
 172
 173 void TensorAllocator::unlock()
 174 {
 175 }