inference-engine/thirdparty/clDNN/kernel_selector/core/kernel_selector_common.cpp

   1 /*
   2 // Copyright (c) 2016 Intel Corporation
   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 #include "kernel_selector_common.h"
  18 #include <sstream>
  19
  20 namespace kernel_selector
  21 {
  22     std::string GetStringEnv(const char* varName)
  23     {
  24         std::string str;
  25 #ifdef _WIN32
  26         char* env = nullptr;
  27         size_t len = 0;
  28         errno_t err = _dupenv_s(&env, &len, varName);
  29         if (err == 0)
  30         {
  31             if (env != nullptr)
  32             {
  33                 str = std::string(env);
  34             }
  35             free(env);
  36         }
  37 #else
  38         const char *env = getenv(varName);
  39         if (env)
  40         {
  41             str = std::string(env);
  42         }
  43 #endif
  44
  45         return str;
  46     }
  47
  48     std::string toString(ActivationFunction activation)
  49     {
  50         std::string method("LINEAR");
  51         switch (activation)
  52         {
  53         case ActivationFunction::LOGISTIC:              method = "LOGISTIC"; break;
  54         case ActivationFunction::HYPERBOLIC_TAN:        method = "HYPERBOLIC_TAN"; break;
  55         case ActivationFunction::RELU:                  method = "RELU"; break;
  56         case ActivationFunction::RELU_NEGATIVE_SLOPE:   method = "RELU_NEGATIVE_SLOPE"; break;
  57         case ActivationFunction::CLAMP:                 method = "CLAMP"; break;
  58         case ActivationFunction::SOFTRELU:              method = "SOFTRELU"; break;
  59         case ActivationFunction::ABS:                   method = "ABS"; break;
  60         case ActivationFunction::SQUARE:                method = "SQUARE"; break;
  61         case ActivationFunction::SQRT:                  method = "SQRT"; break;
  62         case ActivationFunction::LINEAR:                method = "LINEAR"; break;
  63         case ActivationFunction::ELU:                   method = "ELU"; break;
  64         case ActivationFunction::RELU_GRAD:             method = "RELU_GRAD"; break;
  65         case ActivationFunction::RELU_NEGATIVE_SLOPE_GRAD: method = "RELU_NEGATIVE_SLOPE_GRAD"; break;
  66         case ActivationFunction::SIN:                   method = "SIN"; break;
  67         case ActivationFunction::ASIN:                  method = "ASIN"; break;
  68         case ActivationFunction::SINH:                  method = "SINH"; break;
  69         case ActivationFunction::COS:                   method = "COS"; break;
  70         case ActivationFunction::ACOS:                  method = "ACOS"; break;
  71         case ActivationFunction::COSH:                  method = "COSH"; break;
  72         case ActivationFunction::LOG:                   method = "LOG"; break;
  73                 case ActivationFunction::LOG2:                  method = "LOG2"; break;
  74         case ActivationFunction::EXP:                   method = "EXP"; break;
  75         case ActivationFunction::NOT:                   method = "NOT"; break;
  76         case ActivationFunction::NONE:                  method = "NONE"; break;
  77         case ActivationFunction::NONE_GRAD:             method = "NONE_GRAD"; break;
  78         default: break;
  79         }
  80         return method;
  81     }
  82
  83     std::string toString(DataLayout l)
  84     {
  85         switch (l)
  86         {
  87         case kernel_selector::DataLayout::bf:                return "BF";
  88         case kernel_selector::DataLayout::fb:                return "FB";
  89         case kernel_selector::DataLayout::bfyx:              return "BFYX";
  90         case kernel_selector::DataLayout::yxfb:              return "YXFB";
  91         case kernel_selector::DataLayout::byxf:              return "BYXF";
  92         case kernel_selector::DataLayout::fyxb:              return "FYXB";
  93         case kernel_selector::DataLayout::bs_f_bsv8__af8:    return "BS_F_BSV8__AF8";
  94         case kernel_selector::DataLayout::bs_f_bsv16__af8:   return "BS_F_BSV16__AF8";
  95         case kernel_selector::DataLayout::bf8_xy16:          return "BF8_XY16";
  96         case kernel_selector::DataLayout::brfyx:             return "BRFYX";
  97         case kernel_selector::DataLayout::winograd_2x3_s1_data: return "WINOGRAD_2x3_S1_DATA";
  98         case kernel_selector::DataLayout::byxf_af32: return "BYXF_AF32";
  99         case kernel_selector::DataLayout::byx8_f4: return "BYX8_F4";
 100         case kernel_selector::DataLayout::fs_bs_yx_bsv4_fsv32: return "FS_BS_YX_BSV4_FSV32";
 101         case kernel_selector::DataLayout::b_fs_yx_fsv4:      return "B_FS_YX_FSV4";
 102         default: return "";
 103         }
 104     }
 105
 106     std::string toString(Datatype dType)
 107     {
 108         switch (dType)
 109         {
 110         case Datatype::INT8:    return "INT8";
 111         case Datatype::UINT8:   return "UINT8";
 112         case Datatype::INT16:   return "INT16";
 113         case Datatype::UINT16:  return "UINT16";
 114         case Datatype::INT32:   return "INT32";
 115         case Datatype::UINT32:  return "UINT32";
 116         case Datatype::INT64:   return "INT64";
 117         case Datatype::F16:     return "F16";
 118         case Datatype::F32:     return "F32";
 119         default: return "";
 120         }
 121     }
 122
 123     std::string toString(WeightsType wType)
 124     {
 125         switch (wType)
 126         {
 127         case WeightsType::F16:  return "F16";
 128         case WeightsType::F32:  return "F32";
 129         case WeightsType::INT8: return "INT8";
 130         default: return "";
 131         }
 132     }
 133
 134     std::string toString(KernelType kt)
 135     {
 136         switch (kt)
 137         {
 138         case KernelType::UNKNOWN:           return "UNKNOWN";
 139         case KernelType::CONVOLUTION:       return "CONVOLUTION";
 140         case KernelType::LRN:               return "LRN";
 141         case KernelType::POOLING:           return "POOLING";
 142         case KernelType::ROI_POOLING:       return "ROI_POOLING";
 143         case KernelType::FULLY_CONNECTED:   return "FULLY_CONNECTED";
 144         case KernelType::ACTIVATION:        return "ACTIVATION";
 145         case KernelType::SOFT_MAX:          return "SOFT_MAX";
 146         case KernelType::REGION_YOLO:       return "REGION_YOLO";
 147         case KernelType::REORG_YOLO:        return "REORG_YOLO";
 148         case KernelType::ELTWISE:           return "ELTWISE";
 149         case KernelType::REORDER:           return "REORDER";
 150         case KernelType::SELECT:            return "SELECT";
 151         default:
 152             return "";
 153         }
 154     }
 155
 156     std::string toString(EltwiseMode b_mode)
 157     {
 158         switch (b_mode)
 159         {
 160         case EltwiseMode::ADD:      return "ADD";
 161         case EltwiseMode::SUB:      return "SUB";
 162         case EltwiseMode::MUL:      return "MUL";
 163         case EltwiseMode::DIV:      return "DIV";
 164         case EltwiseMode::MIN:      return "MIN";
 165         case EltwiseMode::MAX:      return "MAX";
 166         case EltwiseMode::POW:      return "POW";
 167         case EltwiseMode::MODULU:   return "MODULU";
 168         case EltwiseMode::SQRT:     return "SQRT";
 169         case EltwiseMode::RSQRT:    return "RSQRT";
 170         case EltwiseMode::ASSIGN:   return "ASSIGN";
 171         default:
 172             return "";
 173         }
 174     }
 175
 176     std::string toString(ReorderMode mode)
 177     {
 178         switch (mode)
 179         {
 180         case ReorderMode::xyzw: return "XYZW";
 181         case ReorderMode::xywz: return "XYWZ";
 182         case ReorderMode::xwyz: return "XWYZ";
 183         case ReorderMode::wxyz: return "WXYZ";
 184         case ReorderMode::xzyw: return "XZYW";
 185         case ReorderMode::zyxw: return "ZYXW";
 186         case ReorderMode::yxzw: return "YXZW";
 187         default: return "XYZW";
 188         }
 189     }
 190
 191     std::string toString(MeanSubtractMode mode)
 192     {
 193         switch (mode)
 194         {
 195         case MeanSubtractMode::NONE:            return "NONE";
 196         case MeanSubtractMode::INSIDE_PARAMS:   return "INSIDE_PARAMS";
 197         case MeanSubtractMode::IN_BUFFER:       return "IN_BUFFER";
 198         default: return "";
 199         }
 200     }
 201
 202     std::string toString(ArgMaxMinOut mode)
 203     {
 204         switch (mode)
 205         {
 206         case ArgMaxMinOut::MAX: return "MAX";
 207         case ArgMaxMinOut::MIN: return "MIN";
 208         default: return "";
 209         }
 210     }
 211
 212     std::string toString(ArgMaxMinAxis mode)
 213     {
 214         switch (mode)
 215         {
 216         case ArgMaxMinAxis::BATCH: return "BATCH";
 217         case ArgMaxMinAxis::FEATURE: return "FEATURE";
 218         case ArgMaxMinAxis::X: return "X";
 219         case ArgMaxMinAxis::Y: return "Y";
 220         case ArgMaxMinAxis::XYF: return "XYF";
 221         default: return "";
 222         }
 223     }
 224
 225     std::string toString(LookUpTableAxis mode)
 226     {
 227         switch (mode)
 228         {
 229         case LookUpTableAxis::BATCH: return "BATCH";
 230         case LookUpTableAxis::FEATURE: return "FEATURE";
 231         case LookUpTableAxis::X: return "X";
 232         case LookUpTableAxis::Y: return "Y";
 233         case LookUpTableAxis::XYF: return "XYF";
 234         default: return "";
 235         }
 236     }
 237
 238     std::string toString(PoolType mode)
 239     {
 240         switch (mode)
 241         {
 242         case PoolType::MAX: return "MAX";
 243         case PoolType::AVG: return "AVG";
 244         case PoolType::MAX_WITH_ARGMAX: return "MAX_WITH_ARGMAX";
 245         case PoolType::BILINEAR: return "BILINEAR";
 246         default: return "";
 247         }
 248     }
 249
 250     std::string toString(LRNMode mode)
 251     {
 252         switch (mode)
 253         {
 254         case LRNMode::ACROSS_CHANNEL: return "ACROSS_CHANNEL";
 255         case LRNMode::WITHIN_CHANNEL: return "WITHIN_CHANNEL";
 256         default: return "";
 257         }
 258     }
 259
 260     std::string toString(KernelDividerMode mode)
 261     {
 262         switch (mode)
 263         {
 264         case KernelDividerMode::DONT_CARE:  return "DONT_CARE";
 265         case KernelDividerMode::FIXED:      return "FIXED";
 266         case KernelDividerMode::DYNAMIC:    return "DYNAMIC";
 267         case KernelDividerMode::DYNAMIC_WITH_PADDING:    return "DYNAMIC_WITH_PADDING";
 268         default: return "";
 269         }
 270     }
 271
 272     std::string toString(SoftmaxDim d)
 273     {
 274         switch (d)
 275         {
 276         case SoftmaxDim::X:         return "X";
 277         case SoftmaxDim::Y:         return "Y";
 278         case SoftmaxDim::FEATURE:   return "FEATURE";
 279         default: return "";
 280         }
 281     }
 282
 283     std::string toString(NormalizeMode mode)
 284     {
 285         switch (mode)
 286         {
 287         case NormalizeMode::ACROSS_SPATIAL:         return "ACROSS_SPATIAL";
 288         case NormalizeMode::WITHIN_SPATIAL:         return "WITHIN_SPATIAL";
 289         default: return "";
 290         }
 291     }
 292
 293     std::string toString(MVNMode mode)
 294     {
 295         switch (mode)
 296         {
 297         case MVNMode::ACROSS_CHANNELS:         return "ACROSS_CHANNELS";
 298         case MVNMode::WITHIN_CHANNELS:         return "WITHIN_CHANNELS";
 299         default: return "";
 300         }
 301     }
 302
 303     std::string toString(WeightsLayout layout)
 304     {
 305         switch (layout)
 306         {
 307         case WeightsLayout::oi:                         return "OI";
 308         case WeightsLayout::io:                         return "IO";
 309         case WeightsLayout::oiyx:                       return "OIYX";
 310         case WeightsLayout::oyxi:                       return "OYXI";
 311         case WeightsLayout::iyxo:                       return "IYXO";
 312         case WeightsLayout::yxio:                       return "YXIO";
 313         case WeightsLayout::os_iyx_osv16:               return "OS_IYX_OSV16";
 314         case WeightsLayout::os_iyx_osv32:               return "OS_IYX_OSV32";
 315         case WeightsLayout::os_iyx_osv64:               return "OS_IYX_OSV64";
 316         case WeightsLayout::os_iyx_osv16_rotate_180:    return "OS_IYX_OSV16_ROTATE_180";
 317         case WeightsLayout::os_i_osv16:                 return "OS_I_OSV16";
 318         case WeightsLayout::os_i_osv8__ai8:             return "OS_I_OSV8__AI8";
 319         case WeightsLayout::os_i_osv16__ai8:            return "OS_I_OSV16__AI8";
 320         case WeightsLayout::i_yxs_os_yxsv2_osv16:       return "I_YXS_OS_YXSV2_OSV16";
 321         case WeightsLayout::iy_xs_os_xsv2_osv16__ao32:  return "IY_XS_OS_XSV2_OSV16__AO32";
 322         case WeightsLayout::iy_xs_os_xsv2_osv8__ao32:   return "IY_XS_OS_XSV2_OSV8__AO32";
 323         case WeightsLayout::image_2d_weights_c4_fyx_b:  return "IMAGE_2D_WEIGHTS_C4_FYX_B";
 324         case WeightsLayout::image_2d_weights_c1_b_fyx:  return "IMAGE_2D_WEIGHTS_C1_B_FYX";
 325         case WeightsLayout::winograd_2x3_s1_weights:    return "WINOGRAD_2x3_S1_WEIGHTS";
 326         case WeightsLayout::winograd_2x3_s1_fused_weights:    return "WINOGRAD_2x3_S1_FUSED_WEIGHTS";
 327         case WeightsLayout::winograd_6x3_s1_fused_weights:    return "WINOGRAD_6x3_S1_FUSED_WEIGHTS";
 328         case WeightsLayout::image_2d_weights_winograd_6x3_s1_fbxyb: return "IMAGE_2D_WEIGHTS_WINOGRAD_6x3_S1_FBXYB";
 329         case WeightsLayout::image_2d_weights_winograd_6x3_s1_xfbyb: return "IMAGE_2D_WEIGHTS_WINOGRAD_6x3_S1_XFBYB";
 330         case WeightsLayout::os_is_yx_isa8_osv8_isv4: return "OS_IS_YX_ISA8_OSV8_ISV4";
 331         case WeightsLayout::os_is_yx_isa8_osv8_isv4_swizzled_by_4: return "OS_IS_YX_ISA8_OSV8_ISV4_SWIZZLED_BY_4";
 332         case WeightsLayout::is_o_yx_isv32: return "IS_O_YX_ISV32";
 333         case WeightsLayout::is_o32_yx_isv32_swizzled_by_4: return "IS_O32_YX_ISV32_SWIZZLED_BY_4";
 334         case WeightsLayout::os_is_y_x8_osv8_isv4: return "OS_IS_Y_X8_OSV8_ISV4";
 335         case WeightsLayout::os_is_yx_osv16_isv4:  return "OS_IS_YX_OSV16_ISV4";
 336
 337         default:
 338             return "";
 339             break;
 340         }
 341     }
 342
 343     std::string toString(ConcatAxis a)
 344     {
 345         switch (a)
 346         {
 347         case ConcatAxis::X:         return "X";
 348         case ConcatAxis::Y:         return "Y";
 349         case ConcatAxis::FEATURE:   return "FEATURE";
 350         case ConcatAxis::BATCH:     return "BATCH";
 351         default: return "";
 352         }
 353     }
 354
 355     std::string toString(TileAxis a)
 356     {
 357         switch (a)
 358         {
 359         case TileAxis::X:         return "X";
 360         case TileAxis::Y:         return "Y";
 361         case TileAxis::FEATURE:   return "FEATURE";
 362         case TileAxis::BATCH:     return "BATCH";
 363         default: return "";
 364         }
 365     }
 366
 367     std::string toString(GatherAxis a)
 368     {
 369         switch (a)
 370         {
 371             case GatherAxis::X:         return "X";
 372             case GatherAxis::Y:         return "Y";
 373             case GatherAxis::FEATURE:   return "FEATURE";
 374             case GatherAxis::BATCH:     return "BATCH";
 375             default: return "";
 376         }
 377     }
 378
 379     std::string toString(SampleType type)
 380     {
 381         switch (type)
 382         {
 383         case SampleType::NEAREST: return "SAMPLE_TYPE_NEAREST";
 384         case SampleType::BILINEAR: return "SAMPLE_TYPE_BILINEAR";
 385         default: return "";
 386         }
 387     }
 388
 389     std::string toString(const BorderType type)
 390     {
 391         switch (type)
 392         {
 393         case BorderType::CONSTANT:   return "BORDER_TYPE_CONSTANT";
 394         case BorderType::EDGE:       return "BORDER_TYPE_EDGE";
 395         case BorderType::MIRROR:     return "BORDER_TYPE_MIRROR";
 396         case BorderType::MIRROR_101: return "BORDER_TYPE_MIRROR_101";
 397         default:                     return "";
 398         }
 399     }
 400
 401     std::string toString(const IndexSelectAxis& axis)
 402     {
 403         switch (axis)
 404         {
 405         case IndexSelectAxis::BATCH:       return "INDEX_SELECT_AXIS_BATCH";
 406         case IndexSelectAxis::FEATURE:     return "INDEX_SELECT_AXIS_FEATURE";
 407         case IndexSelectAxis::X:           return "INDEX_SELECT_AXIS_X";
 408         case IndexSelectAxis::Y:           return "INDEX_SELECT_AXIS_Y";
 409         default:                           return "";
 410         }
 411     }
 412
 413     std::string toString(const Tensor::Dim& dim)
 414     {
 415         std::stringstream s;
 416         s << "v" << dim.v << "_p" << dim.pitch << "_" << dim.pad.before << "_" << dim.pad.after;
 417         return s.str();
 418     }
 419
 420     std::string toString(const DataTensor& tensor)
 421     {
 422         std::stringstream s;
 423         s << toString(tensor.GetDType()) << "_";
 424         s << toString(tensor.GetLayout()) << "_";
 425         int i = 0;
 426         for (auto dim : tensor.GetDims())
 427         {
 428             s << "d" << i << "_" << toString(dim) << "_";
 429             i++;
 430         }
 431         return s.str();
 432     }
 433 }