inference-engine/include/ie_common.h

   1 // Copyright (C) 2018-2019 Intel Corporation
   2 // SPDX-License-Identifier: Apache-2.0
   3 //
   4
   5 /**
   6  * @brief This is a header file with common inference engine definitions.
   7  * @file ie_common.h
   8  */
   9 #pragma once
  10
  11 #include <vector>
  12 #include <memory>
  13 #include <string>
  14 #include <ostream>
  15 #include <algorithm>
  16 #include <cstdlib>
  17 #include <details/ie_exception.hpp>
  18
  19 #include "ie_unicode.hpp"
  20
  21 namespace InferenceEngine {
  22 /**
  23  * @brief Represents tensor size.
  24  * The order is opposite to the order in Caffe*: (w,h,n,b) where the most frequently changing element in memory is first.
  25  */
  26 using SizeVector = std::vector<size_t>;
  27
  28 /**
  29  * @brief This class represents the generic layer.
  30  */
  31 class CNNLayer;
  32
  33 /**
  34  * @brief A smart pointer to the CNNLayer
  35  */
  36 using CNNLayerPtr = std::shared_ptr<CNNLayer>;
  37 /**
  38  * @brief A smart weak pointer to the CNNLayer
  39  */
  40 using  CNNLayerWeakPtr = std::weak_ptr<CNNLayer>;
  41
  42 /**
  43  * @brief The main data representation node
  44  */
  45 class Data;
  46
  47 /**
  48  * @brief Smart pointer to Data
  49  */
  50 using DataPtr = std::shared_ptr<Data>;
  51
  52 /**
  53  * @brief Smart pointer to constant Data
  54  */
  55 using CDataPtr = std::shared_ptr<const Data>;
  56
  57 /**
  58  * @brief Smart weak pointer to Data
  59  */
  60 using DataWeakPtr = std::weak_ptr<Data>;
  61
  62 /**
  63  * @union UserValue
  64  * @brief The method holds the user values to enable binding of data per graph node.
  65  */
  66 union UserValue {
  67     int v_int;
  68     float v_float;
  69     void *v_ptr;
  70 };
  71
  72 /**
  73  * @enum Layout
  74  * @brief Layouts that the inference engine supports
  75  */
  76 enum Layout : uint8_t {
  77     ANY = 0,           // "any" layout
  78
  79     // I/O data layouts
  80     NCHW = 1,
  81     NHWC = 2,
  82     NCDHW = 3,
  83     NDHWC = 4,
  84
  85     // weight layouts
  86     OIHW = 64,
  87
  88     // Scalar
  89     SCALAR = 95,
  90
  91     // bias layouts
  92     C = 96,
  93
  94     // Single image layout (for mean image)
  95     CHW = 128,
  96
  97     // 2D
  98     HW = 192,
  99     NC = 193,
 100     CN = 194,
 101
 102     BLOCKED = 200,
 103 };
 104 inline std::ostream & operator << (std::ostream &out, const Layout & p) {
 105     switch (p) {
 106 #define PRINT_LAYOUT(name)\
 107         case name : out << #name; break;
 108
 109             PRINT_LAYOUT(ANY);
 110             PRINT_LAYOUT(NCHW);
 111             PRINT_LAYOUT(NHWC);
 112             PRINT_LAYOUT(OIHW);
 113             PRINT_LAYOUT(C);
 114             PRINT_LAYOUT(CHW);
 115             PRINT_LAYOUT(HW);
 116             PRINT_LAYOUT(NC);
 117             PRINT_LAYOUT(CN);
 118             PRINT_LAYOUT(BLOCKED);
 119 #undef PRINT_LAYOUT
 120             default:
 121                  out << static_cast<int>(p);
 122             break;
 123         }
 124         return out;
 125     }
 126
 127
 128 /**
 129  * @struct InferenceEngineProfileInfo
 130  * @brief Represents basic inference profiling information per layer.
 131  * If the layer is executed using tiling, the sum time per each tile is indicated as the total execution time.
 132  * Due to parallel execution, the total execution time for all layers might be greater than the total inference time.
 133  */
 134 struct InferenceEngineProfileInfo {
 135     /**
 136      * @brief Defines the general status of the layer
 137      */
 138     enum LayerStatus {
 139         NOT_RUN,
 140         OPTIMIZED_OUT,
 141         EXECUTED
 142     };
 143
 144     LayerStatus status;
 145     /**
 146      * @brief The absolute time in microseconds that the layer ran (in total)
 147      */
 148     long long realTime_uSec;
 149     /**
 150      * @brief The net host cpu time that the layer ran
 151      */
 152     long long cpu_uSec;
 153
 154     /**
 155      * @brief An execution type of unit
 156      */
 157     char exec_type[256] = {};
 158
 159     /**
 160      * @brief A layer type
 161      */
 162     char layer_type[256] = {};
 163
 164     /**
 165      * @brief An execution index of the unit
 166      */
 167     unsigned execution_index;
 168 };
 169
 170
 171 /**
 172  * @enum StatusCode
 173  * @brief This enum contains codes for all possible return values of the interface functions
 174  */
 175 enum StatusCode : int {
 176     OK = 0,
 177     GENERAL_ERROR = -1,
 178     NOT_IMPLEMENTED = -2,
 179     NETWORK_NOT_LOADED = -3,
 180     PARAMETER_MISMATCH = -4,
 181     NOT_FOUND = -5,
 182     OUT_OF_BOUNDS = -6,
 183     /*
 184      * @brief exception not of std::exception derived type was thrown
 185      */
 186     UNEXPECTED = -7,
 187     REQUEST_BUSY = -8,
 188     RESULT_NOT_READY = -9,
 189     NOT_ALLOCATED = -10,
 190     INFER_NOT_STARTED = -11,
 191     NETWORK_NOT_READ = -12
 192 };
 193
 194 /**
 195  * @struct ResponseDesc
 196  * @brief  Represents detailed information for an error
 197  */
 198 struct ResponseDesc {
 199     /**
 200      * @brief A character buffer that holds the detailed information for an error.
 201      */
 202     char msg[256] = {};
 203 };
 204
 205 /** @brief This class represents StatusCode::GENERIC_ERROR exception */
 206 class GeneralError : public std::logic_error
 207 { using std::logic_error::logic_error; };
 208
 209 /** @brief This class represents StatusCode::NOT_IMPLEMENTED exception */
 210 class NotImplemented : public std::logic_error
 211 { using std::logic_error::logic_error; };
 212
 213 /** @brief This class represents StatusCode::NETWORK_NOT_LOADED exception */
 214 class NetworkNotLoaded : public std::logic_error
 215 { using std::logic_error::logic_error; };
 216
 217 /** @brief This class represents StatusCode::PARAMETER_MISMATCH exception */
 218 class ParameterMismatch : public std::logic_error
 219 { using std::logic_error::logic_error; };
 220
 221 /** @brief This class represents StatusCode::NOT_FOUND exception */
 222 class NotFound : public std::logic_error
 223 { using std::logic_error::logic_error; };
 224
 225 /** @brief This class represents StatusCode::OUT_OF_BOUNDS exception */
 226 class OutOfBounds : public std::logic_error
 227 { using std::logic_error::logic_error; };
 228
 229 /** @brief This class represents StatusCode::UNEXPECTED exception */
 230 class Unexpected : public std::logic_error
 231 { using std::logic_error::logic_error; };
 232
 233 /** @brief This class represents StatusCode::REQUEST_BUSY exception */
 234 class RequestBusy : public std::logic_error
 235 { using std::logic_error::logic_error; };
 236
 237 /** @brief This class represents StatusCode::RESULT_NOT_READY exception */
 238 class ResultNotReady : public std::logic_error
 239 { using std::logic_error::logic_error; };
 240
 241 /** @brief This class represents StatusCode::NOT_ALLOCATED exception */
 242 class NotAllocated : public std::logic_error
 243 { using std::logic_error::logic_error; };
 244
 245 /** @brief This class represents StatusCode::INFER_NOT_STARTED exception */
 246 class InferNotStarted : public std::logic_error
 247 { using std::logic_error::logic_error; };
 248 }  // namespace InferenceEngine
 249
 250 /** @brief This class represents StatusCode::NETWORK_NOT_READ exception */
 251 class NetworkNotRead : public std::logic_error
 252 { using std::logic_error::logic_error; };
 253
 254 #if defined(_WIN32)
 255     #define __PRETTY_FUNCTION__ __FUNCSIG__
 256 #else
 257     #define __PRETTY_FUNCTION__ __PRETTY_FUNCTION__
 258 #endif