.rst .pdf

Global Namespace

// namespaces

namespace dnnl;
    namespace dnnl::ocl_interop;
    namespace dnnl::sycl_interop;
    namespace dnnl::threadpool_interop;
namespace oneapi;
namespace std;
namespace sycl;

// typedefs

typedef memory::format_tag tag;
typedef memory::data_type dt;
typedef dnnl::memory::dim dim_t;
typedef dnnl::memory::dim dim_t;
typedef memory::format_tag tag;
typedef memory::data_type dt;
typedef memory::format_tag tag;
typedef memory::data_type dt;
typedef memory::format_tag tag;
typedef memory::data_type dt;
typedef memory::format_tag tag;
typedef memory::data_type dt;
typedef memory::format_tag tag;
typedef memory::data_type dt;
typedef memory::format_tag tag;
typedef memory::data_type dt;
typedef memory::format_tag tag;
typedef memory::data_type dt;
typedef memory::format_tag tag;
typedef memory::data_type dt;
typedef memory::format_tag tag;
typedef memory::data_type dt;
typedef memory::format_tag tag;
typedef memory::data_type dt;
typedef memory::format_tag tag;
typedef memory::data_type dt;
typedef memory::format_tag tag;
typedef memory::data_type dt;
typedef memory::format_tag tag;
typedef memory::data_type dt;
typedef memory::format_tag tag;
typedef memory::data_type dt;
typedef memory::format_tag tag;
typedef memory::data_type dt;
typedef memory::format_tag tag;
typedef memory::data_type dt;
typedef memory::format_tag tag;
typedef memory::data_type dt;
typedef memory::format_tag tag;
typedef memory::data_type dt;
typedef memory::format_tag tag;
typedef memory::data_type dt;
typedef int64_t dnnl_dim_t;
typedef dnnl_dim_t dnnl_dims_t[DNNL_MAX_NDIMS];
typedef struct dnnl_memory* dnnl_memory_t;
typedef const struct dnnl_memory* const_dnnl_memory_t;
typedef void* dnnl_op_desc_t;
typedef const void* const_dnnl_op_desc_t;
typedef dnnl_convolution_desc_t dnnl_deconvolution_desc_t;
typedef dnnl_softmax_desc_t dnnl_logsoftmax_desc_t;
typedef struct dnnl_engine* dnnl_engine_t;
typedef struct dnnl_primitive_desc_iterator* dnnl_primitive_desc_iterator_t;
typedef const struct dnnl_primitive_desc_iterator* const_dnnl_primitive_desc_iterator_t;
typedef struct dnnl_primitive_desc* dnnl_primitive_desc_t;
typedef const struct dnnl_primitive_desc* const_dnnl_primitive_desc_t;
typedef struct dnnl_primitive_attr* dnnl_primitive_attr_t;
typedef const struct dnnl_primitive_attr* const_dnnl_primitive_attr_t;
typedef struct dnnl_post_ops* dnnl_post_ops_t;
typedef const struct dnnl_post_ops* const_dnnl_post_ops_t;
typedef struct dnnl_primitive* dnnl_primitive_t;
typedef const struct dnnl_primitive* const_dnnl_primitive_t;
typedef struct dnnl_stream* dnnl_stream_t;
typedef const struct dnnl_stream* const_dnnl_stream_t;

// enums

enum dnnl_alg_kind_t;
enum dnnl_cpu_isa_hints_t;
enum dnnl_cpu_isa_t;
enum dnnl_data_type_t;
enum dnnl_engine_kind_t;
enum dnnl_format_kind_t;
enum dnnl_format_tag_t;
enum dnnl_fpmath_mode_t;
enum dnnl_memory_extra_flags_t;
enum dnnl_normalization_flags_t;
enum dnnl_ocl_interop_memory_kind_t;
enum dnnl_primitive_kind_t;
enum dnnl_prop_kind_t;
enum dnnl_query_t;
enum dnnl_rnn_direction_t;
enum dnnl_rnn_flags_t;
enum dnnl_rnn_packed_memory_format_t;
enum dnnl_scratchpad_mode_t;
enum dnnl_status_t;
enum dnnl_stream_flags_t;
enum dnnl_sycl_interop_memory_kind_t;
enum dnnl_wino_memory_format_t;
enum q10n_scheme_t;

// structs

struct args_t;
struct dnnl_batch_normalization_desc_t;
struct dnnl_binary_desc_t;
struct dnnl_blocking_desc_t;
struct dnnl_convolution_desc_t;
struct dnnl_eltwise_desc_t;
struct dnnl_engine;
struct dnnl_exec_arg_t;
struct dnnl_inner_product_desc_t;
struct dnnl_layer_normalization_desc_t;
struct dnnl_lrn_desc_t;
struct dnnl_matmul_desc_t;
struct dnnl_memory;
struct dnnl_memory_desc_t;
struct dnnl_memory_extra_desc_t;
struct dnnl_pooling_desc_t;
struct dnnl_pooling_v2_desc_t;
struct dnnl_post_ops;
struct dnnl_prelu_desc_t;
struct dnnl_primitive;
struct dnnl_primitive_attr;
struct dnnl_primitive_desc;
struct dnnl_primitive_desc_iterator;
struct dnnl_reduction_desc_t;
struct dnnl_resampling_desc_t;
struct dnnl_rnn_desc_t;
struct dnnl_rnn_packed_desc_t;
struct dnnl_shuffle_desc_t;
struct dnnl_softmax_desc_t;
struct dnnl_stream;
struct dnnl_version_t;
struct dnnl_wino_desc_t;
struct example_allows_unimplemented;

// global variables

const dim_t batch = 32;
const dim_t src_seq_length_max = 10;
const dim_t tgt_seq_length_max = 10;
const dim_t feature_size = 256;
const dim_t enc_bidir_n_layers = 1;
const dim_t enc_unidir_n_layers = 3;
const dim_t dec_n_layers = 4;
const int lstm_n_gates = 4;
const dim_t batch = 32;
const dim_t src_seq_length_max = 10;
const dim_t tgt_seq_length_max = 10;
const dim_t feature_size = 256;
const dim_t enc_bidir_n_layers = 1;
const dim_t enc_unidir_n_layers = 3;
const dim_t dec_n_layers = 4;
const int lstm_n_gates = 4;
const memory::dims strides = {4, 4};
const memory::dims padding = {0, 0};
const int N0 = 1 + rand() % 31;
const int N1 = 1 + rand() % 31;
const int T0 = 31 + 1 + rand() % 31;
const int T1 = 1 + rand() % 31;
const int leftmost_batch = N0 + N1;
const int rightmost_batch = N0;
const int leftmost_seq_length = T1;
const int rightmost_seq_length = T0 - T1;
const int common_feature_size = 1024;
const int common_n_layers = 1;
const int lstm_n_gates = 4;
engine eng(engine::kind::cpu, 0);
int number_of_runs = 1;
float fixed_beta = 0.f;
engine eng(engine::kind::cpu, 0);
int number_of_runs = 1;

// global functions

void bnorm_u8_via_binary_postops(dnnl::engine::kind engine_kind);
int main(int argc, char** argv);
static size_t product(dnnl_dim_t* arr, size_t size);
static void init_net_data(float* data, uint32_t dim, const dnnl_dim_t* dims);
static void prepare_arg_node(args_t* node, int nargs);
static void free_arg_node(args_t* node);
static void set_arg(dnnl_exec_arg_t* arg, int arg_idx, dnnl_memory_t memory);

static void init_data_memory(
    uint32_t dim,
    const dnnl_dim_t* dims,
    dnnl_format_tag_t user_tag,
    dnnl_engine_t engine,
    float* data,
    dnnl_memory_t* memory
    );

dnnl_status_t prepare_reorder(
    dnnl_memory_t* user_memory,
    const dnnl_memory_desc_t* prim_memory_md,
    dnnl_engine_t prim_engine,
    int dir_is_user_to_prim,
    dnnl_memory_t* prim_memory,
    dnnl_primitive_t* reorder,
    uint32_t* net_index,
    dnnl_primitive_t* net,
    args_t* net_args
    );

void simple_net(dnnl_engine_kind_t engine_kind);
int main(int argc, char** argv);
void cnn_inference_f32(engine::kind engine_kind);
int main(int argc, char** argv);
int main(int argc, char** argv);
void simple_net(engine::kind engine_kind);
int main(int argc, char** argv);
void simple_net(engine::kind engine_kind);
int main(int argc, char** argv);
static size_t product(dnnl_dim_t* arr, size_t size);
static void init_net_data(float* data, uint32_t dim, const dnnl_dim_t* dims);
static void prepare_arg_node(args_t* node, int nargs);
static void free_arg_node(args_t* node);
static void set_arg(dnnl_exec_arg_t* arg, int arg_idx, dnnl_memory_t memory);

static void init_data_memory(
    uint32_t dim,
    const dnnl_dim_t* dims,
    dnnl_format_tag_t user_tag,
    dnnl_engine_t engine,
    float* data,
    dnnl_memory_t* memory
    );

dnnl_status_t prepare_reorder(
    dnnl_memory_t* user_memory,
    const dnnl_memory_desc_t* prim_memory_md,
    dnnl_engine_t prim_engine,
    int dir_is_user_to_prim,
    dnnl_memory_t* prim_memory,
    dnnl_primitive_t* reorder,
    uint32_t* net_index,
    dnnl_primitive_t* net,
    args_t* net_args
    );

void simple_net();
int main(int argc, char** argv);
std::vector<float> weighted_src_layer(batch* feature_size, 1. 0f);

std::vector<float> alignment_model(
    src_seq_length_max*batch* feature_size,
    1. 0f
    );

std::vector<float> alignments(src_seq_length_max* batch, 1. 0f);
std::vector<float> exp_sums(batch, 1. 0f);

void compute_weighted_annotations(
    float* weighted_annotations,
    dim_t src_seq_length_max,
    dim_t batch,
    dim_t feature_size,
    float* weights_annot,
    float* annotations
    );

void compute_attention(
    float* context_vectors,
    dim_t src_seq_length_max,
    dim_t batch,
    dim_t feature_size,
    float* weights_src_layer,
    float* dec_src_layer,
    float* annotations,
    float* weighted_annotations,
    float* weights_alignments
    );

void copy_context(
    float* src_iter,
    dim_t n_layers,
    dim_t batch,
    dim_t feature_size
    );

int main(int argc, char** argv);
std::vector<int32_t> weighted_src_layer(batch* feature_size, 1);

std::vector<float> alignment_model(
    src_seq_length_max*batch* feature_size,
    1. 0f
    );

std::vector<float> alignments(src_seq_length_max* batch, 1. 0f);
std::vector<float> exp_sums(batch, 1. 0f);

void compute_weighted_annotations(
    float* weighted_annotations,
    dim_t src_seq_length_max,
    dim_t batch,
    dim_t feature_size,
    float* weights_annot,
    float* annotations
    );

void compute_sum_of_rows(int8_t* a, dim_t rows, dim_t cols, int32_t* a_reduced);

void compute_attention(
    float* context_vectors,
    dim_t src_seq_length_max,
    dim_t batch,
    dim_t feature_size,
    int8_t* weights_src_layer,
    float weights_src_layer_scale,
    int32_t* compensation,
    uint8_t* dec_src_layer,
    float dec_src_layer_scale,
    float dec_src_layer_shift,
    uint8_t* annotations,
    float* weighted_annotations,
    float* weights_alignments
    );

void copy_context(
    float* src_iter,
    dim_t n_layers,
    dim_t batch,
    dim_t feature_size
    );

int main(int argc, char** argv);
size_t product(int n_dims, const dnnl_dim_t dims[]);
void fill(dnnl_memory_t mem, int n_dims, const dnnl_dim_t dims[]);
int find_negative(dnnl_memory_t mem, int n_dims, const dnnl_dim_t dims[]);
void cross_engine_reorder();
int main();
void fill(memory& mem, const memory::dims& adims);
int find_negative(memory& mem, const memory::dims& adims);
int main(int argc, char** argv);
static dnnl_engine_kind_t validate_engine_kind(dnnl_engine_kind_t akind);
static dnnl_engine_kind_t parse_engine_kind(int argc, char** argv);
static const char* engine_kind2str_upper(dnnl_engine_kind_t kind);
static void read_from_dnnl_memory(void* handle, dnnl_memory_t mem);
static void write_to_dnnl_memory(void* handle, dnnl_memory_t mem);
dnnl::engine::kind validate_engine_kind(dnnl::engine::kind akind);
const char* engine_kind2str_upper(dnnl::engine::kind kind);

int handle_example_errors(
    std::initializer_list<dnnl::engine::kind> engine_kinds,
    std::function<void()> example
    );

int handle_example_errors(
    std::function<void(dnnl::engine::kind, int, char**)> example,
    dnnl::engine::kind engine_kind,
    int argc,
    char** argv
    );

int handle_example_errors(
    std::function<void(dnnl::engine::kind)> example,
    dnnl::engine::kind engine_kind
    );

dnnl::engine::kind parse_engine_kind(int argc, char** argv, int extra_args = 0);
dnnl::memory::dim product(const dnnl::memory::dims& dims);
void read_from_dnnl_memory(void* handle, dnnl::memory& mem);
void write_to_dnnl_memory(void* handle, dnnl::memory& mem);
int main(int argc, char** argv);

cl_kernel create_init_opencl_kernel(
    cl_context ocl_ctx,
    const char* kernel_name,
    const char* ocl_code
    );

int main(int argc, char** argv);
int main(int argc, char** argv);
void init_data(memory& m, float v);
void create_and_execute_relu(memory& data, engine& eng, stream& s);
primitive_attr create_attr_with_relu_post_op();
void performance_profiling(engine::kind engine_kind, int argc, char** argv);
int main(int argc, char** argv);
void batch_normalization_example(dnnl::engine::kind engine_kind);
int main(int argc, char** argv);
void binary_example(dnnl::engine::kind engine_kind);
int main(int argc, char** argv);
void concat_example(dnnl::engine::kind engine_kind);
int main(int argc, char** argv);
void convolution_example(dnnl::engine::kind engine_kind);
void depthwise_convolution_example(dnnl::engine::kind engine_kind);
int main(int argc, char** argv);
void eltwise_example(dnnl::engine::kind engine_kind);
int main(int argc, char** argv);
void inner_product_example(dnnl::engine::kind engine_kind);
int main(int argc, char** argv);
void layer_normalization_example(dnnl::engine::kind engine_kind);
int main(int argc, char** argv);
void logsoftmax_example(dnnl::engine::kind engine_kind);
int main(int argc, char** argv);
void lrn_example(dnnl::engine::kind engine_kind);
int main(int argc, char** argv);
void lstm_example(dnnl::engine::kind engine_kind);
int main(int argc, char** argv);
void matmul_example(dnnl::engine::kind engine_kind);
int main(int argc, char** argv);
void pooling_example(dnnl::engine::kind engine_kind);
int main(int argc, char** argv);
void prelu_example(dnnl::engine::kind engine_kind);
int main(int argc, char** argv);
void reduction_example(dnnl::engine::kind engine_kind);
int main(int argc, char** argv);
void reorder_example(dnnl::engine::kind engine_kind);
int main(int argc, char** argv);
void resampling_example(dnnl::engine::kind engine_kind);
int main(int argc, char** argv);
void shuffle_example(dnnl::engine::kind engine_kind);
int main(int argc, char** argv);
void softmax_example(dnnl::engine::kind engine_kind);
int main(int argc, char** argv);
void sum_example(dnnl::engine::kind engine_kind);
int main(int argc, char** argv);
void simple_net(engine::kind engine_kind);
int main(int argc, char** argv);
int main(int argc, char** argv);
void sycl_usm_tutorial(engine::kind engine_kind);
int main(int argc, char** argv);

void quantize(
    q10n_scheme_t q10n_scheme,
    const std::vector<float>& X_f32,
    float scale_X,
    int32_t zp_X,
    memory& X_int_m
    );

void f32_matmul_compute(
    int64_t M,
    int64_t N,
    int64_t K,
    const std::vector<float>& A_f32,
    const std::vector<float>& B_f32,
    std::vector<float>& C_f32
    );

void dynamic_q10n_matmul(
    int64_t M,
    int64_t N,
    int64_t K,
    const std::vector<float>& A_f32,
    const std::vector<float>& B_f32,
    std::vector<uint8_t>& C_u8,
    float& scale_C,
    int32_t& zp_C
    );

void static_q10n_matmul(
    int64_t M,
    int64_t N,
    int64_t K,
    const std::vector<float>& A_f32,
    const std::vector<float>& B_f32,
    float scale_A,
    int32_t zp_A,
    float scale_B,
    float scale_C,
    int32_t zp_C,
    std::vector<uint8_t>& C_u8
    );

void compare_f32_and_quantized_matmuls();
int main(int argc, char** argv);
matmul dynamic_matmul_create();

void dynamic_matmul_execute(
    matmul& matmul_p,
    char transA,
    char transB,
    int64_t M,
    int64_t N,
    int64_t K,
    float alpha,
    const float* A,
    int64_t lda,
    const float* B,
    int64_t ldb,
    float beta,
    float* C,
    int64_t ldc
    );

void static_matmul_create_and_execute(
    char transA,
    char transB,
    int64_t M,
    int64_t N,
    int64_t K,
    float alpha,
    const float* A,
    int64_t lda,
    const float* B,
    int64_t ldb,
    float beta,
    float* C,
    int64_t ldc
    );

void sgemm_and_matmul_with_params(
    char transA,
    char transB,
    int64_t M,
    int64_t N,
    int64_t K,
    float alpha,
    float beta
    );

void sgemm_and_matmul();
int main(int argc, char** argv);
matmul::primitive_desc matmul_pd_create(int64_t K, int64_t N, const engine& eng);

void prepare_input(
    memory& A_u8_mem,
    memory& scale_f32_mem,
    memory& zp_A_mem,
    memory& zp_C_mem
    );

void sanity_check(memory& C_u8_mem, memory& zp_C_mem);

void infer(
    const matmul& matmul_p,
    int64_t M,
    int64_t N,
    int64_t K,
    const memory& B_s8_mem,
    const engine& eng
    );

void inference_int8_matmul(engine::kind engine_kind);
int main(int argc, char** argv);

dnnl_status_t DNNL_API dnnl_primitive_desc_iterator_create(
    dnnl_primitive_desc_iterator_t* iterator,
    const_dnnl_op_desc_t op_desc,
    const_dnnl_primitive_attr_t attr,
    dnnl_engine_t engine,
    const_dnnl_primitive_desc_t hint_forward_primitive_desc
    );

dnnl_status_t DNNL_API dnnl_primitive_desc_iterator_next(dnnl_primitive_desc_iterator_t iterator);
dnnl_primitive_desc_t DNNL_API dnnl_primitive_desc_iterator_fetch(const_dnnl_primitive_desc_iterator_t iterator);
dnnl_status_t DNNL_API dnnl_primitive_desc_iterator_destroy(dnnl_primitive_desc_iterator_t iterator);

dnnl_status_t DNNL_API dnnl_primitive_desc_create(
    dnnl_primitive_desc_t* primitive_desc,
    const_dnnl_op_desc_t op_desc,
    const_dnnl_primitive_attr_t attr,
    dnnl_engine_t engine,
    const_dnnl_primitive_desc_t hint_forward_primitive_desc
    );

dnnl_status_t DNNL_API dnnl_primitive_desc_clone(
    dnnl_primitive_desc_t* primitive_desc,
    const_dnnl_primitive_desc_t existing_primitive_desc
    );

dnnl_status_t DNNL_API dnnl_primitive_desc_get_attr(
    const_dnnl_primitive_desc_t primitive_desc,
    const_dnnl_primitive_attr_t* attr
    );

dnnl_status_t DNNL_API dnnl_primitive_desc_destroy(dnnl_primitive_desc_t primitive_desc);

dnnl_status_t DNNL_API dnnl_primitive_desc_query(
    const_dnnl_primitive_desc_t primitive_desc,
    dnnl_query_t what,
    int index,
    void* result
    );

const dnnl_memory_desc_t DNNL_API* dnnl_primitive_desc_query_md(
    const_dnnl_primitive_desc_t primitive_desc,
    dnnl_query_t what,
    int index
    );

int DNNL_API dnnl_primitive_desc_query_s32(
    const_dnnl_primitive_desc_t primitive_desc,
    dnnl_query_t what,
    int index
    );

dnnl_status_t DNNL_API dnnl_primitive_create(
    dnnl_primitive_t* primitive,
    const_dnnl_primitive_desc_t primitive_desc
    );

dnnl_status_t DNNL_API dnnl_primitive_execute(
    const_dnnl_primitive_t primitive,
    dnnl_stream_t stream,
    int nargs,
    const dnnl_exec_arg_t* args
    );

dnnl_status_t DNNL_API dnnl_primitive_get_primitive_desc(
    const_dnnl_primitive_t primitive,
    const_dnnl_primitive_desc_t* primitive_desc
    );

dnnl_status_t DNNL_API dnnl_primitive_destroy(dnnl_primitive_t primitive);
dnnl_status_t DNNL_API dnnl_primitive_attr_create(dnnl_primitive_attr_t* attr);

dnnl_status_t DNNL_API dnnl_primitive_attr_clone(
    dnnl_primitive_attr_t* attr,
    const_dnnl_primitive_attr_t existing_attr
    );

dnnl_status_t DNNL_API dnnl_primitive_attr_destroy(dnnl_primitive_attr_t attr);

dnnl_status_t DNNL_API dnnl_primitive_attr_get_fpmath_mode(
    const_dnnl_primitive_attr_t attr,
    dnnl_fpmath_mode_t* mode
    );

dnnl_status_t DNNL_API dnnl_primitive_attr_set_fpmath_mode(
    dnnl_primitive_attr_t attr,
    dnnl_fpmath_mode_t mode
    );

dnnl_status_t DNNL_API dnnl_primitive_attr_get_scratchpad_mode(
    const_dnnl_primitive_attr_t attr,
    dnnl_scratchpad_mode_t* mode
    );

dnnl_status_t DNNL_API dnnl_primitive_attr_set_scratchpad_mode(
    dnnl_primitive_attr_t attr,
    dnnl_scratchpad_mode_t mode
    );

dnnl_status_t DNNL_API dnnl_primitive_attr_get_output_scales(
    const_dnnl_primitive_attr_t attr,
    dnnl_dim_t* count,
    int* mask,
    const float** scales
    );

dnnl_status_t DNNL_API dnnl_primitive_attr_set_output_scales(
    dnnl_primitive_attr_t attr,
    dnnl_dim_t count,
    int mask,
    const float* scales
    );

dnnl_status_t DNNL_API dnnl_primitive_attr_get_scales(
    dnnl_primitive_attr_t attr,
    int arg,
    dnnl_dim_t* count,
    int* mask,
    const float** scales
    );

dnnl_status_t DNNL_API dnnl_primitive_attr_set_scales(
    dnnl_primitive_attr_t attr,
    int arg,
    dnnl_dim_t count,
    int mask,
    const float* scales
    );

dnnl_status_t DNNL_API dnnl_primitive_attr_get_zero_points(
    const_dnnl_primitive_attr_t attr,
    int arg,
    dnnl_dim_t* count,
    int* mask,
    const int32_t** zero_points
    );

dnnl_status_t DNNL_API dnnl_primitive_attr_set_zero_points(
    dnnl_primitive_attr_t attr,
    int arg,
    dnnl_dim_t count,
    int mask,
    const int32_t* zero_points
    );

dnnl_status_t DNNL_API dnnl_primitive_attr_get_post_ops(
    const_dnnl_primitive_attr_t attr,
    const_dnnl_post_ops_t* post_ops
    );

dnnl_status_t DNNL_API dnnl_primitive_attr_set_post_ops(
    dnnl_primitive_attr_t attr,
    const_dnnl_post_ops_t post_ops
    );

dnnl_status_t DNNL_API dnnl_post_ops_create(dnnl_post_ops_t* post_ops);
dnnl_status_t DNNL_API dnnl_post_ops_destroy(dnnl_post_ops_t post_ops);
int DNNL_API dnnl_post_ops_len(const_dnnl_post_ops_t post_ops);

dnnl_primitive_kind_t DNNL_API dnnl_post_ops_get_kind(
    const_dnnl_post_ops_t post_ops,
    int index
    );

dnnl_status_t DNNL_API dnnl_post_ops_append_sum(
    dnnl_post_ops_t post_ops,
    float scale
    );

dnnl_status_t DNNL_API dnnl_post_ops_append_sum_v2(
    dnnl_post_ops_t post_ops,
    float scale,
    dnnl_data_type_t data_type
    );

dnnl_status_t DNNL_API dnnl_post_ops_append_sum_v3(
    dnnl_post_ops_t post_ops,
    float scale,
    int32_t zero_point,
    dnnl_data_type_t data_type
    );

dnnl_status_t DNNL_API dnnl_post_ops_get_params_sum(
    const_dnnl_post_ops_t post_ops,
    int index,
    float* scale
    );

dnnl_status_t DNNL_API dnnl_post_ops_get_params_sum_v2(
    const_dnnl_post_ops_t post_ops,
    int index,
    float* scale,
    dnnl_data_type_t* data_type
    );

dnnl_status_t DNNL_API dnnl_post_ops_get_params_sum_v3(
    const_dnnl_post_ops_t post_ops,
    int index,
    float* scale,
    int32_t* zero_point,
    dnnl_data_type_t* data_type
    );

dnnl_status_t DNNL_API dnnl_post_ops_append_eltwise(
    dnnl_post_ops_t post_ops,
    float scale,
    dnnl_alg_kind_t alg_kind,
    float alpha,
    float beta
    );

dnnl_status_t DNNL_API dnnl_post_ops_get_params_eltwise(
    const_dnnl_post_ops_t post_ops,
    int index,
    float* scale,
    dnnl_alg_kind_t* alg_kind,
    float* alpha,
    float* beta
    );

dnnl_status_t DNNL_API dnnl_post_ops_append_dw_k3s1p1(
    dnnl_post_ops_t post_ops,
    dnnl_data_type_t weights_data_type,
    dnnl_data_type_t bias_data_type,
    dnnl_data_type_t dst_data_type,
    dnnl_dim_t count,
    int mask,
    const float* scales
    );

dnnl_status_t DNNL_API dnnl_post_ops_get_params_dw_k3s1p1(
    const_dnnl_post_ops_t post_ops,
    int index,
    dnnl_data_type_t* weights_data_type,
    dnnl_data_type_t* bias_data_type,
    dnnl_data_type_t* dst_data_type,
    dnnl_dim_t* count,
    int* mask,
    const float** scales
    );

dnnl_status_t DNNL_API dnnl_post_ops_append_dw_k3s2p1(
    dnnl_post_ops_t post_ops,
    dnnl_data_type_t weights_data_type,
    dnnl_data_type_t bias_data_type,
    dnnl_data_type_t dst_data_type,
    dnnl_dim_t count,
    int mask,
    const float* scales
    );

dnnl_status_t DNNL_API dnnl_post_ops_get_params_dw_k3s2p1(
    const_dnnl_post_ops_t post_ops,
    int index,
    dnnl_data_type_t* weights_data_type,
    dnnl_data_type_t* bias_data_type,
    dnnl_data_type_t* dst_data_type,
    dnnl_dim_t* count,
    int* mask,
    const float** scales
    );

dnnl_status_t DNNL_API dnnl_post_ops_append_binary(
    dnnl_post_ops_t post_ops,
    dnnl_alg_kind_t alg_kind,
    const dnnl_memory_desc_t* src1_desc
    );

dnnl_status_t DNNL_API dnnl_post_ops_get_params_binary(
    const_dnnl_post_ops_t post_ops,
    int index,
    dnnl_alg_kind_t* alg_kind,
    const dnnl_memory_desc_t** src1_desc
    );

dnnl_status_t DNNL_API dnnl_post_ops_append_prelu(
    dnnl_post_ops_t post_ops,
    int mask
    );

dnnl_status_t DNNL_API dnnl_post_ops_get_params_prelu(
    const_dnnl_post_ops_t post_ops,
    int index,
    int* mask
    );

dnnl_status_t DNNL_API dnnl_memory_desc_init_by_strides(
    dnnl_memory_desc_t* memory_desc,
    int ndims,
    const dnnl_dims_t dims,
    dnnl_data_type_t data_type,
    const dnnl_dims_t strides
    );

dnnl_status_t DNNL_API dnnl_memory_desc_init_by_tag(
    dnnl_memory_desc_t* memory_desc,
    int ndims,
    const dnnl_dims_t dims,
    dnnl_data_type_t data_type,
    dnnl_format_tag_t tag
    );

dnnl_status_t DNNL_API dnnl_memory_desc_init_submemory(
    dnnl_memory_desc_t* memory_desc,
    const dnnl_memory_desc_t* parent_memory_desc,
    const dnnl_dims_t dims,
    const dnnl_dims_t offsets
    );

dnnl_status_t DNNL_API dnnl_memory_desc_reshape(
    dnnl_memory_desc_t* out_memory_desc,
    const dnnl_memory_desc_t* in_memory_desc,
    int ndims,
    const dnnl_dims_t dims
    );

dnnl_status_t DNNL_API dnnl_memory_desc_permute_axes(
    dnnl_memory_desc_t* out_memory_desc,
    const dnnl_memory_desc_t* in_memory_desc,
    const int* permutation
    );

int DNNL_API dnnl_memory_desc_equal(
    const dnnl_memory_desc_t* lhs,
    const dnnl_memory_desc_t* rhs
    );

size_t DNNL_API dnnl_memory_desc_get_size(const dnnl_memory_desc_t* memory_desc);
size_t DNNL_API dnnl_data_type_size(dnnl_data_type_t data_type);

dnnl_status_t DNNL_API dnnl_memory_create(
    dnnl_memory_t* memory,
    const dnnl_memory_desc_t* memory_desc,
    dnnl_engine_t engine,
    void* handle
    );

dnnl_status_t DNNL_API dnnl_memory_get_memory_desc(
    const_dnnl_memory_t memory,
    const dnnl_memory_desc_t** memory_desc
    );

dnnl_status_t DNNL_API dnnl_memory_get_engine(
    const_dnnl_memory_t memory,
    dnnl_engine_t* engine
    );

dnnl_status_t DNNL_API dnnl_memory_map_data(
    const_dnnl_memory_t memory,
    void** mapped_ptr
    );

dnnl_status_t DNNL_API dnnl_memory_unmap_data(
    const_dnnl_memory_t memory,
    void* mapped_ptr
    );

dnnl_status_t DNNL_API dnnl_memory_get_data_handle(
    const_dnnl_memory_t memory,
    void** handle
    );

dnnl_status_t DNNL_API dnnl_memory_set_data_handle(
    dnnl_memory_t memory,
    void* handle
    );

dnnl_status_t DNNL_API dnnl_memory_set_data_handle_v2(
    dnnl_memory_t memory,
    void* handle,
    dnnl_stream_t stream
    );

dnnl_status_t DNNL_API dnnl_memory_destroy(dnnl_memory_t memory);

dnnl_status_t DNNL_API dnnl_reorder_primitive_desc_create(
    dnnl_primitive_desc_t* reorder_primitive_desc,
    const dnnl_memory_desc_t* src_desc,
    dnnl_engine_t src_engine,
    const dnnl_memory_desc_t* dst_desc,
    dnnl_engine_t dst_engine,
    const_dnnl_primitive_attr_t attr
    );

dnnl_status_t DNNL_API dnnl_concat_primitive_desc_create(
    dnnl_primitive_desc_t* concat_primitive_desc,
    const dnnl_memory_desc_t* dst_desc,
    int n,
    int concat_dimension,
    const dnnl_memory_desc_t* src_descs,
    const_dnnl_primitive_attr_t attr,
    dnnl_engine_t engine
    );

dnnl_status_t DNNL_API dnnl_sum_primitive_desc_create(
    dnnl_primitive_desc_t* sum_primitive_desc,
    const dnnl_memory_desc_t* dst_desc,
    int n,
    const float* scales,
    const dnnl_memory_desc_t* src_descs,
    const_dnnl_primitive_attr_t attr,
    dnnl_engine_t engine
    );

dnnl_status_t DNNL_API dnnl_binary_desc_init(
    dnnl_binary_desc_t* binary_desc,
    dnnl_alg_kind_t alg_kind,
    const dnnl_memory_desc_t* src0_desc,
    const dnnl_memory_desc_t* src1_desc,
    const dnnl_memory_desc_t* dst_desc
    );

dnnl_status_t DNNL_API dnnl_convolution_forward_desc_init(
    dnnl_convolution_desc_t* conv_desc,
    dnnl_prop_kind_t prop_kind,
    dnnl_alg_kind_t alg_kind,
    const dnnl_memory_desc_t* src_desc,
    const dnnl_memory_desc_t* weights_desc,
    const dnnl_memory_desc_t* bias_desc,
    const dnnl_memory_desc_t* dst_desc,
    const dnnl_dims_t strides,
    const dnnl_dims_t padding_l,
    const dnnl_dims_t padding_r
    );

dnnl_status_t DNNL_API dnnl_dilated_convolution_forward_desc_init(
    dnnl_convolution_desc_t* conv_desc,
    dnnl_prop_kind_t prop_kind,
    dnnl_alg_kind_t alg_kind,
    const dnnl_memory_desc_t* src_desc,
    const dnnl_memory_desc_t* weights_desc,
    const dnnl_memory_desc_t* bias_desc,
    const dnnl_memory_desc_t* dst_desc,
    const dnnl_dims_t strides,
    const dnnl_dims_t dilates,
    const dnnl_dims_t padding_l,
    const dnnl_dims_t padding_r
    );

dnnl_status_t DNNL_API dnnl_convolution_backward_data_desc_init(
    dnnl_convolution_desc_t* conv_desc,
    dnnl_alg_kind_t alg_kind,
    const dnnl_memory_desc_t* diff_src_desc,
    const dnnl_memory_desc_t* weights_desc,
    const dnnl_memory_desc_t* diff_dst_desc,
    const dnnl_dims_t strides,
    const dnnl_dims_t padding_l,
    const dnnl_dims_t padding_r
    );

dnnl_status_t DNNL_API dnnl_dilated_convolution_backward_data_desc_init(
    dnnl_convolution_desc_t* conv_desc,
    dnnl_alg_kind_t alg_kind,
    const dnnl_memory_desc_t* diff_src_desc,
    const dnnl_memory_desc_t* weights_desc,
    const dnnl_memory_desc_t* diff_dst_desc,
    const dnnl_dims_t strides,
    const dnnl_dims_t dilates,
    const dnnl_dims_t padding_l,
    const dnnl_dims_t padding_r
    );

dnnl_status_t DNNL_API dnnl_convolution_backward_weights_desc_init(
    dnnl_convolution_desc_t* conv_desc,
    dnnl_alg_kind_t alg_kind,
    const dnnl_memory_desc_t* src_desc,
    const dnnl_memory_desc_t* diff_weights_desc,
    const dnnl_memory_desc_t* diff_bias_desc,
    const dnnl_memory_desc_t* diff_dst_desc,
    const dnnl_dims_t strides,
    const dnnl_dims_t padding_l,
    const dnnl_dims_t padding_r
    );

dnnl_status_t DNNL_API dnnl_dilated_convolution_backward_weights_desc_init(
    dnnl_convolution_desc_t* conv_desc,
    dnnl_alg_kind_t alg_kind,
    const dnnl_memory_desc_t* src_desc,
    const dnnl_memory_desc_t* diff_weights_desc,
    const dnnl_memory_desc_t* diff_bias_desc,
    const dnnl_memory_desc_t* diff_dst_desc,
    const dnnl_dims_t strides,
    const dnnl_dims_t dilates,
    const dnnl_dims_t padding_l,
    const dnnl_dims_t padding_r
    );

dnnl_status_t DNNL_API dnnl_deconvolution_forward_desc_init(
    dnnl_deconvolution_desc_t* deconv_desc,
    dnnl_prop_kind_t prop_kind,
    dnnl_alg_kind_t alg_kind,
    const dnnl_memory_desc_t* src_desc,
    const dnnl_memory_desc_t* weights_desc,
    const dnnl_memory_desc_t* bias_desc,
    const dnnl_memory_desc_t* dst_desc,
    const dnnl_dims_t strides,
    const dnnl_dims_t padding_l,
    const dnnl_dims_t padding_r
    );

dnnl_status_t DNNL_API dnnl_dilated_deconvolution_forward_desc_init(
    dnnl_deconvolution_desc_t* deconv_desc,
    dnnl_prop_kind_t prop_kind,
    dnnl_alg_kind_t alg_kind,
    const dnnl_memory_desc_t* src_desc,
    const dnnl_memory_desc_t* weights_desc,
    const dnnl_memory_desc_t* bias_desc,
    const dnnl_memory_desc_t* dst_desc,
    const dnnl_dims_t strides,
    const dnnl_dims_t dilates,
    const dnnl_dims_t padding_l,
    const dnnl_dims_t padding_r
    );

dnnl_status_t DNNL_API dnnl_deconvolution_backward_data_desc_init(
    dnnl_deconvolution_desc_t* deconv_desc,
    dnnl_alg_kind_t alg_kind,
    const dnnl_memory_desc_t* diff_src_desc,
    const dnnl_memory_desc_t* weights_desc,
    const dnnl_memory_desc_t* diff_dst_desc,
    const dnnl_dims_t strides,
    const dnnl_dims_t padding_l,
    const dnnl_dims_t padding_r
    );

dnnl_status_t DNNL_API dnnl_dilated_deconvolution_backward_data_desc_init(
    dnnl_deconvolution_desc_t* deconv_desc,
    dnnl_alg_kind_t alg_kind,
    const dnnl_memory_desc_t* diff_src_desc,
    const dnnl_memory_desc_t* weights_desc,
    const dnnl_memory_desc_t* diff_dst_desc,
    const dnnl_dims_t strides,
    const dnnl_dims_t dilates,
    const dnnl_dims_t padding_l,
    const dnnl_dims_t padding_r
    );

dnnl_status_t DNNL_API dnnl_deconvolution_backward_weights_desc_init(
    dnnl_deconvolution_desc_t* deconv_desc,
    dnnl_alg_kind_t alg_kind,
    const dnnl_memory_desc_t* src_desc,
    const dnnl_memory_desc_t* diff_weights_desc,
    const dnnl_memory_desc_t* diff_bias_desc,
    const dnnl_memory_desc_t* diff_dst_desc,
    const dnnl_dims_t strides,
    const dnnl_dims_t padding_l,
    const dnnl_dims_t padding_r
    );

dnnl_status_t DNNL_API dnnl_dilated_deconvolution_backward_weights_desc_init(
    dnnl_deconvolution_desc_t* deconv_desc,
    dnnl_alg_kind_t alg_kind,
    const dnnl_memory_desc_t* src_desc,
    const dnnl_memory_desc_t* diff_weights_desc,
    const dnnl_memory_desc_t* diff_bias_desc,
    const dnnl_memory_desc_t* diff_dst_desc,
    const dnnl_dims_t strides,
    const dnnl_dims_t dilates,
    const dnnl_dims_t padding_l,
    const dnnl_dims_t padding_r
    );

dnnl_status_t DNNL_API dnnl_shuffle_forward_desc_init(
    dnnl_shuffle_desc_t* shuffle_desc,
    dnnl_prop_kind_t prop_kind,
    const dnnl_memory_desc_t* data_desc,
    int axis,
    dnnl_dim_t group_size
    );

dnnl_status_t DNNL_API dnnl_shuffle_backward_desc_init(
    dnnl_shuffle_desc_t* shuffle_desc,
    const dnnl_memory_desc_t* diff_data_desc,
    int axis,
    dnnl_dim_t group_size
    );

dnnl_status_t DNNL_API dnnl_eltwise_forward_desc_init(
    dnnl_eltwise_desc_t* eltwise_desc,
    dnnl_prop_kind_t prop_kind,
    dnnl_alg_kind_t alg_kind,
    const dnnl_memory_desc_t* data_desc,
    float alpha,
    float beta
    );

dnnl_status_t DNNL_API dnnl_eltwise_backward_desc_init(
    dnnl_eltwise_desc_t* eltwise_desc,
    dnnl_alg_kind_t alg_kind,
    const dnnl_memory_desc_t* diff_data_desc,
    const dnnl_memory_desc_t* data_desc,
    float alpha,
    float beta
    );

dnnl_status_t DNNL_API dnnl_softmax_forward_desc_init(
    dnnl_softmax_desc_t* softmax_desc,
    dnnl_prop_kind_t prop_kind,
    const dnnl_memory_desc_t* data_desc,
    int softmax_axis
    );

dnnl_status_t DNNL_API dnnl_softmax_backward_desc_init(
    dnnl_softmax_desc_t* softmax_desc,
    const dnnl_memory_desc_t* diff_data_desc,
    const dnnl_memory_desc_t* data_desc,
    int softmax_axis
    );

dnnl_status_t DNNL_API dnnl_logsoftmax_forward_desc_init(
    dnnl_logsoftmax_desc_t* logsoftmax_desc,
    dnnl_prop_kind_t prop_kind,
    const dnnl_memory_desc_t* data_desc,
    int logsoftmax_axis
    );

dnnl_status_t DNNL_API dnnl_logsoftmax_backward_desc_init(
    dnnl_logsoftmax_desc_t* logsoftmax_desc,
    const dnnl_memory_desc_t* diff_data_desc,
    const dnnl_memory_desc_t* data_desc,
    int logsoftmax_axis
    );

dnnl_status_t DNNL_API dnnl_pooling_forward_desc_init(
    dnnl_pooling_desc_t* pool_desc,
    dnnl_prop_kind_t prop_kind,
    dnnl_alg_kind_t alg_kind,
    const dnnl_memory_desc_t* src_desc,
    const dnnl_memory_desc_t* dst_desc,
    const dnnl_dims_t strides,
    const dnnl_dims_t kernel,
    const dnnl_dims_t padding_l,
    const dnnl_dims_t padding_r
    );

dnnl_status_t DNNL_API dnnl_pooling_backward_desc_init(
    dnnl_pooling_desc_t* pool_desc,
    dnnl_alg_kind_t alg_kind,
    const dnnl_memory_desc_t* diff_src_desc,
    const dnnl_memory_desc_t* diff_dst_desc,
    const dnnl_dims_t strides,
    const dnnl_dims_t kernel,
    const dnnl_dims_t padding_l,
    const dnnl_dims_t padding_r
    );

dnnl_status_t DNNL_API dnnl_pooling_v2_forward_desc_init(
    dnnl_pooling_v2_desc_t* pool_desc,
    dnnl_prop_kind_t prop_kind,
    dnnl_alg_kind_t alg_kind,
    const dnnl_memory_desc_t* src_desc,
    const dnnl_memory_desc_t* dst_desc,
    const dnnl_dims_t strides,
    const dnnl_dims_t kernel,
    const dnnl_dims_t dilation,
    const dnnl_dims_t padding_l,
    const dnnl_dims_t padding_r
    );

dnnl_status_t DNNL_API dnnl_pooling_v2_backward_desc_init(
    dnnl_pooling_v2_desc_t* pool_desc,
    dnnl_alg_kind_t alg_kind,
    const dnnl_memory_desc_t* diff_src_desc,
    const dnnl_memory_desc_t* diff_dst_desc,
    const dnnl_dims_t strides,
    const dnnl_dims_t kernel,
    const dnnl_dims_t dilation,
    const dnnl_dims_t padding_l,
    const dnnl_dims_t padding_r
    );

dnnl_status_t DNNL_API dnnl_prelu_forward_desc_init(
    dnnl_prelu_desc_t* prelu_desc,
    dnnl_prop_kind_t prop_kind,
    const dnnl_memory_desc_t* data_desc,
    const dnnl_memory_desc_t* weights_desc
    );

dnnl_status_t DNNL_API dnnl_prelu_backward_desc_init(
    dnnl_prelu_desc_t* prelu_desc,
    const dnnl_memory_desc_t* data_desc,
    const dnnl_memory_desc_t* weights_desc,
    const dnnl_memory_desc_t* diff_data_desc,
    const dnnl_memory_desc_t* diff_weights_desc
    );

dnnl_status_t DNNL_API dnnl_lrn_forward_desc_init(
    dnnl_lrn_desc_t* lrn_desc,
    dnnl_prop_kind_t prop_kind,
    dnnl_alg_kind_t alg_kind,
    const dnnl_memory_desc_t* data_desc,
    dnnl_dim_t local_size,
    float alpha,
    float beta,
    float k
    );

dnnl_status_t DNNL_API dnnl_lrn_backward_desc_init(
    dnnl_lrn_desc_t* lrn_desc,
    dnnl_alg_kind_t alg_kind,
    const dnnl_memory_desc_t* diff_data_desc,
    const dnnl_memory_desc_t* data_desc,
    dnnl_dim_t local_size,
    float alpha,
    float beta,
    float k
    );

dnnl_status_t DNNL_API dnnl_batch_normalization_forward_desc_init(
    dnnl_batch_normalization_desc_t* bnrm_desc,
    dnnl_prop_kind_t prop_kind,
    const dnnl_memory_desc_t* data_desc,
    float epsilon,
    unsigned flags
    );

dnnl_status_t DNNL_API dnnl_batch_normalization_backward_desc_init(
    dnnl_batch_normalization_desc_t* bnrm_desc,
    dnnl_prop_kind_t prop_kind,
    const dnnl_memory_desc_t* diff_data_desc,
    const dnnl_memory_desc_t* data_desc,
    float epsilon,
    unsigned flags
    );

dnnl_status_t DNNL_API dnnl_layer_normalization_forward_desc_init(
    dnnl_layer_normalization_desc_t* lnrm_desc,
    dnnl_prop_kind_t prop_kind,
    const dnnl_memory_desc_t* data_desc,
    const dnnl_memory_desc_t* stat_desc,
    float epsilon,
    unsigned flags
    );

dnnl_status_t DNNL_API dnnl_layer_normalization_backward_desc_init(
    dnnl_layer_normalization_desc_t* lnrm_desc,
    dnnl_prop_kind_t prop_kind,
    const dnnl_memory_desc_t* diff_data_desc,
    const dnnl_memory_desc_t* data_desc,
    const dnnl_memory_desc_t* stat_desc,
    float epsilon,
    unsigned flags
    );

dnnl_status_t DNNL_API dnnl_inner_product_forward_desc_init(
    dnnl_inner_product_desc_t* ip_desc,
    dnnl_prop_kind_t prop_kind,
    const dnnl_memory_desc_t* src_desc,
    const dnnl_memory_desc_t* weights_desc,
    const dnnl_memory_desc_t* bias_desc,
    const dnnl_memory_desc_t* dst_desc
    );

dnnl_status_t DNNL_API dnnl_inner_product_backward_data_desc_init(
    dnnl_inner_product_desc_t* ip_desc,
    const dnnl_memory_desc_t* diff_src_desc,
    const dnnl_memory_desc_t* weights_desc,
    const dnnl_memory_desc_t* diff_dst_desc
    );

dnnl_status_t DNNL_API dnnl_inner_product_backward_weights_desc_init(
    dnnl_inner_product_desc_t* ip_desc,
    const dnnl_memory_desc_t* src_desc,
    const dnnl_memory_desc_t* diff_weights_desc,
    const dnnl_memory_desc_t* diff_bias_desc,
    const dnnl_memory_desc_t* diff_dst_desc
    );

dnnl_status_t DNNL_API dnnl_primitive_attr_set_rnn_data_qparams(
    dnnl_primitive_attr_t attr,
    const float scale,
    const float shift
    );

dnnl_status_t DNNL_API dnnl_primitive_attr_get_rnn_data_qparams(
    const_dnnl_primitive_attr_t attr,
    float* scale,
    float* shift
    );

dnnl_status_t DNNL_API dnnl_primitive_attr_set_rnn_weights_qparams(
    dnnl_primitive_attr_t attr,
    dnnl_dim_t count,
    int mask,
    const float* scales
    );

dnnl_status_t DNNL_API dnnl_primitive_attr_get_rnn_weights_qparams(
    const_dnnl_primitive_attr_t attr,
    dnnl_dim_t* count,
    int* mask,
    const float** scales
    );

dnnl_status_t DNNL_API dnnl_primitive_attr_set_rnn_weights_projection_qparams(
    dnnl_primitive_attr_t attr,
    dnnl_dim_t count,
    int mask,
    const float* scales
    );

dnnl_status_t DNNL_API dnnl_primitive_attr_get_rnn_weights_projection_qparams(
    const_dnnl_primitive_attr_t attr,
    dnnl_dim_t* count,
    int* mask,
    const float** scales
    );

dnnl_status_t DNNL_API dnnl_vanilla_rnn_forward_desc_init(
    dnnl_rnn_desc_t* rnn_desc,
    dnnl_prop_kind_t prop_kind,
    const dnnl_alg_kind_t activation,
    const dnnl_rnn_direction_t direction,
    const dnnl_memory_desc_t* src_layer_desc,
    const dnnl_memory_desc_t* src_iter_desc,
    const dnnl_memory_desc_t* weights_layer_desc,
    const dnnl_memory_desc_t* weights_iter_desc,
    const dnnl_memory_desc_t* bias_desc,
    const dnnl_memory_desc_t* dst_layer_desc,
    const dnnl_memory_desc_t* dst_iter_desc,
    unsigned flags,
    float alpha,
    float beta
    );

dnnl_status_t DNNL_API dnnl_vanilla_rnn_backward_desc_init(
    dnnl_rnn_desc_t* rnn_desc,
    dnnl_prop_kind_t prop_kind,
    const dnnl_alg_kind_t activation,
    const dnnl_rnn_direction_t direction,
    const dnnl_memory_desc_t* src_layer_desc,
    const dnnl_memory_desc_t* src_iter_desc,
    const dnnl_memory_desc_t* weights_layer_desc,
    const dnnl_memory_desc_t* weights_iter_desc,
    const dnnl_memory_desc_t* bias_desc,
    const dnnl_memory_desc_t* dst_layer_desc,
    const dnnl_memory_desc_t* dst_iter_desc,
    const dnnl_memory_desc_t* diff_src_layer_desc,
    const dnnl_memory_desc_t* diff_src_iter_desc,
    const dnnl_memory_desc_t* diff_weights_layer_desc,
    const dnnl_memory_desc_t* diff_weights_iter_desc,
    const dnnl_memory_desc_t* diff_bias_desc,
    const dnnl_memory_desc_t* diff_dst_layer_desc,
    const dnnl_memory_desc_t* diff_dst_iter_desc,
    unsigned flags,
    float alpha,
    float beta
    );

dnnl_status_t DNNL_API dnnl_lstm_forward_desc_init(
    dnnl_rnn_desc_t* rnn_desc,
    dnnl_prop_kind_t prop_kind,
    dnnl_rnn_direction_t direction,
    const dnnl_memory_desc_t* src_layer_desc,
    const dnnl_memory_desc_t* src_iter_desc,
    const dnnl_memory_desc_t* src_iter_c_desc,
    const dnnl_memory_desc_t* weights_layer_desc,
    const dnnl_memory_desc_t* weights_iter_desc,
    const dnnl_memory_desc_t* bias_desc,
    const dnnl_memory_desc_t* dst_layer_desc,
    const dnnl_memory_desc_t* dst_iter_desc,
    const dnnl_memory_desc_t* dst_iter_c_desc,
    unsigned flags
    );

dnnl_status_t DNNL_API dnnl_lstm_forward_desc_init_v2(
    dnnl_rnn_desc_t* rnn_desc,
    dnnl_prop_kind_t prop_kind,
    dnnl_rnn_direction_t direction,
    const dnnl_memory_desc_t* src_layer_desc,
    const dnnl_memory_desc_t* src_iter_desc,
    const dnnl_memory_desc_t* src_iter_c_desc,
    const dnnl_memory_desc_t* weights_layer_desc,
    const dnnl_memory_desc_t* weights_iter_desc,
    const dnnl_memory_desc_t* weights_peephole_desc,
    const dnnl_memory_desc_t* bias_desc,
    const dnnl_memory_desc_t* dst_layer_desc,
    const dnnl_memory_desc_t* dst_iter_desc,
    const dnnl_memory_desc_t* dst_iter_c_desc,
    unsigned flags
    );

dnnl_status_t DNNL_API dnnl_lstm_forward_desc_init_v3(
    dnnl_rnn_desc_t* rnn_desc,
    dnnl_prop_kind_t prop_kind,
    dnnl_rnn_direction_t direction,
    const dnnl_memory_desc_t* src_layer_desc,
    const dnnl_memory_desc_t* src_iter_desc,
    const dnnl_memory_desc_t* src_iter_c_desc,
    const dnnl_memory_desc_t* weights_layer_desc,
    const dnnl_memory_desc_t* weights_iter_desc,
    const dnnl_memory_desc_t* weights_peephole_desc,
    const dnnl_memory_desc_t* weights_projection_desc,
    const dnnl_memory_desc_t* bias_desc,
    const dnnl_memory_desc_t* dst_layer_desc,
    const dnnl_memory_desc_t* dst_iter_desc,
    const dnnl_memory_desc_t* dst_iter_c_desc,
    unsigned flags
    );

dnnl_status_t DNNL_API dnnl_lstm_backward_desc_init(
    dnnl_rnn_desc_t* rnn_desc,
    dnnl_prop_kind_t prop_kind,
    dnnl_rnn_direction_t direction,
    const dnnl_memory_desc_t* src_layer_desc,
    const dnnl_memory_desc_t* src_iter_desc,
    const dnnl_memory_desc_t* src_iter_c_desc,
    const dnnl_memory_desc_t* weights_layer_desc,
    const dnnl_memory_desc_t* weights_iter_desc,
    const dnnl_memory_desc_t* bias_desc,
    const dnnl_memory_desc_t* dst_layer_desc,
    const dnnl_memory_desc_t* dst_iter_desc,
    const dnnl_memory_desc_t* dst_iter_c_desc,
    const dnnl_memory_desc_t* diff_src_layer_desc,
    const dnnl_memory_desc_t* diff_src_iter_desc,
    const dnnl_memory_desc_t* diff_src_iter_c_desc,
    const dnnl_memory_desc_t* diff_weights_layer_desc,
    const dnnl_memory_desc_t* diff_weights_iter_desc,
    const dnnl_memory_desc_t* diff_bias_desc,
    const dnnl_memory_desc_t* diff_dst_layer_desc,
    const dnnl_memory_desc_t* diff_dst_iter_desc,
    const dnnl_memory_desc_t* diff_dst_iter_c_desc,
    unsigned flags
    );

dnnl_status_t DNNL_API dnnl_lstm_backward_desc_init_v2(
    dnnl_rnn_desc_t* rnn_desc,
    dnnl_prop_kind_t prop_kind,
    dnnl_rnn_direction_t direction,
    const dnnl_memory_desc_t* src_layer_desc,
    const dnnl_memory_desc_t* src_iter_desc,
    const dnnl_memory_desc_t* src_iter_c_desc,
    const dnnl_memory_desc_t* weights_layer_desc,
    const dnnl_memory_desc_t* weights_iter_desc,
    const dnnl_memory_desc_t* weights_peephole_desc,
    const dnnl_memory_desc_t* bias_desc,
    const dnnl_memory_desc_t* dst_layer_desc,
    const dnnl_memory_desc_t* dst_iter_desc,
    const dnnl_memory_desc_t* dst_iter_c_desc,
    const dnnl_memory_desc_t* diff_src_layer_desc,
    const dnnl_memory_desc_t* diff_src_iter_desc,
    const dnnl_memory_desc_t* diff_src_iter_c_desc,
    const dnnl_memory_desc_t* diff_weights_layer_desc,
    const dnnl_memory_desc_t* diff_weights_iter_desc,
    const dnnl_memory_desc_t* diff_weights_peephole_desc,
    const dnnl_memory_desc_t* diff_bias_desc,
    const dnnl_memory_desc_t* diff_dst_layer_desc,
    const dnnl_memory_desc_t* diff_dst_iter_desc,
    const dnnl_memory_desc_t* diff_dst_iter_c_desc,
    unsigned flags
    );

dnnl_status_t DNNL_API dnnl_lstm_backward_desc_init_v3(
    dnnl_rnn_desc_t* rnn_desc,
    dnnl_prop_kind_t prop_kind,
    dnnl_rnn_direction_t direction,
    const dnnl_memory_desc_t* src_layer_desc,
    const dnnl_memory_desc_t* src_iter_desc,
    const dnnl_memory_desc_t* src_iter_c_desc,
    const dnnl_memory_desc_t* weights_layer_desc,
    const dnnl_memory_desc_t* weights_iter_desc,
    const dnnl_memory_desc_t* weights_peephole_desc,
    const dnnl_memory_desc_t* weights_projection_desc,
    const dnnl_memory_desc_t* bias_desc,
    const dnnl_memory_desc_t* dst_layer_desc,
    const dnnl_memory_desc_t* dst_iter_desc,
    const dnnl_memory_desc_t* dst_iter_c_desc,
    const dnnl_memory_desc_t* diff_src_layer_desc,
    const dnnl_memory_desc_t* diff_src_iter_desc,
    const dnnl_memory_desc_t* diff_src_iter_c_desc,
    const dnnl_memory_desc_t* diff_weights_layer_desc,
    const dnnl_memory_desc_t* diff_weights_iter_desc,
    const dnnl_memory_desc_t* diff_weights_peephole_desc,
    const dnnl_memory_desc_t* diff_weights_projection_desc,
    const dnnl_memory_desc_t* diff_bias_desc,
    const dnnl_memory_desc_t* diff_dst_layer_desc,
    const dnnl_memory_desc_t* diff_dst_iter_desc,
    const dnnl_memory_desc_t* diff_dst_iter_c_desc,
    unsigned flags
    );

dnnl_status_t DNNL_API dnnl_gru_forward_desc_init(
    dnnl_rnn_desc_t* rnn_desc,
    dnnl_prop_kind_t prop_kind,
    dnnl_rnn_direction_t direction,
    const dnnl_memory_desc_t* src_layer_desc,
    const dnnl_memory_desc_t* src_iter_desc,
    const dnnl_memory_desc_t* weights_layer_desc,
    const dnnl_memory_desc_t* weights_iter_desc,
    const dnnl_memory_desc_t* bias_desc,
    const dnnl_memory_desc_t* dst_layer_desc,
    const dnnl_memory_desc_t* dst_iter_desc,
    unsigned flags
    );

dnnl_status_t DNNL_API dnnl_gru_backward_desc_init(
    dnnl_rnn_desc_t* rnn_desc,
    dnnl_prop_kind_t prop_kind,
    dnnl_rnn_direction_t direction,
    const dnnl_memory_desc_t* src_layer_desc,
    const dnnl_memory_desc_t* src_iter_desc,
    const dnnl_memory_desc_t* weights_layer_desc,
    const dnnl_memory_desc_t* weights_iter_desc,
    const dnnl_memory_desc_t* bias_desc,
    const dnnl_memory_desc_t* dst_layer_desc,
    const dnnl_memory_desc_t* dst_iter_desc,
    const dnnl_memory_desc_t* diff_src_layer_desc,
    const dnnl_memory_desc_t* diff_src_iter_desc,
    const dnnl_memory_desc_t* diff_weights_layer_desc,
    const dnnl_memory_desc_t* diff_weights_iter_desc,
    const dnnl_memory_desc_t* diff_bias_desc,
    const dnnl_memory_desc_t* diff_dst_layer_desc,
    const dnnl_memory_desc_t* diff_dst_iter_desc,
    unsigned flags
    );

dnnl_status_t DNNL_API dnnl_lbr_gru_forward_desc_init(
    dnnl_rnn_desc_t* rnn_desc,
    dnnl_prop_kind_t prop_kind,
    dnnl_rnn_direction_t direction,
    const dnnl_memory_desc_t* src_layer_desc,
    const dnnl_memory_desc_t* src_iter_desc,
    const dnnl_memory_desc_t* weights_layer_desc,
    const dnnl_memory_desc_t* weights_iter_desc,
    const dnnl_memory_desc_t* bias_desc,
    const dnnl_memory_desc_t* dst_layer_desc,
    const dnnl_memory_desc_t* dst_iter_desc,
    unsigned flags
    );

dnnl_status_t DNNL_API dnnl_lbr_gru_backward_desc_init(
    dnnl_rnn_desc_t* rnn_desc,
    dnnl_prop_kind_t prop_kind,
    dnnl_rnn_direction_t direction,
    const dnnl_memory_desc_t* src_layer_desc,
    const dnnl_memory_desc_t* src_iter_desc,
    const dnnl_memory_desc_t* weights_layer_desc,
    const dnnl_memory_desc_t* weights_iter_desc,
    const dnnl_memory_desc_t* bias_desc,
    const dnnl_memory_desc_t* dst_layer_desc,
    const dnnl_memory_desc_t* dst_iter_desc,
    const dnnl_memory_desc_t* diff_src_layer_desc,
    const dnnl_memory_desc_t* diff_src_iter_desc,
    const dnnl_memory_desc_t* diff_weights_layer_desc,
    const dnnl_memory_desc_t* diff_weights_iter_desc,
    const dnnl_memory_desc_t* diff_bias_desc,
    const dnnl_memory_desc_t* diff_dst_layer_desc,
    const dnnl_memory_desc_t* diff_dst_iter_desc,
    unsigned flags
    );

dnnl_status_t DNNL_API dnnl_matmul_desc_init(
    dnnl_matmul_desc_t* matmul_desc,
    const dnnl_memory_desc_t* src_desc,
    const dnnl_memory_desc_t* weights_desc,
    const dnnl_memory_desc_t* bias_desc,
    const dnnl_memory_desc_t* dst_desc
    );

dnnl_status_t DNNL_API dnnl_resampling_forward_desc_init(
    dnnl_resampling_desc_t* resampling_desc,
    dnnl_prop_kind_t prop_kind,
    dnnl_alg_kind_t alg_kind,
    const float* factors,
    const dnnl_memory_desc_t* src_desc,
    const dnnl_memory_desc_t* dst_desc
    );

dnnl_status_t DNNL_API dnnl_resampling_backward_desc_init(
    dnnl_resampling_desc_t* resampling_desc,
    dnnl_alg_kind_t alg_kind,
    const float* factors,
    const dnnl_memory_desc_t* diff_src_desc,
    const dnnl_memory_desc_t* diff_dst_desc
    );

dnnl_status_t DNNL_API dnnl_reduction_desc_init(
    dnnl_reduction_desc_t* desc,
    dnnl_alg_kind_t alg_kind,
    const dnnl_memory_desc_t* src_desc,
    const dnnl_memory_desc_t* dst_desc,
    float p,
    float eps
    );

size_t DNNL_API dnnl_engine_get_count(dnnl_engine_kind_t kind);

dnnl_status_t DNNL_API dnnl_engine_create(
    dnnl_engine_t* engine,
    dnnl_engine_kind_t kind,
    size_t index
    );

dnnl_status_t DNNL_API dnnl_engine_get_kind(
    dnnl_engine_t engine,
    dnnl_engine_kind_t* kind
    );

dnnl_status_t DNNL_API dnnl_engine_destroy(dnnl_engine_t engine);

dnnl_status_t DNNL_API dnnl_stream_create(
    dnnl_stream_t* stream,
    dnnl_engine_t engine,
    unsigned flags
    );

dnnl_status_t DNNL_API dnnl_stream_get_engine(
    const_dnnl_stream_t stream,
    dnnl_engine_t* engine
    );

dnnl_status_t DNNL_API dnnl_stream_wait(dnnl_stream_t stream);
dnnl_status_t DNNL_API dnnl_stream_destroy(dnnl_stream_t stream);
dnnl_status_t DNNL_API dnnl_get_primitive_cache_capacity(int* capacity);
dnnl_status_t DNNL_API dnnl_set_primitive_cache_capacity(int capacity);
dnnl_status_t DNNL_API dnnl_get_default_fpmath_mode(dnnl_fpmath_mode_t* mode);
dnnl_status_t DNNL_API dnnl_set_default_fpmath_mode(dnnl_fpmath_mode_t mode);
dnnl_status_t DNNL_API dnnl_set_verbose(int level);
dnnl_status_t DNNL_API dnnl_set_jit_dump(int enable);
const dnnl_version_t DNNL_API* dnnl_version(void);
dnnl_status_t DNNL_API dnnl_set_jit_profiling_flags(unsigned flags);
dnnl_status_t DNNL_API dnnl_set_jit_profiling_jitdumpdir(const char* dir);
dnnl_status_t DNNL_API dnnl_set_max_cpu_isa(dnnl_cpu_isa_t isa);
dnnl_cpu_isa_t DNNL_API dnnl_get_effective_cpu_isa(void);
dnnl_status_t DNNL_API dnnl_set_cpu_isa_hints(dnnl_cpu_isa_hints_t isa_hints);
dnnl_cpu_isa_hints_t DNNL_API dnnl_get_cpu_isa_hints(void);

dnnl_status_t DNNL_API dnnl_sgemm(
    char transa,
    char transb,
    dnnl_dim_t M,
    dnnl_dim_t N,
    dnnl_dim_t K,
    float alpha,
    const float* A,
    dnnl_dim_t lda,
    const float* B,
    dnnl_dim_t ldb,
    float beta,
    float* C,
    dnnl_dim_t ldc
    );

dnnl_status_t DNNL_API dnnl_gemm_u8s8s32(
    char transa,
    char transb,
    char offsetc,
    dnnl_dim_t M,
    dnnl_dim_t N,
    dnnl_dim_t K,
    float alpha,
    const uint8_t* A,
    dnnl_dim_t lda,
    uint8_t ao,
    const int8_t* B,
    dnnl_dim_t ldb,
    int8_t bo,
    float beta,
    int32_t* C,
    dnnl_dim_t ldc,
    const int32_t* co
    );

dnnl_status_t DNNL_API dnnl_gemm_s8s8s32(
    char transa,
    char transb,
    char offsetc,
    dnnl_dim_t M,
    dnnl_dim_t N,
    dnnl_dim_t K,
    float alpha,
    const int8_t* A,
    dnnl_dim_t lda,
    int8_t ao,
    const int8_t* B,
    dnnl_dim_t ldb,
    int8_t bo,
    float beta,
    int32_t* C,
    dnnl_dim_t ldc,
    const int32_t* co
    );

const char DNNL_API* dnnl_status2str(dnnl_status_t v);
const char DNNL_API* dnnl_dt2str(dnnl_data_type_t v);
const char DNNL_API* dnnl_fmt_kind2str(dnnl_format_kind_t v);
const char DNNL_API* dnnl_fmt_tag2str(dnnl_format_tag_t v);
const char DNNL_API* dnnl_prop_kind2str(dnnl_prop_kind_t v);
const char DNNL_API* dnnl_prim_kind2str(dnnl_primitive_kind_t v);
const char DNNL_API* dnnl_alg_kind2str(dnnl_alg_kind_t v);
const char DNNL_API* dnnl_rnn_flags2str(dnnl_rnn_flags_t v);
const char DNNL_API* dnnl_rnn_direction2str(dnnl_rnn_direction_t v);
const char DNNL_API* dnnl_engine_kind2str(dnnl_engine_kind_t v);
const char DNNL_API* dnnl_fpmath_mode2str(dnnl_fpmath_mode_t v);
const char DNNL_API* dnnl_scratchpad_mode2str(dnnl_scratchpad_mode_t v);
const char DNNL_API* dnnl_cpu_isa2str(dnnl_cpu_isa_t v);
const char DNNL_API* dnnl_cpu_isa_hints2str(dnnl_cpu_isa_hints_t v);
const char DNNL_API* dnnl_runtime2str(unsigned v);

dnnl_status_t DNNL_API dnnl_ocl_interop_memory_create(
    dnnl_memory_t* memory,
    const dnnl_memory_desc_t* memory_desc,
    dnnl_engine_t engine,
    dnnl_ocl_interop_memory_kind_t memory_kind,
    void* handle
    );

dnnl_status_t DNNL_API dnnl_ocl_interop_memory_get_memory_kind(
    const_dnnl_memory_t memory,
    dnnl_ocl_interop_memory_kind_t* memory_kind
    );

dnnl_status_t DNNL_API dnnl_ocl_interop_memory_get_mem_object(
    const_dnnl_memory_t memory,
    cl_mem* mem_object
    );

dnnl_status_t DNNL_API dnnl_ocl_interop_memory_set_mem_object(
    dnnl_memory_t memory,
    cl_mem mem_object
    );

dnnl_status_t DNNL_API dnnl_ocl_interop_engine_create(
    dnnl_engine_t* engine,
    cl_device_id device,
    cl_context context
    );

dnnl_status_t DNNL_API dnnl_ocl_interop_engine_get_context(
    dnnl_engine_t engine,
    cl_context* context
    );

dnnl_status_t DNNL_API dnnl_ocl_interop_get_device(
    dnnl_engine_t engine,
    cl_device_id* device
    );

dnnl_status_t DNNL_API dnnl_ocl_interop_stream_create(
    dnnl_stream_t* stream,
    dnnl_engine_t engine,
    cl_command_queue queue
    );

dnnl_status_t DNNL_API dnnl_ocl_interop_stream_get_command_queue(
    dnnl_stream_t stream,
    cl_command_queue* queue
    );

dnnl_status_t DNNL_API dnnl_sycl_interop_engine_create(
    dnnl_engine_t* engine,
    const void* device,
    const void* context
    );

dnnl_status_t DNNL_API dnnl_sycl_interop_engine_get_context(
    dnnl_engine_t engine,
    void** context
    );

dnnl_status_t DNNL_API dnnl_sycl_interop_engine_get_device(
    dnnl_engine_t engine,
    void** device
    );

dnnl_status_t DNNL_API dnnl_sycl_interop_memory_create(
    dnnl_memory_t* memory,
    const dnnl_memory_desc_t* memory_desc,
    dnnl_engine_t engine,
    dnnl_sycl_interop_memory_kind_t memory_kind,
    void* handle
    );

dnnl_status_t DNNL_API dnnl_sycl_interop_memory_get_memory_kind(
    const_dnnl_memory_t memory,
    dnnl_sycl_interop_memory_kind_t* memory_kind
    );

dnnl_status_t DNNL_API dnnl_sycl_interop_memory_set_buffer(
    dnnl_memory_t memory,
    void* buffer,
    dnnl_stream_t stream
    );

dnnl_status_t DNNL_API dnnl_sycl_interop_stream_create(
    dnnl_stream_t* stream,
    dnnl_engine_t engine,
    void* queue
    );

dnnl_status_t DNNL_API dnnl_sycl_interop_stream_get_queue(
    dnnl_stream_t stream,
    void** queue
    );

dnnl_status_t DNNL_API dnnl_sycl_interop_primitive_execute(
    const_dnnl_primitive_t primitive,
    dnnl_stream_t stream,
    int nargs,
    const dnnl_exec_arg_t* args,
    const void* deps,
    void* return_event
    );

dnnl_status_t DNNL_API dnnl_threadpool_interop_stream_create(
    dnnl_stream_t* stream,
    dnnl_engine_t engine,
    void* threadpool
    );

dnnl_status_t DNNL_API dnnl_threadpool_interop_stream_get_threadpool(
    dnnl_stream_t astream,
    void** threadpool
    );

dnnl_status_t DNNL_API dnnl_threadpool_interop_sgemm(
    char transa,
    char transb,
    dnnl_dim_t M,
    dnnl_dim_t N,
    dnnl_dim_t K,
    float alpha,
    const float* A,
    dnnl_dim_t lda,
    const float* B,
    dnnl_dim_t ldb,
    float beta,
    float* C,
    dnnl_dim_t ldc,
    void* threadpool
    );

dnnl_status_t DNNL_API dnnl_threadpool_interop_gemm_u8s8s32(
    char transa,
    char transb,
    char offsetc,
    dnnl_dim_t M,
    dnnl_dim_t N,
    dnnl_dim_t K,
    float alpha,
    const uint8_t* A,
    dnnl_dim_t lda,
    uint8_t ao,
    const int8_t* B,
    dnnl_dim_t ldb,
    int8_t bo,
    float beta,
    int32_t* C,
    dnnl_dim_t ldc,
    const int32_t* co,
    void* threadpool
    );

dnnl_status_t DNNL_API dnnl_threadpool_interop_gemm_s8s8s32(
    char transa,
    char transb,
    char offsetc,
    dnnl_dim_t M,
    dnnl_dim_t N,
    dnnl_dim_t K,
    float alpha,
    const int8_t* A,
    dnnl_dim_t lda,
    int8_t ao,
    const int8_t* B,
    dnnl_dim_t ldb,
    int8_t bo,
    float beta,
    int32_t* C,
    dnnl_dim_t ldc,
    const int32_t* co,
    void* threadpool
    );

// macros

#define BATCH
#define BATCH
#define CHECK(f)
#define COMPLAIN_DNNL_ERROR_AND_EXIT(what, status)
#define COMPLAIN_EXAMPLE_ERROR_AND_EXIT(complain_fmt, ...)
#define CONV_IH
#define CONV_IH
#define CONV_IW
#define CONV_IW
#define CONV_OH
#define CONV_OH
#define CONV_OW
#define CONV_OW
#define CONV_PAD
#define CONV_PAD
#define CONV_STRIDE
#define CONV_STRIDE
#define DNNL_ARG_ATTR_INPUT_SCALES
#define DNNL_ARG_ATTR_MULTIPLE_POST_OP(idx)
#define DNNL_ARG_ATTR_MULTIPLE_POST_OP_BASE
#define DNNL_ARG_ATTR_OUTPUT_SCALES
#define DNNL_ARG_ATTR_POST_OP_DW
#define DNNL_ARG_ATTR_ZERO_POINTS
#define DNNL_ARG_BIAS
#define DNNL_ARG_DIFF_BIAS
#define DNNL_ARG_DIFF_DST
#define DNNL_ARG_DIFF_DST_0
#define DNNL_ARG_DIFF_DST_1
#define DNNL_ARG_DIFF_DST_2
#define DNNL_ARG_DIFF_DST_ITER
#define DNNL_ARG_DIFF_DST_ITER_C
#define DNNL_ARG_DIFF_DST_LAYER
#define DNNL_ARG_DIFF_SCALE
#define DNNL_ARG_DIFF_SCALE_SHIFT
#define DNNL_ARG_DIFF_SHIFT
#define DNNL_ARG_DIFF_SRC
#define DNNL_ARG_DIFF_SRC_0
#define DNNL_ARG_DIFF_SRC_1
#define DNNL_ARG_DIFF_SRC_2
#define DNNL_ARG_DIFF_SRC_ITER
#define DNNL_ARG_DIFF_SRC_ITER_C
#define DNNL_ARG_DIFF_SRC_LAYER
#define DNNL_ARG_DIFF_WEIGHTS
#define DNNL_ARG_DIFF_WEIGHTS_0
#define DNNL_ARG_DIFF_WEIGHTS_1
#define DNNL_ARG_DIFF_WEIGHTS_2
#define DNNL_ARG_DIFF_WEIGHTS_3
#define DNNL_ARG_DIFF_WEIGHTS_ITER
#define DNNL_ARG_DIFF_WEIGHTS_LAYER
#define DNNL_ARG_DIFF_WEIGHTS_PEEPHOLE
#define DNNL_ARG_DIFF_WEIGHTS_PROJECTION
#define DNNL_ARG_DST
#define DNNL_ARG_DST_0
#define DNNL_ARG_DST_1
#define DNNL_ARG_DST_2
#define DNNL_ARG_DST_ITER
#define DNNL_ARG_DST_ITER_C
#define DNNL_ARG_DST_LAYER
#define DNNL_ARG_FROM
#define DNNL_ARG_MEAN
#define DNNL_ARG_MULTIPLE_DST
#define DNNL_ARG_MULTIPLE_SRC
#define DNNL_ARG_SCALE
#define DNNL_ARG_SCALE_SHIFT
#define DNNL_ARG_SCRATCHPAD
#define DNNL_ARG_SHIFT
#define DNNL_ARG_SRC
#define DNNL_ARG_SRC_0
#define DNNL_ARG_SRC_1
#define DNNL_ARG_SRC_2
#define DNNL_ARG_SRC_ITER
#define DNNL_ARG_SRC_ITER_C
#define DNNL_ARG_SRC_LAYER
#define DNNL_ARG_TO
#define DNNL_ARG_VARIANCE
#define DNNL_ARG_WEIGHTS
#define DNNL_ARG_WEIGHTS_0
#define DNNL_ARG_WEIGHTS_1
#define DNNL_ARG_WEIGHTS_2
#define DNNL_ARG_WEIGHTS_3
#define DNNL_ARG_WEIGHTS_ITER
#define DNNL_ARG_WEIGHTS_LAYER
#define DNNL_ARG_WEIGHTS_PEEPHOLE
#define DNNL_ARG_WEIGHTS_PROJECTION
#define DNNL_ARG_WORKSPACE
#define DNNL_ENABLE_EXCEPTIONS
#define DNNL_JIT_PROFILE_LINUX_JITDUMP
#define DNNL_JIT_PROFILE_LINUX_JITDUMP_USE_TSC
#define DNNL_JIT_PROFILE_LINUX_PERF
#define DNNL_JIT_PROFILE_LINUX_PERFMAP
#define DNNL_JIT_PROFILE_NONE
#define DNNL_JIT_PROFILE_VTUNE
#define DNNL_MAX_NDIMS
#define DNNL_MEMORY_ALLOCATE
#define DNNL_MEMORY_NONE
#define DNNL_RNN_MAX_N_PARTS
#define DNNL_RUNTIME_DIM_VAL
#define DNNL_RUNTIME_DPCPP
#define DNNL_RUNTIME_F32_VAL
#define DNNL_RUNTIME_NONE
#define DNNL_RUNTIME_OCL
#define DNNL_RUNTIME_OMP
#define DNNL_RUNTIME_S32_VAL
#define DNNL_RUNTIME_SEQ
#define DNNL_RUNTIME_SIZE_VAL
#define DNNL_RUNTIME_SYCL
#define DNNL_RUNTIME_TBB
#define DNNL_RUNTIME_THREADPOOL
#define DNNL_THROW_ERROR(status, msg)
#define IC
#define IC
#define MKLDNN_API
#define MKLDNN_ARG_BIAS
#define MKLDNN_ARG_DIFF_BIAS
#define MKLDNN_ARG_DIFF_DST
#define MKLDNN_ARG_DIFF_DST_0
#define MKLDNN_ARG_DIFF_DST_1
#define MKLDNN_ARG_DIFF_DST_2
#define MKLDNN_ARG_DIFF_DST_ITER
#define MKLDNN_ARG_DIFF_DST_ITER_C
#define MKLDNN_ARG_DIFF_DST_LAYER
#define MKLDNN_ARG_DIFF_SCALE_SHIFT
#define MKLDNN_ARG_DIFF_SRC
#define MKLDNN_ARG_DIFF_SRC_0
#define MKLDNN_ARG_DIFF_SRC_1
#define MKLDNN_ARG_DIFF_SRC_2
#define MKLDNN_ARG_DIFF_SRC_ITER
#define MKLDNN_ARG_DIFF_SRC_ITER_C
#define MKLDNN_ARG_DIFF_SRC_LAYER
#define MKLDNN_ARG_DIFF_WEIGHTS
#define MKLDNN_ARG_DIFF_WEIGHTS_0
#define MKLDNN_ARG_DIFF_WEIGHTS_1
#define MKLDNN_ARG_DIFF_WEIGHTS_ITER
#define MKLDNN_ARG_DIFF_WEIGHTS_LAYER
#define MKLDNN_ARG_DST
#define MKLDNN_ARG_DST_0
#define MKLDNN_ARG_DST_1
#define MKLDNN_ARG_DST_2
#define MKLDNN_ARG_DST_ITER
#define MKLDNN_ARG_DST_ITER_C
#define MKLDNN_ARG_DST_LAYER
#define MKLDNN_ARG_FROM
#define MKLDNN_ARG_MEAN
#define MKLDNN_ARG_MULTIPLE_DST
#define MKLDNN_ARG_MULTIPLE_SRC
#define MKLDNN_ARG_SCALE_SHIFT
#define MKLDNN_ARG_SCRATCHPAD
#define MKLDNN_ARG_SRC
#define MKLDNN_ARG_SRC_0
#define MKLDNN_ARG_SRC_1
#define MKLDNN_ARG_SRC_2
#define MKLDNN_ARG_SRC_ITER
#define MKLDNN_ARG_SRC_ITER_C
#define MKLDNN_ARG_SRC_LAYER
#define MKLDNN_ARG_TO
#define MKLDNN_ARG_VARIANCE
#define MKLDNN_ARG_WEIGHTS
#define MKLDNN_ARG_WEIGHTS_0
#define MKLDNN_ARG_WEIGHTS_1
#define MKLDNN_ARG_WEIGHTS_ITER
#define MKLDNN_ARG_WEIGHTS_LAYER
#define MKLDNN_ARG_WORKSPACE
#define MKLDNN_CPU_RUNTIME
#define MKLDNN_DEFINE_BITMASK_OPS
#define MKLDNN_GPU_RUNTIME
#define MKLDNN_JIT_DUMP
#define MKLDNN_MAX_NDIMS
#define MKLDNN_MEMORY_ALLOCATE
#define MKLDNN_MEMORY_NONE
#define MKLDNN_RNN_MAX_N_PARTS
#define MKLDNN_RUNTIME_NONE
#define MKLDNN_RUNTIME_OCL
#define MKLDNN_RUNTIME_OMP
#define MKLDNN_RUNTIME_SEQ
#define MKLDNN_RUNTIME_SYCL
#define MKLDNN_RUNTIME_TBB
#define MKLDNN_VERBOSE
#define MKLDNN_VERSION_HASH
#define MKLDNN_VERSION_MAJOR
#define MKLDNN_VERSION_MINOR
#define MKLDNN_VERSION_PATCH
#define MKLDNN_WITH_SYCL
#define OC
#define OC
#define OCL_CHECK(x)
#define POOL_OH
#define POOL_OH
#define POOL_OW
#define POOL_OW
#define POOL_PAD
#define POOL_PAD
#define POOL_STRIDE
#define POOL_STRIDE
#define PRAGMA_MACRO(x)
#define PRAGMA_MACRo(x)
#define PRAGMA_OMP_PARALLEL_FOR_COLLAPSE(n)
#define _POSIX_C_SOURCE
#define _POSIX_C_SOURCE
#define const_mkldnn_engine_t
#define const_mkldnn_memory_t
#define const_mkldnn_op_desc_t
#define const_mkldnn_post_ops_t
#define const_mkldnn_primitive_attr_t
#define const_mkldnn_primitive_desc_iterator_t
#define const_mkldnn_primitive_desc_t
#define const_mkldnn_primitive_t
#define const_mkldnn_stream_t
#define mkldnn
#define mkldnn_
#define mkldnn_ABc16a16b
#define mkldnn_ABc16b16a
#define mkldnn_ABc4a4b
#define mkldnn_ABc4b16a4b
#define mkldnn_ABc4b4a
#define mkldnn_ABc8a16b2a
#define mkldnn_ABc8a8b
#define mkldnn_ABc8b16a2b
#define mkldnn_ABc8b8a
#define mkldnn_ABcd16a16b
#define mkldnn_ABcd16b16a
#define mkldnn_ABcd2a8b8a2b
#define mkldnn_ABcd32a32b
#define mkldnn_ABcd4a4b
#define mkldnn_ABcd4a8b8a4b
#define mkldnn_ABcd4b16a4b
#define mkldnn_ABcd4b4a
#define mkldnn_ABcd8a16b2a
#define mkldnn_ABcd8a8b
#define mkldnn_ABcd8b16a2b
#define mkldnn_ABcd8b8a
#define mkldnn_ABcde16a16b
#define mkldnn_ABcde16b16a
#define mkldnn_ABcde4a4b
#define mkldnn_ABcde4b16a4b
#define mkldnn_ABcde4b4a
#define mkldnn_ABcde8a16b2a
#define mkldnn_ABcde8a8b
#define mkldnn_ABcde8b16a2b
#define mkldnn_ABcde8b8a
#define mkldnn_Abc16a
#define mkldnn_Abc4a
#define mkldnn_Abcd16a
#define mkldnn_Abcd4a
#define mkldnn_Abcde16a
#define mkldnn_Abcde4a
#define mkldnn_Abcde8a
#define mkldnn_Abcdef16a
#define mkldnn_Acb16a
#define mkldnn_Acb4a
#define mkldnn_Acb8a
#define mkldnn_Acdb16a
#define mkldnn_Acdb32a
#define mkldnn_Acdb4a
#define mkldnn_Acdb8a
#define mkldnn_Acdeb16a
#define mkldnn_Acdeb4a
#define mkldnn_Acdeb8a
#define mkldnn_BAc16a16b
#define mkldnn_BAc16b16a
#define mkldnn_BAc8a16b2a
#define mkldnn_BAcd16a16b
#define mkldnn_BAcd16b16a
#define mkldnn_BAcd8a16b2a
#define mkldnn_BAcde16a16b
#define mkldnn_BAcde16b16a
#define mkldnn_BAcde8a16b2a
#define mkldnn_Goidhw16g
#define mkldnn_Goihw16g
#define mkldnn_Goihw8g
#define mkldnn_Goiw16g
#define mkldnn_IOdhw16i16o
#define mkldnn_IOdhw16o16i
#define mkldnn_IOdhw8o16i2o
#define mkldnn_IOhw16i16o
#define mkldnn_IOhw16o16i
#define mkldnn_IOhw8o16i2o
#define mkldnn_IOw16i16o
#define mkldnn_IOw16o16i
#define mkldnn_IOw8o16i2o
#define mkldnn_NCdhw16n16c
#define mkldnn_NChw16n16c
#define mkldnn_NChw32n32c
#define mkldnn_NCw16n16c
#define mkldnn_OIdhw16i16o
#define mkldnn_OIdhw16o16i
#define mkldnn_OIdhw4i16o4i
#define mkldnn_OIdhw4i4o
#define mkldnn_OIdhw4o4i
#define mkldnn_OIdhw8i16o2i
#define mkldnn_OIdhw8i8o
#define mkldnn_OIdhw8o16i2o
#define mkldnn_OIdhw8o8i
#define mkldnn_OIhw16i16o
#define mkldnn_OIhw16i16o2i
#define mkldnn_OIhw16i16o4i
#define mkldnn_OIhw16o16i
#define mkldnn_OIhw2o8i8o2i
#define mkldnn_OIhw4i16o4i
#define mkldnn_OIhw4i4o
#define mkldnn_OIhw4o4i
#define mkldnn_OIhw4o8i8o4i
#define mkldnn_OIhw8i16o2i
#define mkldnn_OIhw8i8o
#define mkldnn_OIhw8o16i2o
#define mkldnn_OIhw8o8i
#define mkldnn_OIw16i16o
#define mkldnn_OIw16o16i
#define mkldnn_OIw4i16o4i
#define mkldnn_OIw4i4o
#define mkldnn_OIw4o4i
#define mkldnn_OIw8i16o2i
#define mkldnn_OIw8i8o
#define mkldnn_OIw8o16i2o
#define mkldnn_OIw8o8i
#define mkldnn_Odhwi16o
#define mkldnn_Odhwi4o
#define mkldnn_Odhwi8o
#define mkldnn_Ohwi16o
#define mkldnn_Ohwi32o
#define mkldnn_Ohwi4o
#define mkldnn_Ohwi8o
#define mkldnn_Oidhw16o
#define mkldnn_Oidhw4o
#define mkldnn_Oihw16o
#define mkldnn_Oihw4o
#define mkldnn_Oiw16o
#define mkldnn_Oiw4o
#define mkldnn_Owi16o
#define mkldnn_Owi4o
#define mkldnn_Owi8o
#define mkldnn_a
#define mkldnn_aBCd16b16c
#define mkldnn_aBCd16c16b
#define mkldnn_aBCd4b4c
#define mkldnn_aBCd4c16b4c
#define mkldnn_aBCd4c4b
#define mkldnn_aBCd8b16c2b
#define mkldnn_aBCd8b8c
#define mkldnn_aBCd8c16b2c
#define mkldnn_aBCd8c8b
#define mkldnn_aBCde16b16c
#define mkldnn_aBCde16c16b
#define mkldnn_aBCde2b8c8b2c
#define mkldnn_aBCde2c8b4c
#define mkldnn_aBCde4b4c
#define mkldnn_aBCde4b8c8b4c
#define mkldnn_aBCde4c16b4c
#define mkldnn_aBCde4c4b
#define mkldnn_aBCde8b16c2b
#define mkldnn_aBCde8b8c
#define mkldnn_aBCde8c16b2c
#define mkldnn_aBCde8c8b
#define mkldnn_aBCdef16b16c
#define mkldnn_aBCdef16c16b
#define mkldnn_aBCdef4b4c
#define mkldnn_aBCdef4c16b4c
#define mkldnn_aBCdef4c4b
#define mkldnn_aBCdef8b16c2b
#define mkldnn_aBCdef8b8c
#define mkldnn_aBCdef8c16b2c
#define mkldnn_aBCdef8c8b
#define mkldnn_aBc16b
#define mkldnn_aBc4b
#define mkldnn_aBc8b
#define mkldnn_aBcd16b
#define mkldnn_aBcd4b
#define mkldnn_aBcd8b
#define mkldnn_aBcde16b
#define mkldnn_aBcde4b
#define mkldnn_aBcde8b
#define mkldnn_aBcdef16b
#define mkldnn_aBcdef4b
#define mkldnn_aBdc16b
#define mkldnn_aBdc4b
#define mkldnn_aBdc8b
#define mkldnn_aBdec16b
#define mkldnn_aBdec32b
#define mkldnn_aBdec4b
#define mkldnn_aBdec8b
#define mkldnn_aBdefc16b
#define mkldnn_aBdefc4b
#define mkldnn_aBdefc8b
#define mkldnn_aCBd16b16c
#define mkldnn_aCBd16c16b
#define mkldnn_aCBd8b16c2b
#define mkldnn_aCBde16b16c
#define mkldnn_aCBde16c16b
#define mkldnn_aCBde8b16c2b
#define mkldnn_aCBdef16b16c
#define mkldnn_aCBdef16c16b
#define mkldnn_aCBdef8b16c2b
#define mkldnn_ab
#define mkldnn_abc
#define mkldnn_abcd
#define mkldnn_abcde
#define mkldnn_abcdef
#define mkldnn_abdec
#define mkldnn_acb
#define mkldnn_acbde
#define mkldnn_acdb
#define mkldnn_acdeb
#define mkldnn_alg_kind2str
#define mkldnn_alg_kind_t
#define mkldnn_alg_kind_undef
#define mkldnn_any_engine
#define mkldnn_ba
#define mkldnn_bac
#define mkldnn_bacd
#define mkldnn_backward
#define mkldnn_backward_bias
#define mkldnn_backward_data
#define mkldnn_backward_weights
#define mkldnn_batch_normalization
#define mkldnn_batch_normalization_backward_desc_init
#define mkldnn_batch_normalization_desc_t
#define mkldnn_batch_normalization_forward_desc_init
#define mkldnn_bca
#define mkldnn_bcda
#define mkldnn_bcdea
#define mkldnn_bf16
#define mkldnn_bidirectional_concat
#define mkldnn_bidirectional_sum
#define mkldnn_blocked
#define mkldnn_blocking_desc_t
#define mkldnn_cba
#define mkldnn_cdba
#define mkldnn_cdeba
#define mkldnn_chwn
#define mkldnn_cn
#define mkldnn_concat
#define mkldnn_concat_primitive_desc_create
#define mkldnn_config
#define mkldnn_convolution
#define mkldnn_convolution_auto
#define mkldnn_convolution_backward_data_desc_init
#define mkldnn_convolution_backward_weights_desc_init
#define mkldnn_convolution_desc_t
#define mkldnn_convolution_direct
#define mkldnn_convolution_forward_desc_init
#define mkldnn_convolution_winograd
#define mkldnn_cpu
#define mkldnn_data_type_t
#define mkldnn_data_type_undef
#define mkldnn_decab
#define mkldnn_deconvolution
#define mkldnn_deconvolution_backward_data_desc_init
#define mkldnn_deconvolution_backward_weights_desc_init
#define mkldnn_deconvolution_desc_t
#define mkldnn_deconvolution_direct
#define mkldnn_deconvolution_forward_desc_init
#define mkldnn_deconvolution_winograd
#define mkldnn_dhwio
#define mkldnn_dilated_convolution_backward_data_desc_init
#define mkldnn_dilated_convolution_backward_weights_desc_init
#define mkldnn_dilated_convolution_forward_desc_init
#define mkldnn_dilated_deconvolution_backward_data_desc_init
#define mkldnn_dilated_deconvolution_backward_weights_desc_init
#define mkldnn_dilated_deconvolution_forward_desc_init
#define mkldnn_dim_t
#define mkldnn_dims_t
#define mkldnn_dt2str
#define mkldnn_eltwise
#define mkldnn_eltwise_abs
#define mkldnn_eltwise_backward_desc_init
#define mkldnn_eltwise_bounded_relu
#define mkldnn_eltwise_desc_t
#define mkldnn_eltwise_elu
#define mkldnn_eltwise_exp
#define mkldnn_eltwise_forward_desc_init
#define mkldnn_eltwise_gelu
#define mkldnn_eltwise_linear
#define mkldnn_eltwise_logistic
#define mkldnn_eltwise_relu
#define mkldnn_eltwise_soft_relu
#define mkldnn_eltwise_sqrt
#define mkldnn_eltwise_square
#define mkldnn_eltwise_swish
#define mkldnn_eltwise_tanh
#define mkldnn_engine
#define mkldnn_engine_create
#define mkldnn_engine_create_ocl
#define mkldnn_engine_destroy
#define mkldnn_engine_get_count
#define mkldnn_engine_get_kind
#define mkldnn_engine_get_ocl_context
#define mkldnn_engine_get_ocl_device
#define mkldnn_engine_kind2str
#define mkldnn_engine_kind_t
#define mkldnn_engine_t
#define mkldnn_exec_arg_t
#define mkldnn_f16
#define mkldnn_f32
#define mkldnn_fmt_kind2str
#define mkldnn_fmt_tag2str
#define mkldnn_format_kind_any
#define mkldnn_format_kind_rnn_packed
#define mkldnn_format_kind_t
#define mkldnn_format_kind_undef
#define mkldnn_format_kind_wino
#define mkldnn_format_tag_any
#define mkldnn_format_tag_last
#define mkldnn_format_tag_t
#define mkldnn_format_tag_undef
#define mkldnn_forward
#define mkldnn_forward_inference
#define mkldnn_forward_scoring
#define mkldnn_forward_training
#define mkldnn_fuse_norm_relu
#define mkldnn_gIOdhw16i16o
#define mkldnn_gIOdhw16o16i
#define mkldnn_gIOdhw8o16i2o
#define mkldnn_gIOhw16i16o
#define mkldnn_gIOhw16o16i
#define mkldnn_gIOhw8o16i2o
#define mkldnn_gIOw16i16o
#define mkldnn_gIOw16o16i
#define mkldnn_gIOw8o16i2o
#define mkldnn_gOIdhw16i16o
#define mkldnn_gOIdhw16o16i
#define mkldnn_gOIdhw4i16o4i
#define mkldnn_gOIdhw4i4o
#define mkldnn_gOIdhw4o4i
#define mkldnn_gOIdhw8i16o2i
#define mkldnn_gOIdhw8i8o
#define mkldnn_gOIdhw8o16i2o
#define mkldnn_gOIdhw8o8i
#define mkldnn_gOIhw16i16o
#define mkldnn_gOIhw16i16o2i
#define mkldnn_gOIhw16i16o4i
#define mkldnn_gOIhw16o16i
#define mkldnn_gOIhw2i8o4i
#define mkldnn_gOIhw2o8i8o2i
#define mkldnn_gOIhw4i16o4i
#define mkldnn_gOIhw4i4o
#define mkldnn_gOIhw4o4i
#define mkldnn_gOIhw4o8i8o4i
#define mkldnn_gOIhw8i16o2i
#define mkldnn_gOIhw8i8o
#define mkldnn_gOIhw8o16i2o
#define mkldnn_gOIhw8o8i
#define mkldnn_gOIw16i16o
#define mkldnn_gOIw16o16i
#define mkldnn_gOIw4i16o4i
#define mkldnn_gOIw4i4o
#define mkldnn_gOIw4o4i
#define mkldnn_gOIw8i16o2i
#define mkldnn_gOIw8i8o
#define mkldnn_gOIw8o16i2o
#define mkldnn_gOIw8o8i
#define mkldnn_gOdhwi16o
#define mkldnn_gOdhwi4o
#define mkldnn_gOdhwi8o
#define mkldnn_gOhwi16o
#define mkldnn_gOhwi32o
#define mkldnn_gOhwi4o
#define mkldnn_gOhwi8o
#define mkldnn_gOidhw16o
#define mkldnn_gOidhw4o
#define mkldnn_gOihw16o
#define mkldnn_gOihw4o
#define mkldnn_gOiw16o
#define mkldnn_gOiw4o
#define mkldnn_gOwi16o
#define mkldnn_gOwi4o
#define mkldnn_gOwi8o
#define mkldnn_gemm
#define mkldnn_gemm_s8s8s32
#define mkldnn_gemm_u8s8s32
#define mkldnn_giohw
#define mkldnn_goidhw
#define mkldnn_goihw
#define mkldnn_goiw
#define mkldnn_gpu
#define mkldnn_gru_backward_desc_init
#define mkldnn_gru_forward_desc_init
#define mkldnn_hwigo
#define mkldnn_hwio
#define mkldnn_idhwo
#define mkldnn_ihwo
#define mkldnn_inner_product
#define mkldnn_inner_product_backward_data_desc_init
#define mkldnn_inner_product_backward_weights_desc_init
#define mkldnn_inner_product_desc_t
#define mkldnn_inner_product_forward_desc_init
#define mkldnn_invalid_arguments
#define mkldnn_io
#define mkldnn_iohw
#define mkldnn_iterator_ends
#define mkldnn_iwo
#define mkldnn_layer_normalization
#define mkldnn_layer_normalization_backward_desc_init
#define mkldnn_layer_normalization_desc_t
#define mkldnn_layer_normalization_forward_desc_init
#define mkldnn_lbr_gru
#define mkldnn_lbr_gru_backward_desc_init
#define mkldnn_lbr_gru_forward_desc_init
#define mkldnn_ldgo
#define mkldnn_ldgoi
#define mkldnn_ldgoi_p
#define mkldnn_ldigo
#define mkldnn_ldigo_p
#define mkldnn_ldnc
#define mkldnn_lrn
#define mkldnn_lrn_across_channels
#define mkldnn_lrn_backward_desc_init
#define mkldnn_lrn_desc_t
#define mkldnn_lrn_forward_desc_init
#define mkldnn_lrn_within_channel
#define mkldnn_lstm_backward_desc_init
#define mkldnn_lstm_forward_desc_init
#define mkldnn_md2dim_str
#define mkldnn_md2fmt_str
#define mkldnn_memory
#define mkldnn_memory_create
#define mkldnn_memory_desc_equal
#define mkldnn_memory_desc_get_size
#define mkldnn_memory_desc_init_by_strides
#define mkldnn_memory_desc_init_by_tag
#define mkldnn_memory_desc_init_submemory
#define mkldnn_memory_desc_t
#define mkldnn_memory_destroy
#define mkldnn_memory_extra_desc_t
#define mkldnn_memory_extra_flag_compensation_conv_s8s8
#define mkldnn_memory_extra_flag_none
#define mkldnn_memory_extra_flag_scale_adjust
#define mkldnn_memory_extra_flags_t
#define mkldnn_memory_get_data_handle
#define mkldnn_memory_get_engine
#define mkldnn_memory_get_memory_desc
#define mkldnn_memory_get_ocl_mem_object
#define mkldnn_memory_map_data
#define mkldnn_memory_set_data_handle
#define mkldnn_memory_set_ocl_mem_object
#define mkldnn_memory_t
#define mkldnn_memory_unmap_data
#define mkldnn_nCdhw16c
#define mkldnn_nCdhw4c
#define mkldnn_nCdhw8c
#define mkldnn_nChw16c
#define mkldnn_nChw4c
#define mkldnn_nChw8c
#define mkldnn_nCw16c
#define mkldnn_nCw4c
#define mkldnn_nCw8c
#define mkldnn_nc
#define mkldnn_ncdhw
#define mkldnn_nchw
#define mkldnn_ncw
#define mkldnn_ndhwc
#define mkldnn_nhwc
#define mkldnn_normalization_flags2str
#define mkldnn_normalization_flags_t
#define mkldnn_not_required
#define mkldnn_nt
#define mkldnn_ntc
#define mkldnn_nwc
#define mkldnn_odhwi
#define mkldnn_ohwi
#define mkldnn_oi
#define mkldnn_oidhw
#define mkldnn_oihw
#define mkldnn_oiw
#define mkldnn_op_desc_t
#define mkldnn_out_of_memory
#define mkldnn_owi
#define mkldnn_packed_format_undef
#define mkldnn_pooling
#define mkldnn_pooling_avg
#define mkldnn_pooling_avg_exclude_padding
#define mkldnn_pooling_avg_include_padding
#define mkldnn_pooling_backward_desc_init
#define mkldnn_pooling_desc_t
#define mkldnn_pooling_forward_desc_init
#define mkldnn_pooling_max
#define mkldnn_post_ops
#define mkldnn_post_ops_append_eltwise
#define mkldnn_post_ops_append_sum
#define mkldnn_post_ops_create
#define mkldnn_post_ops_destroy
#define mkldnn_post_ops_get_kind
#define mkldnn_post_ops_get_params_eltwise
#define mkldnn_post_ops_get_params_sum
#define mkldnn_post_ops_len
#define mkldnn_post_ops_t
#define mkldnn_prim_kind2str
#define mkldnn_primitive
#define mkldnn_primitive_attr
#define mkldnn_primitive_attr_clone
#define mkldnn_primitive_attr_create
#define mkldnn_primitive_attr_destroy
#define mkldnn_primitive_attr_get_output_scales
#define mkldnn_primitive_attr_get_post_ops
#define mkldnn_primitive_attr_get_scratchpad_mode
#define mkldnn_primitive_attr_set_output_scales
#define mkldnn_primitive_attr_set_post_ops
#define mkldnn_primitive_attr_set_rnn_data_qparams
#define mkldnn_primitive_attr_set_rnn_weights_qparams
#define mkldnn_primitive_attr_set_scratchpad_mode
#define mkldnn_primitive_attr_t
#define mkldnn_primitive_create
#define mkldnn_primitive_desc
#define mkldnn_primitive_desc_clone
#define mkldnn_primitive_desc_create
#define mkldnn_primitive_desc_destroy
#define mkldnn_primitive_desc_get_attr
#define mkldnn_primitive_desc_iterator
#define mkldnn_primitive_desc_iterator_create
#define mkldnn_primitive_desc_iterator_destroy
#define mkldnn_primitive_desc_iterator_fetch
#define mkldnn_primitive_desc_iterator_next
#define mkldnn_primitive_desc_iterator_t
#define mkldnn_primitive_desc_query
#define mkldnn_primitive_desc_query_md
#define mkldnn_primitive_desc_query_pd
#define mkldnn_primitive_desc_query_s32
#define mkldnn_primitive_desc_t
#define mkldnn_primitive_destroy
#define mkldnn_primitive_execute
#define mkldnn_primitive_get_primitive_desc
#define mkldnn_primitive_kind_t
#define mkldnn_primitive_t
#define mkldnn_prop_kind2str
#define mkldnn_prop_kind_t
#define mkldnn_prop_kind_undef
#define mkldnn_query_batch_normalization_d
#define mkldnn_query_convolution_d
#define mkldnn_query_deconvolution_d
#define mkldnn_query_diff_dst_md
#define mkldnn_query_diff_src_md
#define mkldnn_query_diff_weights_md
#define mkldnn_query_dst_md
#define mkldnn_query_eltwise_d
#define mkldnn_query_engine
#define mkldnn_query_gemm_d
#define mkldnn_query_impl_info_str
#define mkldnn_query_inner_product_d
#define mkldnn_query_layer_normalization_d
#define mkldnn_query_lrn_d
#define mkldnn_query_memory_consumption_s64
#define mkldnn_query_num_of_inputs_s32
#define mkldnn_query_num_of_outputs_s32
#define mkldnn_query_op_d
#define mkldnn_query_pooling_d
#define mkldnn_query_primitive_kind
#define mkldnn_query_rnn_d
#define mkldnn_query_scratchpad_engine
#define mkldnn_query_scratchpad_md
#define mkldnn_query_shuffle_d
#define mkldnn_query_softmax_d
#define mkldnn_query_some_d
#define mkldnn_query_some_md
#define mkldnn_query_src_md
#define mkldnn_query_t
#define mkldnn_query_time_estimate_f64
#define mkldnn_query_undef
#define mkldnn_query_weights_md
#define mkldnn_query_workspace_md
#define mkldnn_reorder
#define mkldnn_reorder_primitive_desc_create
#define mkldnn_rnn
#define mkldnn_rnn_desc_t
#define mkldnn_rnn_direction2str
#define mkldnn_rnn_direction_t
#define mkldnn_rnn_flags2str
#define mkldnn_rnn_flags_t
#define mkldnn_rnn_flags_undef
#define mkldnn_rnn_packed_desc_t
#define mkldnn_rnn_packed_memory_format_t
#define mkldnn_runtime_error
#define mkldnn_s32
#define mkldnn_s8
#define mkldnn_scratchpad_mode2str
#define mkldnn_scratchpad_mode_library
#define mkldnn_scratchpad_mode_t
#define mkldnn_scratchpad_mode_user
#define mkldnn_set_jit_dump
#define mkldnn_set_verbose
#define mkldnn_sgemm
#define mkldnn_shuffle
#define mkldnn_shuffle_backward_desc_init
#define mkldnn_shuffle_desc_t
#define mkldnn_shuffle_forward_desc_init
#define mkldnn_softmax
#define mkldnn_softmax_backward_desc_init
#define mkldnn_softmax_desc_t
#define mkldnn_softmax_forward_desc_init
#define mkldnn_status2str
#define mkldnn_status_t
#define mkldnn_stream
#define mkldnn_stream_create
#define mkldnn_stream_create_ocl
#define mkldnn_stream_default_flags
#define mkldnn_stream_destroy
#define mkldnn_stream_flags_t
#define mkldnn_stream_get_ocl_command_queue
#define mkldnn_stream_in_order
#define mkldnn_stream_out_of_order
#define mkldnn_stream_t
#define mkldnn_stream_wait
#define mkldnn_success
#define mkldnn_sum
#define mkldnn_sum_primitive_desc_create
#define mkldnn_tn
#define mkldnn_tnc
#define mkldnn_types
#define mkldnn_u8
#define mkldnn_undefined_primitive
#define mkldnn_unidirectional
#define mkldnn_unidirectional_left2right
#define mkldnn_unidirectional_right2left
#define mkldnn_unimplemented
#define mkldnn_use_global_stats
#define mkldnn_use_scaleshift
#define mkldnn_vanilla_gru
#define mkldnn_vanilla_lstm
#define mkldnn_vanilla_rnn
#define mkldnn_vanilla_rnn_backward_desc_init
#define mkldnn_vanilla_rnn_forward_desc_init
#define mkldnn_version
#define mkldnn_version_t
#define mkldnn_wino_desc_t
#define mkldnn_wino_memory_format_t
#define mkldnn_wino_undef
#define mkldnn_wino_wei_OBaaIBOIio
#define mkldnn_wino_wei_aaOBiOo
#define mkldnn_wino_wei_aaOIoi
#define mkldnn_wino_wei_aaOio
#define mkldnn_wio
#define mkldnn_x