src/core/ITensor.cpp

   1 /*
   2  * Copyright (c) 2016-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 #include "arm_compute/core/ITensor.h"
  25
  26 #include "arm_compute/core/Error.h"
  27 #include "arm_compute/core/Helpers.h"
  28 #include "arm_compute/core/Window.h"
  29
  30 #include <cstring>
  31 #include <limits>
  32
  33 using namespace arm_compute;
  34
  35 void ITensor::copy_from(const ITensor &src)
  36 {
  37     if(&src == this)
  38     {
  39         return;
  40     }
  41
  42     const ITensorInfo *src_info = src.info();
  43     ITensorInfo       *dst_info = this->info();
  44
  45     ARM_COMPUTE_ERROR_ON(src_info->num_dimensions() > dst_info->num_dimensions());
  46     ARM_COMPUTE_ERROR_ON(src_info->num_channels() != dst_info->num_channels());
  47     ARM_COMPUTE_ERROR_ON(src_info->element_size() != dst_info->element_size());
  48
  49     for(size_t d = 0; d < src_info->num_dimensions(); d++)
  50     {
  51         ARM_COMPUTE_ERROR_ON(src_info->dimension(d) > dst_info->dimension(d));
  52     }
  53
  54     // Copy information about valid region
  55     dst_info->set_valid_region(src_info->valid_region());
  56
  57     Window win_src;
  58     win_src.use_tensor_dimensions(src_info->tensor_shape(), Window::DimY);
  59     Window win_dst;
  60     win_dst.use_tensor_dimensions(dst_info->tensor_shape(), Window::DimY);
  61
  62     Iterator src_it(&src, win_src);
  63     Iterator dst_it(this, win_dst);
  64
  65     const size_t line_size = src_info->num_channels() * src_info->element_size() * src_info->dimension(0);
  66
  67     execute_window_loop(win_src, [&](const Coordinates & id)
  68     {
  69         memcpy(dst_it.ptr(), src_it.ptr(), line_size);
  70     },
  71     src_it, dst_it);
  72 }
  73
  74 void ITensor::print(std::ostream &s, IOFormatInfo io_fmt) const
  75 {
  76     ARM_COMPUTE_ERROR_ON(this->buffer() == nullptr);
  77
  78     const DataType    dt           = this->info()->data_type();
  79     const size_t      slices2D     = this->info()->tensor_shape().total_size_upper(2);
  80     const Strides     strides      = this->info()->strides_in_bytes();
  81     const PaddingSize padding      = this->info()->padding();
  82     const size_t      num_channels = this->info()->num_channels();
  83
  84     // Set precision
  85     if(is_data_type_float(dt) && (io_fmt.precision_type != IOFormatInfo::PrecisionType::Default))
  86     {
  87         int precision = io_fmt.precision;
  88         if(io_fmt.precision_type == IOFormatInfo::PrecisionType::Full)
  89         {
  90             precision = std::numeric_limits<float>().max_digits10;
  91         }
  92         s.precision(precision);
  93     }
  94
  95     // Define region to print
  96     size_t print_width  = 0;
  97     size_t print_height = 0;
  98     int    start_offset = 0;
  99     switch(io_fmt.print_region)
 100     {
 101         case IOFormatInfo::PrintRegion::NoPadding:
 102             print_width  = this->info()->dimension(0);
 103             print_height = this->info()->dimension(1);
 104             start_offset = this->info()->offset_first_element_in_bytes();
 105             break;
 106         case IOFormatInfo::PrintRegion::ValidRegion:
 107             print_width  = this->info()->valid_region().shape.x();
 108             print_height = this->info()->valid_region().shape.y();
 109             start_offset = this->info()->offset_element_in_bytes(Coordinates(this->info()->valid_region().anchor.x(),
 110                                                                              this->info()->valid_region().anchor.y()));
 111             break;
 112         case IOFormatInfo::PrintRegion::Full:
 113             print_width  = padding.left + this->info()->dimension(0) + padding.right;
 114             print_height = padding.top + this->info()->dimension(1) + padding.bottom;
 115             start_offset = static_cast<int>(this->info()->offset_first_element_in_bytes()) - padding.top * strides[1] - padding.left * strides[0];
 116             break;
 117         default:
 118             break;
 119     }
 120
 121     print_width = print_width * num_channels;
 122
 123     // Set pointer to start
 124     const uint8_t *ptr = this->buffer() + start_offset;
 125
 126     // Start printing
 127     for(size_t i = 0; i < slices2D; ++i)
 128     {
 129         // Find max_width of elements in slice to align columns
 130         int max_element_width = 0;
 131         if(io_fmt.align_columns)
 132         {
 133             size_t offset = i * strides[2];
 134             for(size_t h = 0; h < print_height; ++h)
 135             {
 136                 max_element_width = std::max<int>(max_element_width, max_consecutive_elements_display_width(s, dt, ptr + offset, print_width));
 137                 offset += strides[1];
 138             }
 139         }
 140
 141         // Print slice
 142         {
 143             size_t offset = i * strides[2];
 144             for(size_t h = 0; h < print_height; ++h)
 145             {
 146                 print_consecutive_elements(s, dt, ptr + offset, print_width, max_element_width, io_fmt.element_delim);
 147                 offset += strides[1];
 148                 s << io_fmt.row_delim;
 149             }
 150             s << io_fmt.row_delim;
 151         }
 152     }
 153 }
 154
 155 bool ITensor::is_used() const
 156 {
 157     return _is_used;
 158 }
 159
 160 void ITensor::mark_as_unused() const
 161 {
 162     _is_used = false;
 163 }