inference-engine/thirdparty/mkl-dnn/src/common/verbose.hpp

   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 #ifndef VERBOSE_HPP
  18 #define VERBOSE_HPP
  19
  20 #include "mkldnn_debug.h"
  21 #include "c_types_map.hpp"
  22 #include "utils.hpp"
  23 #include "z_magic.hpp"
  24
  25 namespace mkldnn {
  26 namespace impl {
  27
  28 struct verbose_t {
  29     int level;
  30 };
  31
  32 const verbose_t *mkldnn_verbose();
  33 double get_msec();
  34 const char *get_isa_info();
  35
  36 #if !defined(DISABLE_VERBOSE)
  37 #include <stdio.h>
  38
  39 #define MKLDNN_VERBOSE_BUF_LEN 1024
  40
  41 #define MKLDNN_VERBOSE_DAT_LEN 128
  42 #define MKLDNN_VERBOSE_AUX_LEN 384
  43 #define MKLDNN_VERBOSE_PRB_LEN 384
  44
  45 #define DECL_DAT_AUX_PRB_STRS() \
  46     char dat_str[MKLDNN_VERBOSE_DAT_LEN] = {'\0'}; MAYBE_UNUSED(dat_str); \
  47     char aux_str[MKLDNN_VERBOSE_AUX_LEN] = {'\0'}; MAYBE_UNUSED(aux_str); \
  48     char prb_str[MKLDNN_VERBOSE_PRB_LEN] = {'\0'}; MAYBE_UNUSED(prb_str)
  49
  50 inline void verbose_templ(char *buffer, mkldnn_primitive_kind_t prim_kind,
  51         const char *impl_str, mkldnn_prop_kind_t prop_kind,
  52         const char *data_str, const char *aux_str, const char *prb_str) {
  53     MAYBE_UNUSED(verbose_templ);
  54     snprintf(buffer, MKLDNN_VERBOSE_BUF_LEN, "%s,%s,%s,%s,%s,%s",
  55             mkldnn_prim_kind2str(prim_kind), impl_str,
  56             mkldnn_prop_kind2str(prop_kind), data_str, aux_str, prb_str);
  57 }
  58
  59 inline void format_mem_desc_str_generic(char *str, int len,
  60         const memory_desc_t *md) {
  61     auto ndims = md->ndims;
  62     auto dims = md->dims;
  63     int l = 0;
  64     for (int d = 0; d < ndims - 1; ++d)
  65         l += snprintf(str + l, len - l, "%tdx", dims[d]);
  66     snprintf(str + l, len - l, "%td", dims[ndims - 1]);
  67 }
  68
  69 // XXX: Outputs strings corresponding to memory formats used for data tensors.
  70 inline void format_mem_desc_str(char *str, int len, const memory_desc_t *md) {
  71     auto ndims = md->ndims;
  72     auto dims = md->dims;
  73     if (ndims == 1)
  74         snprintf(str, len, "x%td", dims[0]);
  75     else if (ndims == 2)
  76         snprintf(str, len, "mb%tdic%td", dims[0], dims[1]);
  77     else if (ndims == 3)
  78         snprintf(str, len, "mb%tdic%tdiw%td", dims[0], dims[1], dims[2]);
  79     else if (ndims == 4)
  80         snprintf(str, len, "mb%tdic%tdih%tdiw%td",
  81                 dims[0], dims[1], dims[2], dims[3]);
  82     else if (ndims == 5)
  83         snprintf(str, len, "mb%tdic%tdid%tdih%tdiw%td",
  84                 dims[0], dims[1], dims[2], dims[3], dims[4]);
  85     else
  86         format_mem_desc_str_generic(str, len, md);
  87 }
  88
  89 template <typename pd_t> static void init_info_bnorm(pd_t *s, char *buffer) {
  90     DECL_DAT_AUX_PRB_STRS();
  91
  92     auto fmt_data = s->src_pd()->desc()->format;
  93     auto fmt_diff = s->is_bwd()
  94         ? s->diff_src_pd()->desc()->format : memory_format::undef;
  95     snprintf(dat_str, MKLDNN_VERBOSE_DAT_LEN, "fdata:%s fdiff:%s",
  96             mkldnn_fmt2str(fmt_data), mkldnn_fmt2str(fmt_diff));
  97
  98     snprintf(aux_str, MKLDNN_VERBOSE_AUX_LEN, "flags:%u", s->desc()->flags);
  99
 100     format_mem_desc_str(prb_str, MKLDNN_VERBOSE_PRB_LEN, s->src_pd()->desc());
 101
 102     verbose_templ(buffer, s->kind(), s->name(), s->desc()->prop_kind, dat_str,
 103             aux_str, prb_str);
 104 }
 105
 106 template <typename pd_t> static void init_info_conv(pd_t *s, char *buffer) {
 107     DECL_DAT_AUX_PRB_STRS();
 108
 109     auto fmt_src = (s->desc()->prop_kind == prop_kind::backward_data
 110             ? s->diff_src_pd() : s->src_pd())->desc()->format;
 111     auto fmt_wei = (s->desc()->prop_kind == prop_kind::backward_weights
 112             ? s->diff_weights_pd(0) : s->weights_pd(0))->desc()->format;
 113     auto fmt_bia = s->with_bias()
 114         ? (s->desc()->prop_kind == prop_kind::backward_weights
 115                 ? s->diff_weights_pd(1) : s->weights_pd(1))->desc()->format
 116         : memory_format::undef;
 117     auto fmt_dst = (s->desc()->prop_kind == prop_kind::backward_data
 118             || s->desc()->prop_kind == prop_kind::backward_weights
 119         ? s->diff_dst_pd() : s->dst_pd())->desc()->format;
 120     snprintf(dat_str, MKLDNN_VERBOSE_DAT_LEN,
 121             "fsrc:%s fwei:%s fbia:%s fdst:%s",
 122             mkldnn_fmt2str(fmt_src), mkldnn_fmt2str(fmt_wei),
 123             mkldnn_fmt2str(fmt_bia), mkldnn_fmt2str(fmt_dst));
 124
 125     snprintf(aux_str, MKLDNN_VERBOSE_AUX_LEN,
 126             "alg:%s", mkldnn_alg_kind2str(s->desc()->alg_kind));
 127
 128     if (s->ndims() == 5) {
 129         if (s->with_groups())
 130             snprintf(prb_str, MKLDNN_VERBOSE_PRB_LEN,
 131                 "mb%d_g%dic%doc%d"
 132                 "_id%dod%dkd%dsd%ddd%dpd%d"
 133                 "_ih%doh%dkh%dsh%ddh%dph%d"
 134                 "_iw%dow%dkw%dsw%ddw%dpw%d",
 135                 s->MB(), s->G(), s->IC(), s->OC(),
 136                 s->ID(), s->OD(), s->KD(), s->KSD(), s->KDD(), s->padFront(),
 137                 s->IH(), s->OH(), s->KH(), s->KSH(), s->KDH(), s->padT(),
 138                 s->IW(), s->OW(), s->KW(), s->KSW(), s->KDW(), s->padL());
 139         else
 140             snprintf(prb_str, MKLDNN_VERBOSE_PRB_LEN,
 141                 "mb%d_ic%doc%d"
 142                 "_id%dod%dkd%dsd%ddd%dpd%d"
 143                 "_ih%doh%dkh%dsh%ddh%dph%d"
 144                 "_iw%dow%dkw%dsw%ddw%dpw%d",
 145                 s->MB(), s->IC(), s->OC(),
 146                 s->ID(), s->OD(), s->KD(), s->KSD(), s->KDD(), s->padFront(),
 147                 s->IH(), s->OH(), s->KH(), s->KSH(), s->KDH(), s->padT(),
 148                 s->IW(), s->OW(), s->KW(), s->KSW(), s->KDW(), s->padL());
 149     } else {
 150         if (s->with_groups())
 151             snprintf(prb_str, MKLDNN_VERBOSE_PRB_LEN,
 152                 "mb%d_g%dic%doc%d"
 153                 "_ih%doh%dkh%dsh%ddh%dph%d"
 154                 "_iw%dow%dkw%dsw%ddw%dpw%d",
 155                 s->MB(), s->G(), s->IC(), s->OC(),
 156                 s->IH(), s->OH(), s->KH(), s->KSH(), s->KDH(), s->padT(),
 157                 s->IW(), s->OW(), s->KW(), s->KSW(), s->KDW(), s->padL());
 158         else
 159             snprintf(prb_str, MKLDNN_VERBOSE_PRB_LEN,
 160                 "mb%d_ic%doc%d"
 161                 "_ih%doh%dkh%dsh%ddh%dph%d"
 162                 "_iw%dow%dkw%dsw%ddw%dpw%d",
 163                 s->MB(), s->IC(), s->OC(),
 164                 s->IH(), s->OH(), s->KH(), s->KSH(), s->KDH(), s->padT(),
 165                 s->IW(), s->OW(), s->KW(), s->KSW(), s->KDW(), s->padL());
 166     }
 167
 168     verbose_templ(buffer, s->kind(), s->name(), s->desc()->prop_kind, dat_str,
 169             aux_str, prb_str);
 170 }
 171
 172 template <typename pd_t> static void init_info_shuffle(pd_t *s, char *buffer) {
 173     DECL_DAT_AUX_PRB_STRS();
 174
 175     const auto md = (s->desc()->prop_kind == prop_kind::backward_data
 176             ? s->diff_dst_pd() : s->src_pd())->desc();
 177
 178     snprintf(dat_str, MKLDNN_VERBOSE_DAT_LEN, "dt:%s fmt:%s",
 179             mkldnn_dt2str(md->data_type), mkldnn_fmt2str(md->format));
 180
 181     snprintf(aux_str, MKLDNN_VERBOSE_AUX_LEN, "axis:%d group_size:%d",
 182             s->axis(), s->group_size());
 183
 184     format_mem_desc_str_generic(prb_str, MKLDNN_VERBOSE_PRB_LEN, md);
 185
 186     verbose_templ(buffer, s->kind(), s->name(), s->desc()->prop_kind, dat_str,
 187             aux_str, prb_str);
 188 }
 189
 190 template <typename pd_t> static void init_info_eltwise(pd_t *s, char *buffer) {
 191     DECL_DAT_AUX_PRB_STRS();
 192
 193     auto fmt_data = s->src_pd()->desc()->format;
 194     auto fmt_diff = s->desc()->prop_kind == prop_kind::backward_data
 195         ? s->diff_src_pd()->desc()->format : memory_format::undef;
 196     snprintf(dat_str, MKLDNN_VERBOSE_DAT_LEN, "fdata:%s fdiff:%s",
 197             mkldnn_fmt2str(fmt_data), mkldnn_fmt2str(fmt_diff));
 198
 199     snprintf(aux_str, MKLDNN_VERBOSE_AUX_LEN,
 200             "alg:%s", mkldnn_alg_kind2str(s->desc()->alg_kind));
 201
 202     format_mem_desc_str(prb_str, MKLDNN_VERBOSE_PRB_LEN, s->src_pd()->desc());
 203
 204     verbose_templ(buffer, s->kind(), s->name(), s->desc()->prop_kind, dat_str,
 205             aux_str, prb_str);
 206 }
 207
 208 template <typename pd_t> static void init_info_depthwise(pd_t *s, char *buffer) {
 209     DECL_DAT_AUX_PRB_STRS();
 210
 211     auto fmt_data = s->src_pd()->desc()->format;
 212     auto fmt_diff = s->desc()->prop_kind == prop_kind::backward_data
 213         ? s->diff_src_pd()->desc()->format : memory_format::undef;
 214     snprintf(dat_str, MKLDNN_VERBOSE_DAT_LEN, "fdata:%s fdiff:%s",
 215             mkldnn_fmt2str(fmt_data), mkldnn_fmt2str(fmt_diff));
 216
 217     snprintf(aux_str, MKLDNN_VERBOSE_AUX_LEN,
 218             "alg:%s", mkldnn_alg_kind2str(s->desc()->alg_kind));
 219
 220     snprintf(prb_str, MKLDNN_VERBOSE_PRB_LEN,
 221             "mb%dic%dih%diw%d", s->MB(), s->C(), s->H(), s->W());
 222
 223     verbose_templ(buffer, s->kind(), s->name(), s->desc()->prop_kind, dat_str,
 224             aux_str, prb_str);
 225 }
 226
 227 template <typename pd_t> static void init_info_iprod(pd_t *s, char *buffer) {
 228     DECL_DAT_AUX_PRB_STRS();
 229
 230     auto fmt_src = (s->desc()->prop_kind == prop_kind::backward_data
 231             ? s->diff_src_pd() : s->src_pd())->desc()->format;
 232     auto fmt_wei = (s->desc()->prop_kind == prop_kind::backward_weights
 233             ? s->diff_weights_pd(0) : s->weights_pd(0))->desc()->format;
 234     auto fmt_bia = s->with_bias()
 235         ? (s->desc()->prop_kind == prop_kind::backward_weights
 236                 ? s->diff_weights_pd(1) : s->weights_pd(1))->desc()->format
 237         : memory_format::undef;
 238     auto fmt_dst = (s->desc()->prop_kind == prop_kind::backward_data
 239             || s->desc()->prop_kind == prop_kind::backward_weights
 240         ? s->diff_dst_pd() : s->dst_pd())->desc()->format;
 241     snprintf(dat_str, MKLDNN_VERBOSE_DAT_LEN,
 242             "fsrc:%s fwei:%s fbia:%s fdst:%s",
 243             mkldnn_fmt2str(fmt_src), mkldnn_fmt2str(fmt_wei),
 244             mkldnn_fmt2str(fmt_bia), mkldnn_fmt2str(fmt_dst));
 245
 246     snprintf(prb_str, MKLDNN_VERBOSE_PRB_LEN,
 247             "mb%dic%doc%d", s->MB(), s->IC_total(), s->OC());
 248
 249     verbose_templ(buffer, s->kind(), s->name(), s->desc()->prop_kind, dat_str,
 250             aux_str, prb_str);
 251 }
 252
 253 template <typename pd_t> static void init_info_lrn(pd_t *s, char *buffer) {
 254     DECL_DAT_AUX_PRB_STRS();
 255
 256     auto fmt_data = s->src_pd()->desc()->format;
 257     auto fmt_diff = s->desc()->prop_kind == prop_kind::backward_data
 258         ? s->diff_src_pd()->desc()->format : memory_format::undef;
 259     snprintf(dat_str, MKLDNN_VERBOSE_DAT_LEN, "fdata:%s fdiff:%s",
 260             mkldnn_fmt2str(fmt_data), mkldnn_fmt2str(fmt_diff));
 261
 262     snprintf(aux_str, MKLDNN_VERBOSE_AUX_LEN,
 263             "alg:%s", mkldnn_alg_kind2str(s->desc()->alg_kind));
 264
 265     format_mem_desc_str(prb_str, MKLDNN_VERBOSE_PRB_LEN, s->src_pd()->desc());
 266
 267     verbose_templ(buffer, s->kind(), s->name(), s->desc()->prop_kind, dat_str,
 268             aux_str, prb_str);
 269 }
 270
 271 template <typename pd_t> static void init_info_mem(pd_t *s, char *buffer) {
 272     DECL_DAT_AUX_PRB_STRS();
 273
 274     const auto i_md = s->input_pd(0)->desc();
 275     const auto o_md = s->output_pd(0)->desc();
 276     snprintf(dat_str, MKLDNN_VERBOSE_DAT_LEN,
 277             "in:%s_%s out:%s_%s",
 278             mkldnn_dt2str(i_md->data_type), mkldnn_fmt2str(i_md->format),
 279             mkldnn_dt2str(o_md->data_type), mkldnn_fmt2str(o_md->format));
 280
 281     snprintf(aux_str, MKLDNN_VERBOSE_AUX_LEN, "num:%d", s->n_inputs());
 282
 283     format_mem_desc_str_generic(prb_str, MKLDNN_VERBOSE_PRB_LEN, o_md);
 284
 285     verbose_templ(buffer, s->kind(), s->name(), prop_kind::undef, dat_str,
 286             aux_str, prb_str);
 287 }
 288
 289 template <typename pd_t> static void init_info_pool(pd_t *s, char *buffer) {
 290     DECL_DAT_AUX_PRB_STRS();
 291
 292     auto fmt_data = (s->desc()->prop_kind == prop_kind::backward_data
 293             ? s->diff_src_pd() : s->src_pd())->desc()->format;
 294     auto fmt_ws = s->workspace_pd()
 295         ? s->workspace_pd()->desc()->format : memory_format::undef;
 296     snprintf(dat_str, MKLDNN_VERBOSE_DAT_LEN, "fdata:%s fws:%s",
 297             mkldnn_fmt2str(fmt_data), mkldnn_fmt2str(fmt_ws));
 298
 299     snprintf(aux_str, MKLDNN_VERBOSE_AUX_LEN,
 300             "alg:%s", mkldnn_alg_kind2str(s->desc()->alg_kind));
 301
 302     if (s->is_3d())
 303     {
 304         snprintf(prb_str, MKLDNN_VERBOSE_PRB_LEN,
 305             "mb%dic%d_id%dod%dkd%dsd%dpd%d_ih%doh%dkh%dsh%dph%d_iw%dow%dkw%dsw%dpw%d",
 306             s->MB(), s->C(),
 307             s->ID(), s->OD(), s->KD(), s->KSD(), s->padFront(),
 308             s->IH(), s->OH(), s->KH(), s->KSH(), s->padT(),
 309             s->IW(), s->OW(), s->KW(), s->KSW(), s->padL());
 310     } else {
 311         snprintf(prb_str, MKLDNN_VERBOSE_PRB_LEN,
 312             "mb%dic%d_ih%doh%dkh%dsh%dph%d_iw%dow%dkw%dsw%dpw%d",
 313             s->MB(), s->C(),
 314             s->IH(), s->OH(), s->KH(), s->KSH(), s->padT(),
 315             s->IW(), s->OW(), s->KW(), s->KSW(), s->padL());
 316     }
 317
 318     verbose_templ(buffer, s->kind(), s->name(), s->desc()->prop_kind, dat_str,
 319             aux_str, prb_str);
 320 }
 321
 322 template <typename pd_t> static void init_info_softmax(pd_t *s, char *buffer) {
 323     DECL_DAT_AUX_PRB_STRS();
 324
 325     auto md = (s->desc()->prop_kind == prop_kind::backward_data
 326         ? s->diff_src_pd() : s->src_pd())->desc();
 327     auto fmt_data = md->format;
 328     auto fmt_diff = s->desc()->prop_kind == prop_kind::backward_data
 329         ? s->diff_src_pd()->desc()->format : memory_format::undef;
 330     snprintf(dat_str, MKLDNN_VERBOSE_DAT_LEN, "fdata:%s fdiff:%s",
 331             mkldnn_fmt2str(fmt_data), mkldnn_fmt2str(fmt_diff));
 332
 333     format_mem_desc_str(prb_str, MKLDNN_VERBOSE_PRB_LEN, md);
 334
 335     verbose_templ(buffer, s->kind(), s->name(), s->desc()->prop_kind, dat_str,
 336             aux_str, prb_str);
 337 }
 338
 339 /// @todo print meaningful data
 340 template <typename pd_t> static void init_info_rnn(pd_t *s, char *buffer) {
 341     DECL_DAT_AUX_PRB_STRS();
 342
 343     const mkldnn::impl::memory_desc_t *src_lay_md, *src_iter_md, *wei_lay_md,
 344             *wei_iter_md, *bias_md, *dst_lay_md, *dst_iter_md;
 345     if (s->desc()->prop_kind != prop_kind::backward_data) {
 346         src_lay_md = s->src_pd(0)->desc();
 347         src_iter_md = s->src_pd(1) ? s->src_pd(1)->desc() : nullptr;
 348         wei_lay_md = s->weights_pd(0)->desc();
 349         wei_iter_md = s->weights_pd(1)->desc();
 350         bias_md = s->weights_pd(2)->desc();
 351         dst_lay_md = s->dst_pd(0)->desc();
 352         dst_iter_md = s->dst_pd(1) ? s->dst_pd(1)->desc() : nullptr;
 353     } else {
 354         src_lay_md = s->diff_src_pd(0)->desc();
 355         src_iter_md = s->diff_src_pd(1) ? s->diff_src_pd(1)->desc() : nullptr;
 356         wei_lay_md = s->diff_weights_pd(0)->desc();
 357         wei_iter_md = s->diff_weights_pd(1)->desc();
 358         bias_md = s->diff_weights_pd(2)->desc();
 359         dst_lay_md = s->diff_dst_pd(0)->desc();
 360         dst_iter_md = s->diff_dst_pd(1) ? s->diff_dst_pd(1)->desc() : nullptr;
 361     }
 362
 363     alg_kind_t alg_kind = s->cell_kind();
 364     rnn_direction_t rnn_dir = s->direction();
 365     snprintf(aux_str, MKLDNN_VERBOSE_AUX_LEN,
 366             "alg:%s_%s", mkldnn_alg_kind2str(alg_kind), mkldnn_rnn_direction2str(rnn_dir));
 367     snprintf(dat_str, MKLDNN_VERBOSE_DAT_LEN, "fdata:%s-%s-%s-%s fwei:%s-%s-%s ddata:%s%s-%s%s dwei:%s%s%s",
 368              mkldnn_fmt2str(src_lay_md->format),
 369              mkldnn_fmt2str(src_iter_md ? src_iter_md->format : memory_format::undef),
 370              mkldnn_fmt2str(dst_lay_md->format),
 371              mkldnn_fmt2str(dst_iter_md ? dst_iter_md->format : memory_format::undef),
 372              mkldnn_fmt2str(wei_lay_md->format),
 373              mkldnn_fmt2str(wei_iter_md->format),
 374              mkldnn_fmt2str(bias_md->format),
 375              mkldnn_dt2str(src_lay_md->data_type),
 376              mkldnn_dt2str(src_iter_md ? src_iter_md->data_type : data_type::undef),
 377              mkldnn_dt2str(dst_lay_md->data_type),
 378              mkldnn_dt2str(dst_iter_md ? dst_iter_md->data_type : data_type::undef),
 379              mkldnn_dt2str(wei_lay_md->data_type),
 380              mkldnn_dt2str(wei_iter_md->data_type),
 381              mkldnn_dt2str(bias_md->data_type));
 382
 383     snprintf(prb_str, MKLDNN_VERBOSE_PRB_LEN,
 384             "l%dt%dmb%dsic%dslc%ddic%ddlc%d",
 385              s->L(), s->T(), s->MB(),
 386              s->SIC(), s->SLC(), s->DIC(), s->DLC());
 387
 388     verbose_templ(buffer, s->kind(), s->name(), s->desc()->prop_kind, dat_str,
 389             aux_str, prb_str);
 390 }
 391
 392 template <typename pd_t> static void init_info_roi_pooling(pd_t *s, char *buffer) {
 393     DECL_DAT_AUX_PRB_STRS();
 394
 395     auto fmt_data = s->src_pd()->desc()->format;
 396     auto fmt_diff = s->desc()->prop_kind == prop_kind::backward_data
 397                     ? s->diff_src_pd()->desc()->format : memory_format::undef;
 398     snprintf(dat_str, MKLDNN_VERBOSE_DAT_LEN, "fdata:%s fdiff:%s",
 399              mkldnn_fmt2str(fmt_data), mkldnn_fmt2str(fmt_diff));
 400
 401     snprintf(aux_str, MKLDNN_VERBOSE_AUX_LEN,
 402              "alg:%s", mkldnn_alg_kind2str(s->desc()->alg_kind));
 403
 404     snprintf(prb_str, MKLDNN_VERBOSE_PRB_LEN,
 405              "ph%dpw%dcs%f", s->pooledH(), s->pooledW(), s->spatialScale());
 406     verbose_templ(buffer, s->kind(), s->name(), s->desc()->prop_kind, dat_str,
 407                   aux_str, prb_str);
 408 }
 409
 410 template <typename pd_t> static void init_info_bin_conv(pd_t *s, char *buffer) {
 411     DECL_DAT_AUX_PRB_STRS();
 412
 413     auto fmt_src = s->src_pd()->desc()->format;
 414     auto fmt_wei = s->weights_pd(0)->desc()->format;
 415     auto fmt_dst = s->dst_pd()->desc()->format;
 416
 417     snprintf(dat_str, MKLDNN_VERBOSE_DAT_LEN,
 418             "fsrc:%s fwei:%s fdst:%s",
 419             mkldnn_fmt2str(fmt_src), mkldnn_fmt2str(fmt_wei), mkldnn_fmt2str(fmt_dst));
 420
 421     snprintf(aux_str, MKLDNN_VERBOSE_AUX_LEN,
 422             "alg:%s", mkldnn_alg_kind2str(s->cdesc()->alg_kind));
 423
 424     if (s->ndims() == 5) {
 425         snprintf(prb_str, MKLDNN_VERBOSE_PRB_LEN,
 426             "mb%d_g%dic%doc%d"
 427             "_id%dod%dkd%dsd%ddd%dpd%d"
 428             "_ih%doh%dkh%dsh%ddh%dph%d"
 429             "_iw%dow%dkw%dsw%ddw%dpw%d",
 430             s->MB(), s->G(), s->IC(), s->OC(),
 431             s->ID(), s->OD(), s->KD(), s->KSD(), s->KDD(), s->padFront(),
 432             s->IH(), s->OH(), s->KH(), s->KSH(), s->KDH(), s->padT(),
 433             s->IW(), s->OW(), s->KW(), s->KSW(), s->KDW(), s->padL());
 434     } else {
 435         snprintf(prb_str, MKLDNN_VERBOSE_PRB_LEN,
 436             "mb%d_g%dic%doc%d"
 437             "_ih%doh%dkh%dsh%ddh%dph%d"
 438             "_iw%dow%dkw%dsw%ddw%dpw%d",
 439             s->MB(), s->G(), s->IC(), s->OC(),
 440             s->IH(), s->OH(), s->KH(), s->KSH(), s->KDH(), s->padT(),
 441             s->IW(), s->OW(), s->KW(), s->KSW(), s->KDW(), s->padL());
 442     }
 443
 444     verbose_templ(buffer, s->kind(), s->name(), s->cdesc()->prop_kind, dat_str,
 445             aux_str, prb_str);
 446 }
 447
 448 template <typename pd_t> static void init_info_binarization(pd_t *s, char *buffer) {
 449     DECL_DAT_AUX_PRB_STRS();
 450
 451     auto fmt_data = s->src_pd()->desc()->format;
 452     auto fmt_diff = s->desc()->prop_kind == prop_kind::backward_data
 453         ? s->diff_src_pd()->desc()->format : memory_format::undef;
 454     snprintf(dat_str, MKLDNN_VERBOSE_DAT_LEN, "fdata:%s fdiff:%s",
 455             mkldnn_fmt2str(fmt_data), mkldnn_fmt2str(fmt_diff));
 456
 457     snprintf(aux_str, MKLDNN_VERBOSE_AUX_LEN,
 458             "alg:%s", mkldnn_alg_kind2str(s->desc()->alg_kind));
 459
 460     snprintf(prb_str, MKLDNN_VERBOSE_PRB_LEN,
 461             "mb%dic%dih%diw%d", s->MB(), s->C(), s->H(), s->W());
 462
 463     verbose_templ(buffer, s->kind(), s->name(), s->desc()->prop_kind, dat_str,
 464             aux_str, prb_str);
 465 }
 466
 467 #else /* !defined(DISABLE_VERBOSE) */
 468 #define MKLDNN_VERBOSE_BUF_LEN 1
 469
 470 #define DEFINE_STUB(name) \
 471     template <typename pd_t> \
 472     static void CONCAT2(init_info_, name)(pd_t *s, char *buffer) \
 473     { UNUSED(s); UNUSED(buffer); }
 474
 475 DEFINE_STUB(bnorm);
 476 DEFINE_STUB(conv);
 477 DEFINE_STUB(eltwise);
 478 DEFINE_STUB(depthwise);
 479 DEFINE_STUB(iprod);
 480 DEFINE_STUB(lrn);
 481 DEFINE_STUB(mem);
 482 DEFINE_STUB(pool);
 483 DEFINE_STUB(softmax);
 484 DEFINE_STUB(rnn);
 485 DEFINE_STUB(shuffle);
 486 DEFINE_STUB(roi_pooling);
 487 DEFINE_STUB(bin_conv);
 488 DEFINE_STUB(binarization);
 489 #undef DEFINE_STUB
 490 #endif /* !defined(DISABLE_VERBOSE) */
 491
 492 }
 493 }
 494
 495 #endif