inference-engine/thirdparty/mkl-dnn/src/common/mkldnn_debug.cpp

   1 /*******************************************************************************
   2 * Copyright 2018 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 /* DO NOT EDIT, AUTO-GENERATED */
  18
  19 #include <assert.h>
  20
  21 #include "mkldnn_debug.h"
  22 #include "mkldnn_types.h"
  23
  24 const char *mkldnn_status2str(mkldnn_status_t v) {
  25     if (v == mkldnn_success) return "success";
  26     if (v == mkldnn_out_of_memory) return "out_of_memory";
  27     if (v == mkldnn_try_again) return "try_again";
  28     if (v == mkldnn_invalid_arguments) return "invalid_arguments";
  29     if (v == mkldnn_not_ready) return "not_ready";
  30     if (v == mkldnn_unimplemented) return "unimplemented";
  31     if (v == mkldnn_iterator_ends) return "iterator_ends";
  32     if (v == mkldnn_runtime_error) return "runtime_error";
  33     if (v == mkldnn_not_required) return "not_required";
  34     assert(!"unknown status");
  35     return "unknown status";
  36 }
  37
  38 const char *mkldnn_dt2str(mkldnn_data_type_t v) {
  39     if (v == mkldnn_data_type_undef) return "undef";
  40     if (v == mkldnn_f32) return "f32";
  41     if (v == mkldnn_s32) return "s32";
  42     if (v == mkldnn_s16) return "s16";
  43     if (v == mkldnn_s8) return "s8";
  44     if (v == mkldnn_u8) return "u8";
  45     if (v == mkldnn_bin) return "bin";
  46     assert(!"unknown dt");
  47     return "unknown dt";
  48 }
  49
  50 const char *mkldnn_rmode2str(mkldnn_round_mode_t v) {
  51     if (v == mkldnn_round_nearest) return "round_nearest";
  52     if (v == mkldnn_round_down) return "round_down";
  53     assert(!"unknown rmode");
  54     return "unknown rmode";
  55 }
  56
  57 const char *mkldnn_fmt2str(mkldnn_memory_format_t v) {
  58     if (v == mkldnn_format_undef) return "undef";
  59     if (v == mkldnn_any) return "any";
  60     if (v == mkldnn_blocked) return "blocked";
  61     if (v == mkldnn_x) return "x";
  62     if (v == mkldnn_nc) return "nc";
  63     if (v == mkldnn_ncw) return "ncw";
  64     if (v == mkldnn_nwc) return "nwc";
  65     if (v == mkldnn_nchw) return "nchw";
  66     if (v == mkldnn_nhwc) return "nhwc";
  67     if (v == mkldnn_chwn) return "chwn";
  68     if (v == mkldnn_ncdhw) return "ncdhw";
  69     if (v == mkldnn_ndhwc) return "ndhwc";
  70     if (v == mkldnn_oi) return "oi";
  71     if (v == mkldnn_io) return "io";
  72     if (v == mkldnn_oiw) return "oiw";
  73     if (v == mkldnn_wio) return "wio";
  74     if (v == mkldnn_oihw) return "oihw";
  75     if (v == mkldnn_hwio) return "hwio";
  76     if (v == mkldnn_ihwo) return "ihwo";
  77     if (v == mkldnn_iohw) return "iohw";
  78     if (v == mkldnn_oidhw) return "oidhw";
  79     if (v == mkldnn_dhwio) return "dhwio";
  80     if (v == mkldnn_goiw) return "goiw";
  81     if (v == mkldnn_goihw) return "goihw";
  82     if (v == mkldnn_hwigo) return "hwigo";
  83     if (v == mkldnn_giohw) return "giohw";
  84     if (v == mkldnn_goidhw) return "goidhw";
  85     if (v == mkldnn_ntc) return "ntc";
  86     if (v == mkldnn_tnc) return "tnc";
  87     if (v == mkldnn_ldsnc) return "ldsnc";
  88     if (v == mkldnn_ldigo) return "ldigo";
  89     if (v == mkldnn_ldgoi) return "ldgoi";
  90     if (v == mkldnn_ldgo) return "ldgo";
  91     if (v == mkldnn_nCw4c) return "nCw4c";
  92     if (v == mkldnn_nCw8c) return "nCw8c";
  93     if (v == mkldnn_nCw16c) return "nCw16c";
  94     if (v == mkldnn_nChw4c) return "nChw4c";
  95     if (v == mkldnn_nChw8c) return "nChw8c";
  96     if (v == mkldnn_nChw16c) return "nChw16c";
  97     if (v == mkldnn_nCdhw4c) return "nCdhw4c";
  98     if (v == mkldnn_nCdhw8c) return "nCdhw8c";
  99     if (v == mkldnn_nCdhw16c) return "nCdhw16c";
 100     if (v == mkldnn_Owi4o) return "Owi4o";
 101     if (v == mkldnn_OIw4i4o) return "OIw4i4o";
 102     if (v == mkldnn_Owi8o) return "Owi8o";
 103     if (v == mkldnn_OIw8i8o) return "OIw8i8o";
 104     if (v == mkldnn_OIw8o8i) return "OIw8o8i";
 105     if (v == mkldnn_OIw16i16o) return "OIw16i16o";
 106     if (v == mkldnn_OIw16o16i) return "OIw16o16i";
 107     if (v == mkldnn_Oiw4o) return "Oiw4o";
 108     if (v == mkldnn_Oiw16o) return "Oiw16o";
 109     if (v == mkldnn_Owi16o) return "Owi16o";
 110     if (v == mkldnn_OIw8i16o2i) return "OIw8i16o2i";
 111     if (v == mkldnn_OIw8o16i2o) return "OIw8o16i2o";
 112     if (v == mkldnn_IOw16o16i) return "IOw16o16i";
 113     if (v == mkldnn_hwio_s8s8) return "hwio_s8s8";
 114     if (v == mkldnn_oIhw8i) return "oIhw8i";
 115     if (v == mkldnn_oIhw16i) return "oIhw16i";
 116     if (v == mkldnn_OIhw4i4o) return "OIhw4i4o";
 117     if (v == mkldnn_OIhw8i8o) return "OIhw8i8o";
 118     if (v == mkldnn_OIhw16i16o) return "OIhw16i16o";
 119     if (v == mkldnn_OIhw4i16o4i) return "OIhw4i16o4i";
 120     if (v == mkldnn_OIhw4i16o4i_s8s8) return "OIhw4i16o4i_s8s8";
 121     if (v == mkldnn_OIhw8i16o2i) return "OIhw8i16o2i";
 122     if (v == mkldnn_OIhw8o16i2o) return "OIhw8o16i2o";
 123     if (v == mkldnn_OIhw8o8i) return "OIhw8o8i";
 124     if (v == mkldnn_OIhw16o16i) return "OIhw16o16i";
 125     if (v == mkldnn_IOhw16o16i) return "IOhw16o16i";
 126     if (v == mkldnn_Oihw8o) return "Oihw8o";
 127     if (v == mkldnn_Oihw4o) return "Oihw4o";
 128     if (v == mkldnn_Oihw16o) return "Oihw16o";
 129     if (v == mkldnn_Ohwi8o) return "Ohwi8o";
 130     if (v == mkldnn_Ohwi4o) return "Ohwi4o";
 131     if (v == mkldnn_Ohwi16o) return "Ohwi16o";
 132     if (v == mkldnn_OhIw16o4i) return "OhIw16o4i";
 133     if (v == mkldnn_OhIw8o4i) return "OhIw8o4i";
 134     if (v == mkldnn_OhIw8o4i_s8s8) return "OhIw8o4i_s8s8";
 135     if (v == mkldnn_OhIw8o32i) return "OhIw8o32i";
 136     if (v == mkldnn_OhIw16o32i) return "OhIw16o32i";
 137     if (v == mkldnn_oIdhw8i) return "oIdhw8i";
 138     if (v == mkldnn_oIdhw16i) return "oIdhw16i";
 139     if (v == mkldnn_OIdhw4i4o) return "OIdhw4i4o";
 140     if (v == mkldnn_Odhwi4o) return "Odhwi4o";
 141     if (v == mkldnn_OIdhw8i8o) return "OIdhw8i8o";
 142     if (v == mkldnn_OIdhw8o8i) return "OIdhw8o8i";
 143     if (v == mkldnn_Odhwi8o) return "Odhwi8o";
 144     if (v == mkldnn_OIdhw16i16o) return "OIdhw16i16o";
 145     if (v == mkldnn_OIdhw16o16i) return "OIdhw16o16i";
 146     if (v == mkldnn_Oidhw4o) return "Oidhw4o";
 147     if (v == mkldnn_Oidhw16o) return "Oidhw16o";
 148     if (v == mkldnn_Odhwi16o) return "Odhwi16o";
 149     if (v == mkldnn_OIdhw8i16o2i) return "OIdhw8i16o2i";
 150     if (v == mkldnn_gOwi4o) return "gOwi4o";
 151     if (v == mkldnn_gOIw4i4o) return "gOIw4i4o";
 152     if (v == mkldnn_gOwi8o) return "gOwi8o";
 153     if (v == mkldnn_gOIw8o8i) return "gOIw8o8i";
 154     if (v == mkldnn_gOIw8i8o) return "gOIw8i8o";
 155     if (v == mkldnn_gOIw16i16o) return "gOIw16i16o";
 156     if (v == mkldnn_gOIw16o16i) return "gOIw16o16i";
 157     if (v == mkldnn_gOiw4o) return "gOiw4o";
 158     if (v == mkldnn_gOiw16o) return "gOiw16o";
 159     if (v == mkldnn_gOwi16o) return "gOwi16o";
 160     if (v == mkldnn_gOIw8i16o2i) return "gOIw8i16o2i";
 161     if (v == mkldnn_gOIw8o16i2o) return "gOIw8o16i2o";
 162     if (v == mkldnn_gIOw16o16i) return "gIOw16o16i";
 163     if (v == mkldnn_hwigo_s8s8) return "hwigo_s8s8";
 164     if (v == mkldnn_gOIhw4i4o) return "gOIhw4i4o";
 165     if (v == mkldnn_gOIhw8i8o) return "gOIhw8i8o";
 166     if (v == mkldnn_gOIhw16i16o) return "gOIhw16i16o";
 167     if (v == mkldnn_gOIhw4i16o4i) return "gOIhw4i16o4i";
 168     if (v == mkldnn_gOIhw4i16o4i_s8s8) return "gOIhw4i16o4i_s8s8";
 169     if (v == mkldnn_gOIhw2i8o4i) return "gOIhw2i8o4i";
 170     if (v == mkldnn_gOIhw2i8o4i_s8s8) return "gOIhw2i8o4i_s8s8";
 171     if (v == mkldnn_gOIhw8i16o2i) return "gOIhw8i16o2i";
 172     if (v == mkldnn_gOIhw8o16i2o) return "gOIhw8o16i2o";
 173     if (v == mkldnn_gOIhw4o4i) return "gOIhw4o4i";
 174     if (v == mkldnn_gOIhw4o4i_s8s8) return "gOIhw4o4i_s8s8";
 175     if (v == mkldnn_gOIhw8o8i) return "gOIhw8o8i";
 176     if (v == mkldnn_gOIhw16o16i) return "gOIhw16o16i";
 177     if (v == mkldnn_gIOhw16o16i) return "gIOhw16o16i";
 178     if (v == mkldnn_gOihw8o) return "gOihw8o";
 179     if (v == mkldnn_gOihw4o) return "gOihw4o";
 180     if (v == mkldnn_gOihw16o) return "gOihw16o";
 181     if (v == mkldnn_gOhwi8o) return "gOhwi8o";
 182     if (v == mkldnn_gOhwi4o) return "gOhwi4o";
 183     if (v == mkldnn_gOhwi16o) return "gOhwi16o";
 184     if (v == mkldnn_Goihw8g) return "Goihw8g";
 185     if (v == mkldnn_Goihw16g) return "Goihw16g";
 186     if (v == mkldnn_Goihw16g_s8s8) return "Goihw16g_s8s8";
 187     if (v == mkldnn_gOhIw16o4i) return "gOhIw16o4i";
 188     if (v == mkldnn_gOIdhw4i4o) return "gOIdhw4i4o";
 189     if (v == mkldnn_gOdhwi4o) return "gOdhwi4o";
 190     if (v == mkldnn_gOhIw8o4i) return "gOhIw8o4i";
 191     if (v == mkldnn_gOhIw8o4i_s8s8) return "gOhIw8o4i_s8s8";
 192     if (v == mkldnn_gOIdhw8i8o) return "gOIdhw8i8o";
 193     if (v == mkldnn_gOIdhw8o8i) return "gOIdhw8o8i";
 194     if (v == mkldnn_gOdhwi8o) return "gOdhwi8o";
 195     if (v == mkldnn_gOIdhw8i16o2i) return "gOIdhw8i16o2i";
 196     if (v == mkldnn_gOIdhw16i16o) return "gOIdhw16i16o";
 197     if (v == mkldnn_gOIdhw16o16i) return "gOIdhw16o16i";
 198     if (v == mkldnn_gOidhw4o) return "gOidhw4o";
 199     if (v == mkldnn_gOidhw16o) return "gOidhw16o";
 200     if (v == mkldnn_gOdhwi16o) return "gOdhwi16o";
 201     if (v == mkldnn_wino_fmt) return "wino_fmt";
 202     if (v == mkldnn_rnn_packed) return "rnn_packed";
 203     if (v == mkldnn_format_last) return "format_last";
 204     assert(!"unknown fmt");
 205     return "unknown fmt";
 206 }
 207
 208 const char *mkldnn_prop_kind2str(mkldnn_prop_kind_t v) {
 209     if (v == mkldnn_prop_kind_undef) return "undef";
 210     if (v == mkldnn_forward_training) return "forward_training";
 211     if (v == mkldnn_forward_inference) return "forward_inference";
 212     if (v == mkldnn_forward_scoring) return "forward_scoring";
 213     if (v == mkldnn_forward) return "forward";
 214     if (v == mkldnn_backward) return "backward";
 215     if (v == mkldnn_backward_data) return "backward_data";
 216     if (v == mkldnn_backward_weights) return "backward_weights";
 217     if (v == mkldnn_backward_bias) return "backward_bias";
 218     assert(!"unknown prop_kind");
 219     return "unknown prop_kind";
 220 }
 221
 222 const char *mkldnn_prim_kind2str(mkldnn_primitive_kind_t v) {
 223     if (v == mkldnn_undefined_primitive) return "undef";
 224     if (v == mkldnn_memory) return "memory";
 225     if (v == mkldnn_view) return "view";
 226     if (v == mkldnn_reorder) return "reorder";
 227     if (v == mkldnn_shuffle) return "shuffle";
 228     if (v == mkldnn_concat) return "concat";
 229     if (v == mkldnn_concat_inplace) return "concat_inplace";
 230     if (v == mkldnn_sum) return "sum";
 231     if (v == mkldnn_convolution) return "convolution";
 232     if (v == mkldnn_deconvolution) return "deconvolution";
 233     if (v == mkldnn_eltwise) return "eltwise";
 234     if (v == mkldnn_depthwise) return "depthwise";
 235     if (v == mkldnn_softmax) return "softmax";
 236     if (v == mkldnn_pooling) return "pooling";
 237     if (v == mkldnn_lrn) return "lrn";
 238     if (v == mkldnn_batch_normalization) return "batch_normalization";
 239     if (v == mkldnn_inner_product) return "inner_product";
 240     if (v == mkldnn_rnn) return "rnn";
 241     if (v == mkldnn_roi_pooling) return "roi_pooling";
 242     if (v == mkldnn_binary_convolution) return "binary_convolution";
 243     if (v == mkldnn_binarization) return "binarization";
 244     assert(!"unknown prim_kind");
 245     return "unknown prim_kind";
 246 }
 247
 248 const char *mkldnn_alg_kind2str(mkldnn_alg_kind_t v) {
 249     if (v == mkldnn_alg_kind_undef) return "undef";
 250     if (v == mkldnn_convolution_auto) return "convolution_auto";
 251     if (v == mkldnn_convolution_direct) return "convolution_direct";
 252     if (v == mkldnn_convolution_winograd) return "convolution_winograd";
 253     if (v == mkldnn_eltwise_relu) return "eltwise_relu";
 254     if (v == mkldnn_eltwise_tanh) return "eltwise_tanh";
 255     if (v == mkldnn_eltwise_elu) return "eltwise_elu";
 256     if (v == mkldnn_eltwise_square) return "eltwise_square";
 257     if (v == mkldnn_eltwise_abs) return "eltwise_abs";
 258     if (v == mkldnn_eltwise_sqrt) return "eltwise_sqrt";
 259     if (v == mkldnn_eltwise_linear) return "eltwise_linear";
 260     if (v == mkldnn_eltwise_bounded_relu) return "eltwise_bounded_relu";
 261     if (v == mkldnn_eltwise_soft_relu) return "eltwise_soft_relu";
 262     if (v == mkldnn_eltwise_logistic) return "eltwise_logistic";
 263     if (v == mkldnn_eltwise_clamp) return "eltwise_clamp";
 264     if (v == mkldnn_eltwise_exp) return "eltwise_exp";
 265     if (v == mkldnn_eltwise_not) return "eltwise_not";
 266     if (v == mkldnn_pooling_max) return "pooling_max";
 267     if (v == mkldnn_pooling_avg_include_padding) return "pooling_avg_include_padding";
 268     if (v == mkldnn_pooling_avg_exclude_padding) return "pooling_avg_exclude_padding";
 269     if (v == mkldnn_pooling_avg) return "pooling_avg";
 270     if (v == mkldnn_lrn_across_channels) return "lrn_across_channels";
 271     if (v == mkldnn_lrn_within_channel) return "lrn_within_channel";
 272     if (v == mkldnn_deconvolution_direct) return "deconvolution_direct";
 273     if (v == mkldnn_deconvolution_winograd) return "deconvolution_winograd";
 274     if (v == mkldnn_vanilla_rnn) return "vanilla_rnn";
 275     if (v == mkldnn_vanilla_lstm) return "vanilla_lstm";
 276     if (v == mkldnn_vanilla_gru) return "vanilla_gru";
 277     if (v == mkldnn_gru_linear_before_reset) return "gru_linear_before_reset";
 278     if (v == mkldnn_depthwise_scale_shift) return "depthwise_scale_shift";
 279     if (v == mkldnn_depthwise_prelu) return "depthwise_prelu";
 280     if (v == mkldnn_roi_pooling_max) return "roi_pooling_max";
 281     if (v == mkldnn_roi_pooling_bilinear) return "roi_pooling_bilinear";
 282     if (v == mkldnn_binary_convolution_direct) return "binary_convolution_direct";
 283     if (v == mkldnn_binarization_depthwise) return "binarization_depthwise";
 284     assert(!"unknown alg_kind");
 285     return "unknown alg_kind";
 286 }
 287
 288 const char *mkldnn_rnn_direction2str(mkldnn_rnn_direction_t v) {
 289     if (v == mkldnn_unidirectional_left2right) return "unidirectional_left2right";
 290     if (v == mkldnn_unidirectional_right2left) return "unidirectional_right2left";
 291     if (v == mkldnn_bidirectional_concat) return "bidirectional_concat";
 292     if (v == mkldnn_bidirectional_sum) return "bidirectional_sum";
 293     if (v == mkldnn_unidirectional) return "unidirectional";
 294     assert(!"unknown rnn_direction");
 295     return "unknown rnn_direction";
 296 }
 297
 298