mkldnn_types.h

Go to the documentation of this file.

/*******************************************************************************
* Copyright 2016-2018 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_try_again = 2,
    mkldnn_invalid_arguments = 3,
    mkldnn_not_ready = 4,
    mkldnn_unimplemented = 5,
    mkldnn_iterator_ends = 6,
    mkldnn_runtime_error = 7,
    mkldnn_not_required = 8,
} mkldnn_status_t;

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

typedef enum {
    mkldnn_round_nearest = 1,
    mkldnn_round_down = 2,
} mkldnn_round_mode_t;

typedef enum {
    mkldnn_format_undef = 0,
    mkldnn_any,
    mkldnn_blocked,
    mkldnn_x,
    mkldnn_nc,
    mkldnn_ncw,
    mkldnn_nwc,
    mkldnn_nchw,
    mkldnn_nhwc,
    mkldnn_chwn,
    mkldnn_ncdhw,
    mkldnn_ndhwc,
    mkldnn_oi,
    mkldnn_io,
    mkldnn_oiw,
    mkldnn_wio,
    mkldnn_oihw,
    mkldnn_hwio,
    mkldnn_ihwo,
    mkldnn_iohw,
    mkldnn_oidhw,
    mkldnn_dhwio,
    mkldnn_goiw,
    mkldnn_goihw,
    mkldnn_hwigo,
    mkldnn_giohw,
    mkldnn_goidhw,
    mkldnn_ntc,
    mkldnn_tnc,
    mkldnn_ldsnc,
    mkldnn_ldigo,
    mkldnn_ldgoi,
    mkldnn_ldgo,

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

    /* data */
    mkldnn_nCw4c ,
    mkldnn_nCw8c ,
    mkldnn_nCw16c ,
    mkldnn_nChw4c ,
    mkldnn_nChw8c ,
    mkldnn_nChw16c ,
    mkldnn_nCdhw4c ,
    mkldnn_nCdhw8c ,
    mkldnn_nCdhw16c ,

    /* weights, 3D */
    mkldnn_Owi4o ,
    mkldnn_OIw4i4o ,
    mkldnn_Owi8o ,
    mkldnn_OIw8i8o ,
    mkldnn_OIw8o8i ,
    mkldnn_OIw16i16o ,
    mkldnn_OIw16o16i ,
    mkldnn_Oiw4o ,
    mkldnn_Oiw16o ,
    mkldnn_Owi16o ,
    mkldnn_OIw8i16o2i ,
    mkldnn_OIw8o16i2o ,
    mkldnn_IOw16o16i ,
    mkldnn_OIw4i16o4i ,
    mkldnn_OIw4i16o4i_s8s8,

    /* weights, 4D */
    mkldnn_hwio_s8s8,
    mkldnn_oIhw8i ,
    mkldnn_oIhw16i ,
    mkldnn_OIhw4i4o ,
    mkldnn_OIhw8i8o ,
    mkldnn_OIhw16i16o ,
    mkldnn_OIhw4i16o4i ,
    mkldnn_OIhw4i16o4i_s8s8,
    mkldnn_OIhw8i16o2i ,
    mkldnn_OIhw8o16i2o ,
    mkldnn_OIhw8o8i ,
    mkldnn_OIhw16o16i ,
    mkldnn_IOhw16o16i ,
    mkldnn_Oihw8o ,
    mkldnn_Oihw4o ,
    mkldnn_Oihw16o ,
    mkldnn_Ohwi8o ,
    mkldnn_Ohwi4o ,
    mkldnn_Ohwi16o ,
    mkldnn_OhIw16o4i ,

    /* weights, 5D */
    mkldnn_oIdhw8i ,
    mkldnn_oIdhw16i ,
    mkldnn_OIdhw4i4o ,
    mkldnn_Odhwi4o ,
    mkldnn_OIdhw8i8o ,
    mkldnn_OIdhw8o8i ,
    mkldnn_Odhwi8o ,
    mkldnn_OIdhw16i16o ,
    mkldnn_OIdhw16o16i ,
    mkldnn_Oidhw4o ,
    mkldnn_Oidhw16o ,
    mkldnn_Odhwi16o ,
    mkldnn_OIdhw8i16o2i ,

    /* weights w/ groups, 4D */
    mkldnn_gOwi4o ,
    mkldnn_gOIw4i4o ,
    mkldnn_gOwi8o ,
    mkldnn_gOIw8o8i ,
    mkldnn_gOIw8i8o ,
    mkldnn_gOIw16i16o ,
    mkldnn_gOIw16o16i ,
    mkldnn_gOiw4o ,
    mkldnn_gOiw16o ,
    mkldnn_gOwi16o ,
    mkldnn_gOIw8i16o2i ,
    mkldnn_gOIw8o16i2o ,
    mkldnn_gIOw16o16i ,
    mkldnn_gOIw4i16o4i ,
    mkldnn_gOIw4i16o4i_s8s8,
    mkldnn_Goiw16g ,
    mkldnn_Goiw16g_s8s8,

    /* weights w/ groups, 5D */
    mkldnn_hwigo_s8s8,
    mkldnn_gOIhw4i4o ,
    mkldnn_gOIhw8i8o ,
    mkldnn_gOIhw16i16o ,
    mkldnn_gOIhw4i16o4i ,
    mkldnn_gOIhw4i16o4i_s8s8,
    mkldnn_gOIhw2i8o4i ,
    mkldnn_gOIhw2i8o4i_s8s8,
    mkldnn_gOIhw8i16o2i ,
    mkldnn_gOIhw8o16i2o ,
    mkldnn_gOIhw4o4i ,
    mkldnn_gOIhw4o4i_s8s8 ,
    mkldnn_gOIhw8o8i ,
    mkldnn_gOIhw16o16i ,
    mkldnn_gIOhw16o16i ,
    mkldnn_gOihw8o ,
    mkldnn_gOihw4o ,
    mkldnn_gOihw16o ,
    mkldnn_gOhwi8o ,
    mkldnn_gOhwi4o ,
    mkldnn_gOhwi16o ,
    mkldnn_Goihw8g ,
    mkldnn_Goihw16g ,
    mkldnn_Goihw16g_s8s8,
    mkldnn_gOhIw16o4i ,

    /* weights w/ groups, 6D */
    mkldnn_gOIdhw4i4o ,
    mkldnn_gOdhwi4o ,
    mkldnn_gOIdhw8i8o ,
    mkldnn_gOIdhw8o8i ,
    mkldnn_gOdhwi8o ,
    mkldnn_gOIdhw8i16o2i ,
    mkldnn_gOIdhw16i16o ,
    mkldnn_gOIdhw16o16i ,
    mkldnn_gOidhw4o ,
    mkldnn_gOidhw16o ,
    mkldnn_gOdhwi16o ,

    mkldnn_wino_fmt ,

    mkldnn_rnn_packed ,

    mkldnn_format_last,
} mkldnn_memory_format_t;

typedef enum {
    mkldnn_padding_zero,
} mkldnn_padding_kind_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_memory,
    mkldnn_view,
    mkldnn_reorder,
    mkldnn_shuffle,
    mkldnn_concat,
    mkldnn_concat_inplace,
    mkldnn_sum,
    mkldnn_convolution,
    mkldnn_deconvolution,
    mkldnn_eltwise,
    mkldnn_softmax,
    mkldnn_pooling,
    mkldnn_lrn,
    mkldnn_batch_normalization,
    mkldnn_inner_product,
    mkldnn_rnn,
} 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_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_gru_linear_before_reset = 0x4fff,
} mkldnn_alg_kind_t;

typedef enum {
    mkldnn_use_global_stats = 0x1U,
    mkldnn_use_scaleshift = 0x2U,
    mkldnn_fuse_bn_relu = 0x4U,
} mkldnn_batch_normalization_flag_t;

#define TENSOR_MAX_DIMS 12

typedef int mkldnn_dims_t[TENSOR_MAX_DIMS];
typedef ptrdiff_t mkldnn_strides_t[TENSOR_MAX_DIMS];

typedef struct {
    mkldnn_dims_t block_dims;
    mkldnn_strides_t strides[2];
    mkldnn_dims_t padding_dims;
    mkldnn_dims_t offset_padding_to_data;
    ptrdiff_t offset_padding;
} mkldnn_blocking_desc_t;

typedef enum {
    mkldnn_wino_undef = 0,
    mkldnn_wino_wei_aaOIoi,
    mkldnn_wino_wei_aaOio,
    mkldnn_wino_wei_aaOBiOo,
    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;

/* Maximum number of parts of RNN weights tensor that require separate
 * computation. */
#define MKLDNN_RNN_MAX_N_PARTS 4

typedef struct {
    mkldnn_rnn_packed_memory_format_t format;
    int n_parts;
    int n;
    int parts[MKLDNN_RNN_MAX_N_PARTS];
    size_t part_pack_size[MKLDNN_RNN_MAX_N_PARTS];
    size_t offset_compensation;
    size_t size;
} mkldnn_rnn_packed_desc_t;

typedef void *mkldnn_op_desc_t;
typedef const void *const_mkldnn_op_desc_t;

typedef struct {
    mkldnn_primitive_kind_t primitive_kind;
    int ndims;
    mkldnn_dims_t dims;
    mkldnn_data_type_t data_type;
    mkldnn_memory_format_t format;
    union {
        mkldnn_blocking_desc_t blocking;
        mkldnn_wino_desc_t wino_desc;
        mkldnn_rnn_packed_desc_t rnn_packed_desc;
        /* ... other descriptions possible */
    } layout_desc;
} mkldnn_memory_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_padding_kind_t padding_kind;
    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;
    int 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_padding_kind_t padding_kind;
    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;
    int 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 mean_desc;
    mkldnn_memory_desc_t variance_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_cell_with_relu = 0x1U,
    mkldnn_rnn_cell_with_clipping = 0x2U,
} mkldnn_rnn_cell_flags_t;

typedef struct {
    mkldnn_alg_kind_t cell_kind;
    mkldnn_alg_kind_t activation_kind;
    unsigned int flags;
    float alpha;
    float clipping;
} mkldnn_rnn_cell_desc_t;

typedef enum {
    /* Unidirectional execution of RNN primitive from left to right. */
    mkldnn_unidirectional_left2right,
    /* Unidirectional execution of RNN primitive from right to left. */
    mkldnn_unidirectional_right2left,
    /* Bidirectional execution of RNN primitive with concatenation of the
     * results. */
    mkldnn_bidirectional_concat,
    /* Bidirectional execution of RNN primitive with summation of the
     * results. */
    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_rnn_cell_desc_t cell_desc;
    mkldnn_rnn_direction_t direction;
    mkldnn_memory_desc_t src_layer_desc;
    mkldnn_memory_desc_t src_iter_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 diff_src_layer_desc;
    mkldnn_memory_desc_t diff_src_iter_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_rnn_desc_t;

typedef enum {
    mkldnn_any_engine,
    mkldnn_cpu,
} 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;

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;

typedef struct {
    const_mkldnn_primitive_t primitive;
    size_t output_index;
} mkldnn_primitive_at_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_impl_info_str, 
    /* memory and op descriptor section */
    mkldnn_query_some_d = 64, 
    mkldnn_query_op_d, 
    mkldnn_query_memory_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, 
    /* (memory) primitive descriptor section */
    mkldnn_query_some_pd = 128, 
    mkldnn_query_input_pd, 
    mkldnn_query_output_pd, 
    mkldnn_query_src_pd, 
    mkldnn_query_diff_src_pd, 
    mkldnn_query_weights_pd, 
    mkldnn_query_diff_weights_pd, 
    mkldnn_query_dst_pd, 
    mkldnn_query_diff_dst_pd, 
    mkldnn_query_workspace_pd, 
} mkldnn_query_t;

typedef enum {
    mkldnn_any_stream,
    mkldnn_eager,
    mkldnn_lazy,
} mkldnn_stream_kind_t;

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

#ifdef __cplusplus
}
#endif


#endif