mkldnn_types.h

Go to the documentation of this file.

/*******************************************************************************
* Copyright 2016-2019 Intel Corporation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*     http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*******************************************************************************/


#ifndef MKLDNN_TYPES_H
#define MKLDNN_TYPES_H

#ifdef __cplusplus
extern "C" {
#endif

#ifndef DOXYGEN_SHOULD_SKIP_THIS
#include <stddef.h>
#include <stdint.h>
#endif


typedef struct {
    int    major;
    int    minor;
    int    patch;
    const char *hash;
} mkldnn_version_t;

typedef enum {
    mkldnn_success = 0,
    mkldnn_out_of_memory = 1,
    mkldnn_invalid_arguments = 2,
    mkldnn_unimplemented = 3,
    mkldnn_iterator_ends = 4,
    mkldnn_runtime_error = 5,
    mkldnn_not_required = 6,
} mkldnn_status_t;

typedef enum {
    mkldnn_data_type_undef = 0,
    mkldnn_f16 = 1,
    mkldnn_bf16 = 2,
    mkldnn_f32 = 3,
    mkldnn_s32 = 4,
    mkldnn_s8 = 5,
    mkldnn_u8 = 6,
} mkldnn_data_type_t;

typedef enum {
    mkldnn_format_kind_undef = 0,
    mkldnn_format_kind_any,
    mkldnn_blocked,
    mkldnn_format_kind_wino,
    mkldnn_format_kind_rnn_packed,
} mkldnn_format_kind_t;

typedef enum {
    mkldnn_format_tag_undef = 0,
    mkldnn_format_tag_any,

    // Semantic agnostic section
    // The physical order of dimensions is defined by the permutation of the
    // characters, assuming that ab..z defines the natural order.

    // Plain formats

    mkldnn_a, 
    mkldnn_ab, 
    mkldnn_abc, 
    mkldnn_abcd, 
    mkldnn_abcde, 
    mkldnn_abcdef, 

    // Permuted plain formats

    mkldnn_abdec, 
    mkldnn_acb, 
    mkldnn_acbde, 
    mkldnn_acdb, 
    mkldnn_acdeb, 
    mkldnn_ba, 
    mkldnn_bac, 
    mkldnn_bacd, 
    mkldnn_bca, 
    mkldnn_bcda, 
    mkldnn_bcdea, 
    mkldnn_cba, 
    mkldnn_cdba, 
    mkldnn_cdeba, 
    mkldnn_decab, 

    // Opaque blocked formats

    mkldnn_Abc16a,
    mkldnn_ABc16a16b,
    mkldnn_aBc16b,
    mkldnn_ABc16b16a,
    mkldnn_Abc4a,
    mkldnn_aBc4b,
    mkldnn_ABc4b16a4b,
    mkldnn_ABc4b4a,
    mkldnn_ABc8a16b2a,
    mkldnn_ABc8a8b,
    mkldnn_aBc8b,
    mkldnn_ABc8b16a2b,
    mkldnn_BAc8a16b2a,
    mkldnn_ABc8b8a,
    mkldnn_Abcd16a,
    mkldnn_ABcd16a16b,
    mkldnn_ABcd32a32b,
    mkldnn_aBcd16b,
    mkldnn_ABcd16b16a,
    mkldnn_aBCd16b16c,
    mkldnn_aBCd16c16b,
    mkldnn_Abcd4a,
    mkldnn_aBcd4b,
    mkldnn_ABcd4b16a4b,
    mkldnn_ABcd4b4a,
    mkldnn_aBCd4c16b4c,
    mkldnn_aBCd4c4b,
    mkldnn_ABcd8a16b2a,
    mkldnn_ABcd8a8b,
    mkldnn_aBcd8b,
    mkldnn_ABcd8b16a2b,
    mkldnn_aBCd8b16c2b,
    mkldnn_BAcd8a16b2a,
    mkldnn_ABcd8b8a,
    mkldnn_aBCd8b8c,
    mkldnn_aBCd8c16b2c,
    mkldnn_ABcde8a16b2a,
    mkldnn_aCBd8b16c2b,
    mkldnn_aBCd8c8b,
    mkldnn_Abcde16a,
    mkldnn_ABcde16a16b,
    mkldnn_BAcde8a16b2a,
    mkldnn_aBcde16b,
    mkldnn_ABcde16b16a,
    mkldnn_aBCde16b16c,
    mkldnn_aBCde16c16b,
    mkldnn_aBCde2c8b4c,
    mkldnn_Abcde4a,
    mkldnn_aBcde4b,
    mkldnn_ABcde4b4a,
    mkldnn_aBCde4b4c,
    mkldnn_aBCde4c16b4c,
    mkldnn_aBCde4c4b,
    mkldnn_Abcde8a,
    mkldnn_ABcde8a8b,
    mkldnn_BAcde16b16a,
    mkldnn_aBcde8b,
    mkldnn_ABcde8b16a2b,
    mkldnn_aBCde8b16c2b,
    mkldnn_aCBde8b16c2b,
    mkldnn_ABcde8b8a,
    mkldnn_aBCde8b8c,
    mkldnn_ABcd4a8b8a4b,
    mkldnn_ABcd2a8b8a2b,
    mkldnn_aBCde4b8c8b4c,
    mkldnn_aBCde2b8c8b2c,
    mkldnn_aBCde8c16b2c,
    mkldnn_aBCde8c8b,
    mkldnn_aBcdef16b,
    mkldnn_aBCdef16b16c,
    mkldnn_aBCdef16c16b,
    mkldnn_aBcdef4b,
    mkldnn_aBCdef4c4b,
    mkldnn_aBCdef8b8c,
    mkldnn_aBCdef8c16b2c,
    mkldnn_aBCdef8b16c2b,
    mkldnn_aCBdef8b16c2b,
    mkldnn_aBCdef8c8b,
    mkldnn_aBdc16b,
    mkldnn_aBdc4b,
    mkldnn_aBdc8b,
    mkldnn_aBdec16b,
    mkldnn_aBdec32b,
    mkldnn_aBdec4b,
    mkldnn_aBdec8b,
    mkldnn_aBdefc16b,
    mkldnn_aCBdef16c16b,
    mkldnn_aBdefc4b,
    mkldnn_aBdefc8b,
    mkldnn_Abcdef16a,
    mkldnn_Acb16a,
    mkldnn_Acb4a,
    mkldnn_Acb8a,
    mkldnn_aCBd16b16c,
    mkldnn_aCBd16c16b,
    mkldnn_aCBde16b16c,
    mkldnn_aCBde16c16b,
    mkldnn_Acdb16a,
    mkldnn_Acdb32a,
    mkldnn_Acdb4a,
    mkldnn_Acdb8a,
    mkldnn_Acdeb16a,
    mkldnn_Acdeb4a,
    mkldnn_Acdeb8a,
    mkldnn_BAc16a16b,
    mkldnn_BAc16b16a,
    mkldnn_BAcd16a16b,
    mkldnn_BAcd16b16a,

    mkldnn_format_tag_last,

    // Aliases

    mkldnn_x = mkldnn_a,
    mkldnn_nc = mkldnn_ab,
    mkldnn_cn = mkldnn_ba,
    mkldnn_ncw = mkldnn_abc,
    mkldnn_nwc = mkldnn_acb,
    mkldnn_nchw = mkldnn_abcd,
    mkldnn_nhwc = mkldnn_acdb,
    mkldnn_chwn = mkldnn_bcda,
    mkldnn_ncdhw = mkldnn_abcde,
    mkldnn_ndhwc = mkldnn_acdeb,

    mkldnn_oi = mkldnn_ab,
    mkldnn_io = mkldnn_ba,
    mkldnn_oiw = mkldnn_abc,
    mkldnn_owi = mkldnn_acb,
    mkldnn_wio = mkldnn_cba,
    mkldnn_iwo = mkldnn_bca,
    mkldnn_oihw = mkldnn_abcd,
    mkldnn_hwio = mkldnn_cdba,
    mkldnn_ohwi = mkldnn_acdb,
    mkldnn_ihwo = mkldnn_bcda,
    mkldnn_iohw = mkldnn_bacd,
    mkldnn_oidhw = mkldnn_abcde,
    mkldnn_dhwio = mkldnn_cdeba,
    mkldnn_odhwi = mkldnn_acdeb,
    mkldnn_idhwo = mkldnn_bcdea,

    mkldnn_goiw = mkldnn_abcd,
    mkldnn_goihw = mkldnn_abcde,
    mkldnn_hwigo = mkldnn_decab,
    mkldnn_giohw = mkldnn_acbde,
    mkldnn_goidhw = mkldnn_abcdef,

    mkldnn_tnc = mkldnn_abc,
    mkldnn_ntc = mkldnn_bac,
    mkldnn_ldnc = mkldnn_abcd,
    mkldnn_ldigo = mkldnn_abcde,
    mkldnn_ldgoi = mkldnn_abdec,
    mkldnn_ldgo = mkldnn_abcd,

    // Opaque data types, are not to be used explicitly

    // data

    mkldnn_nCdhw16c = mkldnn_aBcde16b,
    mkldnn_nCdhw4c = mkldnn_aBcde4b,
    mkldnn_nCdhw8c = mkldnn_aBcde8b,
    mkldnn_nChw16c = mkldnn_aBcd16b,
    mkldnn_nChw4c = mkldnn_aBcd4b,
    mkldnn_nChw8c = mkldnn_aBcd8b,
    mkldnn_nCw16c = mkldnn_aBc16b,
    mkldnn_nCw4c = mkldnn_aBc4b,
    mkldnn_nCw8c = mkldnn_aBc8b,
    mkldnn_NCw16n16c = mkldnn_ABc16a16b,
    mkldnn_NCdhw16n16c = mkldnn_ABcde16a16b,
    mkldnn_NChw16n16c = mkldnn_ABcd16a16b,
    mkldnn_NChw32n32c = mkldnn_ABcd32a32b,

    // weights, 3D
    mkldnn_IOw16o16i = mkldnn_BAc16a16b,
    mkldnn_IOw16i16o = mkldnn_BAc16b16a,
    mkldnn_OIw16i16o = mkldnn_ABc16b16a,
    mkldnn_OIw16o16i = mkldnn_ABc16a16b,
    mkldnn_Oiw16o = mkldnn_Abc16a,
    mkldnn_OIw4i16o4i = mkldnn_ABc4b16a4b,
    mkldnn_OIw4i4o = mkldnn_ABc4b4a,
    mkldnn_Oiw4o = mkldnn_Abc4a,
    mkldnn_OIw8i16o2i = mkldnn_ABc8b16a2b,
    mkldnn_OIw8i8o = mkldnn_ABc8b8a,
    mkldnn_OIw8o16i2o = mkldnn_ABc8a16b2a,
    mkldnn_IOw8o16i2o = mkldnn_BAc8a16b2a,
    mkldnn_OIw8o8i = mkldnn_ABc8a8b,
    mkldnn_Owi16o = mkldnn_Acb16a,
    mkldnn_Owi4o = mkldnn_Acb4a,
    mkldnn_Owi8o = mkldnn_Acb8a,

    // weights, 4D
    mkldnn_IOhw16i16o = mkldnn_BAcd16b16a,
    mkldnn_IOhw16o16i = mkldnn_BAcd16a16b,
    mkldnn_Ohwi16o = mkldnn_Acdb16a,
    mkldnn_Ohwi32o = mkldnn_Acdb32a,
    mkldnn_Ohwi4o = mkldnn_Acdb4a,
    mkldnn_Ohwi8o = mkldnn_Acdb8a,
    mkldnn_OIhw16i16o = mkldnn_ABcd16b16a,
    mkldnn_OIhw16o16i = mkldnn_ABcd16a16b,
    mkldnn_Oihw16o = mkldnn_Abcd16a,
    mkldnn_OIhw4i16o4i = mkldnn_ABcd4b16a4b,
    mkldnn_OIhw4i4o = mkldnn_ABcd4b4a,
    mkldnn_Oihw4o = mkldnn_Abcd4a,
    mkldnn_OIhw8i16o2i = mkldnn_ABcd8b16a2b,
    mkldnn_OIhw8i8o = mkldnn_ABcd8b8a,
    mkldnn_OIhw8o16i2o = mkldnn_ABcd8a16b2a,
    mkldnn_IOhw8o16i2o = mkldnn_BAcd8a16b2a,
    mkldnn_OIhw8o8i = mkldnn_ABcd8a8b,

    // weights, 5D
    mkldnn_Odhwi16o = mkldnn_Acdeb16a,
    mkldnn_Odhwi4o = mkldnn_Acdeb4a,
    mkldnn_Odhwi8o = mkldnn_Acdeb8a,
    mkldnn_OIdhw16i16o = mkldnn_ABcde16b16a,
    mkldnn_OIdhw16o16i = mkldnn_ABcde16a16b,
    mkldnn_Oidhw16o = mkldnn_Abcde16a,
    mkldnn_OIdhw4i4o = mkldnn_ABcde4b4a,
    mkldnn_Oidhw4o = mkldnn_Abcde4a,
    mkldnn_OIdhw8i16o2i = mkldnn_ABcde8b16a2b,
    mkldnn_OIdhw8i8o = mkldnn_ABcde8b8a,
    mkldnn_OIdhw8o16i2o = mkldnn_ABcde8a16b2a,
    mkldnn_IOdhw8o16i2o = mkldnn_BAcde8a16b2a,
    mkldnn_OIdhw8o8i = mkldnn_ABcde8a8b,
    mkldnn_IOdhw16i16o = mkldnn_BAcde16b16a,

    // weights w/ groups, 3D
    mkldnn_Goiw16g = mkldnn_Abcd16a,
    mkldnn_gIOw16o16i = mkldnn_aCBd16b16c,
    mkldnn_gIOw16i16o = mkldnn_aCBd16c16b,
    mkldnn_gOIw16i16o = mkldnn_aBCd16c16b,
    mkldnn_gOIw16o16i = mkldnn_aBCd16b16c,
    mkldnn_gOiw16o = mkldnn_aBcd16b,
    mkldnn_gOIw4i16o4i = mkldnn_aBCd4c16b4c,
    mkldnn_gOIw4i4o = mkldnn_aBCd4c4b,
    mkldnn_gOiw4o = mkldnn_aBcd4b,
    mkldnn_gOIw8i16o2i = mkldnn_aBCd8c16b2c,
    mkldnn_gOIw8i8o = mkldnn_aBCd8c8b,
    mkldnn_gOIw8o16i2o = mkldnn_aBCd8b16c2b,
    mkldnn_gIOw8o16i2o = mkldnn_aCBd8b16c2b,
    mkldnn_gOIw8o8i = mkldnn_aBCd8b8c,
    mkldnn_gOwi16o = mkldnn_aBdc16b,
    mkldnn_gOwi4o = mkldnn_aBdc4b,
    mkldnn_gOwi8o = mkldnn_aBdc8b,

    // weights w/ groups, 4D
    mkldnn_gIOhw16i16o = mkldnn_aCBde16c16b,
    mkldnn_gIOhw16o16i = mkldnn_aCBde16b16c,
    mkldnn_gOhwi16o = mkldnn_aBdec16b,
    mkldnn_gOhwi32o = mkldnn_aBdec32b,
    mkldnn_gOhwi4o = mkldnn_aBdec4b,
    mkldnn_gOhwi8o = mkldnn_aBdec8b,
    mkldnn_Goihw16g = mkldnn_Abcde16a,
    mkldnn_gOIhw16i16o = mkldnn_aBCde16c16b,
    mkldnn_gOIhw16o16i = mkldnn_aBCde16b16c,
    mkldnn_gOihw16o = mkldnn_aBcde16b,
    mkldnn_gOIhw2i8o4i = mkldnn_aBCde2c8b4c,
    mkldnn_gOIhw4i16o4i = mkldnn_aBCde4c16b4c,
    mkldnn_gOIhw4i4o = mkldnn_aBCde4c4b,
    mkldnn_gOIhw4o4i = mkldnn_aBCde4b4c,
    mkldnn_gOihw4o = mkldnn_aBcde4b,
    mkldnn_Goihw8g = mkldnn_Abcde8a,
    mkldnn_gOIhw8i16o2i = mkldnn_aBCde8c16b2c,
    mkldnn_gOIhw8i8o = mkldnn_aBCde8c8b,
    mkldnn_gOIhw8o16i2o = mkldnn_aBCde8b16c2b,
    mkldnn_gIOhw8o16i2o = mkldnn_aCBde8b16c2b,
    mkldnn_gOIhw8o8i = mkldnn_aBCde8b8c,

    mkldnn_OIhw4o8i8o4i = mkldnn_ABcd4a8b8a4b,
    mkldnn_OIhw2o8i8o2i = mkldnn_ABcd2a8b8a2b,
    mkldnn_gOIhw4o8i8o4i = mkldnn_aBCde4b8c8b4c,
    mkldnn_gOIhw2o8i8o2i = mkldnn_aBCde2b8c8b2c,

    // weights w/ groups, 6D
    mkldnn_gIOdhw16i16o = mkldnn_aCBdef16c16b,
    mkldnn_gOdhwi16o = mkldnn_aBdefc16b,
    mkldnn_gOdhwi4o = mkldnn_aBdefc4b,
    mkldnn_gOdhwi8o = mkldnn_aBdefc8b,
    mkldnn_gOIdhw16i16o = mkldnn_aBCdef16c16b,
    mkldnn_gOIdhw16o16i = mkldnn_aBCdef16b16c,
    mkldnn_gOidhw16o = mkldnn_aBcdef16b,
    mkldnn_gOIdhw4i4o = mkldnn_aBCdef4c4b,
    mkldnn_gOidhw4o = mkldnn_aBcdef4b,
    mkldnn_gOIdhw8i16o2i = mkldnn_aBCdef8c16b2c,
    mkldnn_gOIdhw8i8o = mkldnn_aBCdef8c8b,
    mkldnn_gOIdhw8o16i2o = mkldnn_aBCdef8b16c2b,
    mkldnn_gIOdhw8o16i2o = mkldnn_aCBdef8b16c2b,
    mkldnn_gOIdhw8o8i = mkldnn_aBCdef8b8c,
    mkldnn_Goidhw16g = mkldnn_Abcdef16a,
} mkldnn_format_tag_t;

typedef enum {
    // TODO: suggest renames
    mkldnn_prop_kind_undef = 0,
    mkldnn_forward_training = 64,
    mkldnn_forward_inference = 96,
    mkldnn_forward_scoring = mkldnn_forward_inference,
    mkldnn_forward = mkldnn_forward_training,
    mkldnn_backward = 128,
    mkldnn_backward_data = 160,
    mkldnn_backward_weights = 192,
    mkldnn_backward_bias = 193,
} mkldnn_prop_kind_t;

typedef enum {
    mkldnn_undefined_primitive,
    mkldnn_reorder,
    mkldnn_shuffle,
    mkldnn_concat,
    mkldnn_sum,
    mkldnn_convolution,
    mkldnn_deconvolution,
    mkldnn_eltwise,
    mkldnn_softmax,
    mkldnn_pooling,
    mkldnn_lrn,
    mkldnn_batch_normalization,
    mkldnn_inner_product,
    mkldnn_rnn,
    mkldnn_gemm,
} mkldnn_primitive_kind_t;

typedef enum {
    mkldnn_alg_kind_undef,
    mkldnn_convolution_direct = 0x1,
    mkldnn_convolution_winograd = 0x2,
    mkldnn_convolution_auto = 0x3,
    mkldnn_deconvolution_direct = 0xa,
    mkldnn_deconvolution_winograd = 0xb,
    mkldnn_eltwise_relu = 0x1f,
    mkldnn_eltwise_tanh = 0x2f,
    mkldnn_eltwise_elu = 0x3f,
    mkldnn_eltwise_square = 0x4f,
    mkldnn_eltwise_abs = 0x5f,
    mkldnn_eltwise_sqrt = 0x6f,
    mkldnn_eltwise_linear = 0x7f,
    mkldnn_eltwise_bounded_relu = 0x8f,
    mkldnn_eltwise_soft_relu = 0x9f,
    mkldnn_eltwise_logistic = 0xaf,
    mkldnn_eltwise_exp = 0xbf,
    mkldnn_eltwise_gelu = 0xcf,
    mkldnn_pooling_max = 0x1ff,
    mkldnn_pooling_avg_include_padding = 0x2ff,
    mkldnn_pooling_avg_exclude_padding = 0x3ff,
    mkldnn_pooling_avg = mkldnn_pooling_avg_exclude_padding,
    mkldnn_lrn_across_channels = 0xaff,
    mkldnn_lrn_within_channel = 0xbff,
    mkldnn_vanilla_rnn = 0x1fff,
    mkldnn_vanilla_lstm = 0x2fff,
    mkldnn_vanilla_gru = 0x3fff,
    mkldnn_lbr_gru = 0x4fff,
} mkldnn_alg_kind_t;

typedef enum {
    mkldnn_use_global_stats = 0x1U,

    mkldnn_use_scaleshift = 0x2U,

    mkldnn_fuse_norm_relu = 0x4U,
} mkldnn_normalization_flags_t;



#define MKLDNN_MAX_NDIMS 12

typedef int64_t mkldnn_dim_t;

typedef mkldnn_dim_t mkldnn_dims_t[MKLDNN_MAX_NDIMS];

typedef struct {
    mkldnn_dims_t strides;
    // Innermost section
    // ASSUMPTION: the innermost blocks are always dense
    int inner_nblks;
    mkldnn_dims_t inner_blks;
    mkldnn_dims_t inner_idxs;
} mkldnn_blocking_desc_t;

typedef enum {
    mkldnn_wino_undef = 0,
    // Tensors of weights for 2x3 winograd convolutions.
    mkldnn_wino_wei_aaOIoi, 
    mkldnn_wino_wei_aaOio, 
    mkldnn_wino_wei_aaOBiOo, 
    // Tensor of weights for 4x3 convolution.
    mkldnn_wino_wei_OBaaIBOIio 
} mkldnn_wino_memory_format_t;

typedef struct {
    mkldnn_wino_memory_format_t wino_format;
    int r;
    int alpha;
    int ic;
    int oc;
    int ic_block;
    int oc_block;
    int ic2_block;
    int oc2_block;
    float adj_scale;
    size_t size;
} mkldnn_wino_desc_t;

typedef enum {
    mkldnn_packed_format_undef = 0,
    mkldnn_ldigo_p,
    mkldnn_ldgoi_p
} mkldnn_rnn_packed_memory_format_t;

#define MKLDNN_RNN_MAX_N_PARTS 4

typedef struct {
    mkldnn_rnn_packed_memory_format_t format;
    int n_parts;
    int n;
    int ldb;
    int parts[MKLDNN_RNN_MAX_N_PARTS];
    size_t part_pack_size[MKLDNN_RNN_MAX_N_PARTS];
    unsigned pack_part[MKLDNN_RNN_MAX_N_PARTS];
    size_t offset_compensation;
    size_t size;
    char reserved[200];
} mkldnn_rnn_packed_desc_t;

typedef enum {
    mkldnn_memory_extra_flag_none = 0x0U,
    mkldnn_memory_extra_flag_compensation_conv_s8s8 = 0x1U,
    mkldnn_memory_extra_flag_scale_adjust = 0x2U,
} mkldnn_memory_extra_flags_t;

typedef struct {
    uint64_t flags;
    int compensation_mask;
    float scale_adjust;
    char reserved[64];
} mkldnn_memory_extra_desc_t;

typedef struct {
    int ndims;
    mkldnn_dims_t dims;

    mkldnn_data_type_t data_type;

    mkldnn_dims_t padded_dims;

    mkldnn_dims_t padded_offsets;

    mkldnn_dim_t offset0;

    mkldnn_format_kind_t format_kind;
    union {
        mkldnn_blocking_desc_t blocking;
        mkldnn_wino_desc_t wino_desc;
        mkldnn_rnn_packed_desc_t rnn_packed_desc;
        // ... other descriptions possible
    } format_desc;

    mkldnn_memory_extra_desc_t extra;
} mkldnn_memory_desc_t;

struct mkldnn_memory;

typedef struct mkldnn_memory *mkldnn_memory_t;

typedef const struct mkldnn_memory *const_mkldnn_memory_t;

#define MKLDNN_MEMORY_NONE (NULL)
#define MKLDNN_MEMORY_ALLOCATE ((void *)(size_t)-1)



typedef void *mkldnn_op_desc_t;
typedef const void *const_mkldnn_op_desc_t;

typedef struct {
    mkldnn_primitive_kind_t primitive_kind;
    mkldnn_prop_kind_t prop_kind;
    mkldnn_alg_kind_t alg_kind;
    mkldnn_memory_desc_t src_desc;
    mkldnn_memory_desc_t diff_src_desc;
    mkldnn_memory_desc_t weights_desc;
    mkldnn_memory_desc_t diff_weights_desc;
    mkldnn_memory_desc_t bias_desc;
    mkldnn_memory_desc_t diff_bias_desc;
    mkldnn_memory_desc_t dst_desc;
    mkldnn_memory_desc_t diff_dst_desc;
    mkldnn_dims_t strides;
    mkldnn_dims_t dilates;
    mkldnn_dims_t padding[2];
    mkldnn_data_type_t accum_data_type;
} mkldnn_convolution_desc_t;

typedef mkldnn_convolution_desc_t mkldnn_deconvolution_desc_t;

typedef struct {
    mkldnn_primitive_kind_t primitive_kind;
    mkldnn_prop_kind_t prop_kind;
    mkldnn_memory_desc_t data_desc;
    int axis;
    mkldnn_dim_t group_size;
} mkldnn_shuffle_desc_t;

typedef struct {
    mkldnn_primitive_kind_t primitive_kind;
    mkldnn_prop_kind_t prop_kind;
    mkldnn_alg_kind_t alg_kind;
    mkldnn_memory_desc_t data_desc;
    mkldnn_memory_desc_t diff_data_desc;
    float alpha, beta;
} mkldnn_eltwise_desc_t;

typedef struct {
    mkldnn_primitive_kind_t primitive_kind;
    mkldnn_prop_kind_t prop_kind;
    mkldnn_memory_desc_t data_desc;
    mkldnn_memory_desc_t diff_desc;
    int softmax_axis;
} mkldnn_softmax_desc_t;

typedef struct {
    mkldnn_primitive_kind_t primitive_kind;
    mkldnn_prop_kind_t prop_kind;
    mkldnn_alg_kind_t alg_kind;
    mkldnn_memory_desc_t src_desc;
    mkldnn_memory_desc_t diff_src_desc;
    mkldnn_memory_desc_t dst_desc;
    mkldnn_memory_desc_t diff_dst_desc;
    mkldnn_dims_t strides;
    mkldnn_dims_t kernel;
    mkldnn_dims_t padding[2];
    mkldnn_data_type_t accum_data_type;
} mkldnn_pooling_desc_t;

typedef struct {
    mkldnn_primitive_kind_t primitive_kind;
    mkldnn_prop_kind_t prop_kind;
    mkldnn_alg_kind_t alg_kind;
    mkldnn_memory_desc_t data_desc;
    mkldnn_memory_desc_t diff_data_desc;
    mkldnn_dim_t local_size;
    float lrn_alpha;
    float lrn_beta;
    float lrn_k;
} mkldnn_lrn_desc_t;

typedef struct {
    mkldnn_primitive_kind_t primitive_kind;
    mkldnn_prop_kind_t prop_kind;
    mkldnn_memory_desc_t data_desc;
    mkldnn_memory_desc_t diff_data_desc;
    mkldnn_memory_desc_t data_scaleshift_desc;
    mkldnn_memory_desc_t diff_data_scaleshift_desc;
    mkldnn_memory_desc_t stat_desc;
    float batch_norm_epsilon;
    unsigned flags;
} mkldnn_batch_normalization_desc_t;

typedef struct {
    mkldnn_primitive_kind_t primitive_kind;
    mkldnn_prop_kind_t prop_kind;
    mkldnn_memory_desc_t src_desc;
    mkldnn_memory_desc_t diff_src_desc;
    mkldnn_memory_desc_t weights_desc;
    mkldnn_memory_desc_t diff_weights_desc;
    mkldnn_memory_desc_t bias_desc;
    mkldnn_memory_desc_t diff_bias_desc;
    mkldnn_memory_desc_t dst_desc;
    mkldnn_memory_desc_t diff_dst_desc;
    mkldnn_data_type_t accum_data_type;
} mkldnn_inner_product_desc_t;

typedef enum {
    mkldnn_rnn_flags_undef = 0x0
} mkldnn_rnn_flags_t;

typedef enum {
    mkldnn_unidirectional_left2right,
    mkldnn_unidirectional_right2left,
    mkldnn_bidirectional_concat,
    mkldnn_bidirectional_sum,
    mkldnn_unidirectional = mkldnn_unidirectional_left2right,
} mkldnn_rnn_direction_t;

typedef struct {
    mkldnn_primitive_kind_t primitive_kind;
    mkldnn_prop_kind_t prop_kind;
    mkldnn_alg_kind_t cell_kind;
    mkldnn_rnn_direction_t direction;
    mkldnn_memory_desc_t src_layer_desc;
    mkldnn_memory_desc_t src_iter_desc;
    mkldnn_memory_desc_t src_iter_c_desc;
    mkldnn_memory_desc_t weights_layer_desc;
    mkldnn_memory_desc_t weights_iter_desc;
    mkldnn_memory_desc_t bias_desc;
    mkldnn_memory_desc_t dst_layer_desc;
    mkldnn_memory_desc_t dst_iter_desc;
    mkldnn_memory_desc_t dst_iter_c_desc;
    mkldnn_memory_desc_t placeholder_desc;
    mkldnn_memory_desc_t placeholder2_desc;

    mkldnn_memory_desc_t diff_src_layer_desc;
    mkldnn_memory_desc_t diff_src_iter_desc;
    mkldnn_memory_desc_t diff_src_iter_c_desc;
    mkldnn_memory_desc_t diff_weights_layer_desc;
    mkldnn_memory_desc_t diff_weights_iter_desc;
    mkldnn_memory_desc_t diff_bias_desc;
    mkldnn_memory_desc_t diff_dst_layer_desc;
    mkldnn_memory_desc_t diff_dst_iter_desc;
    mkldnn_memory_desc_t diff_dst_iter_c_desc;
    mkldnn_memory_desc_t diff_placeholder_desc;
    mkldnn_memory_desc_t diff_placeholder2_desc;

    unsigned int flags;
    mkldnn_alg_kind_t activation_kind;
    float alpha;
    float beta;

} mkldnn_rnn_desc_t;



typedef enum {
    mkldnn_any_engine,
    mkldnn_cpu,
    mkldnn_gpu,
} mkldnn_engine_kind_t;

struct mkldnn_engine;
typedef struct mkldnn_engine *mkldnn_engine_t;
#if 0
// FIXME: looks like this never happens
typedef const struct mkldnn_engine *const_mkldnn_engine_t;
#endif



struct mkldnn_primitive_desc_iterator;

typedef struct mkldnn_primitive_desc_iterator
    *mkldnn_primitive_desc_iterator_t;

typedef const struct mkldnn_primitive_desc_iterator
    *const_mkldnn_primitive_desc_iterator_t;



struct mkldnn_primitive_desc;

typedef struct mkldnn_primitive_desc *mkldnn_primitive_desc_t;

typedef const struct mkldnn_primitive_desc *const_mkldnn_primitive_desc_t;



typedef enum {
    mkldnn_scratchpad_mode_library,
    mkldnn_scratchpad_mode_user,
} mkldnn_scratchpad_mode_t;

struct mkldnn_primitive_attr;

typedef struct mkldnn_primitive_attr *mkldnn_primitive_attr_t;

typedef const struct mkldnn_primitive_attr *const_mkldnn_primitive_attr_t;

struct mkldnn_post_ops;

typedef struct mkldnn_post_ops *mkldnn_post_ops_t;

typedef const struct mkldnn_post_ops *const_mkldnn_post_ops_t;



struct mkldnn_primitive;
typedef struct mkldnn_primitive *mkldnn_primitive_t;
typedef const struct mkldnn_primitive *const_mkldnn_primitive_t;


#define MKLDNN_ARG_SRC_0                1
#define MKLDNN_ARG_SRC                  MKLDNN_ARG_SRC_0
#define MKLDNN_ARG_SRC_LAYER            MKLDNN_ARG_SRC_0
#define MKLDNN_ARG_FROM                 MKLDNN_ARG_SRC_0

#define MKLDNN_ARG_SRC_1                2
#define MKLDNN_ARG_SRC_ITER             MKLDNN_ARG_SRC_1

#define MKLDNN_ARG_SRC_2                3
#define MKLDNN_ARG_SRC_ITER_C           MKLDNN_ARG_SRC_2

#define MKLDNN_ARG_DST_0                17
#define MKLDNN_ARG_DST                  MKLDNN_ARG_DST_0
#define MKLDNN_ARG_TO                   MKLDNN_ARG_DST_0
#define MKLDNN_ARG_DST_LAYER            MKLDNN_ARG_DST_0

#define MKLDNN_ARG_DST_1                18
#define MKLDNN_ARG_DST_ITER             MKLDNN_ARG_DST_1

#define MKLDNN_ARG_DST_2                19
#define MKLDNN_ARG_DST_ITER_C           MKLDNN_ARG_DST_2

#define MKLDNN_ARG_WEIGHTS_0            33
#define MKLDNN_ARG_WEIGHTS              MKLDNN_ARG_WEIGHTS_0
#define MKLDNN_ARG_SCALE_SHIFT          MKLDNN_ARG_WEIGHTS_0
#define MKLDNN_ARG_WEIGHTS_LAYER        MKLDNN_ARG_WEIGHTS_0

#define MKLDNN_ARG_WEIGHTS_1            34
#define MKLDNN_ARG_WEIGHTS_ITER         MKLDNN_ARG_WEIGHTS_1

#define MKLDNN_ARG_BIAS                 41

#define MKLDNN_ARG_MEAN                 49
#define MKLDNN_ARG_VARIANCE             50

#define MKLDNN_ARG_WORKSPACE            64
#define MKLDNN_ARG_SCRATCHPAD           80

#define MKLDNN_ARG_DIFF_SRC_0           129
#define MKLDNN_ARG_DIFF_SRC             MKLDNN_ARG_DIFF_SRC_0
#define MKLDNN_ARG_DIFF_SRC_LAYER       MKLDNN_ARG_DIFF_SRC_0

#define MKLDNN_ARG_DIFF_SRC_1           130
#define MKLDNN_ARG_DIFF_SRC_ITER        MKLDNN_ARG_DIFF_SRC_1

#define MKLDNN_ARG_DIFF_SRC_2           131
#define MKLDNN_ARG_DIFF_SRC_ITER_C      MKLDNN_ARG_DIFF_SRC_2

#define MKLDNN_ARG_DIFF_DST_0           145
#define MKLDNN_ARG_DIFF_DST             MKLDNN_ARG_DIFF_DST_0
#define MKLDNN_ARG_DIFF_DST_LAYER       MKLDNN_ARG_DIFF_DST_0

#define MKLDNN_ARG_DIFF_DST_1           146
#define MKLDNN_ARG_DIFF_DST_ITER        MKLDNN_ARG_DIFF_DST_1

#define MKLDNN_ARG_DIFF_DST_2           147
#define MKLDNN_ARG_DIFF_DST_ITER_C      MKLDNN_ARG_DIFF_DST_2

#define MKLDNN_ARG_DIFF_WEIGHTS_0       161
#define MKLDNN_ARG_DIFF_WEIGHTS         MKLDNN_ARG_DIFF_WEIGHTS_0
#define MKLDNN_ARG_DIFF_SCALE_SHIFT     MKLDNN_ARG_DIFF_WEIGHTS_0
#define MKLDNN_ARG_DIFF_WEIGHTS_LAYER   MKLDNN_ARG_DIFF_WEIGHTS_0

#define MKLDNN_ARG_DIFF_WEIGHTS_1       162
#define MKLDNN_ARG_DIFF_WEIGHTS_ITER    MKLDNN_ARG_DIFF_WEIGHTS_1

#define MKLDNN_ARG_DIFF_BIAS            169

#define MKLDNN_ARG_MULTIPLE_SRC         1024
#define MKLDNN_ARG_MULTIPLE_DST         2048


typedef struct {
    int arg; 
    mkldnn_memory_t memory; 
} mkldnn_exec_arg_t;



typedef enum {
    mkldnn_query_undef = 0, 

    mkldnn_query_engine, 
    mkldnn_query_primitive_kind, 

    mkldnn_query_num_of_inputs_s32, 
    mkldnn_query_num_of_outputs_s32, 

    mkldnn_query_time_estimate_f64, 
    mkldnn_query_memory_consumption_s64, 

    mkldnn_query_scratchpad_engine, 

    mkldnn_query_impl_info_str, 

    // memory and op descriptor section
    mkldnn_query_some_d = 64, 
    mkldnn_query_op_d, 
    mkldnn_query_convolution_d, 
    mkldnn_query_deconvolution_d, 
    mkldnn_query_shuffle_d, 
    mkldnn_query_eltwise_d, 
    mkldnn_query_softmax_d, 
    mkldnn_query_pooling_d, 
    mkldnn_query_lrn_d, 
    mkldnn_query_batch_normalization_d, 
    mkldnn_query_inner_product_d, 
    mkldnn_query_rnn_d, 
    mkldnn_query_gemm_d, 

    // memory descriptor section
    mkldnn_query_some_md = 128, 
    mkldnn_query_src_md, 
    mkldnn_query_diff_src_md, 
    mkldnn_query_weights_md, 
    mkldnn_query_diff_weights_md, 
    mkldnn_query_dst_md, 
    mkldnn_query_diff_dst_md, 
    mkldnn_query_workspace_md, 
    mkldnn_query_scratchpad_md, 
} mkldnn_query_t;



typedef enum {
    mkldnn_stream_default_order = 0x1U,
    mkldnn_stream_in_order = 0x2U,
    mkldnn_stream_out_of_order = 0x4U,
    mkldnn_stream_default_flags = mkldnn_stream_default_order,
} mkldnn_stream_flags_t;

struct mkldnn_stream;
typedef struct mkldnn_stream *mkldnn_stream_t;
typedef const struct mkldnn_stream *const_mkldnn_stream_t;


#ifdef __cplusplus
}
#endif


#endif