runtime/onert/backend/cpu/Tensor.h

   1 /*
   2  * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #ifndef __ONERT_BACKEND_CPU_TENSOR_H__
  18 #define __ONERT_BACKEND_CPU_TENSOR_H__
  19
  20 #include <backend/cpu_common/Tensor.h>
  21 #include <ir/Data.h>
  22
  23 namespace onert
  24 {
  25 namespace backend
  26 {
  27 namespace cpu
  28 {
  29
  30 using Tensor = cpu_common::Tensor;
  31
  32 /**
  33  * @brief Class that uses data from external memory that is not managed by a backend
  34  *        instead of allocating and copying the data. ExternalTensor's data pointer points to
  35  *        an address of memory such as where memory is already allocated, or mmapped area.
  36  *        This is meaning that ExternalTensor can take all of types' ir::Data.
  37  *        To support this, assume below things no padding, always NHWC layout,
  38  *        constant tensor and not dynamic.
  39  */
  40 class ExternalTensor : public Tensor
  41 {
  42 public:
  43   ExternalTensor() = delete;
  44
  45 public:
  46   ExternalTensor(const ir::OperandInfo &info, const ir::Layout layout)
  47       : Tensor(info, layout, nullptr)
  48   {
  49     assert(_layout == ir::Layout::NHWC);
  50     assert(_info.isConstant());
  51     assert(_info.isDynamic() == false);
  52   }
  53
  54 public:
  55   /**
  56    * @brief     set Data to be shared from external so that this ExternalTensor will not be
  57    *            allocated on CPU backend
  58    * @param[in] data    data of Operand to be set
  59    */
  60   void setData(const std::shared_ptr<ir::Data> data)
  61   {
  62     assert(data != nullptr);
  63     _data = data;
  64     // Note. Some op such as cker::Conv could take buffer as nullptr.
  65     // That's why _buffer also would be used
  66     _buffer = const_cast<uint8_t *>(_data->base());
  67   }
  68
  69 public:
  70   uint8_t *buffer() const override { return _buffer; }
  71
  72   bool is_constant() const override { return true; }
  73   bool is_dynamic() const override { return false; }
  74   void set_dynamic() override
  75   {
  76     throw std::runtime_error("This tensor does not support changing dynamic");
  77   }
  78
  79   void setShape(const ir::Shape &) override
  80   {
  81     throw std::runtime_error("This tensor does not support changing shape");
  82   }
  83
  84   void increase_ref() override { ++_num_references; }
  85
  86   void decrease_ref() override
  87   {
  88     assert(_data != nullptr);
  89     assert(_num_references > 0);
  90     --_num_references;
  91     if (_num_references == 0)
  92     {
  93       _data.reset();
  94       _buffer = nullptr;
  95     }
  96   }
  97
  98 private:
  99   std::shared_ptr<const ir::Data> _data;
 100 };
 101
 102 } // namespace cpu
 103 } // namespace backend
 104 } // namespace onert
 105
 106 #endif // __ONERT_BACKEND_CPU_TENSOR_H__