src/armnn/Descriptors.cpp

   1 //
   2 // Copyright © 2017 Arm Ltd. All rights reserved.
   3 // SPDX-License-Identifier: MIT
   4 //
   5 #include "armnn/Descriptors.hpp"
   6
   7 #include <algorithm>
   8 #include <array>
   9 #include <vector>
  10
  11 #include <boost/format.hpp>
  12 #include <boost/log/trivial.hpp>
  13 #include <boost/numeric/conversion/cast.hpp>
  14
  15 namespace armnn
  16 {
  17
  18 PermutationVector::PermutationVector(const ValueType *dimMappings, const SizeType numDimMappings)
  19 {
  20     // Validation
  21
  22     if (numDimMappings > MaxNumOfTensorDimensions)
  23     {
  24         boost::format fmt("The number of mappings (%1%) cannot be greater "
  25                           "than the maximum number of dimensions supported (%2%)");
  26         throw InvalidArgumentException(boost::str(fmt % numDimMappings % MaxNumOfTensorDimensions));
  27     }
  28
  29     if ((dimMappings == nullptr) && (numDimMappings != 0))
  30     {
  31         throw InvalidArgumentException("Dimension mappings must not be NULL if the number of mappings is positive");
  32     }
  33
  34     for (SizeType i = 0; i < numDimMappings; ++i)
  35     {
  36         const ValueType dstIndex = dimMappings[i];
  37         if (dstIndex >= numDimMappings)
  38         {
  39             boost::format fmt("Dimension mapping at index %1% is invalid: %2% is outside of the valid range [0,%3%]");
  40             throw InvalidArgumentException(boost::str(fmt % i % dstIndex % (numDimMappings - 1)));
  41         }
  42     }
  43
  44     // Validation: Detect duplicates
  45     {
  46         std::array<bool, MaxNumOfTensorDimensions> observedDims;
  47         observedDims.fill(false);
  48
  49         for (SizeType i = 0; i < numDimMappings; ++i)
  50         {
  51             const ValueType dstIndex = dimMappings[i];
  52             if (observedDims[dstIndex])
  53             {
  54                 throw InvalidArgumentException("Invalid dimension mappings: Two or more source dimensions are mapped "
  55                     "to the same output dimension");
  56             }
  57             observedDims[dstIndex] = true;
  58         }
  59     }
  60
  61     // Initialize
  62     for (SizeType i = 0; i < numDimMappings; ++i)
  63     {
  64         m_DimMappings[i] = dimMappings[i];
  65     }
  66     m_NumDimMappings = numDimMappings;
  67 }
  68
  69 PermutationVector::PermutationVector(std::initializer_list<ValueType> dimMappings)
  70     : PermutationVector(dimMappings.begin(), boost::numeric_cast<SizeType>(dimMappings.size()))
  71 {
  72 }
  73
  74 OriginsDescriptor::OriginsDescriptor()
  75 : m_ConcatAxis(1)
  76 , m_NumViews(0)
  77 , m_NumDimensions(0)
  78 , m_ViewOrigins(nullptr)
  79 {}
  80
  81 OriginsDescriptor::OriginsDescriptor(uint32_t numViews, uint32_t numDimensions /*= 4*/)
  82 : m_ConcatAxis(1)
  83 , m_NumViews(numViews)
  84 , m_NumDimensions(numDimensions)
  85 , m_ViewOrigins(numViews && numDimensions > 0 ? new uint32_t *[numViews]() : nullptr)
  86 {
  87     for (uint32_t i = 0; m_NumDimensions > 0 && i < m_NumViews; ++i)
  88     {
  89         m_ViewOrigins[i] = new uint32_t[m_NumDimensions]();
  90     }
  91 }
  92
  93 OriginsDescriptor::OriginsDescriptor(const OriginsDescriptor& other)
  94 : m_ConcatAxis(other.m_ConcatAxis)
  95 , m_NumViews(other.m_NumViews)
  96 , m_NumDimensions(other.m_NumDimensions)
  97 , m_ViewOrigins(other.m_NumViews && other.m_NumDimensions > 0 ? new uint32_t *[other.m_NumViews]() : nullptr)
  98 {
  99     for (uint32_t i = 0; m_NumDimensions > 0 && i < m_NumViews; ++i)
 100     {
 101         m_ViewOrigins[i] = new uint32_t[m_NumDimensions]();
 102         memcpy(m_ViewOrigins[i], other.m_ViewOrigins[i], m_NumDimensions * sizeof(uint32_t));
 103     }
 104 }
 105
 106 OriginsDescriptor::OriginsDescriptor(OriginsDescriptor&& other)
 107 : OriginsDescriptor()
 108 {
 109     swap(*this, other);
 110 }
 111
 112 OriginsDescriptor::~OriginsDescriptor()
 113 {
 114     for (uint32_t i = 0; m_NumDimensions > 0 && i < m_NumViews; ++i)
 115     {
 116         delete[] m_ViewOrigins[i];
 117     }
 118     delete[] m_ViewOrigins;
 119 }
 120
 121 OriginsDescriptor& OriginsDescriptor::operator=(OriginsDescriptor rhs)
 122 {
 123     swap(*this, rhs);
 124     return *this;
 125 }
 126
 127 void OriginsDescriptor::SetConcatAxis(unsigned int concatAxis)
 128 {
 129     m_ConcatAxis = concatAxis;
 130 }
 131 unsigned int OriginsDescriptor::GetConcatAxis() const
 132 {
 133     return m_ConcatAxis;
 134 }
 135
 136 Status OriginsDescriptor::SetViewOriginCoord(uint32_t view, uint32_t coord, uint32_t value)
 137 {
 138     if (view >= m_NumViews)
 139     {
 140         BOOST_LOG_TRIVIAL(error) << "OriginsDescriptor::SetViewOriginCoord: view argument:" << view <<
 141             " is out of range";
 142         return Status::Failure;
 143     }
 144     if (coord >= m_NumDimensions)
 145     {
 146         BOOST_LOG_TRIVIAL(error) << "OriginsDescriptor::SetViewOriginCoord: coord argument:" << coord <<
 147             " is out of range";
 148         return Status::Failure;
 149     }
 150
 151     m_ViewOrigins[view][coord] = value;
 152     return Status::Success;
 153 }
 154
 155
 156 uint32_t OriginsDescriptor::GetNumViews() const
 157 {
 158     return m_NumViews;
 159 }
 160
 161 uint32_t OriginsDescriptor::GetNumDimensions() const
 162 {
 163     return m_NumDimensions;
 164 }
 165
 166 const uint32_t* OriginsDescriptor::GetViewOrigin(uint32_t idx) const
 167 {
 168     return m_ViewOrigins ? m_ViewOrigins[idx] : nullptr;
 169 }
 170
 171
 172 // Reorders the viewOrigins in accordance with the indices presented in newOrdering array.
 173 void OriginsDescriptor::ReorderOrigins(unsigned int*  newOrdering, unsigned int numNewOrdering)
 174 {
 175     BOOST_ASSERT_MSG(m_NumViews == numNewOrdering, "number of views must match number of "
 176         "elements in the new ordering array");
 177     std::vector<uint32_t*> viewOrigins(&m_ViewOrigins[0], &m_ViewOrigins[m_NumViews]);
 178
 179     for (unsigned int i = 0; i < numNewOrdering; ++i)
 180     {
 181         m_ViewOrigins[i] = viewOrigins[newOrdering[i]];
 182     }
 183 }
 184
 185 ViewsDescriptor::ViewsDescriptor()
 186 : m_Origins()
 187 , m_ViewSizes(nullptr)
 188 {}
 189
 190 ViewsDescriptor::ViewsDescriptor(uint32_t numViews, uint32_t numDimensions /*= 4*/)
 191     : m_Origins(numViews, numDimensions)
 192     , m_ViewSizes(numViews > 0 && numDimensions > 0 ?
 193                       new uint32_t *[numViews]() : nullptr)
 194 {
 195     if (m_ViewSizes)
 196     {
 197         for (uint32_t i = 0; GetNumDimensions() > 0 && i < GetNumViews(); ++i)
 198         {
 199             m_ViewSizes[i] = new uint32_t[GetNumDimensions()]();
 200         }
 201     }
 202 }
 203
 204 ViewsDescriptor::ViewsDescriptor(const ViewsDescriptor& other)
 205     : m_Origins(other.m_Origins)
 206     , m_ViewSizes(other.GetNumViews() > 0 && other.GetNumDimensions() > 0 ?
 207                       new uint32_t *[other.GetNumViews()]() : nullptr)
 208 {
 209     if (m_ViewSizes)
 210     {
 211         for (uint32_t i = 0; GetNumDimensions() > 0 && i < GetNumViews(); ++i)
 212         {
 213             m_ViewSizes[i] = new uint32_t[GetNumDimensions()]();
 214             memcpy(m_ViewSizes[i], other.m_ViewSizes[i], GetNumDimensions() * sizeof(uint32_t));
 215         }
 216     }
 217 }
 218
 219 ViewsDescriptor::ViewsDescriptor(ViewsDescriptor&& other)
 220     : ViewsDescriptor()
 221 {
 222     swap(*this, other);
 223 }
 224
 225 ViewsDescriptor::~ViewsDescriptor()
 226 {
 227     if (m_ViewSizes)
 228     {
 229         for (uint32_t i = 0; GetNumDimensions() > 0 && i < GetNumViews(); ++i)
 230         {
 231             delete[] m_ViewSizes[i];
 232         }
 233         delete[] m_ViewSizes;
 234     }
 235 }
 236
 237 ViewsDescriptor& ViewsDescriptor::operator=(ViewsDescriptor rhs)
 238 {
 239     swap(*this, rhs);
 240     return *this;
 241 }
 242
 243 uint32_t ViewsDescriptor::GetNumViews() const
 244 {
 245     return m_Origins.GetNumViews();
 246 }
 247
 248 uint32_t ViewsDescriptor::GetNumDimensions() const
 249 {
 250     return m_Origins.GetNumDimensions();
 251 }
 252
 253 const uint32_t* ViewsDescriptor::GetViewOrigin(uint32_t idx) const
 254 {
 255     return m_Origins.GetViewOrigin(idx);
 256 }
 257
 258 Status ViewsDescriptor::SetViewOriginCoord(uint32_t view, uint32_t coord, uint32_t value)
 259 {
 260     return m_Origins.SetViewOriginCoord(view, coord, value);
 261 }
 262
 263 Status ViewsDescriptor::SetViewSize(uint32_t view, uint32_t coord, uint32_t value)
 264 {
 265     if (!m_ViewSizes)
 266     {
 267         BOOST_LOG_TRIVIAL(error) << "ViewsDescriptor::SetViewSize: invalid view sizes";
 268         return Status::Failure;
 269     }
 270
 271     if (view >= GetNumViews())
 272     {
 273         BOOST_LOG_TRIVIAL(error) << "ViewsDescriptor::SetViewSize: view argument:" << view <<
 274                                  " is out of range";
 275         return Status::Failure;
 276     }
 277     if (coord >= GetNumDimensions())
 278     {
 279         BOOST_LOG_TRIVIAL(error) << "ViewsDescriptor::SetViewSize: coord argument:" << coord <<
 280                                  " is out of range";
 281         return Status::Failure;
 282     }
 283
 284     m_ViewSizes[view][coord] = value;
 285     return Status::Success;
 286 }
 287
 288 const uint32_t* ViewsDescriptor::GetViewSizes(uint32_t idx) const
 289 {
 290     return m_ViewSizes ? m_ViewSizes[idx] : nullptr;
 291 }
 292
 293 void swap(OriginsDescriptor& first, OriginsDescriptor& second)
 294 {
 295     using std::swap;
 296     swap(first.m_NumViews, second.m_NumViews);
 297     swap(first.m_NumDimensions, second.m_NumDimensions);
 298     swap(first.m_ViewOrigins, second.m_ViewOrigins);
 299     swap(first.m_ConcatAxis, second.m_ConcatAxis);
 300 }
 301
 302 void swap(ViewsDescriptor& first, ViewsDescriptor& second)
 303 {
 304     using std::swap;
 305     swap(first.m_Origins, second.m_Origins);
 306     swap(first.m_ViewSizes, second.m_ViewSizes);
 307 }
 308
 309 int StridedSliceDescriptor::GetStartForAxis(const TensorShape& inputShape,
 310                                             unsigned int axis) const
 311 {
 312     int start = m_Begin[axis];
 313
 314     if (m_BeginMask & (1 << axis))
 315     {
 316         if (m_Stride[axis] > 0)
 317         {
 318             start = std::numeric_limits<int>::min();
 319         }
 320         else
 321         {
 322             start = std::numeric_limits<int>::max();
 323         }
 324     }
 325
 326     const int axisSize = boost::numeric_cast<int>(inputShape[axis]);
 327     if (start < 0)
 328     {
 329         start += (axisSize);
 330     }
 331
 332     return std::max(0, std::min(start, axisSize - 1));
 333
 334 }
 335
 336 int StridedSliceDescriptor::GetStopForAxis(const TensorShape& inputShape,
 337                                            unsigned int axis,
 338                                            int startForAxis) const
 339 {
 340
 341     if (m_ShrinkAxisMask & (1 << axis))
 342     {
 343         return startForAxis + 1;
 344     }
 345
 346     int stop = m_End[axis];
 347
 348     if (m_EndMask & (1 << axis))
 349     {
 350         if (m_Stride[axis] > 0)
 351         {
 352             stop = std::numeric_limits<int>::max();
 353         }
 354         else
 355         {
 356             stop = std::numeric_limits<int>::min();
 357         }
 358     }
 359
 360     const int axisSize = boost::numeric_cast<int>(inputShape[axis]);
 361     if (stop < 0)
 362     {
 363         stop += axisSize;
 364     }
 365
 366     return m_Stride[axis] > 0 ? std::max(0, std::min(stop, axisSize)) :
 367                                 std::max(-1, std::min(stop, axisSize - 1));
 368
 369 }
 370
 371 }