mkldnn (JavaCPP Presets for MKL-DNN 0.18.1-1.5 API)

java.lang.Object
- org.bytedeco.mkldnn.presets.mkldnn
- - org.bytedeco.mkldnn.global.mkldnn

All Implemented Interfaces:

InfoMapper
```
public class mkldnn
extends mkldnn
```

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`algorithm_undef` enum mkldnn::algorithm
`static int`	`backward` enum mkldnn::prop_kind
`static int`	`backward_bias` enum mkldnn::prop_kind
`static int`	`backward_data` enum mkldnn::prop_kind
`static int`	`backward_weights` enum mkldnn::prop_kind
`static int`	`batch_normalization_d` enum mkldnn::query
`static int`	`bidirectional_concat` enum mkldnn::rnn_direction
`static int`	`bidirectional_sum` enum mkldnn::rnn_direction
`static int`	`convolution_auto` enum mkldnn::algorithm
`static int`	`convolution_d` enum mkldnn::query
`static int`	`convolution_direct` enum mkldnn::algorithm
`static int`	`convolution_winograd` enum mkldnn::algorithm
`static int`	`deconvolution_d` enum mkldnn::query
`static int`	`deconvolution_direct` enum mkldnn::algorithm
`static int`	`deconvolution_winograd` enum mkldnn::algorithm
`static int`	`diff_dst_pd` enum mkldnn::query
`static int`	`diff_src_pd` enum mkldnn::query
`static int`	`diff_weights_pd` enum mkldnn::query
`static int`	`dst_pd` enum mkldnn::query
`static int`	`eengine` enum mkldnn::query
`static int`	`eltwise_abs` enum mkldnn::algorithm
`static int`	`eltwise_bounded_relu` enum mkldnn::algorithm
`static int`	`eltwise_d` enum mkldnn::query
`static int`	`eltwise_elu` enum mkldnn::algorithm
`static int`	`eltwise_linear` enum mkldnn::algorithm
`static int`	`eltwise_logistic` enum mkldnn::algorithm
`static int`	`eltwise_relu` enum mkldnn::algorithm
`static int`	`eltwise_soft_relu` enum mkldnn::algorithm
`static int`	`eltwise_sqrt` enum mkldnn::algorithm
`static int`	`eltwise_square` enum mkldnn::algorithm
`static int`	`eltwise_tanh` enum mkldnn::algorithm
`static int`	`forward` enum mkldnn::prop_kind
`static int`	`forward_inference` enum mkldnn::prop_kind
`static int`	`forward_scoring` enum mkldnn::prop_kind
`static int`	`forward_training` enum mkldnn::prop_kind
`static int`	`fuse_bn_relu` enum mkldnn::batch_normalization_flag
`static int`	`gru_linear_before_reset` enum mkldnn::algorithm
`static int`	`impl_info_str` enum mkldnn::query
`static int`	`inner_product_d` enum mkldnn::query
`static int`	`input_pd` enum mkldnn::query
`static int`	`lrn_across_channels` enum mkldnn::algorithm
`static int`	`lrn_d` enum mkldnn::query
`static int`	`lrn_within_channel` enum mkldnn::algorithm
`static int`	`memory_consumption_s64` enum mkldnn::query
`static int`	`memory_d` enum mkldnn::query
`static int`	`mkldnn_alg_kind_undef` enum mkldnn_alg_kind_t
`static int`	`mkldnn_any` enum mkldnn_memory_format_t
`static int`	`mkldnn_any_engine` enum mkldnn_engine_kind_t
`static int`	`mkldnn_any_stream` enum mkldnn_stream_kind_t
`static int`	`mkldnn_backward` enum mkldnn_prop_kind_t
`static int`	`mkldnn_backward_bias` enum mkldnn_prop_kind_t
`static int`	`mkldnn_backward_data` enum mkldnn_prop_kind_t
`static int`	`mkldnn_backward_weights` enum mkldnn_prop_kind_t
`static int`	`mkldnn_batch_normalization` enum mkldnn_primitive_kind_t
`static int`	`mkldnn_bidirectional_concat` enum mkldnn_rnn_direction_t
`static int`	`mkldnn_bidirectional_sum` enum mkldnn_rnn_direction_t
`static int`	`mkldnn_blocked` enum mkldnn_memory_format_t
`static int`	`mkldnn_chwn` enum mkldnn_memory_format_t
`static int`	`mkldnn_concat` enum mkldnn_primitive_kind_t
`static int`	`mkldnn_concat_inplace` enum mkldnn_primitive_kind_t
`static int`	`mkldnn_convolution` enum mkldnn_primitive_kind_t
`static int`	`mkldnn_convolution_auto` enum mkldnn_alg_kind_t
`static int`	`mkldnn_convolution_direct` enum mkldnn_alg_kind_t
`static int`	`mkldnn_convolution_winograd` enum mkldnn_alg_kind_t
`static int`	`mkldnn_cpu` enum mkldnn_engine_kind_t
`static int`	`mkldnn_data_type_undef` enum mkldnn_data_type_t
`static int`	`mkldnn_deconvolution` enum mkldnn_primitive_kind_t
`static int`	`mkldnn_deconvolution_direct` enum mkldnn_alg_kind_t
`static int`	`mkldnn_deconvolution_winograd` enum mkldnn_alg_kind_t
`static int`	`mkldnn_dhwio` enum mkldnn_memory_format_t
`static int`	`mkldnn_eager` enum mkldnn_stream_kind_t
`static int`	`mkldnn_eltwise` enum mkldnn_primitive_kind_t
`static int`	`mkldnn_eltwise_abs` enum mkldnn_alg_kind_t
`static int`	`mkldnn_eltwise_bounded_relu` enum mkldnn_alg_kind_t
`static int`	`mkldnn_eltwise_elu` enum mkldnn_alg_kind_t
`static int`	`mkldnn_eltwise_linear` enum mkldnn_alg_kind_t
`static int`	`mkldnn_eltwise_logistic` enum mkldnn_alg_kind_t
`static int`	`mkldnn_eltwise_relu` enum mkldnn_alg_kind_t
`static int`	`mkldnn_eltwise_soft_relu` enum mkldnn_alg_kind_t
`static int`	`mkldnn_eltwise_sqrt` enum mkldnn_alg_kind_t
`static int`	`mkldnn_eltwise_square` enum mkldnn_alg_kind_t
`static int`	`mkldnn_eltwise_tanh` enum mkldnn_alg_kind_t
`static int`	`mkldnn_f32` enum mkldnn_data_type_t
`static int`	`mkldnn_format_last` enum mkldnn_memory_format_t
`static int`	`mkldnn_format_undef` enum mkldnn_memory_format_t
`static int`	`mkldnn_forward` enum mkldnn_prop_kind_t
`static int`	`mkldnn_forward_inference` enum mkldnn_prop_kind_t
`static int`	`mkldnn_forward_scoring` enum mkldnn_prop_kind_t
`static int`	`mkldnn_forward_training` enum mkldnn_prop_kind_t
`static int`	`mkldnn_fuse_bn_relu` enum mkldnn_batch_normalization_flag_t
`static int`	`mkldnn_giohw` enum mkldnn_memory_format_t
`static int`	`mkldnn_gIOhw16o16i` enum mkldnn_memory_format_t
`static int`	`mkldnn_gIOw16o16i` enum mkldnn_memory_format_t
`static int`	`mkldnn_gOdhwi16o` enum mkldnn_memory_format_t
`static int`	`mkldnn_gOdhwi8o` enum mkldnn_memory_format_t
`static int`	`mkldnn_gOhIw16o4i` enum mkldnn_memory_format_t
`static int`	`mkldnn_gOhwi16o` enum mkldnn_memory_format_t
`static int`	`mkldnn_gOhwi8o` enum mkldnn_memory_format_t
`static int`	`mkldnn_goidhw` enum mkldnn_memory_format_t
`static int`	`mkldnn_gOIdhw16i16o` enum mkldnn_memory_format_t
`static int`	`mkldnn_gOidhw16o` enum mkldnn_memory_format_t
`static int`	`mkldnn_gOIdhw16o16i` enum mkldnn_memory_format_t
`static int`	`mkldnn_gOIdhw8i16o2i` enum mkldnn_memory_format_t
`static int`	`mkldnn_gOIdhw8i8o` enum mkldnn_memory_format_t
`static int`	`mkldnn_gOIdhw8o8i` enum mkldnn_memory_format_t
`static int`	`mkldnn_goihw` enum mkldnn_memory_format_t
`static int`	`mkldnn_Goihw16g` enum mkldnn_memory_format_t
`static int`	`mkldnn_Goihw16g_s8s8` enum mkldnn_memory_format_t
`static int`	`mkldnn_gOIhw16i16o` enum mkldnn_memory_format_t
`static int`	`mkldnn_gOihw16o` enum mkldnn_memory_format_t
`static int`	`mkldnn_gOIhw16o16i` enum mkldnn_memory_format_t
`static int`	`mkldnn_gOIhw4i16o4i` enum mkldnn_memory_format_t
`static int`	`mkldnn_gOIhw4i16o4i_s8s8` enum mkldnn_memory_format_t
`static int`	`mkldnn_Goihw8g` enum mkldnn_memory_format_t
`static int`	`mkldnn_gOIhw8i16o2i` enum mkldnn_memory_format_t
`static int`	`mkldnn_gOIhw8i8o` enum mkldnn_memory_format_t
`static int`	`mkldnn_gOihw8o` enum mkldnn_memory_format_t
`static int`	`mkldnn_gOIhw8o16i2o` enum mkldnn_memory_format_t
`static int`	`mkldnn_gOIhw8o8i` enum mkldnn_memory_format_t
`static int`	`mkldnn_goiw` enum mkldnn_memory_format_t
`static int`	`mkldnn_gOIw16i16o` enum mkldnn_memory_format_t
`static int`	`mkldnn_gOiw16o` enum mkldnn_memory_format_t
`static int`	`mkldnn_gOIw16o16i` enum mkldnn_memory_format_t
`static int`	`mkldnn_gOIw8i16o2i` enum mkldnn_memory_format_t
`static int`	`mkldnn_gOIw8i8o` enum mkldnn_memory_format_t
`static int`	`mkldnn_gOIw8o16i2o` enum mkldnn_memory_format_t
`static int`	`mkldnn_gOIw8o8i` enum mkldnn_memory_format_t
`static int`	`mkldnn_gOwi16o` enum mkldnn_memory_format_t
`static int`	`mkldnn_gOwi8o` enum mkldnn_memory_format_t
`static int`	`mkldnn_gru_linear_before_reset` enum mkldnn_alg_kind_t
`static int`	`mkldnn_hwigo` enum mkldnn_memory_format_t
`static int`	`mkldnn_hwigo_s8s8` enum mkldnn_memory_format_t
`static int`	`mkldnn_hwio` enum mkldnn_memory_format_t
`static int`	`mkldnn_hwio_s8s8` enum mkldnn_memory_format_t
`static int`	`mkldnn_ihwo` enum mkldnn_memory_format_t
`static int`	`mkldnn_inner_product` enum mkldnn_primitive_kind_t
`static int`	`mkldnn_invalid_arguments` enum mkldnn_status_t
`static int`	`mkldnn_io` enum mkldnn_memory_format_t
`static int`	`mkldnn_iohw` enum mkldnn_memory_format_t
`static int`	`mkldnn_IOhw16o16i` enum mkldnn_memory_format_t
`static int`	`mkldnn_IOw16o16i` enum mkldnn_memory_format_t
`static int`	`mkldnn_iterator_ends` enum mkldnn_status_t
`static int`	`mkldnn_lazy` enum mkldnn_stream_kind_t
`static int`	`mkldnn_ldgo` enum mkldnn_memory_format_t
`static int`	`mkldnn_ldgoi` enum mkldnn_memory_format_t
`static int`	`mkldnn_ldgoi_p` enum mkldnn_rnn_packed_memory_format_t
`static int`	`mkldnn_ldigo` enum mkldnn_memory_format_t
`static int`	`mkldnn_ldigo_p` enum mkldnn_rnn_packed_memory_format_t
`static int`	`mkldnn_ldsnc` enum mkldnn_memory_format_t
`static int`	`mkldnn_lrn` enum mkldnn_primitive_kind_t
`static int`	`mkldnn_lrn_across_channels` enum mkldnn_alg_kind_t
`static int`	`mkldnn_lrn_within_channel` enum mkldnn_alg_kind_t
`static int`	`mkldnn_memory` enum mkldnn_primitive_kind_t
`static int`	`mkldnn_nc` enum mkldnn_memory_format_t
`static int`	`mkldnn_ncdhw` enum mkldnn_memory_format_t
`static int`	`mkldnn_nCdhw16c` enum mkldnn_memory_format_t
`static int`	`mkldnn_nCdhw8c` enum mkldnn_memory_format_t
`static int`	`mkldnn_nchw` enum mkldnn_memory_format_t
`static int`	`mkldnn_nChw16c` enum mkldnn_memory_format_t
`static int`	`mkldnn_nChw8c` enum mkldnn_memory_format_t
`static int`	`mkldnn_ncw` enum mkldnn_memory_format_t
`static int`	`mkldnn_nCw16c` enum mkldnn_memory_format_t
`static int`	`mkldnn_nCw8c` enum mkldnn_memory_format_t
`static int`	`mkldnn_ndhwc` enum mkldnn_memory_format_t
`static int`	`mkldnn_nhwc` enum mkldnn_memory_format_t
`static int`	`mkldnn_not_ready` enum mkldnn_status_t
`static int`	`mkldnn_not_required` enum mkldnn_status_t
`static int`	`mkldnn_ntc` enum mkldnn_memory_format_t
`static int`	`mkldnn_nwc` enum mkldnn_memory_format_t
`static int`	`mkldnn_Odhwi16o` enum mkldnn_memory_format_t
`static int`	`mkldnn_Odhwi8o` enum mkldnn_memory_format_t
`static int`	`mkldnn_OhIw16o4i` enum mkldnn_memory_format_t
`static int`	`mkldnn_Ohwi16o` enum mkldnn_memory_format_t
`static int`	`mkldnn_Ohwi8o` enum mkldnn_memory_format_t
`static int`	`mkldnn_oi` enum mkldnn_memory_format_t
`static int`	`mkldnn_oidhw` enum mkldnn_memory_format_t
`static int`	`mkldnn_oIdhw16i` enum mkldnn_memory_format_t
`static int`	`mkldnn_OIdhw16i16o` enum mkldnn_memory_format_t
`static int`	`mkldnn_Oidhw16o` enum mkldnn_memory_format_t
`static int`	`mkldnn_OIdhw16o16i` enum mkldnn_memory_format_t
`static int`	`mkldnn_oIdhw8i` enum mkldnn_memory_format_t
`static int`	`mkldnn_OIdhw8i16o2i` enum mkldnn_memory_format_t
`static int`	`mkldnn_OIdhw8i8o` enum mkldnn_memory_format_t
`static int`	`mkldnn_OIdhw8o8i` enum mkldnn_memory_format_t
`static int`	`mkldnn_oihw` enum mkldnn_memory_format_t
`static int`	`mkldnn_oIhw16i` enum mkldnn_memory_format_t
`static int`	`mkldnn_OIhw16i16o` enum mkldnn_memory_format_t
`static int`	`mkldnn_Oihw16o` enum mkldnn_memory_format_t
`static int`	`mkldnn_OIhw16o16i` enum mkldnn_memory_format_t
`static int`	`mkldnn_OIhw4i16o4i` enum mkldnn_memory_format_t
`static int`	`mkldnn_OIhw4i16o4i_s8s8` enum mkldnn_memory_format_t
`static int`	`mkldnn_oIhw8i` enum mkldnn_memory_format_t
`static int`	`mkldnn_OIhw8i16o2i` enum mkldnn_memory_format_t
`static int`	`mkldnn_OIhw8i8o` enum mkldnn_memory_format_t
`static int`	`mkldnn_Oihw8o` enum mkldnn_memory_format_t
`static int`	`mkldnn_OIhw8o16i2o` enum mkldnn_memory_format_t
`static int`	`mkldnn_OIhw8o8i` enum mkldnn_memory_format_t
`static int`	`mkldnn_oiw` enum mkldnn_memory_format_t
`static int`	`mkldnn_OIw16i16o` enum mkldnn_memory_format_t
`static int`	`mkldnn_Oiw16o` enum mkldnn_memory_format_t
`static int`	`mkldnn_OIw16o16i` enum mkldnn_memory_format_t
`static int`	`mkldnn_OIw8i16o2i` enum mkldnn_memory_format_t
`static int`	`mkldnn_OIw8i8o` enum mkldnn_memory_format_t
`static int`	`mkldnn_OIw8o16i2o` enum mkldnn_memory_format_t
`static int`	`mkldnn_OIw8o8i` enum mkldnn_memory_format_t
`static int`	`mkldnn_out_of_memory` enum mkldnn_status_t
`static int`	`mkldnn_Owi16o` enum mkldnn_memory_format_t
`static int`	`mkldnn_Owi8o` enum mkldnn_memory_format_t
`static int`	`mkldnn_packed_format_undef` enum mkldnn_rnn_packed_memory_format_t
`static int`	`mkldnn_padding_zero` enum mkldnn_padding_kind_t
`static int`	`mkldnn_pooling` enum mkldnn_primitive_kind_t
`static int`	`mkldnn_pooling_avg` enum mkldnn_alg_kind_t
`static int`	`mkldnn_pooling_avg_exclude_padding` enum mkldnn_alg_kind_t
`static int`	`mkldnn_pooling_avg_include_padding` enum mkldnn_alg_kind_t
`static int`	`mkldnn_pooling_max` enum mkldnn_alg_kind_t
`static int`	`mkldnn_prop_kind_undef` enum mkldnn_prop_kind_t
`static int`	`mkldnn_query_batch_normalization_d` enum mkldnn_query_t
`static int`	`mkldnn_query_convolution_d` enum mkldnn_query_t
`static int`	`mkldnn_query_deconvolution_d` enum mkldnn_query_t
`static int`	`mkldnn_query_diff_dst_pd` enum mkldnn_query_t
`static int`	`mkldnn_query_diff_src_pd` enum mkldnn_query_t
`static int`	`mkldnn_query_diff_weights_pd` enum mkldnn_query_t
`static int`	`mkldnn_query_dst_pd` enum mkldnn_query_t
`static int`	`mkldnn_query_eltwise_d` enum mkldnn_query_t
`static int`	`mkldnn_query_engine` enum mkldnn_query_t
`static int`	`mkldnn_query_impl_info_str` enum mkldnn_query_t
`static int`	`mkldnn_query_inner_product_d` enum mkldnn_query_t
`static int`	`mkldnn_query_input_pd` enum mkldnn_query_t
`static int`	`mkldnn_query_lrn_d` enum mkldnn_query_t
`static int`	`mkldnn_query_memory_consumption_s64` enum mkldnn_query_t
`static int`	`mkldnn_query_memory_d` enum mkldnn_query_t
`static int`	`mkldnn_query_num_of_inputs_s32` enum mkldnn_query_t
`static int`	`mkldnn_query_num_of_outputs_s32` enum mkldnn_query_t
`static int`	`mkldnn_query_op_d` enum mkldnn_query_t
`static int`	`mkldnn_query_output_pd` enum mkldnn_query_t
`static int`	`mkldnn_query_pooling_d` enum mkldnn_query_t
`static int`	`mkldnn_query_primitive_kind` enum mkldnn_query_t
`static int`	`mkldnn_query_rnn_d` enum mkldnn_query_t
`static int`	`mkldnn_query_shuffle_d` enum mkldnn_query_t
`static int`	`mkldnn_query_softmax_d` enum mkldnn_query_t
`static int`	`mkldnn_query_some_d` enum mkldnn_query_t
`static int`	`mkldnn_query_some_pd` enum mkldnn_query_t
`static int`	`mkldnn_query_src_pd` enum mkldnn_query_t
`static int`	`mkldnn_query_time_estimate_f64` enum mkldnn_query_t
`static int`	`mkldnn_query_undef` enum mkldnn_query_t
`static int`	`mkldnn_query_weights_pd` enum mkldnn_query_t
`static int`	`mkldnn_query_workspace_pd` enum mkldnn_query_t
`static int`	`mkldnn_reorder` enum mkldnn_primitive_kind_t
`static int`	`mkldnn_rnn` enum mkldnn_primitive_kind_t
`static int`	`mkldnn_rnn_cell_with_clipping` enum mkldnn_rnn_cell_flags_t
`static int`	`mkldnn_rnn_cell_with_relu` enum mkldnn_rnn_cell_flags_t
`static int`	`MKLDNN_RNN_MAX_N_PARTS`
`static int`	`mkldnn_rnn_packed` enum mkldnn_memory_format_t
`static int`	`mkldnn_round_down` enum mkldnn_round_mode_t
`static int`	`mkldnn_round_nearest` enum mkldnn_round_mode_t
`static int`	`mkldnn_runtime_error` enum mkldnn_status_t
`static int`	`mkldnn_s16` enum mkldnn_data_type_t
`static int`	`mkldnn_s32` enum mkldnn_data_type_t
`static int`	`mkldnn_s8` enum mkldnn_data_type_t
`static int`	`mkldnn_shuffle` enum mkldnn_primitive_kind_t
`static int`	`mkldnn_softmax` enum mkldnn_primitive_kind_t
`static int`	`mkldnn_success` enum mkldnn_status_t
`static int`	`mkldnn_sum` enum mkldnn_primitive_kind_t
`static int`	`mkldnn_tnc` enum mkldnn_memory_format_t
`static int`	`mkldnn_try_again` enum mkldnn_status_t
`static int`	`mkldnn_u8` enum mkldnn_data_type_t
`static int`	`mkldnn_undefined_primitive` enum mkldnn_primitive_kind_t
`static int`	`mkldnn_unidirectional` enum mkldnn_rnn_direction_t
`static int`	`mkldnn_unidirectional_left2right` enum mkldnn_rnn_direction_t
`static int`	`mkldnn_unidirectional_right2left` enum mkldnn_rnn_direction_t
`static int`	`mkldnn_unimplemented` enum mkldnn_status_t
`static int`	`mkldnn_use_global_stats` enum mkldnn_batch_normalization_flag_t
`static int`	`mkldnn_use_scaleshift` enum mkldnn_batch_normalization_flag_t
`static int`	`mkldnn_vanilla_gru` enum mkldnn_alg_kind_t
`static int`	`mkldnn_vanilla_lstm` enum mkldnn_alg_kind_t
`static int`	`mkldnn_vanilla_rnn` enum mkldnn_alg_kind_t
`static int`	`mkldnn_view` enum mkldnn_primitive_kind_t
`static int`	`mkldnn_wino_fmt` enum mkldnn_memory_format_t
`static int`	`mkldnn_wino_undef` enum mkldnn_wino_memory_format_t
`static int`	`mkldnn_wino_wei_aaOBiOo` enum mkldnn_wino_memory_format_t
`static int`	`mkldnn_wino_wei_aaOio` enum mkldnn_wino_memory_format_t
`static int`	`mkldnn_wino_wei_aaOIoi` enum mkldnn_wino_memory_format_t
`static int`	`mkldnn_wino_wei_OBaaIBOIio` enum mkldnn_wino_memory_format_t
`static int`	`mkldnn_wio` enum mkldnn_memory_format_t
`static int`	`mkldnn_x` enum mkldnn_memory_format_t
`static int`	`num_of_inputs_s32` enum mkldnn::query
`static int`	`num_of_outputs_s32` enum mkldnn::query
`static int`	`op_d` enum mkldnn::query
`static int`	`output_pd` enum mkldnn::query
`static int`	`pooling_avg` enum mkldnn::algorithm
`static int`	`pooling_avg_exclude_padding` enum mkldnn::algorithm
`static int`	`pooling_avg_include_padding` enum mkldnn::algorithm
`static int`	`pooling_d` enum mkldnn::query
`static int`	`pooling_max` enum mkldnn::algorithm
`static int`	`primitive_kind` enum mkldnn::query
`static int`	`rnn_d` enum mkldnn::query
`static int`	`round_down` enum mkldnn::round_mode
`static int`	`round_nearest` enum mkldnn::round_mode
`static int`	`shuffle_d` enum mkldnn::query
`static int`	`softmax_d` enum mkldnn::query
`static int`	`src_pd` enum mkldnn::query
`static int`	`TENSOR_MAX_DIMS` Maximum number of dimensions a tensor can have.
`static int`	`time_estimate_f64` enum mkldnn::query
`static int`	`undef` enum mkldnn::query
`static int`	`unidirectional` enum mkldnn::rnn_direction
`static int`	`unidirectional_left2right` enum mkldnn::rnn_direction
`static int`	`unidirectional_right2left` enum mkldnn::rnn_direction
`static int`	`use_global_stats` enum mkldnn::batch_normalization_flag
`static int`	`use_scale_shift` enum mkldnn::batch_normalization_flag
`static int`	`vanilla_gru` enum mkldnn::algorithm
`static int`	`vanilla_lstm` enum mkldnn::algorithm
`static int`	`vanilla_rnn` enum mkldnn::algorithm
`static int`	`weights_pd` enum mkldnn::query
`static int`	`workspace_pd` enum mkldnn::query
`static int`	`zero` enum mkldnn::padding_kind

Constructor Summary

Constructors
Constructor and Description

mkldnn()

Constructors
Constructor and Description
`mkldnn()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static void`	`check_num_parameters(mkldnn_primitive_desc aprimitive_desc, int n_inputs, int n_outputs, BytePointer prim_name)`
`static void`	`check_num_parameters(mkldnn_primitive_desc aprimitive_desc, int n_inputs, int n_outputs, String prim_name)`
`static int`	`convert_to_c(int akind)` \addtogroup cpp_api C++ API \{
`static boolean`	`equals(int a, int b)`
`static boolean`	`is_null_memory(mkldnn_primitive aprimitive)`
`static int`	`mkldnn_batch_normalization_backward_desc_init(mkldnn_batch_normalization_desc_t bnrm_desc, int prop_kind, mkldnn_memory_desc_t diff_data_desc, mkldnn_memory_desc_t data_desc, float epsilon, int flags)` Initializes a batch normalization descriptor \p bnrm_desc for backward propagation with respect to data and scale-shift parameters using memory descriptors \p data_desc and \p diff_data_desc, normalization parameter \p epsilon, and \p flags set using bit flags of type mkldnn_batch_normalization_desc_t.
`static int`	`mkldnn_batch_normalization_forward_desc_init(mkldnn_batch_normalization_desc_t bnrm_desc, int prop_kind, mkldnn_memory_desc_t data_desc, float epsilon, int flags)` Initializes a batch normalization descriptor \p bnrm_desc for forward propagation using \p prop_kind (possible values are #mkldnn_forward_training and #mkldnn_forward_inference), memory descriptor \p data_desc, normalization parameter \p epsilon, and \p flags set using bit flags of type mkldnn_batch_normalization_desc_t.
`static int`	`mkldnn_concat_primitive_desc_create(mkldnn_primitive_desc concat_primitive_desc, mkldnn_memory_desc_t output_desc, int n, int concat_dimension, mkldnn_primitive_desc input_pds)` Creates out-of-place \p concat_primitive_desc for concatenation of \p n inputs by \p concat_dimension with resulting \p output_desc memory descriptor.
`static int`	`mkldnn_concat_primitive_desc_create(PointerPointer concat_primitive_desc, mkldnn_memory_desc_t output_desc, int n, int concat_dimension, PointerPointer input_pds)`
`static int`	`mkldnn_convolution_backward_data_desc_init(mkldnn_convolution_desc_t conv_desc, int alg_kind, mkldnn_memory_desc_t diff_src_desc, mkldnn_memory_desc_t weights_desc, mkldnn_memory_desc_t diff_dst_desc, int[] strides, int[] padding_l, int[] padding_r, int padding_kind)`
`static int`	`mkldnn_convolution_backward_data_desc_init(mkldnn_convolution_desc_t conv_desc, int alg_kind, mkldnn_memory_desc_t diff_src_desc, mkldnn_memory_desc_t weights_desc, mkldnn_memory_desc_t diff_dst_desc, IntBuffer strides, IntBuffer padding_l, IntBuffer padding_r, int padding_kind)`
`static int`	`mkldnn_convolution_backward_data_desc_init(mkldnn_convolution_desc_t conv_desc, int alg_kind, mkldnn_memory_desc_t diff_src_desc, mkldnn_memory_desc_t weights_desc, mkldnn_memory_desc_t diff_dst_desc, IntPointer strides, IntPointer padding_l, IntPointer padding_r, int padding_kind)` Initializes a convolution descriptor \p conv_desc for backward propagation with respect to data using \p alg_kind, memory descriptors, \p strides, \p padding_l, \p padding_r, and \p padding_kind.
`static int`	`mkldnn_convolution_backward_weights_desc_init(mkldnn_convolution_desc_t conv_desc, int alg_kind, mkldnn_memory_desc_t src_desc, mkldnn_memory_desc_t diff_weights_desc, mkldnn_memory_desc_t diff_bias_desc, mkldnn_memory_desc_t diff_dst_desc, int[] strides, int[] padding_l, int[] padding_r, int padding_kind)`
`static int`	`mkldnn_convolution_backward_weights_desc_init(mkldnn_convolution_desc_t conv_desc, int alg_kind, mkldnn_memory_desc_t src_desc, mkldnn_memory_desc_t diff_weights_desc, mkldnn_memory_desc_t diff_bias_desc, mkldnn_memory_desc_t diff_dst_desc, IntBuffer strides, IntBuffer padding_l, IntBuffer padding_r, int padding_kind)`
`static int`	`mkldnn_convolution_backward_weights_desc_init(mkldnn_convolution_desc_t conv_desc, int alg_kind, mkldnn_memory_desc_t src_desc, mkldnn_memory_desc_t diff_weights_desc, mkldnn_memory_desc_t diff_bias_desc, mkldnn_memory_desc_t diff_dst_desc, IntPointer strides, IntPointer padding_l, IntPointer padding_r, int padding_kind)` Initializes a convolution descriptor \p conv_desc for backward propagation with respect to weights using \p alg_kind, memory descriptors, \p strides, \p padding_l, \p padding_r, and \p padding_kind.
`static int`	`mkldnn_convolution_forward_desc_init(mkldnn_convolution_desc_t conv_desc, int prop_kind, int alg_kind, mkldnn_memory_desc_t src_desc, mkldnn_memory_desc_t weights_desc, mkldnn_memory_desc_t bias_desc, mkldnn_memory_desc_t dst_desc, int[] strides, int[] padding_l, int[] padding_r, int padding_kind)`
`static int`	`mkldnn_convolution_forward_desc_init(mkldnn_convolution_desc_t conv_desc, int prop_kind, int alg_kind, mkldnn_memory_desc_t src_desc, mkldnn_memory_desc_t weights_desc, mkldnn_memory_desc_t bias_desc, mkldnn_memory_desc_t dst_desc, IntBuffer strides, IntBuffer padding_l, IntBuffer padding_r, int padding_kind)`
`static int`	`mkldnn_convolution_forward_desc_init(mkldnn_convolution_desc_t conv_desc, int prop_kind, int alg_kind, mkldnn_memory_desc_t src_desc, mkldnn_memory_desc_t weights_desc, mkldnn_memory_desc_t bias_desc, mkldnn_memory_desc_t dst_desc, IntPointer strides, IntPointer padding_l, IntPointer padding_r, int padding_kind)` Initializes a convolution descriptor \p conv_desc for forward propagation using \p prop_kind (possible values are #mkldnn_forward_training and #mkldnn_forward_inference), \p alg_kind, memory descriptors, \p strides, \p padding_l, \p padding_r, and \p padding_kind.
`static int`	`mkldnn_deconvolution_backward_data_desc_init(mkldnn_convolution_desc_t conv_desc, int alg_kind, mkldnn_memory_desc_t diff_src_desc, mkldnn_memory_desc_t weights_desc, mkldnn_memory_desc_t diff_dst_desc, int[] strides, int[] padding_l, int[] padding_r, int padding_kind)`
`static int`	`mkldnn_deconvolution_backward_data_desc_init(mkldnn_convolution_desc_t conv_desc, int alg_kind, mkldnn_memory_desc_t diff_src_desc, mkldnn_memory_desc_t weights_desc, mkldnn_memory_desc_t diff_dst_desc, IntBuffer strides, IntBuffer padding_l, IntBuffer padding_r, int padding_kind)`
`static int`	`mkldnn_deconvolution_backward_data_desc_init(mkldnn_convolution_desc_t conv_desc, int alg_kind, mkldnn_memory_desc_t diff_src_desc, mkldnn_memory_desc_t weights_desc, mkldnn_memory_desc_t diff_dst_desc, IntPointer strides, IntPointer padding_l, IntPointer padding_r, int padding_kind)` Initializes a deconvolution descriptor \p conv_desc for backward propagation with respect to data using \p alg_kind, memory descriptors, \p strides, \p padding_l, \p padding_r, and \p padding_kind.
`static int`	`mkldnn_deconvolution_backward_weights_desc_init(mkldnn_convolution_desc_t conv_desc, int alg_kind, mkldnn_memory_desc_t src_desc, mkldnn_memory_desc_t diff_weights_desc, mkldnn_memory_desc_t diff_bias_desc, mkldnn_memory_desc_t diff_dst_desc, int[] strides, int[] padding_l, int[] padding_r, int padding_kind)`
`static int`	`mkldnn_deconvolution_backward_weights_desc_init(mkldnn_convolution_desc_t conv_desc, int alg_kind, mkldnn_memory_desc_t src_desc, mkldnn_memory_desc_t diff_weights_desc, mkldnn_memory_desc_t diff_bias_desc, mkldnn_memory_desc_t diff_dst_desc, IntBuffer strides, IntBuffer padding_l, IntBuffer padding_r, int padding_kind)`
`static int`	`mkldnn_deconvolution_backward_weights_desc_init(mkldnn_convolution_desc_t conv_desc, int alg_kind, mkldnn_memory_desc_t src_desc, mkldnn_memory_desc_t diff_weights_desc, mkldnn_memory_desc_t diff_bias_desc, mkldnn_memory_desc_t diff_dst_desc, IntPointer strides, IntPointer padding_l, IntPointer padding_r, int padding_kind)` Initializes a deconvolution descriptor \p conv_desc for backward propagation with respect to weights using \p alg_kind, memory descriptors, \p strides, \p padding_l, \p padding_r, and \p padding_kind.
`static int`	`mkldnn_deconvolution_forward_desc_init(mkldnn_convolution_desc_t conv_desc, int prop_kind, int alg_kind, mkldnn_memory_desc_t src_desc, mkldnn_memory_desc_t weights_desc, mkldnn_memory_desc_t bias_desc, mkldnn_memory_desc_t dst_desc, int[] strides, int[] padding_l, int[] padding_r, int padding_kind)`
`static int`	`mkldnn_deconvolution_forward_desc_init(mkldnn_convolution_desc_t conv_desc, int prop_kind, int alg_kind, mkldnn_memory_desc_t src_desc, mkldnn_memory_desc_t weights_desc, mkldnn_memory_desc_t bias_desc, mkldnn_memory_desc_t dst_desc, IntBuffer strides, IntBuffer padding_l, IntBuffer padding_r, int padding_kind)`
`static int`	`mkldnn_deconvolution_forward_desc_init(mkldnn_convolution_desc_t conv_desc, int prop_kind, int alg_kind, mkldnn_memory_desc_t src_desc, mkldnn_memory_desc_t weights_desc, mkldnn_memory_desc_t bias_desc, mkldnn_memory_desc_t dst_desc, IntPointer strides, IntPointer padding_l, IntPointer padding_r, int padding_kind)` Initializes a deconvolution descriptor \p deconv_desc for forward propagation using \p prop_kind (possible values are #mkldnn_forward_training and #mkldnn_forward_inference), \p alg_kind, memory descriptors, \p strides, \p padding_l, \p padding_r, and \p padding_kind.
`static int`	`mkldnn_dilated_convolution_backward_data_desc_init(mkldnn_convolution_desc_t conv_desc, int alg_kind, mkldnn_memory_desc_t diff_src_desc, mkldnn_memory_desc_t weights_desc, mkldnn_memory_desc_t diff_dst_desc, int[] strides, int[] dilates, int[] padding_l, int[] padding_r, int padding_kind)`
`static int`	`mkldnn_dilated_convolution_backward_data_desc_init(mkldnn_convolution_desc_t conv_desc, int alg_kind, mkldnn_memory_desc_t diff_src_desc, mkldnn_memory_desc_t weights_desc, mkldnn_memory_desc_t diff_dst_desc, IntBuffer strides, IntBuffer dilates, IntBuffer padding_l, IntBuffer padding_r, int padding_kind)`
`static int`	`mkldnn_dilated_convolution_backward_data_desc_init(mkldnn_convolution_desc_t conv_desc, int alg_kind, mkldnn_memory_desc_t diff_src_desc, mkldnn_memory_desc_t weights_desc, mkldnn_memory_desc_t diff_dst_desc, IntPointer strides, IntPointer dilates, IntPointer padding_l, IntPointer padding_r, int padding_kind)` Initializes a dilated convolution descriptor \p conv_desc for backward propagation with respect to data using \p alg_kind, memory descriptors, \p strides, \p dilates \p padding_l, \p padding_r, and \p padding_kind.
`static int`	`mkldnn_dilated_convolution_backward_weights_desc_init(mkldnn_convolution_desc_t conv_desc, int alg_kind, mkldnn_memory_desc_t src_desc, mkldnn_memory_desc_t diff_weights_desc, mkldnn_memory_desc_t diff_bias_desc, mkldnn_memory_desc_t diff_dst_desc, int[] strides, int[] dilates, int[] padding_l, int[] padding_r, int padding_kind)`
`static int`	`mkldnn_dilated_convolution_backward_weights_desc_init(mkldnn_convolution_desc_t conv_desc, int alg_kind, mkldnn_memory_desc_t src_desc, mkldnn_memory_desc_t diff_weights_desc, mkldnn_memory_desc_t diff_bias_desc, mkldnn_memory_desc_t diff_dst_desc, IntBuffer strides, IntBuffer dilates, IntBuffer padding_l, IntBuffer padding_r, int padding_kind)`
`static int`	`mkldnn_dilated_convolution_backward_weights_desc_init(mkldnn_convolution_desc_t conv_desc, int alg_kind, mkldnn_memory_desc_t src_desc, mkldnn_memory_desc_t diff_weights_desc, mkldnn_memory_desc_t diff_bias_desc, mkldnn_memory_desc_t diff_dst_desc, IntPointer strides, IntPointer dilates, IntPointer padding_l, IntPointer padding_r, int padding_kind)` Initializes a convolution descriptor \p conv_desc for backward propagation with respect to weights using \p alg_kind, memory descriptors, \p strides, \p dilates \p padding_l, \p padding_r, and \p padding_kind.
`static int`	`mkldnn_dilated_convolution_forward_desc_init(mkldnn_convolution_desc_t conv_desc, int prop_kind, int alg_kind, mkldnn_memory_desc_t src_desc, mkldnn_memory_desc_t weights_desc, mkldnn_memory_desc_t bias_desc, mkldnn_memory_desc_t dst_desc, int[] strides, int[] dilates, int[] padding_l, int[] padding_r, int padding_kind)`
`static int`	`mkldnn_dilated_convolution_forward_desc_init(mkldnn_convolution_desc_t conv_desc, int prop_kind, int alg_kind, mkldnn_memory_desc_t src_desc, mkldnn_memory_desc_t weights_desc, mkldnn_memory_desc_t bias_desc, mkldnn_memory_desc_t dst_desc, IntBuffer strides, IntBuffer dilates, IntBuffer padding_l, IntBuffer padding_r, int padding_kind)`
`static int`	`mkldnn_dilated_convolution_forward_desc_init(mkldnn_convolution_desc_t conv_desc, int prop_kind, int alg_kind, mkldnn_memory_desc_t src_desc, mkldnn_memory_desc_t weights_desc, mkldnn_memory_desc_t bias_desc, mkldnn_memory_desc_t dst_desc, IntPointer strides, IntPointer dilates, IntPointer padding_l, IntPointer padding_r, int padding_kind)` Initializes a dilated convolution descriptor \p conv_desc for forward propagation using \p prop_kind (possible values are #mkldnn_forward_training and #mkldnn_forward_inference), \p alg_kind, memory descriptors, \p strides, \p dilates, \p padding_l, \p padding_r, and \p padding_kind.
`static int`	`mkldnn_dilated_deconvolution_backward_data_desc_init(mkldnn_convolution_desc_t conv_desc, int alg_kind, mkldnn_memory_desc_t diff_src_desc, mkldnn_memory_desc_t weights_desc, mkldnn_memory_desc_t diff_dst_desc, int[] strides, int[] dilates, int[] padding_l, int[] padding_r, int padding_kind)`
`static int`	`mkldnn_dilated_deconvolution_backward_data_desc_init(mkldnn_convolution_desc_t conv_desc, int alg_kind, mkldnn_memory_desc_t diff_src_desc, mkldnn_memory_desc_t weights_desc, mkldnn_memory_desc_t diff_dst_desc, IntBuffer strides, IntBuffer dilates, IntBuffer padding_l, IntBuffer padding_r, int padding_kind)`
`static int`	`mkldnn_dilated_deconvolution_backward_data_desc_init(mkldnn_convolution_desc_t conv_desc, int alg_kind, mkldnn_memory_desc_t diff_src_desc, mkldnn_memory_desc_t weights_desc, mkldnn_memory_desc_t diff_dst_desc, IntPointer strides, IntPointer dilates, IntPointer padding_l, IntPointer padding_r, int padding_kind)` Initializes a dilated deconvolution descriptor \p conv_desc for backward propagation with respect to data using \p alg_kind, memory descriptors, \p strides, \p dilates, \p padding_l, \p padding_r, and \p padding_kind.
`static int`	`mkldnn_dilated_deconvolution_backward_weights_desc_init(mkldnn_convolution_desc_t conv_desc, int alg_kind, mkldnn_memory_desc_t src_desc, mkldnn_memory_desc_t diff_weights_desc, mkldnn_memory_desc_t diff_bias_desc, mkldnn_memory_desc_t diff_dst_desc, int[] strides, int[] dilates, int[] padding_l, int[] padding_r, int padding_kind)`
`static int`	`mkldnn_dilated_deconvolution_backward_weights_desc_init(mkldnn_convolution_desc_t conv_desc, int alg_kind, mkldnn_memory_desc_t src_desc, mkldnn_memory_desc_t diff_weights_desc, mkldnn_memory_desc_t diff_bias_desc, mkldnn_memory_desc_t diff_dst_desc, IntBuffer strides, IntBuffer dilates, IntBuffer padding_l, IntBuffer padding_r, int padding_kind)`
`static int`	`mkldnn_dilated_deconvolution_backward_weights_desc_init(mkldnn_convolution_desc_t conv_desc, int alg_kind, mkldnn_memory_desc_t src_desc, mkldnn_memory_desc_t diff_weights_desc, mkldnn_memory_desc_t diff_bias_desc, mkldnn_memory_desc_t diff_dst_desc, IntPointer strides, IntPointer dilates, IntPointer padding_l, IntPointer padding_r, int padding_kind)` Initializes a dilated deconvolution descriptor \p conv_desc for backward propagation with respect to weights using \p alg_kind, memory descriptors, \p strides, \p dilates, \p padding_l, \p padding_r, and \p padding_kind.
`static int`	`mkldnn_dilated_deconvolution_forward_desc_init(mkldnn_convolution_desc_t conv_desc, int prop_kind, int alg_kind, mkldnn_memory_desc_t src_desc, mkldnn_memory_desc_t weights_desc, mkldnn_memory_desc_t bias_desc, mkldnn_memory_desc_t dst_desc, int[] strides, int[] dilates, int[] padding_l, int[] padding_r, int padding_kind)`
`static int`	`mkldnn_dilated_deconvolution_forward_desc_init(mkldnn_convolution_desc_t conv_desc, int prop_kind, int alg_kind, mkldnn_memory_desc_t src_desc, mkldnn_memory_desc_t weights_desc, mkldnn_memory_desc_t bias_desc, mkldnn_memory_desc_t dst_desc, IntBuffer strides, IntBuffer dilates, IntBuffer padding_l, IntBuffer padding_r, int padding_kind)`
`static int`	`mkldnn_dilated_deconvolution_forward_desc_init(mkldnn_convolution_desc_t conv_desc, int prop_kind, int alg_kind, mkldnn_memory_desc_t src_desc, mkldnn_memory_desc_t weights_desc, mkldnn_memory_desc_t bias_desc, mkldnn_memory_desc_t dst_desc, IntPointer strides, IntPointer dilates, IntPointer padding_l, IntPointer padding_r, int padding_kind)` Initializes a dilated deconvolution descriptor \p deconv_desc for forward propagation using \p prop_kind (possible values are #mkldnn_forward_training and #mkldnn_forward_inference), \p alg_kind, memory descriptors, \p strides, \p dilates, \p padding_l, \p padding_r, and \p padding_kind.
`static int`	`mkldnn_eltwise_backward_desc_init(mkldnn_eltwise_desc_t eltwise_desc, int alg_kind, mkldnn_memory_desc_t diff_data_desc, mkldnn_memory_desc_t data_desc, float alpha, float beta)` Initializes an \p eltwise_desc for backward propagation using \p alg_kind algorithm memory descriptors \p diff_data_desc and \p data_desc, and the \p alpha and \p beta parameters.
`static int`	`mkldnn_eltwise_forward_desc_init(mkldnn_eltwise_desc_t eltwise_desc, int prop_kind, int alg_kind, mkldnn_memory_desc_t data_desc, float alpha, float beta)` Initializes an \p eltwise_desc for forward propagation using \p prop_kind (possible values are #mkldnn_forward_training and #mkldnn_forward_inference), \p alg_kind algorithm, memory descriptor \p data_desc, \p alpha, and \p beta parameters.
`static int`	`mkldnn_engine_create(mkldnn_engine engine, int kind, long index)` Creates an \p engine of particular \p kind and \p index.
`static int`	`mkldnn_engine_create(PointerPointer engine, int kind, long index)`
`static int`	`mkldnn_engine_destroy(mkldnn_engine engine)` Destroys an \p engine.
`static long`	`mkldnn_engine_get_count(int kind)` Returns the number of engines of a particular \p kind.
`static int`	`mkldnn_engine_get_kind(mkldnn_engine engine, int[] kind)`
`static int`	`mkldnn_engine_get_kind(mkldnn_engine engine, IntBuffer kind)`
`static int`	`mkldnn_engine_get_kind(mkldnn_engine engine, IntPointer kind)` Returns the kind of an \p engine.
`static int`	`mkldnn_gemm_s8s8s32(BytePointer transa, BytePointer transb, BytePointer offsetc, int[] M, int[] N, int[] K, float[] alpha, byte[] A, int[] lda, byte[] ao, byte[] B, int[] ldb, byte[] bo, float[] beta, int[] c, int[] ldc, int[] co)`
`static int`	`mkldnn_gemm_s8s8s32(BytePointer transa, BytePointer transb, BytePointer offsetc, IntBuffer M, IntBuffer N, IntBuffer K, FloatBuffer alpha, ByteBuffer A, IntBuffer lda, ByteBuffer ao, ByteBuffer B, IntBuffer ldb, ByteBuffer bo, FloatBuffer beta, IntBuffer c, IntBuffer ldc, IntBuffer co)`
`static int`	`mkldnn_gemm_s8s8s32(BytePointer transa, BytePointer transb, BytePointer offsetc, IntPointer M, IntPointer N, IntPointer K, FloatPointer alpha, BytePointer A, IntPointer lda, BytePointer ao, BytePointer B, IntPointer ldb, BytePointer bo, FloatPointer beta, IntPointer c, IntPointer ldc, IntPointer co)`
`static int`	`mkldnn_gemm_s8s8s32(String transa, String transb, String offsetc, int[] M, int[] N, int[] K, float[] alpha, byte[] A, int[] lda, byte[] ao, byte[] B, int[] ldb, byte[] bo, float[] beta, int[] c, int[] ldc, int[] co)`
`static int`	`mkldnn_gemm_s8s8s32(String transa, String transb, String offsetc, IntBuffer M, IntBuffer N, IntBuffer K, FloatBuffer alpha, ByteBuffer A, IntBuffer lda, ByteBuffer ao, ByteBuffer B, IntBuffer ldb, ByteBuffer bo, FloatBuffer beta, IntBuffer c, IntBuffer ldc, IntBuffer co)`
`static int`	`mkldnn_gemm_s8s8s32(String transa, String transb, String offsetc, IntPointer M, IntPointer N, IntPointer K, FloatPointer alpha, BytePointer A, IntPointer lda, BytePointer ao, BytePointer B, IntPointer ldb, BytePointer bo, FloatPointer beta, IntPointer c, IntPointer ldc, IntPointer co)`
`static int`	`mkldnn_gemm_s8u8s32(BytePointer transa, BytePointer transb, BytePointer offsetc, int[] M, int[] N, int[] K, float[] alpha, byte[] A, int[] lda, byte[] ao, byte[] B, int[] ldb, byte[] bo, float[] beta, int[] c, int[] ldc, int[] co)`
`static int`	`mkldnn_gemm_s8u8s32(BytePointer transa, BytePointer transb, BytePointer offsetc, IntBuffer M, IntBuffer N, IntBuffer K, FloatBuffer alpha, ByteBuffer A, IntBuffer lda, ByteBuffer ao, ByteBuffer B, IntBuffer ldb, ByteBuffer bo, FloatBuffer beta, IntBuffer c, IntBuffer ldc, IntBuffer co)`
`static int`	`mkldnn_gemm_s8u8s32(BytePointer transa, BytePointer transb, BytePointer offsetc, IntPointer M, IntPointer N, IntPointer K, FloatPointer alpha, BytePointer A, IntPointer lda, BytePointer ao, BytePointer B, IntPointer ldb, BytePointer bo, FloatPointer beta, IntPointer c, IntPointer ldc, IntPointer co)` gemm_s8u8s32 and gemm_s8s8s32 perform a matrix-matrix multiplication operation and add the result to a scalar-matrix product.
`static int`	`mkldnn_gemm_s8u8s32(String transa, String transb, String offsetc, int[] M, int[] N, int[] K, float[] alpha, byte[] A, int[] lda, byte[] ao, byte[] B, int[] ldb, byte[] bo, float[] beta, int[] c, int[] ldc, int[] co)`
`static int`	`mkldnn_gemm_s8u8s32(String transa, String transb, String offsetc, IntBuffer M, IntBuffer N, IntBuffer K, FloatBuffer alpha, ByteBuffer A, IntBuffer lda, ByteBuffer ao, ByteBuffer B, IntBuffer ldb, ByteBuffer bo, FloatBuffer beta, IntBuffer c, IntBuffer ldc, IntBuffer co)`
`static int`	`mkldnn_gemm_s8u8s32(String transa, String transb, String offsetc, IntPointer M, IntPointer N, IntPointer K, FloatPointer alpha, BytePointer A, IntPointer lda, BytePointer ao, BytePointer B, IntPointer ldb, BytePointer bo, FloatPointer beta, IntPointer c, IntPointer ldc, IntPointer co)`
`static int`	`mkldnn_inner_product_backward_data_desc_init(mkldnn_inner_product_desc_t ip_desc, mkldnn_memory_desc_t diff_src_desc, mkldnn_memory_desc_t weights_desc, mkldnn_memory_desc_t diff_dst_desc)` Initializes an inner product descriptor \p ip_desc for backward propagation with respect to data using memory descriptors.
`static int`	`mkldnn_inner_product_backward_weights_desc_init(mkldnn_inner_product_desc_t ip_desc, mkldnn_memory_desc_t src_desc, mkldnn_memory_desc_t diff_weights_desc, mkldnn_memory_desc_t diff_bias_desc, mkldnn_memory_desc_t diff_dst_desc)` Initializes an inner product descriptor \p ip_desc for backward propagation with respect to weights using memory descriptors.
`static int`	`mkldnn_inner_product_forward_desc_init(mkldnn_inner_product_desc_t ip_desc, int prop_kind, mkldnn_memory_desc_t src_desc, mkldnn_memory_desc_t weights_desc, mkldnn_memory_desc_t bias_desc, mkldnn_memory_desc_t dst_desc)` Initializes an inner product descriptor \p ip_desc for forward propagation using \p prop_kind (possible values are #mkldnn_forward_training and #mkldnn_forward_inference) and memory descriptors.
`static int`	`mkldnn_lrn_backward_desc_init(mkldnn_lrn_desc_t lrn_desc, int alg_kind, mkldnn_memory_desc_t diff_data_desc, mkldnn_memory_desc_t data_desc, int local_size, float alpha, float beta, float k)` Initializes an \p lrn_desc for backward propagation using \p alg_kind, memory descriptors \p data_desc and \p diff_data_desc, and regularization parameters \p local_size, \p alpha, \p beta, and \p k.
`static int`	`mkldnn_lrn_forward_desc_init(mkldnn_lrn_desc_t lrn_desc, int prop_kind, int alg_kind, mkldnn_memory_desc_t data_desc, int local_size, float alpha, float beta, float k)` Initializes an \p lrn_desc for forward propagation using \p prop_kind (possible values are #mkldnn_forward_training and #mkldnn_forward_inference), \p alg_kind, memory descriptor \p data_desc, and regularization parameters \p local_size, \p alpha, \p beta, and \p k.
`static int`	`mkldnn_memory_desc_init(mkldnn_memory_desc_t memory_desc, int ndims, int[] dims, int data_type, int format)`
`static int`	`mkldnn_memory_desc_init(mkldnn_memory_desc_t memory_desc, int ndims, IntBuffer dims, int data_type, int format)`
`static int`	`mkldnn_memory_desc_init(mkldnn_memory_desc_t memory_desc, int ndims, IntPointer dims, int data_type, int format)` Initializes a \p memory_desc memory descriptor using \p ndims, \p dims, \p data_type, and data \p format.
`static int`	`mkldnn_memory_get_data_handle(mkldnn_primitive memory, Pointer handle)`
`static int`	`mkldnn_memory_get_data_handle(mkldnn_primitive memory, PointerPointer handle)` For a \p memory primitive, returns the data \p handle.
`static int`	`mkldnn_memory_primitive_desc_create(mkldnn_primitive_desc memory_primitive_desc, mkldnn_memory_desc_t memory_desc, mkldnn_engine engine)` Creates a \p memory_primitive_desc memory primitive descriptor using \p memory_desc and \p engine.
`static int`	`mkldnn_memory_primitive_desc_create(PointerPointer memory_primitive_desc, mkldnn_memory_desc_t memory_desc, mkldnn_engine engine)`
`static int`	`mkldnn_memory_primitive_desc_equal(mkldnn_primitive_desc lhs, mkldnn_primitive_desc rhs)` Compares two descriptors of memory primitives.
`static long`	`mkldnn_memory_primitive_desc_get_size(mkldnn_primitive_desc memory_primitive_desc)` Returns the size (in bytes) that is required for given \p memory_primitive_desc
`static int`	`mkldnn_memory_set_data_handle(mkldnn_primitive memory, Pointer handle)` For a \p memory primitive, sets the data \p handle.
`static int`	`mkldnn_pooling_backward_desc_init(mkldnn_pooling_desc_t pool_desc, int alg_kind, mkldnn_memory_desc_t diff_src_desc, mkldnn_memory_desc_t diff_dst_desc, int[] strides, int[] kernel, int[] padding_l, int[] padding_r, int padding_kind)`
`static int`	`mkldnn_pooling_backward_desc_init(mkldnn_pooling_desc_t pool_desc, int alg_kind, mkldnn_memory_desc_t diff_src_desc, mkldnn_memory_desc_t diff_dst_desc, IntBuffer strides, IntBuffer kernel, IntBuffer padding_l, IntBuffer padding_r, int padding_kind)`
`static int`	`mkldnn_pooling_backward_desc_init(mkldnn_pooling_desc_t pool_desc, int alg_kind, mkldnn_memory_desc_t diff_src_desc, mkldnn_memory_desc_t diff_dst_desc, IntPointer strides, IntPointer kernel, IntPointer padding_l, IntPointer padding_r, int padding_kind)` Initializes a pooling descriptor \p pool_desc for backward propagation using \p alg_kind, memory descriptors, and pooling parameters in the spatial domain: \p strides, \p kernel sizes, \p padding_l, \p padding_r, and \p padding_kind.
`static int`	`mkldnn_pooling_forward_desc_init(mkldnn_pooling_desc_t pool_desc, int prop_kind, int alg_kind, mkldnn_memory_desc_t src_desc, mkldnn_memory_desc_t dst_desc, int[] strides, int[] kernel, int[] padding_l, int[] padding_r, int padding_kind)`
`static int`	`mkldnn_pooling_forward_desc_init(mkldnn_pooling_desc_t pool_desc, int prop_kind, int alg_kind, mkldnn_memory_desc_t src_desc, mkldnn_memory_desc_t dst_desc, IntBuffer strides, IntBuffer kernel, IntBuffer padding_l, IntBuffer padding_r, int padding_kind)`
`static int`	`mkldnn_pooling_forward_desc_init(mkldnn_pooling_desc_t pool_desc, int prop_kind, int alg_kind, mkldnn_memory_desc_t src_desc, mkldnn_memory_desc_t dst_desc, IntPointer strides, IntPointer kernel, IntPointer padding_l, IntPointer padding_r, int padding_kind)` Initializes a pooling descriptor \p pool_desc for forward propagation using \p prop_kind (possible values are #mkldnn_forward_training and #mkldnn_forward_inference), \p alg_kind, memory descriptors, and pooling parameters in the spatial domain: \p strides, \p kernel sizes, \p padding_l, \p padding_r, and \p padding_kind.
`static int`	`mkldnn_post_ops_append_eltwise(mkldnn_post_ops post_ops, float scale, int alg, float alpha, float beta)` Appends eltwise post operation to the \p post_ops with given parameters \p kind, \p alpha, and \p beta (@see mkldnn_eltwise_forward_desc_init and mkldnn_eltwise_desc_t).
`static int`	`mkldnn_post_ops_append_sum(mkldnn_post_ops post_ops, float scale)` Appends accumulation (sum) post operation to the \p post_ops.
`static int`	`mkldnn_post_ops_create(mkldnn_post_ops post_ops)` Creates an empty sequence of post operations \p post_ops.
`static int`	`mkldnn_post_ops_create(PointerPointer post_ops)`
`static int`	`mkldnn_post_ops_destroy(mkldnn_post_ops post_ops)` Deletes a \p post_ops sequence.
`static int`	`mkldnn_post_ops_get_kind(mkldnn_post_ops post_ops, int index)` Returns the type of post operation with index \p index in given \p post_ops.
`static int`	`mkldnn_post_ops_get_params_eltwise(mkldnn_post_ops post_ops, int index, float[] scale, int[] alg, float[] alpha, float[] beta)`
`static int`	`mkldnn_post_ops_get_params_eltwise(mkldnn_post_ops post_ops, int index, FloatBuffer scale, IntBuffer alg, FloatBuffer alpha, FloatBuffer beta)`
`static int`	`mkldnn_post_ops_get_params_eltwise(mkldnn_post_ops post_ops, int index, FloatPointer scale, IntPointer alg, FloatPointer alpha, FloatPointer beta)` Gets the eltwise parameters of the post operation with index \p index in the sequence of \p post_ops.
`static int`	`mkldnn_post_ops_get_params_sum(mkldnn_post_ops post_ops, int index, float[] scale)`
`static int`	`mkldnn_post_ops_get_params_sum(mkldnn_post_ops post_ops, int index, FloatBuffer scale)`
`static int`	`mkldnn_post_ops_get_params_sum(mkldnn_post_ops post_ops, int index, FloatPointer scale)` Gets the parameters of the accumulation (sum) post operation with index \p index in the sequence of \p post_ops.
`static int`	`mkldnn_post_ops_len(mkldnn_post_ops post_ops)` Returns the \p length of post operations for given \p post_ops.
`static mkldnn_primitive_at_t`	`mkldnn_primitive_at(mkldnn_primitive primitive, long output_index)` Creates an #mkldnn_primitive_at_t structure from a \p primitive and \p output_index.
`static int`	`mkldnn_primitive_attr_clone(mkldnn_primitive_attr attr, mkldnn_primitive_attr existing_attr)` Makes a copy of an \p existing_attr.
`static int`	`mkldnn_primitive_attr_clone(PointerPointer attr, mkldnn_primitive_attr existing_attr)`
`static int`	`mkldnn_primitive_attr_create(mkldnn_primitive_attr attr)` Creates an empty (default) \p attr attribute.
`static int`	`mkldnn_primitive_attr_create(PointerPointer attr)`
`static int`	`mkldnn_primitive_attr_destroy(mkldnn_primitive_attr attr)` Deletes an \p attr.
`static int`	`mkldnn_primitive_attr_get_int_output_round_mode(mkldnn_primitive_attr attr, int[] round_mode)`
`static int`	`mkldnn_primitive_attr_get_int_output_round_mode(mkldnn_primitive_attr attr, IntBuffer round_mode)`
`static int`	`mkldnn_primitive_attr_get_int_output_round_mode(mkldnn_primitive_attr attr, IntPointer round_mode)` Returns integer output rounding mode \p round_mode for a given \p attr, previously set by mkldnn_primitive_attr_set_int_output_round_mode.
`static int`	`mkldnn_primitive_attr_get_output_scales(mkldnn_primitive_attr attr, int[] count, int[] mask, float[] scales)`
`static int`	`mkldnn_primitive_attr_get_output_scales(mkldnn_primitive_attr attr, IntBuffer count, IntBuffer mask, FloatBuffer scales)`
`static int`	`mkldnn_primitive_attr_get_output_scales(mkldnn_primitive_attr attr, IntPointer count, IntPointer mask, FloatPointer scales)`
`static int`	`mkldnn_primitive_attr_get_output_scales(mkldnn_primitive_attr attr, IntPointer count, IntPointer mask, PointerPointer scales)` Returns \p count, correspondence scale \p mask, and a pointer to a constant floating point array of output \p scales for given \p attr, previously set by mkldnn_primitive_attr_set_output_scales.
`static int`	`mkldnn_primitive_attr_get_post_ops(mkldnn_primitive_attr attr, mkldnn_post_ops post_ops)` Returns \p post_ops for given \p attr.
`static int`	`mkldnn_primitive_attr_get_post_ops(mkldnn_primitive_attr attr, PointerPointer post_ops)`
`static int`	`mkldnn_primitive_attr_set_int_output_round_mode(mkldnn_primitive_attr attr, int round_mode)` Sets output rounding mode \p round_mode for integer operations for a given \p attr.
`static int`	`mkldnn_primitive_attr_set_output_scales(mkldnn_primitive_attr attr, int count, int mask, float[] scales)`
`static int`	`mkldnn_primitive_attr_set_output_scales(mkldnn_primitive_attr attr, int count, int mask, FloatBuffer scales)`
`static int`	`mkldnn_primitive_attr_set_output_scales(mkldnn_primitive_attr attr, int count, int mask, FloatPointer scales)` Sets output \p scales for primitive operations.
`static int`	`mkldnn_primitive_attr_set_post_ops(mkldnn_primitive_attr attr, mkldnn_post_ops post_ops)` Sets configured \p post_ops to an attribute \p attr for future use (when primitive descriptor is being created).
`static int`	`mkldnn_primitive_attr_set_rnn_data_qparams(mkldnn_primitive_attr attr, float scale, float shift)` Sets quantization \p scale and \p shift for RNN data tensors.
`static int`	`mkldnn_primitive_attr_set_rnn_weights_qparams(mkldnn_primitive_attr attr, int count, int mask, float[] weights_scales)`
`static int`	`mkldnn_primitive_attr_set_rnn_weights_qparams(mkldnn_primitive_attr attr, int count, int mask, FloatBuffer weights_scales)`
`static int`	`mkldnn_primitive_attr_set_rnn_weights_qparams(mkldnn_primitive_attr attr, int count, int mask, FloatPointer weights_scales)` Sets quantization scales \p weights_scales for RNN weights tensors.
`static int`	`mkldnn_primitive_create(mkldnn_primitive primitive, mkldnn_primitive_desc primitive_desc, mkldnn_primitive_at_t inputs, mkldnn_primitive outputs)` Creates a \p primitive using a \p primitive_desc descriptor and arrays of \p inputs and \p outputs.
`static int`	`mkldnn_primitive_create(PointerPointer primitive, mkldnn_primitive_desc primitive_desc, mkldnn_primitive_at_t inputs, PointerPointer outputs)`
`static int`	`mkldnn_primitive_desc_clone(mkldnn_primitive_desc primitive_desc, mkldnn_primitive_desc existing_primitive_desc)` Makes a copy of a \p primitive_desc.
`static int`	`mkldnn_primitive_desc_clone(PointerPointer primitive_desc, mkldnn_primitive_desc existing_primitive_desc)`
`static int`	`mkldnn_primitive_desc_create_v2(mkldnn_primitive_desc primitive_desc, const_mkldnn_op_desc_t op_desc, mkldnn_primitive_attr attr, mkldnn_engine engine, mkldnn_primitive_desc hint_forward_primitive_desc)` Creates a \p primitive_desc using \p op_desc, \p attr, \p engine, and optionally a hint primitive descriptor from forward propagation.
`static int`	`mkldnn_primitive_desc_create_v2(PointerPointer primitive_desc, const_mkldnn_op_desc_t op_desc, mkldnn_primitive_attr attr, mkldnn_engine engine, mkldnn_primitive_desc hint_forward_primitive_desc)`
`static int`	`mkldnn_primitive_desc_create(mkldnn_primitive_desc primitive_desc, const_mkldnn_op_desc_t op_desc, mkldnn_engine engine, mkldnn_primitive_desc hint_forward_primitive_desc)` Creates a \p primitive_desc using \p op_desc, \p engine, and optionally a hint primitive descriptor from forward propagation.
`static int`	`mkldnn_primitive_desc_create(PointerPointer primitive_desc, const_mkldnn_op_desc_t op_desc, mkldnn_engine engine, mkldnn_primitive_desc hint_forward_primitive_desc)`
`static int`	`mkldnn_primitive_desc_destroy(mkldnn_primitive_desc primitive_desc)` Deletes a \p primitive_desc.
`static int`	`mkldnn_primitive_desc_get_attr(mkldnn_primitive_desc primitive_desc, mkldnn_primitive_attr attr)` Returns a constant reference to the attribute of a \p primitive_desc.
`static int`	`mkldnn_primitive_desc_get_attr(mkldnn_primitive_desc primitive_desc, PointerPointer attr)`
`static int`	`mkldnn_primitive_desc_iterator_create_v2(mkldnn_primitive_desc_iterator iterator, const_mkldnn_op_desc_t op_desc, mkldnn_primitive_attr attr, mkldnn_engine engine, mkldnn_primitive_desc hint_forward_primitive_desc)` Creates a primitive descriptor \p iterator for given \p op_desc, \p attr, \p engine, and optionally a hint primitive descriptor from forward propagation (required for backward propagation).
`static int`	`mkldnn_primitive_desc_iterator_create_v2(PointerPointer iterator, const_mkldnn_op_desc_t op_desc, mkldnn_primitive_attr attr, mkldnn_engine engine, mkldnn_primitive_desc hint_forward_primitive_desc)`
`static int`	`mkldnn_primitive_desc_iterator_create(mkldnn_primitive_desc_iterator iterator, const_mkldnn_op_desc_t op_desc, mkldnn_engine engine, mkldnn_primitive_desc hint_forward_primitive_desc)` Creates a primitive descriptor \p iterator for given \p op_desc, \p engine, and optionally a hint primitive descriptor from forward propagation (required for backward propagation).
`static int`	`mkldnn_primitive_desc_iterator_create(PointerPointer iterator, const_mkldnn_op_desc_t op_desc, mkldnn_engine engine, mkldnn_primitive_desc hint_forward_primitive_desc)`
`static int`	`mkldnn_primitive_desc_iterator_destroy(mkldnn_primitive_desc_iterator iterator)` Deletes a primitive descriptor \p iterator
`static mkldnn_primitive_desc`	`mkldnn_primitive_desc_iterator_fetch(mkldnn_primitive_desc_iterator iterator)` Fetches the current primitive descriptor.
`static int`	`mkldnn_primitive_desc_iterator_next(mkldnn_primitive_desc_iterator iterator)` Iterates over primitive descriptors.
`static mkldnn_memory_desc_t`	`mkldnn_primitive_desc_query_memory_d(mkldnn_primitive_desc primitive_desc)` Queries primitive descriptor for memory descriptor
`static mkldnn_primitive_desc`	`mkldnn_primitive_desc_query_pd(mkldnn_primitive_desc primitive_desc, int what, int index)` Queries primitive descriptor for primitive descriptor
`static int`	`mkldnn_primitive_desc_query_s32(mkldnn_primitive_desc primitive_desc, int what, int index)` Queries primitive descriptor for signed 32bit int
`static int`	`mkldnn_primitive_desc_query(mkldnn_primitive_desc primitive_desc, int what, int index, Pointer result)` Queries primitive descriptor One of the most typical use cases is to query a convolution primitive descriptor created with source, weights, and destination formats equal to #mkldnn_any about the corresponding memory primitive descriptors (\p what equals #mkldnn_query_src_pd, #mkldnn_query_weights_pd, and #mkldnn_query_dst_pd respectively) to be able to prepare memory and create reorders if required.
`static int`	`mkldnn_primitive_destroy(mkldnn_primitive primitive)` Deletes a \p primitive.
`static int`	`mkldnn_primitive_get_input_at(mkldnn_primitive primitive, long index, mkldnn_primitive_at_t input)` For a \p primitive, returns \p input at the \p index position.
`static int`	`mkldnn_primitive_get_output(mkldnn_primitive primitive, long index, mkldnn_primitive output)` For a \p primitive, returns \p output at the \p index position.
`static int`	`mkldnn_primitive_get_output(mkldnn_primitive primitive, long index, PointerPointer output)`
`static int`	`mkldnn_primitive_get_primitive_desc(mkldnn_primitive primitive, mkldnn_primitive_desc primitive_desc)` Retrieves a reference to the \p primitive_desc descriptor of given \p primitive.
`static int`	`mkldnn_primitive_get_primitive_desc(mkldnn_primitive primitive, PointerPointer primitive_desc)`
`static int`	`mkldnn_reorder_primitive_desc_create_v2(mkldnn_primitive_desc reorder_primitive_desc, mkldnn_primitive_desc input, mkldnn_primitive_desc output, mkldnn_primitive_attr attr)` Initializes a \p reorder_primitive_desc using an \p attr attribute and descriptors of \p input and \p output memory primitives.
`static int`	`mkldnn_reorder_primitive_desc_create_v2(PointerPointer reorder_primitive_desc, mkldnn_primitive_desc input, mkldnn_primitive_desc output, mkldnn_primitive_attr attr)`
`static int`	`mkldnn_reorder_primitive_desc_create(mkldnn_primitive_desc reorder_primitive_desc, mkldnn_primitive_desc input, mkldnn_primitive_desc output)` Initializes a \p reorder_primitive_desc using descriptors of \p input and \p output memory primitives.
`static int`	`mkldnn_reorder_primitive_desc_create(PointerPointer reorder_primitive_desc, mkldnn_primitive_desc input, mkldnn_primitive_desc output)`
`static int`	mkldnn_rnn_backward_desc_init(mkldnn_rnn_desc_t rnn_desc, int prop_kind, mkldnn_rnn_cell_desc_t rnn_cell_desc, int 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, mkldnn_memory_desc_t diff_dst_iter_desc) Initializes a rnn descriptor \p rnn_desc for backward propagation using \p prop_kind, \p rnn_cell_desc, \p direction, and memory descriptors.
`static int`	`mkldnn_rnn_cell_desc_init(mkldnn_rnn_cell_desc_t rnn_cell_desc, int kind, int f, int flags, float alpha, float clipping)` Initializes a recurrent cell descriptor \p rnn_cell_desc using \p rnn_cell_desc, \p kind (possible values are #mkldnn_vanilla_rnn, #mkldnn_vanilla_lstm, #mkldnn_vanilla_gru, and #mkldnn_gru_linear_before_reset), \p f (possible values are #mkldnn_eltwise_relu and #mkldnn_eltwise_tanh), \p flags, \p alpha, and \p clipping.
`static int`	`mkldnn_rnn_cell_get_gates_count(mkldnn_rnn_cell_desc_t rnn_cell_desc)` Returns the number of gates of a particular \p rnn_cell_desc.
`static int`	`mkldnn_rnn_cell_get_states_count(mkldnn_rnn_cell_desc_t rnn_cell_desc)` Returns the number of states of a particular \p rnn_cell_desc.
`static int`	`mkldnn_rnn_forward_desc_init(mkldnn_rnn_desc_t rnn_desc, int prop_kind, mkldnn_rnn_cell_desc_t rnn_cell_desc, int 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)` Initializes a rnn descriptor \p rnn_desc for forward propagation using \p prop_kind, \p rnn_cell_desc, \p direction, and memory descriptors.
`static int`	`mkldnn_set_jit_dump(int dump)` Sets jit dump control.
`static int`	`mkldnn_set_verbose(int level)` Sets verbosity level (print information to stdout).
`static int`	`mkldnn_sgemm(BytePointer transa, BytePointer transb, int[] M, int[] N, int[] K, float[] alpha, float[] A, int[] lda, float[] B, int[] ldb, float[] beta, float[] C, int[] ldc)`
`static int`	`mkldnn_sgemm(BytePointer transa, BytePointer transb, IntBuffer M, IntBuffer N, IntBuffer K, FloatBuffer alpha, FloatBuffer A, IntBuffer lda, FloatBuffer B, IntBuffer ldb, FloatBuffer beta, FloatBuffer C, IntBuffer ldc)`
`static int`	`mkldnn_sgemm(BytePointer transa, BytePointer transb, IntPointer M, IntPointer N, IntPointer K, FloatPointer alpha, FloatPointer A, IntPointer lda, FloatPointer B, IntPointer ldb, FloatPointer beta, FloatPointer C, IntPointer ldc)` SGEMM performs matrix-matrix multiplication operation C := alphaop( A )op( B ) + betaC, where op( X ) is one of op( X ) = X or op( X ) = X*T, alpha and beta are scalars, and A, B and C are matrices, with op( A ) an m by k matrix, op( B ) a k by n matrix and C an m by n matrix.
`static int`	`mkldnn_sgemm(String transa, String transb, int[] M, int[] N, int[] K, float[] alpha, float[] A, int[] lda, float[] B, int[] ldb, float[] beta, float[] C, int[] ldc)`
`static int`	`mkldnn_sgemm(String transa, String transb, IntBuffer M, IntBuffer N, IntBuffer K, FloatBuffer alpha, FloatBuffer A, IntBuffer lda, FloatBuffer B, IntBuffer ldb, FloatBuffer beta, FloatBuffer C, IntBuffer ldc)`
`static int`	`mkldnn_sgemm(String transa, String transb, IntPointer M, IntPointer N, IntPointer K, FloatPointer alpha, FloatPointer A, IntPointer lda, FloatPointer B, IntPointer ldb, FloatPointer beta, FloatPointer C, IntPointer ldc)`
`static int`	`mkldnn_shuffle_backward_desc_init(mkldnn_shuffle_desc_t shuffle_desc, mkldnn_memory_desc_t diff_data_desc, int axis, int group_size)` Initializes a \p shuffle_desc for backward propagation using memory descriptor \p diff_data_desc, \p axis, and \p group_size.
`static int`	`mkldnn_shuffle_forward_desc_init(mkldnn_shuffle_desc_t shuffle_desc, int prop_kind, mkldnn_memory_desc_t data_desc, int axis, int group_size)` Initializes a \p shuffle_desc for forward propagation using \p prop_kind, memory descriptor \p data_desc, \p axis, and \p group_size.
`static int`	`mkldnn_softmax_backward_desc_init(mkldnn_softmax_desc_t softmax_desc, mkldnn_memory_desc_t diff_desc, mkldnn_memory_desc_t data_desc, int softmax_axis)` Initializes a \p softmax_desc for backward propagation using memory descriptors \p diff_desc and \p data_desc.
`static int`	`mkldnn_softmax_forward_desc_init(mkldnn_softmax_desc_t softmax_desc, int prop_kind, mkldnn_memory_desc_t data_desc, int softmax_axis)` Initializes a \p softmax_desc for forward propagation using \p prop_kind (possible values are #mkldnn_forward_training and #mkldnn_forward_inference) and memory descriptor \p data_desc.
`static int`	`mkldnn_stream_create(mkldnn_stream stream, int stream_kind)` Creates an execution \p stream of \p stream_kind.
`static int`	`mkldnn_stream_create(PointerPointer stream, int stream_kind)`
`static int`	`mkldnn_stream_destroy(mkldnn_stream stream)` Destroys an execution \p stream.
`static int`	`mkldnn_stream_rerun(mkldnn_stream stream, mkldnn_primitive error_primitive)` Reruns all the primitives within the \p stream.
`static int`	`mkldnn_stream_rerun(mkldnn_stream stream, PointerPointer error_primitive)`
`static int`	`mkldnn_stream_submit(mkldnn_stream stream, long n, mkldnn_primitive primitives, mkldnn_primitive error_primitive)` Submits \p primitives to an execution \p stream.
`static int`	`mkldnn_stream_submit(mkldnn_stream stream, long n, PointerPointer primitives, PointerPointer error_primitive)`
`static int`	`mkldnn_stream_wait(mkldnn_stream stream, int block, mkldnn_primitive error_primitive)` Waits for all primitives in the execution \p stream to finish.
`static int`	`mkldnn_stream_wait(mkldnn_stream stream, int block, PointerPointer error_primitive)`
`static int`	`mkldnn_sum_primitive_desc_create(mkldnn_primitive_desc sum_primitive_desc, mkldnn_memory_desc_t output_desc, int n, float[] scales, mkldnn_primitive_desc input_pds)`
`static int`	`mkldnn_sum_primitive_desc_create(mkldnn_primitive_desc sum_primitive_desc, mkldnn_memory_desc_t output_desc, int n, FloatBuffer scales, mkldnn_primitive_desc input_pds)`
`static int`	`mkldnn_sum_primitive_desc_create(mkldnn_primitive_desc sum_primitive_desc, mkldnn_memory_desc_t output_desc, int n, FloatPointer scales, mkldnn_primitive_desc input_pds)` Creates out-of-place \p sum_primitive_desc for sum of \p n inputs multiplied by scale with resulting \p output_desc memory descriptor.
`static int`	`mkldnn_sum_primitive_desc_create(PointerPointer sum_primitive_desc, mkldnn_memory_desc_t output_desc, int n, float[] scales, PointerPointer input_pds)`
`static int`	`mkldnn_sum_primitive_desc_create(PointerPointer sum_primitive_desc, mkldnn_memory_desc_t output_desc, int n, FloatBuffer scales, PointerPointer input_pds)`
`static int`	`mkldnn_sum_primitive_desc_create(PointerPointer sum_primitive_desc, mkldnn_memory_desc_t output_desc, int n, FloatPointer scales, PointerPointer input_pds)`
`static mkldnn_version_t`	`mkldnn_version()` Gets library version information.
`static int`	`mkldnn_view_primitive_desc_create(mkldnn_primitive_desc view_primitive_desc, mkldnn_primitive_desc memory_primitive_desc, int[] dims, int[] offsets)`
`static int`	`mkldnn_view_primitive_desc_create(mkldnn_primitive_desc view_primitive_desc, mkldnn_primitive_desc memory_primitive_desc, IntBuffer dims, IntBuffer offsets)`
`static int`	`mkldnn_view_primitive_desc_create(mkldnn_primitive_desc view_primitive_desc, mkldnn_primitive_desc memory_primitive_desc, IntPointer dims, IntPointer offsets)` Creates a \p view_primitive_desc for a given \p memory_primitive_desc, with \p dims sizes and \p offsets offsets.
`static int`	`mkldnn_view_primitive_desc_create(PointerPointer view_primitive_desc, mkldnn_primitive_desc memory_primitive_desc, int[] dims, int[] offsets)`
`static int`	`mkldnn_view_primitive_desc_create(PointerPointer view_primitive_desc, mkldnn_primitive_desc memory_primitive_desc, IntBuffer dims, IntBuffer offsets)`
`static int`	`mkldnn_view_primitive_desc_create(PointerPointer view_primitive_desc, mkldnn_primitive_desc memory_primitive_desc, IntPointer dims, IntPointer offsets)`
`static boolean`	`notEquals(int a, int b)`
`static memory`	`null_memory(engine eng)`
`static memory.desc`	`zero_md()`

Methods inherited from class org.bytedeco.mkldnn.presets.mkldnn
map

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail
- mkldnn_success
```
public static final int mkldnn_success
```
  enum mkldnn_status_t
  
  See Also:
  
  Constant Field Values
- mkldnn_out_of_memory
```
public static final int mkldnn_out_of_memory
```
  enum mkldnn_status_t
  
  See Also:
  
  Constant Field Values
- mkldnn_try_again
```
public static final int mkldnn_try_again
```
  enum mkldnn_status_t
  
  See Also:
  
  Constant Field Values
- mkldnn_invalid_arguments
```
public static final int mkldnn_invalid_arguments
```
  enum mkldnn_status_t
  
  See Also:
  
  Constant Field Values
- mkldnn_not_ready
```
public static final int mkldnn_not_ready
```
  enum mkldnn_status_t
  
  See Also:
  
  Constant Field Values
- mkldnn_unimplemented
```
public static final int mkldnn_unimplemented
```
  enum mkldnn_status_t
  
  See Also:
  
  Constant Field Values
- mkldnn_iterator_ends
```
public static final int mkldnn_iterator_ends
```
  enum mkldnn_status_t
  
  See Also:
  
  Constant Field Values
- mkldnn_runtime_error
```
public static final int mkldnn_runtime_error
```
  enum mkldnn_status_t
  
  See Also:
  
  Constant Field Values
- mkldnn_not_required
```
public static final int mkldnn_not_required
```
  enum mkldnn_status_t
  
  See Also:
  
  Constant Field Values
- mkldnn_data_type_undef
```
public static final int mkldnn_data_type_undef
```
  enum mkldnn_data_type_t
  
  See Also:
  
  Constant Field Values
- mkldnn_f32
```
public static final int mkldnn_f32
```
  enum mkldnn_data_type_t
  
  See Also:
  
  Constant Field Values
- mkldnn_s32
```
public static final int mkldnn_s32
```
  enum mkldnn_data_type_t
  
  See Also:
  
  Constant Field Values
- mkldnn_s16
```
public static final int mkldnn_s16
```
  enum mkldnn_data_type_t
  
  See Also:
  
  Constant Field Values
- mkldnn_s8
```
public static final int mkldnn_s8
```
  enum mkldnn_data_type_t
  
  See Also:
  
  Constant Field Values
- mkldnn_u8
```
public static final int mkldnn_u8
```
  enum mkldnn_data_type_t
  
  See Also:
  
  Constant Field Values
- mkldnn_round_nearest
```
public static final int mkldnn_round_nearest
```
  enum mkldnn_round_mode_t
  
  See Also:
  
  Constant Field Values
- mkldnn_round_down
```
public static final int mkldnn_round_down
```
  enum mkldnn_round_mode_t
  
  See Also:
  
  Constant Field Values
- mkldnn_format_undef
```
public static final int mkldnn_format_undef
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_any
```
public static final int mkldnn_any
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_blocked
```
public static final int mkldnn_blocked
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_x
```
public static final int mkldnn_x
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_nc
```
public static final int mkldnn_nc
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_ncw
```
public static final int mkldnn_ncw
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_nwc
```
public static final int mkldnn_nwc
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_nchw
```
public static final int mkldnn_nchw
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_nhwc
```
public static final int mkldnn_nhwc
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_chwn
```
public static final int mkldnn_chwn
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_ncdhw
```
public static final int mkldnn_ncdhw
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_ndhwc
```
public static final int mkldnn_ndhwc
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_oi
```
public static final int mkldnn_oi
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_io
```
public static final int mkldnn_io
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_oiw
```
public static final int mkldnn_oiw
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_wio
```
public static final int mkldnn_wio
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_oihw
```
public static final int mkldnn_oihw
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_hwio
```
public static final int mkldnn_hwio
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_ihwo
```
public static final int mkldnn_ihwo
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_iohw
```
public static final int mkldnn_iohw
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_oidhw
```
public static final int mkldnn_oidhw
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_dhwio
```
public static final int mkldnn_dhwio
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_goiw
```
public static final int mkldnn_goiw
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_goihw
```
public static final int mkldnn_goihw
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_hwigo
```
public static final int mkldnn_hwigo
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_giohw
```
public static final int mkldnn_giohw
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_goidhw
```
public static final int mkldnn_goidhw
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_ntc
```
public static final int mkldnn_ntc
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_tnc
```
public static final int mkldnn_tnc
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_ldsnc
```
public static final int mkldnn_ldsnc
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_ldigo
```
public static final int mkldnn_ldigo
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_ldgoi
```
public static final int mkldnn_ldgoi
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_ldgo
```
public static final int mkldnn_ldgo
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_nCw8c
```
public static final int mkldnn_nCw8c
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_nCw16c
```
public static final int mkldnn_nCw16c
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_nChw8c
```
public static final int mkldnn_nChw8c
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_nChw16c
```
public static final int mkldnn_nChw16c
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_nCdhw8c
```
public static final int mkldnn_nCdhw8c
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_nCdhw16c
```
public static final int mkldnn_nCdhw16c
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_Owi8o
```
public static final int mkldnn_Owi8o
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_OIw8i8o
```
public static final int mkldnn_OIw8i8o
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_OIw8o8i
```
public static final int mkldnn_OIw8o8i
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_OIw16i16o
```
public static final int mkldnn_OIw16i16o
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_OIw16o16i
```
public static final int mkldnn_OIw16o16i
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_Oiw16o
```
public static final int mkldnn_Oiw16o
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_Owi16o
```
public static final int mkldnn_Owi16o
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_OIw8i16o2i
```
public static final int mkldnn_OIw8i16o2i
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_OIw8o16i2o
```
public static final int mkldnn_OIw8o16i2o
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_IOw16o16i
```
public static final int mkldnn_IOw16o16i
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_hwio_s8s8
```
public static final int mkldnn_hwio_s8s8
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_oIhw8i
```
public static final int mkldnn_oIhw8i
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_oIhw16i
```
public static final int mkldnn_oIhw16i
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_OIhw8i8o
```
public static final int mkldnn_OIhw8i8o
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_OIhw16i16o
```
public static final int mkldnn_OIhw16i16o
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_OIhw4i16o4i
```
public static final int mkldnn_OIhw4i16o4i
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_OIhw4i16o4i_s8s8
```
public static final int mkldnn_OIhw4i16o4i_s8s8
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_OIhw8i16o2i
```
public static final int mkldnn_OIhw8i16o2i
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_OIhw8o16i2o
```
public static final int mkldnn_OIhw8o16i2o
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_OIhw8o8i
```
public static final int mkldnn_OIhw8o8i
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_OIhw16o16i
```
public static final int mkldnn_OIhw16o16i
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_IOhw16o16i
```
public static final int mkldnn_IOhw16o16i
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_Oihw8o
```
public static final int mkldnn_Oihw8o
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_Oihw16o
```
public static final int mkldnn_Oihw16o
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_Ohwi8o
```
public static final int mkldnn_Ohwi8o
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_Ohwi16o
```
public static final int mkldnn_Ohwi16o
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_OhIw16o4i
```
public static final int mkldnn_OhIw16o4i
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_oIdhw8i
```
public static final int mkldnn_oIdhw8i
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_oIdhw16i
```
public static final int mkldnn_oIdhw16i
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_OIdhw8i8o
```
public static final int mkldnn_OIdhw8i8o
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_OIdhw8o8i
```
public static final int mkldnn_OIdhw8o8i
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_Odhwi8o
```
public static final int mkldnn_Odhwi8o
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_OIdhw16i16o
```
public static final int mkldnn_OIdhw16i16o
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_OIdhw16o16i
```
public static final int mkldnn_OIdhw16o16i
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_Oidhw16o
```
public static final int mkldnn_Oidhw16o
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_Odhwi16o
```
public static final int mkldnn_Odhwi16o
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_OIdhw8i16o2i
```
public static final int mkldnn_OIdhw8i16o2i
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_gOwi8o
```
public static final int mkldnn_gOwi8o
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_gOIw8o8i
```
public static final int mkldnn_gOIw8o8i
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_gOIw8i8o
```
public static final int mkldnn_gOIw8i8o
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_gOIw16i16o
```
public static final int mkldnn_gOIw16i16o
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_gOIw16o16i
```
public static final int mkldnn_gOIw16o16i
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_gOiw16o
```
public static final int mkldnn_gOiw16o
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_gOwi16o
```
public static final int mkldnn_gOwi16o
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_gOIw8i16o2i
```
public static final int mkldnn_gOIw8i16o2i
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_gOIw8o16i2o
```
public static final int mkldnn_gOIw8o16i2o
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_gIOw16o16i
```
public static final int mkldnn_gIOw16o16i
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_hwigo_s8s8
```
public static final int mkldnn_hwigo_s8s8
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_gOIhw8i8o
```
public static final int mkldnn_gOIhw8i8o
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_gOIhw16i16o
```
public static final int mkldnn_gOIhw16i16o
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_gOIhw4i16o4i
```
public static final int mkldnn_gOIhw4i16o4i
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_gOIhw4i16o4i_s8s8
```
public static final int mkldnn_gOIhw4i16o4i_s8s8
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_gOIhw8i16o2i
```
public static final int mkldnn_gOIhw8i16o2i
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_gOIhw8o16i2o
```
public static final int mkldnn_gOIhw8o16i2o
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_gOIhw8o8i
```
public static final int mkldnn_gOIhw8o8i
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_gOIhw16o16i
```
public static final int mkldnn_gOIhw16o16i
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_gIOhw16o16i
```
public static final int mkldnn_gIOhw16o16i
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_gOihw8o
```
public static final int mkldnn_gOihw8o
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_gOihw16o
```
public static final int mkldnn_gOihw16o
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_gOhwi8o
```
public static final int mkldnn_gOhwi8o
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_gOhwi16o
```
public static final int mkldnn_gOhwi16o
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_Goihw8g
```
public static final int mkldnn_Goihw8g
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_Goihw16g
```
public static final int mkldnn_Goihw16g
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_Goihw16g_s8s8
```
public static final int mkldnn_Goihw16g_s8s8
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_gOhIw16o4i
```
public static final int mkldnn_gOhIw16o4i
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_gOIdhw8i8o
```
public static final int mkldnn_gOIdhw8i8o
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_gOIdhw8o8i
```
public static final int mkldnn_gOIdhw8o8i
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_gOdhwi8o
```
public static final int mkldnn_gOdhwi8o
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_gOIdhw8i16o2i
```
public static final int mkldnn_gOIdhw8i16o2i
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_gOIdhw16i16o
```
public static final int mkldnn_gOIdhw16i16o
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_gOIdhw16o16i
```
public static final int mkldnn_gOIdhw16o16i
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_gOidhw16o
```
public static final int mkldnn_gOidhw16o
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_gOdhwi16o
```
public static final int mkldnn_gOdhwi16o
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_wino_fmt
```
public static final int mkldnn_wino_fmt
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_rnn_packed
```
public static final int mkldnn_rnn_packed
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_format_last
```
public static final int mkldnn_format_last
```
  enum mkldnn_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_padding_zero
```
public static final int mkldnn_padding_zero
```
  enum mkldnn_padding_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_prop_kind_undef
```
public static final int mkldnn_prop_kind_undef
```
  enum mkldnn_prop_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_forward_training
```
public static final int mkldnn_forward_training
```
  enum mkldnn_prop_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_forward_inference
```
public static final int mkldnn_forward_inference
```
  enum mkldnn_prop_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_forward_scoring
```
public static final int mkldnn_forward_scoring
```
  enum mkldnn_prop_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_forward
```
public static final int mkldnn_forward
```
  enum mkldnn_prop_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_backward
```
public static final int mkldnn_backward
```
  enum mkldnn_prop_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_backward_data
```
public static final int mkldnn_backward_data
```
  enum mkldnn_prop_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_backward_weights
```
public static final int mkldnn_backward_weights
```
  enum mkldnn_prop_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_backward_bias
```
public static final int mkldnn_backward_bias
```
  enum mkldnn_prop_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_undefined_primitive
```
public static final int mkldnn_undefined_primitive
```
  enum mkldnn_primitive_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_memory
```
public static final int mkldnn_memory
```
  enum mkldnn_primitive_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_view
```
public static final int mkldnn_view
```
  enum mkldnn_primitive_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_reorder
```
public static final int mkldnn_reorder
```
  enum mkldnn_primitive_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_shuffle
```
public static final int mkldnn_shuffle
```
  enum mkldnn_primitive_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_concat
```
public static final int mkldnn_concat
```
  enum mkldnn_primitive_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_concat_inplace
```
public static final int mkldnn_concat_inplace
```
  enum mkldnn_primitive_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_sum
```
public static final int mkldnn_sum
```
  enum mkldnn_primitive_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_convolution
```
public static final int mkldnn_convolution
```
  enum mkldnn_primitive_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_deconvolution
```
public static final int mkldnn_deconvolution
```
  enum mkldnn_primitive_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_eltwise
```
public static final int mkldnn_eltwise
```
  enum mkldnn_primitive_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_softmax
```
public static final int mkldnn_softmax
```
  enum mkldnn_primitive_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_pooling
```
public static final int mkldnn_pooling
```
  enum mkldnn_primitive_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_lrn
```
public static final int mkldnn_lrn
```
  enum mkldnn_primitive_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_batch_normalization
```
public static final int mkldnn_batch_normalization
```
  enum mkldnn_primitive_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_inner_product
```
public static final int mkldnn_inner_product
```
  enum mkldnn_primitive_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_rnn
```
public static final int mkldnn_rnn
```
  enum mkldnn_primitive_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_alg_kind_undef
```
public static final int mkldnn_alg_kind_undef
```
  enum mkldnn_alg_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_convolution_direct
```
public static final int mkldnn_convolution_direct
```
  enum mkldnn_alg_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_convolution_winograd
```
public static final int mkldnn_convolution_winograd
```
  enum mkldnn_alg_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_convolution_auto
```
public static final int mkldnn_convolution_auto
```
  enum mkldnn_alg_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_deconvolution_direct
```
public static final int mkldnn_deconvolution_direct
```
  enum mkldnn_alg_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_deconvolution_winograd
```
public static final int mkldnn_deconvolution_winograd
```
  enum mkldnn_alg_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_eltwise_relu
```
public static final int mkldnn_eltwise_relu
```
  enum mkldnn_alg_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_eltwise_tanh
```
public static final int mkldnn_eltwise_tanh
```
  enum mkldnn_alg_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_eltwise_elu
```
public static final int mkldnn_eltwise_elu
```
  enum mkldnn_alg_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_eltwise_square
```
public static final int mkldnn_eltwise_square
```
  enum mkldnn_alg_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_eltwise_abs
```
public static final int mkldnn_eltwise_abs
```
  enum mkldnn_alg_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_eltwise_sqrt
```
public static final int mkldnn_eltwise_sqrt
```
  enum mkldnn_alg_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_eltwise_linear
```
public static final int mkldnn_eltwise_linear
```
  enum mkldnn_alg_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_eltwise_bounded_relu
```
public static final int mkldnn_eltwise_bounded_relu
```
  enum mkldnn_alg_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_eltwise_soft_relu
```
public static final int mkldnn_eltwise_soft_relu
```
  enum mkldnn_alg_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_eltwise_logistic
```
public static final int mkldnn_eltwise_logistic
```
  enum mkldnn_alg_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_pooling_max
```
public static final int mkldnn_pooling_max
```
  enum mkldnn_alg_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_pooling_avg_include_padding
```
public static final int mkldnn_pooling_avg_include_padding
```
  enum mkldnn_alg_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_pooling_avg_exclude_padding
```
public static final int mkldnn_pooling_avg_exclude_padding
```
  enum mkldnn_alg_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_pooling_avg
```
public static final int mkldnn_pooling_avg
```
  enum mkldnn_alg_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_lrn_across_channels
```
public static final int mkldnn_lrn_across_channels
```
  enum mkldnn_alg_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_lrn_within_channel
```
public static final int mkldnn_lrn_within_channel
```
  enum mkldnn_alg_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_vanilla_rnn
```
public static final int mkldnn_vanilla_rnn
```
  enum mkldnn_alg_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_vanilla_lstm
```
public static final int mkldnn_vanilla_lstm
```
  enum mkldnn_alg_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_vanilla_gru
```
public static final int mkldnn_vanilla_gru
```
  enum mkldnn_alg_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_gru_linear_before_reset
```
public static final int mkldnn_gru_linear_before_reset
```
  enum mkldnn_alg_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_use_global_stats
```
public static final int mkldnn_use_global_stats
```
  enum mkldnn_batch_normalization_flag_t
  
  See Also:
  
  Constant Field Values
- mkldnn_use_scaleshift
```
public static final int mkldnn_use_scaleshift
```
  enum mkldnn_batch_normalization_flag_t
  
  See Also:
  
  Constant Field Values
- mkldnn_fuse_bn_relu
```
public static final int mkldnn_fuse_bn_relu
```
  enum mkldnn_batch_normalization_flag_t
  
  See Also:
  
  Constant Field Values
- TENSOR_MAX_DIMS
```
public static final int TENSOR_MAX_DIMS
```
  Maximum number of dimensions a tensor can have. Only restricts the amount of space used for the tensor description. Individual computational primitives may support only tensors of certain dimensions.
  
  See Also:
  
  Constant Field Values
- mkldnn_wino_undef
```
public static final int mkldnn_wino_undef
```
  enum mkldnn_wino_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_wino_wei_aaOIoi
```
public static final int mkldnn_wino_wei_aaOIoi
```
  enum mkldnn_wino_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_wino_wei_aaOio
```
public static final int mkldnn_wino_wei_aaOio
```
  enum mkldnn_wino_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_wino_wei_aaOBiOo
```
public static final int mkldnn_wino_wei_aaOBiOo
```
  enum mkldnn_wino_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_wino_wei_OBaaIBOIio
```
public static final int mkldnn_wino_wei_OBaaIBOIio
```
  enum mkldnn_wino_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_packed_format_undef
```
public static final int mkldnn_packed_format_undef
```
  enum mkldnn_rnn_packed_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_ldigo_p
```
public static final int mkldnn_ldigo_p
```
  enum mkldnn_rnn_packed_memory_format_t
  
  See Also:
  
  Constant Field Values
- mkldnn_ldgoi_p
```
public static final int mkldnn_ldgoi_p
```
  enum mkldnn_rnn_packed_memory_format_t
  
  See Also:
  
  Constant Field Values
- MKLDNN_RNN_MAX_N_PARTS
```
public static final int MKLDNN_RNN_MAX_N_PARTS
```
  See Also:
  
  Constant Field Values
- mkldnn_rnn_cell_with_relu
```
public static final int mkldnn_rnn_cell_with_relu
```
  enum mkldnn_rnn_cell_flags_t
  
  See Also:
  
  Constant Field Values
- mkldnn_rnn_cell_with_clipping
```
public static final int mkldnn_rnn_cell_with_clipping
```
  enum mkldnn_rnn_cell_flags_t
  
  See Also:
  
  Constant Field Values
- mkldnn_unidirectional_left2right
```
public static final int mkldnn_unidirectional_left2right
```
  enum mkldnn_rnn_direction_t
  
  See Also:
  
  Constant Field Values
- mkldnn_unidirectional_right2left
```
public static final int mkldnn_unidirectional_right2left
```
  enum mkldnn_rnn_direction_t
  
  See Also:
  
  Constant Field Values
- mkldnn_bidirectional_concat
```
public static final int mkldnn_bidirectional_concat
```
  enum mkldnn_rnn_direction_t
  
  See Also:
  
  Constant Field Values
- mkldnn_bidirectional_sum
```
public static final int mkldnn_bidirectional_sum
```
  enum mkldnn_rnn_direction_t
  
  See Also:
  
  Constant Field Values
- mkldnn_unidirectional
```
public static final int mkldnn_unidirectional
```
  enum mkldnn_rnn_direction_t
  
  See Also:
  
  Constant Field Values
- mkldnn_any_engine
```
public static final int mkldnn_any_engine
```
  enum mkldnn_engine_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_cpu
```
public static final int mkldnn_cpu
```
  enum mkldnn_engine_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_query_undef
```
public static final int mkldnn_query_undef
```
  enum mkldnn_query_t
  
  See Also:
  
  Constant Field Values
- mkldnn_query_engine
```
public static final int mkldnn_query_engine
```
  enum mkldnn_query_t
  
  See Also:
  
  Constant Field Values
- mkldnn_query_primitive_kind
```
public static final int mkldnn_query_primitive_kind
```
  enum mkldnn_query_t
  
  See Also:
  
  Constant Field Values
- mkldnn_query_num_of_inputs_s32
```
public static final int mkldnn_query_num_of_inputs_s32
```
  enum mkldnn_query_t
  
  See Also:
  
  Constant Field Values
- mkldnn_query_num_of_outputs_s32
```
public static final int mkldnn_query_num_of_outputs_s32
```
  enum mkldnn_query_t
  
  See Also:
  
  Constant Field Values
- mkldnn_query_time_estimate_f64
```
public static final int mkldnn_query_time_estimate_f64
```
  enum mkldnn_query_t
  
  See Also:
  
  Constant Field Values
- mkldnn_query_memory_consumption_s64
```
public static final int mkldnn_query_memory_consumption_s64
```
  enum mkldnn_query_t
  
  See Also:
  
  Constant Field Values
- mkldnn_query_impl_info_str
```
public static final int mkldnn_query_impl_info_str
```
  enum mkldnn_query_t
  
  See Also:
  
  Constant Field Values
- mkldnn_query_some_d
```
public static final int mkldnn_query_some_d
```
  enum mkldnn_query_t
  
  See Also:
  
  Constant Field Values
- mkldnn_query_op_d
```
public static final int mkldnn_query_op_d
```
  enum mkldnn_query_t
  
  See Also:
  
  Constant Field Values
- mkldnn_query_memory_d
```
public static final int mkldnn_query_memory_d
```
  enum mkldnn_query_t
  
  See Also:
  
  Constant Field Values
- mkldnn_query_convolution_d
```
public static final int mkldnn_query_convolution_d
```
  enum mkldnn_query_t
  
  See Also:
  
  Constant Field Values
- mkldnn_query_deconvolution_d
```
public static final int mkldnn_query_deconvolution_d
```
  enum mkldnn_query_t
  
  See Also:
  
  Constant Field Values
- mkldnn_query_shuffle_d
```
public static final int mkldnn_query_shuffle_d
```
  enum mkldnn_query_t
  
  See Also:
  
  Constant Field Values
- mkldnn_query_eltwise_d
```
public static final int mkldnn_query_eltwise_d
```
  enum mkldnn_query_t
  
  See Also:
  
  Constant Field Values
- mkldnn_query_softmax_d
```
public static final int mkldnn_query_softmax_d
```
  enum mkldnn_query_t
  
  See Also:
  
  Constant Field Values
- mkldnn_query_pooling_d
```
public static final int mkldnn_query_pooling_d
```
  enum mkldnn_query_t
  
  See Also:
  
  Constant Field Values
- mkldnn_query_lrn_d
```
public static final int mkldnn_query_lrn_d
```
  enum mkldnn_query_t
  
  See Also:
  
  Constant Field Values
- mkldnn_query_batch_normalization_d
```
public static final int mkldnn_query_batch_normalization_d
```
  enum mkldnn_query_t
  
  See Also:
  
  Constant Field Values
- mkldnn_query_inner_product_d
```
public static final int mkldnn_query_inner_product_d
```
  enum mkldnn_query_t
  
  See Also:
  
  Constant Field Values
- mkldnn_query_rnn_d
```
public static final int mkldnn_query_rnn_d
```
  enum mkldnn_query_t
  
  See Also:
  
  Constant Field Values
- mkldnn_query_some_pd
```
public static final int mkldnn_query_some_pd
```
  enum mkldnn_query_t
  
  See Also:
  
  Constant Field Values
- mkldnn_query_input_pd
```
public static final int mkldnn_query_input_pd
```
  enum mkldnn_query_t
  
  See Also:
  
  Constant Field Values
- mkldnn_query_output_pd
```
public static final int mkldnn_query_output_pd
```
  enum mkldnn_query_t
  
  See Also:
  
  Constant Field Values
- mkldnn_query_src_pd
```
public static final int mkldnn_query_src_pd
```
  enum mkldnn_query_t
  
  See Also:
  
  Constant Field Values
- mkldnn_query_diff_src_pd
```
public static final int mkldnn_query_diff_src_pd
```
  enum mkldnn_query_t
  
  See Also:
  
  Constant Field Values
- mkldnn_query_weights_pd
```
public static final int mkldnn_query_weights_pd
```
  enum mkldnn_query_t
  
  See Also:
  
  Constant Field Values
- mkldnn_query_diff_weights_pd
```
public static final int mkldnn_query_diff_weights_pd
```
  enum mkldnn_query_t
  
  See Also:
  
  Constant Field Values
- mkldnn_query_dst_pd
```
public static final int mkldnn_query_dst_pd
```
  enum mkldnn_query_t
  
  See Also:
  
  Constant Field Values
- mkldnn_query_diff_dst_pd
```
public static final int mkldnn_query_diff_dst_pd
```
  enum mkldnn_query_t
  
  See Also:
  
  Constant Field Values
- mkldnn_query_workspace_pd
```
public static final int mkldnn_query_workspace_pd
```
  enum mkldnn_query_t
  
  See Also:
  
  Constant Field Values
- mkldnn_any_stream
```
public static final int mkldnn_any_stream
```
  enum mkldnn_stream_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_eager
```
public static final int mkldnn_eager
```
  enum mkldnn_stream_kind_t
  
  See Also:
  
  Constant Field Values
- mkldnn_lazy
```
public static final int mkldnn_lazy
```
  enum mkldnn_stream_kind_t
  
  See Also:
  
  Constant Field Values
- round_nearest
```
public static final int round_nearest
```
  enum mkldnn::round_mode
  
  See Also:
  
  Constant Field Values
- round_down
```
public static final int round_down
```
  enum mkldnn::round_mode
  
  See Also:
  
  Constant Field Values
- zero
```
public static final int zero
```
  enum mkldnn::padding_kind
  
  See Also:
  
  Constant Field Values
- forward_training
```
public static final int forward_training
```
  enum mkldnn::prop_kind
  
  See Also:
  
  Constant Field Values
- forward_scoring
```
public static final int forward_scoring
```
  enum mkldnn::prop_kind
  
  See Also:
  
  Constant Field Values
- forward_inference
```
public static final int forward_inference
```
  enum mkldnn::prop_kind
  
  See Also:
  
  Constant Field Values
- forward
```
public static final int forward
```
  enum mkldnn::prop_kind
  
  See Also:
  
  Constant Field Values
- backward
```
public static final int backward
```
  enum mkldnn::prop_kind
  
  See Also:
  
  Constant Field Values
- backward_data
```
public static final int backward_data
```
  enum mkldnn::prop_kind
  
  See Also:
  
  Constant Field Values
- backward_weights
```
public static final int backward_weights
```
  enum mkldnn::prop_kind
  
  See Also:
  
  Constant Field Values
- backward_bias
```
public static final int backward_bias
```
  enum mkldnn::prop_kind
  
  See Also:
  
  Constant Field Values
- algorithm_undef
```
public static final int algorithm_undef
```
  enum mkldnn::algorithm
  
  See Also:
  
  Constant Field Values
- convolution_auto
```
public static final int convolution_auto
```
  enum mkldnn::algorithm
  
  See Also:
  
  Constant Field Values
- convolution_direct
```
public static final int convolution_direct
```
  enum mkldnn::algorithm
  
  See Also:
  
  Constant Field Values
- convolution_winograd
```
public static final int convolution_winograd
```
  enum mkldnn::algorithm
  
  See Also:
  
  Constant Field Values
- deconvolution_direct
```
public static final int deconvolution_direct
```
  enum mkldnn::algorithm
  
  See Also:
  
  Constant Field Values
- deconvolution_winograd
```
public static final int deconvolution_winograd
```
  enum mkldnn::algorithm
  
  See Also:
  
  Constant Field Values
- eltwise_relu
```
public static final int eltwise_relu
```
  enum mkldnn::algorithm
  
  See Also:
  
  Constant Field Values
- eltwise_tanh
```
public static final int eltwise_tanh
```
  enum mkldnn::algorithm
  
  See Also:
  
  Constant Field Values
- eltwise_elu
```
public static final int eltwise_elu
```
  enum mkldnn::algorithm
  
  See Also:
  
  Constant Field Values
- eltwise_square
```
public static final int eltwise_square
```
  enum mkldnn::algorithm
  
  See Also:
  
  Constant Field Values
- eltwise_abs
```
public static final int eltwise_abs
```
  enum mkldnn::algorithm
  
  See Also:
  
  Constant Field Values
- eltwise_sqrt
```
public static final int eltwise_sqrt
```
  enum mkldnn::algorithm
  
  See Also:
  
  Constant Field Values
- eltwise_linear
```
public static final int eltwise_linear
```
  enum mkldnn::algorithm
  
  See Also:
  
  Constant Field Values
- eltwise_bounded_relu
```
public static final int eltwise_bounded_relu
```
  enum mkldnn::algorithm
  
  See Also:
  
  Constant Field Values
- eltwise_soft_relu
```
public static final int eltwise_soft_relu
```
  enum mkldnn::algorithm
  
  See Also:
  
  Constant Field Values
- eltwise_logistic
```
public static final int eltwise_logistic
```
  enum mkldnn::algorithm
  
  See Also:
  
  Constant Field Values
- lrn_across_channels
```
public static final int lrn_across_channels
```
  enum mkldnn::algorithm
  
  See Also:
  
  Constant Field Values
- lrn_within_channel
```
public static final int lrn_within_channel
```
  enum mkldnn::algorithm
  
  See Also:
  
  Constant Field Values
- pooling_max
```
public static final int pooling_max
```
  enum mkldnn::algorithm
  
  See Also:
  
  Constant Field Values
- pooling_avg
```
public static final int pooling_avg
```
  enum mkldnn::algorithm
  
  See Also:
  
  Constant Field Values
- pooling_avg_include_padding
```
public static final int pooling_avg_include_padding
```
  enum mkldnn::algorithm
  
  See Also:
  
  Constant Field Values
- pooling_avg_exclude_padding
```
public static final int pooling_avg_exclude_padding
```
  enum mkldnn::algorithm
  
  See Also:
  
  Constant Field Values
- vanilla_rnn
```
public static final int vanilla_rnn
```
  enum mkldnn::algorithm
  
  See Also:
  
  Constant Field Values
- vanilla_lstm
```
public static final int vanilla_lstm
```
  enum mkldnn::algorithm
  
  See Also:
  
  Constant Field Values
- vanilla_gru
```
public static final int vanilla_gru
```
  enum mkldnn::algorithm
  
  See Also:
  
  Constant Field Values
- gru_linear_before_reset
```
public static final int gru_linear_before_reset
```
  enum mkldnn::algorithm
  
  See Also:
  
  Constant Field Values
- use_global_stats
```
public static final int use_global_stats
```
  enum mkldnn::batch_normalization_flag
  
  See Also:
  
  Constant Field Values
- use_scale_shift
```
public static final int use_scale_shift
```
  enum mkldnn::batch_normalization_flag
  
  See Also:
  
  Constant Field Values
- fuse_bn_relu
```
public static final int fuse_bn_relu
```
  enum mkldnn::batch_normalization_flag
  
  See Also:
  
  Constant Field Values
- unidirectional_left2right
```
public static final int unidirectional_left2right
```
  enum mkldnn::rnn_direction
  
  See Also:
  
  Constant Field Values
- unidirectional_right2left
```
public static final int unidirectional_right2left
```
  enum mkldnn::rnn_direction
  
  See Also:
  
  Constant Field Values
- unidirectional
```
public static final int unidirectional
```
  enum mkldnn::rnn_direction
  
  See Also:
  
  Constant Field Values
- bidirectional_concat
```
public static final int bidirectional_concat
```
  enum mkldnn::rnn_direction
  
  See Also:
  
  Constant Field Values
- bidirectional_sum
```
public static final int bidirectional_sum
```
  enum mkldnn::rnn_direction
  
  See Also:
  
  Constant Field Values
- undef
```
public static final int undef
```
  enum mkldnn::query
  
  See Also:
  
  Constant Field Values
- eengine
```
public static final int eengine
```
  enum mkldnn::query
  
  See Also:
  
  Constant Field Values
- primitive_kind
```
public static final int primitive_kind
```
  enum mkldnn::query
  
  See Also:
  
  Constant Field Values
- num_of_inputs_s32
```
public static final int num_of_inputs_s32
```
  enum mkldnn::query
  
  See Also:
  
  Constant Field Values
- num_of_outputs_s32
```
public static final int num_of_outputs_s32
```
  enum mkldnn::query
  
  See Also:
  
  Constant Field Values
- time_estimate_f64
```
public static final int time_estimate_f64
```
  enum mkldnn::query
  
  See Also:
  
  Constant Field Values
- memory_consumption_s64
```
public static final int memory_consumption_s64
```
  enum mkldnn::query
  
  See Also:
  
  Constant Field Values
- impl_info_str
```
public static final int impl_info_str
```
  enum mkldnn::query
  
  See Also:
  
  Constant Field Values
- op_d
```
public static final int op_d
```
  enum mkldnn::query
  
  See Also:
  
  Constant Field Values
- memory_d
```
public static final int memory_d
```
  enum mkldnn::query
  
  See Also:
  
  Constant Field Values
- convolution_d
```
public static final int convolution_d
```
  enum mkldnn::query
  
  See Also:
  
  Constant Field Values
- deconvolution_d
```
public static final int deconvolution_d
```
  enum mkldnn::query
  
  See Also:
  
  Constant Field Values
- shuffle_d
```
public static final int shuffle_d
```
  enum mkldnn::query
  
  See Also:
  
  Constant Field Values
- eltwise_d
```
public static final int eltwise_d
```
  enum mkldnn::query
  
  See Also:
  
  Constant Field Values
- softmax_d
```
public static final int softmax_d
```
  enum mkldnn::query
  
  See Also:
  
  Constant Field Values
- pooling_d
```
public static final int pooling_d
```
  enum mkldnn::query
  
  See Also:
  
  Constant Field Values
- lrn_d
```
public static final int lrn_d
```
  enum mkldnn::query
  
  See Also:
  
  Constant Field Values
- batch_normalization_d
```
public static final int batch_normalization_d
```
  enum mkldnn::query
  
  See Also:
  
  Constant Field Values
- inner_product_d
```
public static final int inner_product_d
```
  enum mkldnn::query
  
  See Also:
  
  Constant Field Values
- rnn_d
```
public static final int rnn_d
```
  enum mkldnn::query
  
  See Also:
  
  Constant Field Values
- input_pd
```
public static final int input_pd
```
  enum mkldnn::query
  
  See Also:
  
  Constant Field Values
- output_pd
```
public static final int output_pd
```
  enum mkldnn::query
  
  See Also:
  
  Constant Field Values
- src_pd
```
public static final int src_pd
```
  enum mkldnn::query
  
  See Also:
  
  Constant Field Values
- diff_src_pd
```
public static final int diff_src_pd
```
  enum mkldnn::query
  
  See Also:
  
  Constant Field Values
- weights_pd
```
public static final int weights_pd
```
  enum mkldnn::query
  
  See Also:
  
  Constant Field Values
- diff_weights_pd
```
public static final int diff_weights_pd
```
  enum mkldnn::query
  
  See Also:
  
  Constant Field Values
- dst_pd
```
public static final int dst_pd
```
  enum mkldnn::query
  
  See Also:
  
  Constant Field Values
- diff_dst_pd
```
public static final int diff_dst_pd
```
  enum mkldnn::query
  
  See Also:
  
  Constant Field Values
- workspace_pd
```
public static final int workspace_pd
```
  enum mkldnn::query
  
  See Also:
  
  Constant Field Values

Constructor Detail
- mkldnn
```
public mkldnn()
```

Method Detail

mkldnn_primitive_desc_iterator_create

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_desc_iterator_create(@ByPtrPtr
                                                                                        mkldnn_primitive_desc_iterator iterator,
                                                                                        const_mkldnn_op_desc_t op_desc,
                                                                                        mkldnn_engine engine,
                                                                                        @Const
                                                                                        mkldnn_primitive_desc hint_forward_primitive_desc)

Creates a primitive descriptor \p iterator for given \p op_desc, \p engine, and optionally a hint primitive descriptor from forward propagation (required for backward propagation). Pass \c NULL for forward propagation.

mkldnn_primitive_desc_iterator_create

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_desc_iterator_create(@Cast(value="mkldnn_primitive_desc_iterator_t*")
                                                                                        PointerPointer iterator,
                                                                                        const_mkldnn_op_desc_t op_desc,
                                                                                        mkldnn_engine engine,
                                                                                        @Const
                                                                                        mkldnn_primitive_desc hint_forward_primitive_desc)

mkldnn_primitive_desc_iterator_create_v2

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_desc_iterator_create_v2(@ByPtrPtr
                                                                                           mkldnn_primitive_desc_iterator iterator,
                                                                                           const_mkldnn_op_desc_t op_desc,
                                                                                           @Const
                                                                                           mkldnn_primitive_attr attr,
                                                                                           mkldnn_engine engine,
                                                                                           @Const
                                                                                           mkldnn_primitive_desc hint_forward_primitive_desc)

Creates a primitive descriptor \p iterator for given \p op_desc, \p attr, \p engine, and optionally a hint primitive descriptor from forward propagation (required for backward propagation). Pass \c NULL for forward propagation.

mkldnn_primitive_desc_iterator_create_v2

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_desc_iterator_create_v2(@Cast(value="mkldnn_primitive_desc_iterator_t*")
                                                                                           PointerPointer iterator,
                                                                                           const_mkldnn_op_desc_t op_desc,
                                                                                           @Const
                                                                                           mkldnn_primitive_attr attr,
                                                                                           mkldnn_engine engine,
                                                                                           @Const
                                                                                           mkldnn_primitive_desc hint_forward_primitive_desc)

mkldnn_primitive_desc_iterator_next
```
@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_desc_iterator_next(mkldnn_primitive_desc_iterator iterator)
```
Iterates over primitive descriptors. Returns #mkldnn_iterator_ends if no more primitive descriptors are available.

mkldnn_primitive_desc_iterator_fetch

public static mkldnn_primitive_desc mkldnn_primitive_desc_iterator_fetch(@Const
                                                                         mkldnn_primitive_desc_iterator iterator)

Fetches the current primitive descriptor. \note The user should delete the fetched primitive descriptor using mkldnn_primitive_desc_destroy() once it is no longer needed.

mkldnn_primitive_desc_iterator_destroy

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_desc_iterator_destroy(mkldnn_primitive_desc_iterator iterator)

Deletes a primitive descriptor \p iterator

mkldnn_primitive_desc_create

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_desc_create(@ByPtrPtr
                                                                               mkldnn_primitive_desc primitive_desc,
                                                                               const_mkldnn_op_desc_t op_desc,
                                                                               mkldnn_engine engine,
                                                                               @Const
                                                                               mkldnn_primitive_desc hint_forward_primitive_desc)

Creates a \p primitive_desc using \p op_desc, \p engine, and optionally a hint primitive descriptor from forward propagation. The call is equivalent to creating a primitive descriptor iterator, immediately fetching a primitive descriptor, and then destroying the iterator.

mkldnn_primitive_desc_create

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_desc_create(@Cast(value="mkldnn_primitive_desc_t*")
                                                                               PointerPointer primitive_desc,
                                                                               const_mkldnn_op_desc_t op_desc,
                                                                               mkldnn_engine engine,
                                                                               @Const
                                                                               mkldnn_primitive_desc hint_forward_primitive_desc)

mkldnn_primitive_desc_create_v2

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_desc_create_v2(@ByPtrPtr
                                                                                  mkldnn_primitive_desc primitive_desc,
                                                                                  const_mkldnn_op_desc_t op_desc,
                                                                                  @Const
                                                                                  mkldnn_primitive_attr attr,
                                                                                  mkldnn_engine engine,
                                                                                  @Const
                                                                                  mkldnn_primitive_desc hint_forward_primitive_desc)

Creates a \p primitive_desc using \p op_desc, \p attr, \p engine, and optionally a hint primitive descriptor from forward propagation. The call is equivalent to creating a primitive descriptor iterator, immediately fetching a primitive descriptor, and then destroying the iterator.

mkldnn_primitive_desc_create_v2

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_desc_create_v2(@Cast(value="mkldnn_primitive_desc_t*")
                                                                                  PointerPointer primitive_desc,
                                                                                  const_mkldnn_op_desc_t op_desc,
                                                                                  @Const
                                                                                  mkldnn_primitive_attr attr,
                                                                                  mkldnn_engine engine,
                                                                                  @Const
                                                                                  mkldnn_primitive_desc hint_forward_primitive_desc)

mkldnn_primitive_desc_clone

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_desc_clone(@ByPtrPtr
                                                                              mkldnn_primitive_desc primitive_desc,
                                                                              @Const
                                                                              mkldnn_primitive_desc existing_primitive_desc)

Makes a copy of a \p primitive_desc.

mkldnn_primitive_desc_clone

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_desc_clone(@Cast(value="mkldnn_primitive_desc_t*")
                                                                              PointerPointer primitive_desc,
                                                                              @Const
                                                                              mkldnn_primitive_desc existing_primitive_desc)

mkldnn_primitive_desc_get_attr

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_desc_get_attr(@Const
                                                                                 mkldnn_primitive_desc primitive_desc,
                                                                                 @Const @ByPtrPtr
                                                                                 mkldnn_primitive_attr attr)

Returns a constant reference to the attribute of a \p primitive_desc. \warning The user should not destroy the obtained \p attr. \warning The lifetime of an \p attr is the same as that of a \p primitive_desc, so it is illegal to use the \p attr once \p primitive_desc has been destroyed.

mkldnn_primitive_desc_get_attr

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_desc_get_attr(@Const
                                                                                 mkldnn_primitive_desc primitive_desc,
                                                                                 @Cast(value="const_mkldnn_primitive_attr_t*")
                                                                                 PointerPointer attr)

mkldnn_primitive_desc_destroy

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_desc_destroy(mkldnn_primitive_desc primitive_desc)

Deletes a \p primitive_desc.

mkldnn_primitive_desc_query
```
@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_desc_query(@Const
                                                                              mkldnn_primitive_desc primitive_desc,
                                                                              @Cast(value="mkldnn_query_t")
                                                                              int what,
                                                                              int index,
                                                                              Pointer result)
```
Queries primitive descriptor One of the most typical use cases is to query a convolution primitive descriptor created with source, weights, and destination formats equal to #mkldnn_any about the corresponding memory primitive descriptors (\p what equals #mkldnn_query_src_pd, #mkldnn_query_weights_pd, and #mkldnn_query_dst_pd respectively) to be able to prepare memory and create reorders if required. Another quite typical use case is to query an operation primitive descriptor for a workspace (\p what equals #mkldnn_query_workspace_pd). The returned status #mkldnn_not_required indicates that a workspace is not required. A few other possibilities: - query a memory primitive descriptor for the underlying memory descriptor (#mkldnn_query_memory_d) - query an operation primitive descriptor for the underlying operation descriptor (#mkldnn_query_convolution_d, #mkldnn_query_eltwise_d, #mkldnn_query_rnn_d, etc.) - query an operation primitive descriptor for the implementation information string (#mkldnn_query_impl_info_str) - query an operation primitive descriptor for the number of inputs and outputs (#mkldnn_query_num_of_inputs_s32 and #mkldnn_query_num_of_outputs_s32 respectively)

See Also:

for more options

mkldnn_primitive_desc_query_memory_d

@Const
public static mkldnn_memory_desc_t mkldnn_primitive_desc_query_memory_d(@Const
                                                                                mkldnn_primitive_desc primitive_desc)

Queries primitive descriptor for memory descriptor

Returns:: NULL in case of any error (in particular if the queried entity is not of type mkldnn_memory_desc_t). This is just a specialized version of mkldnn_primitive_desc_query used for convenience.

mkldnn_primitive_desc_query_pd

@Const
public static mkldnn_primitive_desc mkldnn_primitive_desc_query_pd(@Const
                                                                           mkldnn_primitive_desc primitive_desc,
                                                                           @Cast(value="mkldnn_query_t")
                                                                           int what,
                                                                           int index)

Queries primitive descriptor for primitive descriptor

Returns:: NULL in case of any error (in particular if the queried entity is not of type const_mkldnn_primitive_desc_t). This is just a specialized version of mkldnn_primitive_desc_query used for convenience. Example: Query an operation primitive descriptor for a workspace (\p what equals #mkldnn_query_workspace_pd). Returned NULL indicates that the primitive does not require a workspace. Otherwise, a user should prepare the workspace and pass it to the corresponding primitive.

mkldnn_primitive_desc_query_s32

public static int mkldnn_primitive_desc_query_s32(@Const
                                                  mkldnn_primitive_desc primitive_desc,
                                                  @Cast(value="mkldnn_query_t")
                                                  int what,
                                                  int index)

Queries primitive descriptor for signed 32bit int

Returns:: 0 in case of any error (in particular if the queried entity is not of type int32_t). Note that 0 might also be the actual returned value. This is just a specialized version of mkldnn_primitive_desc_query used for convenience.

mkldnn_primitive_create

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_create(@ByPtrPtr
                                                                          mkldnn_primitive primitive,
                                                                          @Const
                                                                          mkldnn_primitive_desc primitive_desc,
                                                                          @Const
                                                                          mkldnn_primitive_at_t inputs,
                                                                          @Const @ByPtrPtr
                                                                          mkldnn_primitive outputs)

Creates a \p primitive using a \p primitive_desc descriptor and arrays of \p inputs and \p outputs.

mkldnn_primitive_create

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_create(@Cast(value="mkldnn_primitive_t*")
                                                                          PointerPointer primitive,
                                                                          @Const
                                                                          mkldnn_primitive_desc primitive_desc,
                                                                          @Const
                                                                          mkldnn_primitive_at_t inputs,
                                                                          @Cast(value="const_mkldnn_primitive_t*")
                                                                          PointerPointer outputs)

mkldnn_primitive_get_primitive_desc

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_get_primitive_desc(@Const
                                                                                      mkldnn_primitive primitive,
                                                                                      @Const @ByPtrPtr
                                                                                      mkldnn_primitive_desc primitive_desc)

Retrieves a reference to the \p primitive_desc descriptor of given \p primitive. \warning The returned object must not be destroyed by the user. The \c const qualifier of the returned object prevents such attempts.

mkldnn_primitive_get_primitive_desc

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_get_primitive_desc(@Const
                                                                                      mkldnn_primitive primitive,
                                                                                      @Cast(value="const_mkldnn_primitive_desc_t*")
                                                                                      PointerPointer primitive_desc)

mkldnn_primitive_get_input_at

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_get_input_at(@Const
                                                                                mkldnn_primitive primitive,
                                                                                @Cast(value="size_t")
                                                                                long index,
                                                                                mkldnn_primitive_at_t input)

For a \p primitive, returns \p input at the \p index position.

mkldnn_primitive_get_output

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_get_output(@Const
                                                                              mkldnn_primitive primitive,
                                                                              @Cast(value="size_t")
                                                                              long index,
                                                                              @Const @ByPtrPtr
                                                                              mkldnn_primitive output)

For a \p primitive, returns \p output at the \p index position.

mkldnn_primitive_get_output

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_get_output(@Const
                                                                              mkldnn_primitive primitive,
                                                                              @Cast(value="size_t")
                                                                              long index,
                                                                              @Cast(value="const_mkldnn_primitive_t*")
                                                                              PointerPointer output)

mkldnn_primitive_destroy

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_destroy(mkldnn_primitive primitive)

Deletes a \p primitive.

mkldnn_primitive_at

@ByVal
public static mkldnn_primitive_at_t mkldnn_primitive_at(@Const
                                                                mkldnn_primitive primitive,
                                                                @Cast(value="size_t")
                                                                long output_index)

Creates an #mkldnn_primitive_at_t structure from a \p primitive and \p output_index. This function only fills in the data structure and does not check whether arguments are correct. The actual error checking is done when the resulting #mkldnn_primitive_at structure is passed to a primitive creation function.

mkldnn_primitive_attr_create

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_attr_create(@ByPtrPtr
                                                                               mkldnn_primitive_attr attr)

Creates an empty (default) \p attr attribute. All the parameters are set to default values. An empty attribute is used in primitive descriptor creation whenever it is not passed explicitly, e.g. in mkldnn_primitive_desc_create.

mkldnn_primitive_attr_create

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_attr_create(@Cast(value="mkldnn_primitive_attr_t*")
                                                                               PointerPointer attr)

mkldnn_primitive_attr_clone

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_attr_clone(@ByPtrPtr
                                                                              mkldnn_primitive_attr attr,
                                                                              @Const
                                                                              mkldnn_primitive_attr existing_attr)

Makes a copy of an \p existing_attr.

mkldnn_primitive_attr_clone

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_attr_clone(@Cast(value="mkldnn_primitive_attr_t*")
                                                                              PointerPointer attr,
                                                                              @Const
                                                                              mkldnn_primitive_attr existing_attr)

mkldnn_primitive_attr_destroy

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_attr_destroy(mkldnn_primitive_attr attr)

Deletes an \p attr.

mkldnn_primitive_attr_get_int_output_round_mode

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_attr_get_int_output_round_mode(@Const
                                                                                                  mkldnn_primitive_attr attr,
                                                                                                  @Cast(value="mkldnn_round_mode_t*")
                                                                                                  IntPointer round_mode)

Returns integer output rounding mode \p round_mode for a given \p attr, previously set by mkldnn_primitive_attr_set_int_output_round_mode.

mkldnn_primitive_attr_get_int_output_round_mode

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_attr_get_int_output_round_mode(@Const
                                                                                                  mkldnn_primitive_attr attr,
                                                                                                  @Cast(value="mkldnn_round_mode_t*")
                                                                                                  IntBuffer round_mode)

mkldnn_primitive_attr_get_int_output_round_mode

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_attr_get_int_output_round_mode(@Const
                                                                                                  mkldnn_primitive_attr attr,
                                                                                                  @Cast(value="mkldnn_round_mode_t*")
                                                                                                  int[] round_mode)

mkldnn_primitive_attr_set_int_output_round_mode

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_attr_set_int_output_round_mode(mkldnn_primitive_attr attr,
                                                                                                  @Cast(value="mkldnn_round_mode_t")
                                                                                                  int round_mode)

Sets output rounding mode \p round_mode for integer operations for a given \p attr. The default value is #mkldnn_round_nearest.

mkldnn_primitive_attr_get_output_scales

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_attr_get_output_scales(@Const
                                                                                          mkldnn_primitive_attr attr,
                                                                                          IntPointer count,
                                                                                          IntPointer mask,
                                                                                          @Cast(value="const float**")
                                                                                          PointerPointer scales)

Returns \p count, correspondence scale \p mask, and a pointer to a constant floating point array of output \p scales for given \p attr, previously set by mkldnn_primitive_attr_set_output_scales. \warning The \p scales array points to the internal \p attr field, so the user should not modify or destroy \p scales. \warning The lifetime of \p scales is the same as that of the \p attr to which it belongs, so it is illegal to use \p scales after \p attr is destroyed.

mkldnn_primitive_attr_get_output_scales

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_attr_get_output_scales(@Const
                                                                                          mkldnn_primitive_attr attr,
                                                                                          IntPointer count,
                                                                                          IntPointer mask,
                                                                                          @Const @ByPtrPtr
                                                                                          FloatPointer scales)

mkldnn_primitive_attr_get_output_scales

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_attr_get_output_scales(@Const
                                                                                          mkldnn_primitive_attr attr,
                                                                                          IntBuffer count,
                                                                                          IntBuffer mask,
                                                                                          @Const @ByPtrPtr
                                                                                          FloatBuffer scales)

mkldnn_primitive_attr_get_output_scales

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_attr_get_output_scales(@Const
                                                                                          mkldnn_primitive_attr attr,
                                                                                          int[] count,
                                                                                          int[] mask,
                                                                                          @Const @ByPtrPtr
                                                                                          float[] scales)

mkldnn_primitive_attr_set_output_scales

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_attr_set_output_scales(mkldnn_primitive_attr attr,
                                                                                          int count,
                                                                                          int mask,
                                                                                          @Const
                                                                                          FloatPointer scales)

Sets output \p scales for primitive operations. The number of elements \p count and correspondence scale \p mask are stored for future use. The \p mask argument defines the correspondence between the output tensor dimensions and the \p scales array. Set the i-th bit of \p mask to 1 to use a dedicated scaling factor for each slice of the output tensor over the i-th dimension. Set \p mask to 0 to use a common scaling factor for the whole output tensor. \note The dimension order is always native and does not depend on the actual layout used. Examples: - 2D dimensional data the order of dimensions is always: (n, c) - 4D dimensional data the order is always: (n, c, h, w) - 5D dimensional weights the order is always: (g, oc, ic, kh, kw) Example usage:


      int mb = 32, oc = 32, oh = 14, ow = 14; // convolution output params
      float scales[oc] = { ... }; // unique output scales per output channel
      int oc_dim = 1; // mb_dim = 0, channel_dim = 1, height_dim = 2, ...

      mkldnn_convolution_desc_t cd; // create & configure convolution op_desc

      mkldnn_primitive_attr_t attr;
      mkldnn_primitive_attr_create(&attr);  // create default attributes
      mkldnn_primitive_attr_set_output_scales(attr, oc, 1 << oc_dim, scales);

      mkldnn_primitive_desc_t cpd;
      mkldnn_primitive_desc_create_v2(&cpd, &cd, attr, NULL);

\note There is no way to check that \p count corresponds to \p mask until an actual primitive descriptor is created, so it is the user's responsibility to set proper values. The following formula must hold:

 \[count = \prod\limits_{d \in mask} output.dims[d]\]

mkldnn_primitive_attr_set_output_scales

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_attr_set_output_scales(mkldnn_primitive_attr attr,
                                                                                          int count,
                                                                                          int mask,
                                                                                          @Const
                                                                                          FloatBuffer scales)

mkldnn_primitive_attr_set_output_scales

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_attr_set_output_scales(mkldnn_primitive_attr attr,
                                                                                          int count,
                                                                                          int mask,
                                                                                          @Const
                                                                                          float[] scales)

mkldnn_primitive_attr_get_post_ops

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_attr_get_post_ops(@Const
                                                                                     mkldnn_primitive_attr attr,
                                                                                     @Const @ByPtrPtr
                                                                                     mkldnn_post_ops post_ops)

Returns \p post_ops for given \p attr. \warning \p post_ops points to the internal \p attr field, so the user should not modify or destroy \p post_ops. Also, the lifetime of \p post_ops is the same as that of the \p attr it belongs to, so it is illegal to use \p post_ops after \p attr has been destroyed.

mkldnn_primitive_attr_get_post_ops

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_attr_get_post_ops(@Const
                                                                                     mkldnn_primitive_attr attr,
                                                                                     @Cast(value="const_mkldnn_post_ops_t*")
                                                                                     PointerPointer post_ops)

mkldnn_primitive_attr_set_post_ops

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_attr_set_post_ops(mkldnn_primitive_attr attr,
                                                                                     @Const
                                                                                     mkldnn_post_ops post_ops)

Sets configured \p post_ops to an attribute \p attr for future use (when primitive descriptor is being created). \note At this point in time, there is no way to check whether the primitive descriptor does or does not support a given sequence of post operations. Therefore the user should handle an error that might occur at the mkldnn_primitive_desc_create call.

mkldnn_post_ops_create

@Cast(value="mkldnn_status_t")
public static int mkldnn_post_ops_create(@ByPtrPtr
                                                                         mkldnn_post_ops post_ops)

Creates an empty sequence of post operations \p post_ops.

mkldnn_post_ops_create

@Cast(value="mkldnn_status_t")
public static int mkldnn_post_ops_create(@Cast(value="mkldnn_post_ops_t*")
                                                                         PointerPointer post_ops)

mkldnn_post_ops_destroy

@Cast(value="mkldnn_status_t")
public static int mkldnn_post_ops_destroy(mkldnn_post_ops post_ops)

Deletes a \p post_ops sequence.

mkldnn_post_ops_len

public static int mkldnn_post_ops_len(@Const
                                      mkldnn_post_ops post_ops)

Returns the \p length of post operations for given \p post_ops.

mkldnn_post_ops_get_kind

@Cast(value="mkldnn_primitive_kind_t")
public static int mkldnn_post_ops_get_kind(@Const
                                                                                   mkldnn_post_ops post_ops,
                                                                                   int index)

Returns the type of post operation with index \p index in given \p post_ops. In case of error, returns #mkldnn_undefined_primitive.

mkldnn_post_ops_append_sum
```
@Cast(value="mkldnn_status_t")
public static int mkldnn_post_ops_append_sum(mkldnn_post_ops post_ops,
                                                                             float scale)
```
Appends accumulation (sum) post operation to the \p post_ops. Prior to accumulating the result, the previous value would be multiplied by \p scale. The kind of this post operation is #mkldnn_sum. This feature might improve performance for cases like residual learning blocks, where the result of convolution is accumulated to the previously computed activations. The parameter \p scale might be extreme for the integer-based computations when the result and previous activations have different logical scaling factors. In the simplest case when the accumulation is the only post operation, the computations would be: dst[] <- scale * dst[] + op(...) // instead of dst[] <- op(...) \note This post operation (as well as all the others) disregards the original layout of the destination; that is, the layout of the original destination is expected to be the same as the layout of the stored destination.

mkldnn_post_ops_get_params_sum

@Cast(value="mkldnn_status_t")
public static int mkldnn_post_ops_get_params_sum(@Const
                                                                                 mkldnn_post_ops post_ops,
                                                                                 int index,
                                                                                 FloatPointer scale)

Gets the parameters of the accumulation (sum) post operation with index \p index in the sequence of \p post_ops. \note If index \p index would not correspond to the accumulation post operation, the function returns #mkldnn_invalid_arguments.

mkldnn_post_ops_get_params_sum

@Cast(value="mkldnn_status_t")
public static int mkldnn_post_ops_get_params_sum(@Const
                                                                                 mkldnn_post_ops post_ops,
                                                                                 int index,
                                                                                 FloatBuffer scale)

mkldnn_post_ops_get_params_sum

@Cast(value="mkldnn_status_t")
public static int mkldnn_post_ops_get_params_sum(@Const
                                                                                 mkldnn_post_ops post_ops,
                                                                                 int index,
                                                                                 float[] scale)

mkldnn_post_ops_append_eltwise

@Cast(value="mkldnn_status_t")
public static int mkldnn_post_ops_append_eltwise(mkldnn_post_ops post_ops,
                                                                                 float scale,
                                                                                 @Cast(value="mkldnn_alg_kind_t")
                                                                                 int alg,
                                                                                 float alpha,
                                                                                 float beta)

Appends eltwise post operation to the \p post_ops with given parameters \p kind, \p alpha, and \p beta (@see mkldnn_eltwise_forward_desc_init and mkldnn_eltwise_desc_t). The kind of this post operation is #mkldnn_eltwise. In the simplest case when the eltwise is the only post operation, the computations would be: dst[] <- scale * eltwise_op ( op(...) ) // instead of dst[] <- op(...) where eltwise_op is configured with the given parameters.

mkldnn_post_ops_get_params_eltwise

@Cast(value="mkldnn_status_t")
public static int mkldnn_post_ops_get_params_eltwise(@Const
                                                                                     mkldnn_post_ops post_ops,
                                                                                     int index,
                                                                                     FloatPointer scale,
                                                                                     @Cast(value="mkldnn_alg_kind_t*")
                                                                                     IntPointer alg,
                                                                                     FloatPointer alpha,
                                                                                     FloatPointer beta)

Gets the eltwise parameters of the post operation with index \p index in the sequence of \p post_ops.

mkldnn_post_ops_get_params_eltwise

@Cast(value="mkldnn_status_t")
public static int mkldnn_post_ops_get_params_eltwise(@Const
                                                                                     mkldnn_post_ops post_ops,
                                                                                     int index,
                                                                                     FloatBuffer scale,
                                                                                     @Cast(value="mkldnn_alg_kind_t*")
                                                                                     IntBuffer alg,
                                                                                     FloatBuffer alpha,
                                                                                     FloatBuffer beta)

mkldnn_post_ops_get_params_eltwise

@Cast(value="mkldnn_status_t")
public static int mkldnn_post_ops_get_params_eltwise(@Const
                                                                                     mkldnn_post_ops post_ops,
                                                                                     int index,
                                                                                     float[] scale,
                                                                                     @Cast(value="mkldnn_alg_kind_t*")
                                                                                     int[] alg,
                                                                                     float[] alpha,
                                                                                     float[] beta)

mkldnn_memory_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_memory_desc_init(mkldnn_memory_desc_t memory_desc,
                                                                          int ndims,
                                                                          @Const
                                                                          IntPointer dims,
                                                                          @Cast(value="mkldnn_data_type_t")
                                                                          int data_type,
                                                                          @Cast(value="mkldnn_memory_format_t")
                                                                          int format)

Initializes a \p memory_desc memory descriptor using \p ndims, \p dims, \p data_type, and data \p format. \p format can be #mkldnn_any, which means that specific data layouts are not permitted.

mkldnn_memory_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_memory_desc_init(mkldnn_memory_desc_t memory_desc,
                                                                          int ndims,
                                                                          @Const
                                                                          IntBuffer dims,
                                                                          @Cast(value="mkldnn_data_type_t")
                                                                          int data_type,
                                                                          @Cast(value="mkldnn_memory_format_t")
                                                                          int format)

mkldnn_memory_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_memory_desc_init(mkldnn_memory_desc_t memory_desc,
                                                                          int ndims,
                                                                          @Const
                                                                          int[] dims,
                                                                          @Cast(value="mkldnn_data_type_t")
                                                                          int data_type,
                                                                          @Cast(value="mkldnn_memory_format_t")
                                                                          int format)

mkldnn_memory_primitive_desc_create

@Cast(value="mkldnn_status_t")
public static int mkldnn_memory_primitive_desc_create(@ByPtrPtr
                                                                                      mkldnn_primitive_desc memory_primitive_desc,
                                                                                      @Const
                                                                                      mkldnn_memory_desc_t memory_desc,
                                                                                      mkldnn_engine engine)

Creates a \p memory_primitive_desc memory primitive descriptor using \p memory_desc and \p engine. \p memory_desc cannot be uncertain; that is, it cannot be initialized with #mkldnn_any.

mkldnn_memory_primitive_desc_create

@Cast(value="mkldnn_status_t")
public static int mkldnn_memory_primitive_desc_create(@Cast(value="mkldnn_primitive_desc_t*")
                                                                                      PointerPointer memory_primitive_desc,
                                                                                      @Const
                                                                                      mkldnn_memory_desc_t memory_desc,
                                                                                      mkldnn_engine engine)

mkldnn_view_primitive_desc_create

@Cast(value="mkldnn_status_t")
public static int mkldnn_view_primitive_desc_create(@ByPtrPtr
                                                                                    mkldnn_primitive_desc view_primitive_desc,
                                                                                    @Const
                                                                                    mkldnn_primitive_desc memory_primitive_desc,
                                                                                    @Const
                                                                                    IntPointer dims,
                                                                                    @Const
                                                                                    IntPointer offsets)

Creates a \p view_primitive_desc for a given \p memory_primitive_desc, with \p dims sizes and \p offsets offsets. May fail if the format used does not allow obtaining the desired view. In this case, consider using the extract primitive.

mkldnn_view_primitive_desc_create

@Cast(value="mkldnn_status_t")
public static int mkldnn_view_primitive_desc_create(@Cast(value="mkldnn_primitive_desc_t*")
                                                                                    PointerPointer view_primitive_desc,
                                                                                    @Const
                                                                                    mkldnn_primitive_desc memory_primitive_desc,
                                                                                    @Const
                                                                                    IntBuffer dims,
                                                                                    @Const
                                                                                    IntBuffer offsets)

mkldnn_view_primitive_desc_create

@Cast(value="mkldnn_status_t")
public static int mkldnn_view_primitive_desc_create(@ByPtrPtr
                                                                                    mkldnn_primitive_desc view_primitive_desc,
                                                                                    @Const
                                                                                    mkldnn_primitive_desc memory_primitive_desc,
                                                                                    @Const
                                                                                    int[] dims,
                                                                                    @Const
                                                                                    int[] offsets)

mkldnn_view_primitive_desc_create

@Cast(value="mkldnn_status_t")
public static int mkldnn_view_primitive_desc_create(@Cast(value="mkldnn_primitive_desc_t*")
                                                                                    PointerPointer view_primitive_desc,
                                                                                    @Const
                                                                                    mkldnn_primitive_desc memory_primitive_desc,
                                                                                    @Const
                                                                                    IntPointer dims,
                                                                                    @Const
                                                                                    IntPointer offsets)

mkldnn_view_primitive_desc_create

@Cast(value="mkldnn_status_t")
public static int mkldnn_view_primitive_desc_create(@ByPtrPtr
                                                                                    mkldnn_primitive_desc view_primitive_desc,
                                                                                    @Const
                                                                                    mkldnn_primitive_desc memory_primitive_desc,
                                                                                    @Const
                                                                                    IntBuffer dims,
                                                                                    @Const
                                                                                    IntBuffer offsets)

mkldnn_view_primitive_desc_create

@Cast(value="mkldnn_status_t")
public static int mkldnn_view_primitive_desc_create(@Cast(value="mkldnn_primitive_desc_t*")
                                                                                    PointerPointer view_primitive_desc,
                                                                                    @Const
                                                                                    mkldnn_primitive_desc memory_primitive_desc,
                                                                                    @Const
                                                                                    int[] dims,
                                                                                    @Const
                                                                                    int[] offsets)

mkldnn_memory_primitive_desc_equal

public static int mkldnn_memory_primitive_desc_equal(@Const
                                                     mkldnn_primitive_desc lhs,
                                                     @Const
                                                     mkldnn_primitive_desc rhs)

Compares two descriptors of memory primitives.

Returns:: 1 if the descriptors are the same.

mkldnn_memory_primitive_desc_get_size

@Cast(value="size_t")
public static long mkldnn_memory_primitive_desc_get_size(@Const
                                                                                mkldnn_primitive_desc memory_primitive_desc)

Returns the size (in bytes) that is required for given \p memory_primitive_desc

mkldnn_memory_get_data_handle

@Cast(value="mkldnn_status_t")
public static int mkldnn_memory_get_data_handle(@Const
                                                                                mkldnn_primitive memory,
                                                                                @Cast(value="void**")
                                                                                PointerPointer handle)

For a \p memory primitive, returns the data \p handle. For the CPU engine, the data handle is a pointer to the actual data.

mkldnn_memory_get_data_handle

@Cast(value="mkldnn_status_t")
public static int mkldnn_memory_get_data_handle(@Const
                                                                                mkldnn_primitive memory,
                                                                                @Cast(value="void**") @ByPtrPtr
                                                                                Pointer handle)

mkldnn_memory_set_data_handle

@Cast(value="mkldnn_status_t")
public static int mkldnn_memory_set_data_handle(mkldnn_primitive memory,
                                                                                Pointer handle)

For a \p memory primitive, sets the data \p handle.

mkldnn_reorder_primitive_desc_create

@Cast(value="mkldnn_status_t")
public static int mkldnn_reorder_primitive_desc_create(@ByPtrPtr
                                                                                       mkldnn_primitive_desc reorder_primitive_desc,
                                                                                       @Const
                                                                                       mkldnn_primitive_desc input,
                                                                                       @Const
                                                                                       mkldnn_primitive_desc output)

Initializes a \p reorder_primitive_desc using descriptors of \p input and \p output memory primitives. Order of inputs: - input (#mkldnn_query_input_pd, 0) Order of outputs: - output (#mkldnn_query_output_pd, 0)

mkldnn_reorder_primitive_desc_create

@Cast(value="mkldnn_status_t")
public static int mkldnn_reorder_primitive_desc_create(@Cast(value="mkldnn_primitive_desc_t*")
                                                                                       PointerPointer reorder_primitive_desc,
                                                                                       @Const
                                                                                       mkldnn_primitive_desc input,
                                                                                       @Const
                                                                                       mkldnn_primitive_desc output)

mkldnn_reorder_primitive_desc_create_v2

@Cast(value="mkldnn_status_t")
public static int mkldnn_reorder_primitive_desc_create_v2(@ByPtrPtr
                                                                                          mkldnn_primitive_desc reorder_primitive_desc,
                                                                                          @Const
                                                                                          mkldnn_primitive_desc input,
                                                                                          @Const
                                                                                          mkldnn_primitive_desc output,
                                                                                          @Const
                                                                                          mkldnn_primitive_attr attr)

Initializes a \p reorder_primitive_desc using an \p attr attribute and descriptors of \p input and \p output memory primitives. Order of inputs: - input (#mkldnn_query_input_pd, 0) Order of outputs: - output (#mkldnn_query_output_pd, 0)

mkldnn_reorder_primitive_desc_create_v2

@Cast(value="mkldnn_status_t")
public static int mkldnn_reorder_primitive_desc_create_v2(@Cast(value="mkldnn_primitive_desc_t*")
                                                                                          PointerPointer reorder_primitive_desc,
                                                                                          @Const
                                                                                          mkldnn_primitive_desc input,
                                                                                          @Const
                                                                                          mkldnn_primitive_desc output,
                                                                                          @Const
                                                                                          mkldnn_primitive_attr attr)

mkldnn_concat_primitive_desc_create

@Cast(value="mkldnn_status_t")
public static int mkldnn_concat_primitive_desc_create(@ByPtrPtr
                                                                                      mkldnn_primitive_desc concat_primitive_desc,
                                                                                      @Const
                                                                                      mkldnn_memory_desc_t output_desc,
                                                                                      int n,
                                                                                      int concat_dimension,
                                                                                      @Const @ByPtrPtr
                                                                                      mkldnn_primitive_desc input_pds)

Creates out-of-place \p concat_primitive_desc for concatenation of \p n inputs by \p concat_dimension with resulting \p output_desc memory descriptor. \p output_desc can be NULL or specified with the #mkldnn_any format -- in this case, the appropriate memory format would be chosen automatically. Order of inputs: - input 0 (#mkldnn_query_input_pd, 0) - input 1 (#mkldnn_query_input_pd, 1) - ... - input \p n - 1 (#mkldnn_query_input_pd, \p n - 1) Order of outputs: - output (#mkldnn_query_output_pd, 0)

mkldnn_concat_primitive_desc_create

@Cast(value="mkldnn_status_t")
public static int mkldnn_concat_primitive_desc_create(@Cast(value="mkldnn_primitive_desc_t*")
                                                                                      PointerPointer concat_primitive_desc,
                                                                                      @Const
                                                                                      mkldnn_memory_desc_t output_desc,
                                                                                      int n,
                                                                                      int concat_dimension,
                                                                                      @Cast(value="const_mkldnn_primitive_desc_t*")
                                                                                      PointerPointer input_pds)

mkldnn_sum_primitive_desc_create

@Cast(value="mkldnn_status_t")
public static int mkldnn_sum_primitive_desc_create(@ByPtrPtr
                                                                                   mkldnn_primitive_desc sum_primitive_desc,
                                                                                   @Const
                                                                                   mkldnn_memory_desc_t output_desc,
                                                                                   int n,
                                                                                   @Const
                                                                                   FloatPointer scales,
                                                                                   @Const @ByPtrPtr
                                                                                   mkldnn_primitive_desc input_pds)

Creates out-of-place \p sum_primitive_desc for sum of \p n inputs multiplied by scale with resulting \p output_desc memory descriptor. \p output_desc can be NULL or specified with the #mkldnn_any format -- in this case, the appropriate memory format would be chosen automatically. Order of inputs: - input 0 (#mkldnn_query_input_pd, 0) - input 1 (#mkldnn_query_input_pd, 1) - ... - input \p n - 1 (#mkldnn_query_input_pd, \p n - 1) Order of outputs: - output (#mkldnn_query_output_pd, 0)

mkldnn_sum_primitive_desc_create

@Cast(value="mkldnn_status_t")
public static int mkldnn_sum_primitive_desc_create(@Cast(value="mkldnn_primitive_desc_t*")
                                                                                   PointerPointer sum_primitive_desc,
                                                                                   @Const
                                                                                   mkldnn_memory_desc_t output_desc,
                                                                                   int n,
                                                                                   @Const
                                                                                   FloatBuffer scales,
                                                                                   @Cast(value="const_mkldnn_primitive_desc_t*")
                                                                                   PointerPointer input_pds)

mkldnn_sum_primitive_desc_create

@Cast(value="mkldnn_status_t")
public static int mkldnn_sum_primitive_desc_create(@ByPtrPtr
                                                                                   mkldnn_primitive_desc sum_primitive_desc,
                                                                                   @Const
                                                                                   mkldnn_memory_desc_t output_desc,
                                                                                   int n,
                                                                                   @Const
                                                                                   float[] scales,
                                                                                   @Const @ByPtrPtr
                                                                                   mkldnn_primitive_desc input_pds)

mkldnn_sum_primitive_desc_create

@Cast(value="mkldnn_status_t")
public static int mkldnn_sum_primitive_desc_create(@Cast(value="mkldnn_primitive_desc_t*")
                                                                                   PointerPointer sum_primitive_desc,
                                                                                   @Const
                                                                                   mkldnn_memory_desc_t output_desc,
                                                                                   int n,
                                                                                   @Const
                                                                                   FloatPointer scales,
                                                                                   @Cast(value="const_mkldnn_primitive_desc_t*")
                                                                                   PointerPointer input_pds)

mkldnn_sum_primitive_desc_create

@Cast(value="mkldnn_status_t")
public static int mkldnn_sum_primitive_desc_create(@ByPtrPtr
                                                                                   mkldnn_primitive_desc sum_primitive_desc,
                                                                                   @Const
                                                                                   mkldnn_memory_desc_t output_desc,
                                                                                   int n,
                                                                                   @Const
                                                                                   FloatBuffer scales,
                                                                                   @Const @ByPtrPtr
                                                                                   mkldnn_primitive_desc input_pds)

mkldnn_sum_primitive_desc_create

@Cast(value="mkldnn_status_t")
public static int mkldnn_sum_primitive_desc_create(@Cast(value="mkldnn_primitive_desc_t*")
                                                                                   PointerPointer sum_primitive_desc,
                                                                                   @Const
                                                                                   mkldnn_memory_desc_t output_desc,
                                                                                   int n,
                                                                                   @Const
                                                                                   float[] scales,
                                                                                   @Cast(value="const_mkldnn_primitive_desc_t*")
                                                                                   PointerPointer input_pds)

mkldnn_convolution_forward_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_convolution_forward_desc_init(mkldnn_convolution_desc_t conv_desc,
                                                                                       @Cast(value="mkldnn_prop_kind_t")
                                                                                       int prop_kind,
                                                                                       @Cast(value="mkldnn_alg_kind_t")
                                                                                       int alg_kind,
                                                                                       @Const
                                                                                       mkldnn_memory_desc_t src_desc,
                                                                                       @Const
                                                                                       mkldnn_memory_desc_t weights_desc,
                                                                                       @Const
                                                                                       mkldnn_memory_desc_t bias_desc,
                                                                                       @Const
                                                                                       mkldnn_memory_desc_t dst_desc,
                                                                                       @Const
                                                                                       IntPointer strides,
                                                                                       @Const
                                                                                       IntPointer padding_l,
                                                                                       @Const
                                                                                       IntPointer padding_r,
                                                                                       @Cast(value="mkldnn_padding_kind_t")
                                                                                       int padding_kind)

Initializes a convolution descriptor \p conv_desc for forward propagation using \p prop_kind (possible values are #mkldnn_forward_training and #mkldnn_forward_inference), \p alg_kind, memory descriptors, \p strides, \p padding_l, \p padding_r, and \p padding_kind. In order to create a convolution without bias, \p bias_desc should either be \c NULL or point to a descriptor with memory format equal to #mkldnn_format_undef. \note If \p padding_r is \c NULL, the padding is supposed to be symmetric. \note Memory descriptors are allowed to be initialized with #mkldnn_any value of \p format_kind. Order of inputs: - src (#mkldnn_query_src_pd, 0) - weights (#mkldnn_query_weights_pd, 0) - bias (#mkldnn_query_weights_pd, 1), if created with bias Order of outputs: - dst (#mkldnn_query_dst_pd, 0)

mkldnn_convolution_forward_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_convolution_forward_desc_init(mkldnn_convolution_desc_t conv_desc,
                                                                                       @Cast(value="mkldnn_prop_kind_t")
                                                                                       int prop_kind,
                                                                                       @Cast(value="mkldnn_alg_kind_t")
                                                                                       int alg_kind,
                                                                                       @Const
                                                                                       mkldnn_memory_desc_t src_desc,
                                                                                       @Const
                                                                                       mkldnn_memory_desc_t weights_desc,
                                                                                       @Const
                                                                                       mkldnn_memory_desc_t bias_desc,
                                                                                       @Const
                                                                                       mkldnn_memory_desc_t dst_desc,
                                                                                       @Const
                                                                                       IntBuffer strides,
                                                                                       @Const
                                                                                       IntBuffer padding_l,
                                                                                       @Const
                                                                                       IntBuffer padding_r,
                                                                                       @Cast(value="mkldnn_padding_kind_t")
                                                                                       int padding_kind)

mkldnn_convolution_forward_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_convolution_forward_desc_init(mkldnn_convolution_desc_t conv_desc,
                                                                                       @Cast(value="mkldnn_prop_kind_t")
                                                                                       int prop_kind,
                                                                                       @Cast(value="mkldnn_alg_kind_t")
                                                                                       int alg_kind,
                                                                                       @Const
                                                                                       mkldnn_memory_desc_t src_desc,
                                                                                       @Const
                                                                                       mkldnn_memory_desc_t weights_desc,
                                                                                       @Const
                                                                                       mkldnn_memory_desc_t bias_desc,
                                                                                       @Const
                                                                                       mkldnn_memory_desc_t dst_desc,
                                                                                       @Const
                                                                                       int[] strides,
                                                                                       @Const
                                                                                       int[] padding_l,
                                                                                       @Const
                                                                                       int[] padding_r,
                                                                                       @Cast(value="mkldnn_padding_kind_t")
                                                                                       int padding_kind)

mkldnn_dilated_convolution_forward_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_dilated_convolution_forward_desc_init(mkldnn_convolution_desc_t conv_desc,
                                                                                               @Cast(value="mkldnn_prop_kind_t")
                                                                                               int prop_kind,
                                                                                               @Cast(value="mkldnn_alg_kind_t")
                                                                                               int alg_kind,
                                                                                               @Const
                                                                                               mkldnn_memory_desc_t src_desc,
                                                                                               @Const
                                                                                               mkldnn_memory_desc_t weights_desc,
                                                                                               @Const
                                                                                               mkldnn_memory_desc_t bias_desc,
                                                                                               @Const
                                                                                               mkldnn_memory_desc_t dst_desc,
                                                                                               @Const
                                                                                               IntPointer strides,
                                                                                               @Const
                                                                                               IntPointer dilates,
                                                                                               @Const
                                                                                               IntPointer padding_l,
                                                                                               @Const
                                                                                               IntPointer padding_r,
                                                                                               @Cast(value="mkldnn_padding_kind_t")
                                                                                               int padding_kind)

Initializes a dilated convolution descriptor \p conv_desc for forward propagation using \p prop_kind (possible values are #mkldnn_forward_training and #mkldnn_forward_inference), \p alg_kind, memory descriptors, \p strides, \p dilates, \p padding_l, \p padding_r, and \p padding_kind. In order to create a dilated convolution without bias, \p bias_desc should either be \c NULL or point to a descriptor with memory format equal to #mkldnn_format_undef. \note If \p padding_r is \c NULL, the padding is supposed to be symmetric. \note Memory descriptors are allowed to be initialized with #mkldnn_any value of \p format_kind. Order of inputs: - src (#mkldnn_query_src_pd, 0) - weights (#mkldnn_query_weights_pd, 0) - bias (#mkldnn_query_weights_pd, 1), if created with bias Order of outputs: - dst (#mkldnn_query_dst_pd, 0)

mkldnn_dilated_convolution_forward_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_dilated_convolution_forward_desc_init(mkldnn_convolution_desc_t conv_desc,
                                                                                               @Cast(value="mkldnn_prop_kind_t")
                                                                                               int prop_kind,
                                                                                               @Cast(value="mkldnn_alg_kind_t")
                                                                                               int alg_kind,
                                                                                               @Const
                                                                                               mkldnn_memory_desc_t src_desc,
                                                                                               @Const
                                                                                               mkldnn_memory_desc_t weights_desc,
                                                                                               @Const
                                                                                               mkldnn_memory_desc_t bias_desc,
                                                                                               @Const
                                                                                               mkldnn_memory_desc_t dst_desc,
                                                                                               @Const
                                                                                               IntBuffer strides,
                                                                                               @Const
                                                                                               IntBuffer dilates,
                                                                                               @Const
                                                                                               IntBuffer padding_l,
                                                                                               @Const
                                                                                               IntBuffer padding_r,
                                                                                               @Cast(value="mkldnn_padding_kind_t")
                                                                                               int padding_kind)

mkldnn_dilated_convolution_forward_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_dilated_convolution_forward_desc_init(mkldnn_convolution_desc_t conv_desc,
                                                                                               @Cast(value="mkldnn_prop_kind_t")
                                                                                               int prop_kind,
                                                                                               @Cast(value="mkldnn_alg_kind_t")
                                                                                               int alg_kind,
                                                                                               @Const
                                                                                               mkldnn_memory_desc_t src_desc,
                                                                                               @Const
                                                                                               mkldnn_memory_desc_t weights_desc,
                                                                                               @Const
                                                                                               mkldnn_memory_desc_t bias_desc,
                                                                                               @Const
                                                                                               mkldnn_memory_desc_t dst_desc,
                                                                                               @Const
                                                                                               int[] strides,
                                                                                               @Const
                                                                                               int[] dilates,
                                                                                               @Const
                                                                                               int[] padding_l,
                                                                                               @Const
                                                                                               int[] padding_r,
                                                                                               @Cast(value="mkldnn_padding_kind_t")
                                                                                               int padding_kind)

mkldnn_convolution_backward_data_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_convolution_backward_data_desc_init(mkldnn_convolution_desc_t conv_desc,
                                                                                             @Cast(value="mkldnn_alg_kind_t")
                                                                                             int alg_kind,
                                                                                             @Const
                                                                                             mkldnn_memory_desc_t diff_src_desc,
                                                                                             @Const
                                                                                             mkldnn_memory_desc_t weights_desc,
                                                                                             @Const
                                                                                             mkldnn_memory_desc_t diff_dst_desc,
                                                                                             @Const
                                                                                             IntPointer strides,
                                                                                             @Const
                                                                                             IntPointer padding_l,
                                                                                             @Const
                                                                                             IntPointer padding_r,
                                                                                             @Cast(value="mkldnn_padding_kind_t")
                                                                                             int padding_kind)

Initializes a convolution descriptor \p conv_desc for backward propagation with respect to data using \p alg_kind, memory descriptors, \p strides, \p padding_l, \p padding_r, and \p padding_kind. \note Memory descriptors are allowed to be initialized with #mkldnn_any value of \p format_kind. Order of inputs: - diff_dst (#mkldnn_query_diff_dst_pd, 0) - weights (#mkldnn_query_weights_pd, 0) Order of outputs: - diff_src (#mkldnn_query_diff_src_pd, 0)

mkldnn_convolution_backward_data_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_convolution_backward_data_desc_init(mkldnn_convolution_desc_t conv_desc,
                                                                                             @Cast(value="mkldnn_alg_kind_t")
                                                                                             int alg_kind,
                                                                                             @Const
                                                                                             mkldnn_memory_desc_t diff_src_desc,
                                                                                             @Const
                                                                                             mkldnn_memory_desc_t weights_desc,
                                                                                             @Const
                                                                                             mkldnn_memory_desc_t diff_dst_desc,
                                                                                             @Const
                                                                                             IntBuffer strides,
                                                                                             @Const
                                                                                             IntBuffer padding_l,
                                                                                             @Const
                                                                                             IntBuffer padding_r,
                                                                                             @Cast(value="mkldnn_padding_kind_t")
                                                                                             int padding_kind)

mkldnn_convolution_backward_data_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_convolution_backward_data_desc_init(mkldnn_convolution_desc_t conv_desc,
                                                                                             @Cast(value="mkldnn_alg_kind_t")
                                                                                             int alg_kind,
                                                                                             @Const
                                                                                             mkldnn_memory_desc_t diff_src_desc,
                                                                                             @Const
                                                                                             mkldnn_memory_desc_t weights_desc,
                                                                                             @Const
                                                                                             mkldnn_memory_desc_t diff_dst_desc,
                                                                                             @Const
                                                                                             int[] strides,
                                                                                             @Const
                                                                                             int[] padding_l,
                                                                                             @Const
                                                                                             int[] padding_r,
                                                                                             @Cast(value="mkldnn_padding_kind_t")
                                                                                             int padding_kind)

mkldnn_dilated_convolution_backward_data_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_dilated_convolution_backward_data_desc_init(mkldnn_convolution_desc_t conv_desc,
                                                                                                     @Cast(value="mkldnn_alg_kind_t")
                                                                                                     int alg_kind,
                                                                                                     @Const
                                                                                                     mkldnn_memory_desc_t diff_src_desc,
                                                                                                     @Const
                                                                                                     mkldnn_memory_desc_t weights_desc,
                                                                                                     @Const
                                                                                                     mkldnn_memory_desc_t diff_dst_desc,
                                                                                                     @Const
                                                                                                     IntPointer strides,
                                                                                                     @Const
                                                                                                     IntPointer dilates,
                                                                                                     @Const
                                                                                                     IntPointer padding_l,
                                                                                                     @Const
                                                                                                     IntPointer padding_r,
                                                                                                     @Cast(value="mkldnn_padding_kind_t")
                                                                                                     int padding_kind)

Initializes a dilated convolution descriptor \p conv_desc for backward propagation with respect to data using \p alg_kind, memory descriptors, \p strides, \p dilates \p padding_l, \p padding_r, and \p padding_kind. \note Memory descriptors are allowed to be initialized with #mkldnn_any value of \p format_kind. Order of inputs: - diff_dst (#mkldnn_query_diff_dst_pd, 0) - weights (#mkldnn_query_weights_pd, 0) Order of outputs: - diff_src (#mkldnn_query_diff_src_pd, 0)

mkldnn_dilated_convolution_backward_data_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_dilated_convolution_backward_data_desc_init(mkldnn_convolution_desc_t conv_desc,
                                                                                                     @Cast(value="mkldnn_alg_kind_t")
                                                                                                     int alg_kind,
                                                                                                     @Const
                                                                                                     mkldnn_memory_desc_t diff_src_desc,
                                                                                                     @Const
                                                                                                     mkldnn_memory_desc_t weights_desc,
                                                                                                     @Const
                                                                                                     mkldnn_memory_desc_t diff_dst_desc,
                                                                                                     @Const
                                                                                                     IntBuffer strides,
                                                                                                     @Const
                                                                                                     IntBuffer dilates,
                                                                                                     @Const
                                                                                                     IntBuffer padding_l,
                                                                                                     @Const
                                                                                                     IntBuffer padding_r,
                                                                                                     @Cast(value="mkldnn_padding_kind_t")
                                                                                                     int padding_kind)

mkldnn_dilated_convolution_backward_data_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_dilated_convolution_backward_data_desc_init(mkldnn_convolution_desc_t conv_desc,
                                                                                                     @Cast(value="mkldnn_alg_kind_t")
                                                                                                     int alg_kind,
                                                                                                     @Const
                                                                                                     mkldnn_memory_desc_t diff_src_desc,
                                                                                                     @Const
                                                                                                     mkldnn_memory_desc_t weights_desc,
                                                                                                     @Const
                                                                                                     mkldnn_memory_desc_t diff_dst_desc,
                                                                                                     @Const
                                                                                                     int[] strides,
                                                                                                     @Const
                                                                                                     int[] dilates,
                                                                                                     @Const
                                                                                                     int[] padding_l,
                                                                                                     @Const
                                                                                                     int[] padding_r,
                                                                                                     @Cast(value="mkldnn_padding_kind_t")
                                                                                                     int padding_kind)

mkldnn_convolution_backward_weights_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_convolution_backward_weights_desc_init(mkldnn_convolution_desc_t conv_desc,
                                                                                                @Cast(value="mkldnn_alg_kind_t")
                                                                                                int alg_kind,
                                                                                                @Const
                                                                                                mkldnn_memory_desc_t src_desc,
                                                                                                @Const
                                                                                                mkldnn_memory_desc_t diff_weights_desc,
                                                                                                @Const
                                                                                                mkldnn_memory_desc_t diff_bias_desc,
                                                                                                @Const
                                                                                                mkldnn_memory_desc_t diff_dst_desc,
                                                                                                @Const
                                                                                                IntPointer strides,
                                                                                                @Const
                                                                                                IntPointer padding_l,
                                                                                                @Const
                                                                                                IntPointer padding_r,
                                                                                                @Cast(value="mkldnn_padding_kind_t")
                                                                                                int padding_kind)

Initializes a convolution descriptor \p conv_desc for backward propagation with respect to weights using \p alg_kind, memory descriptors, \p strides, \p padding_l, \p padding_r, and \p padding_kind. \note Memory descriptors are allowed to be initialized with #mkldnn_any value of \p format_kind. Order of inputs: - src (#mkldnn_query_src_pd, 0) - diff_dst (#mkldnn_query_diff_dst_pd, 0) Order of outputs: - diff_weights (#mkldnn_query_diff_weights_pd, 0) - diff_bias (#mkldnn_query_diff_weights_pd, 1), if created with bias

mkldnn_convolution_backward_weights_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_convolution_backward_weights_desc_init(mkldnn_convolution_desc_t conv_desc,
                                                                                                @Cast(value="mkldnn_alg_kind_t")
                                                                                                int alg_kind,
                                                                                                @Const
                                                                                                mkldnn_memory_desc_t src_desc,
                                                                                                @Const
                                                                                                mkldnn_memory_desc_t diff_weights_desc,
                                                                                                @Const
                                                                                                mkldnn_memory_desc_t diff_bias_desc,
                                                                                                @Const
                                                                                                mkldnn_memory_desc_t diff_dst_desc,
                                                                                                @Const
                                                                                                IntBuffer strides,
                                                                                                @Const
                                                                                                IntBuffer padding_l,
                                                                                                @Const
                                                                                                IntBuffer padding_r,
                                                                                                @Cast(value="mkldnn_padding_kind_t")
                                                                                                int padding_kind)

mkldnn_convolution_backward_weights_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_convolution_backward_weights_desc_init(mkldnn_convolution_desc_t conv_desc,
                                                                                                @Cast(value="mkldnn_alg_kind_t")
                                                                                                int alg_kind,
                                                                                                @Const
                                                                                                mkldnn_memory_desc_t src_desc,
                                                                                                @Const
                                                                                                mkldnn_memory_desc_t diff_weights_desc,
                                                                                                @Const
                                                                                                mkldnn_memory_desc_t diff_bias_desc,
                                                                                                @Const
                                                                                                mkldnn_memory_desc_t diff_dst_desc,
                                                                                                @Const
                                                                                                int[] strides,
                                                                                                @Const
                                                                                                int[] padding_l,
                                                                                                @Const
                                                                                                int[] padding_r,
                                                                                                @Cast(value="mkldnn_padding_kind_t")
                                                                                                int padding_kind)

mkldnn_dilated_convolution_backward_weights_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_dilated_convolution_backward_weights_desc_init(mkldnn_convolution_desc_t conv_desc,
                                                                                                        @Cast(value="mkldnn_alg_kind_t")
                                                                                                        int alg_kind,
                                                                                                        @Const
                                                                                                        mkldnn_memory_desc_t src_desc,
                                                                                                        @Const
                                                                                                        mkldnn_memory_desc_t diff_weights_desc,
                                                                                                        @Const
                                                                                                        mkldnn_memory_desc_t diff_bias_desc,
                                                                                                        @Const
                                                                                                        mkldnn_memory_desc_t diff_dst_desc,
                                                                                                        @Const
                                                                                                        IntPointer strides,
                                                                                                        @Const
                                                                                                        IntPointer dilates,
                                                                                                        @Const
                                                                                                        IntPointer padding_l,
                                                                                                        @Const
                                                                                                        IntPointer padding_r,
                                                                                                        @Cast(value="mkldnn_padding_kind_t")
                                                                                                        int padding_kind)

Initializes a convolution descriptor \p conv_desc for backward propagation with respect to weights using \p alg_kind, memory descriptors, \p strides, \p dilates \p padding_l, \p padding_r, and \p padding_kind. \note Memory descriptors are allowed to be initialized with #mkldnn_any value of \p format_kind. Order of inputs: - src (#mkldnn_query_src_pd, 0) - diff_dst (#mkldnn_query_diff_dst_pd, 0) Order of outputs: - diff_weights (#mkldnn_query_diff_weights_pd, 0) - diff_bias (#mkldnn_query_diff_weights_pd, 1), if created with bias

mkldnn_dilated_convolution_backward_weights_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_dilated_convolution_backward_weights_desc_init(mkldnn_convolution_desc_t conv_desc,
                                                                                                        @Cast(value="mkldnn_alg_kind_t")
                                                                                                        int alg_kind,
                                                                                                        @Const
                                                                                                        mkldnn_memory_desc_t src_desc,
                                                                                                        @Const
                                                                                                        mkldnn_memory_desc_t diff_weights_desc,
                                                                                                        @Const
                                                                                                        mkldnn_memory_desc_t diff_bias_desc,
                                                                                                        @Const
                                                                                                        mkldnn_memory_desc_t diff_dst_desc,
                                                                                                        @Const
                                                                                                        IntBuffer strides,
                                                                                                        @Const
                                                                                                        IntBuffer dilates,
                                                                                                        @Const
                                                                                                        IntBuffer padding_l,
                                                                                                        @Const
                                                                                                        IntBuffer padding_r,
                                                                                                        @Cast(value="mkldnn_padding_kind_t")
                                                                                                        int padding_kind)

mkldnn_dilated_convolution_backward_weights_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_dilated_convolution_backward_weights_desc_init(mkldnn_convolution_desc_t conv_desc,
                                                                                                        @Cast(value="mkldnn_alg_kind_t")
                                                                                                        int alg_kind,
                                                                                                        @Const
                                                                                                        mkldnn_memory_desc_t src_desc,
                                                                                                        @Const
                                                                                                        mkldnn_memory_desc_t diff_weights_desc,
                                                                                                        @Const
                                                                                                        mkldnn_memory_desc_t diff_bias_desc,
                                                                                                        @Const
                                                                                                        mkldnn_memory_desc_t diff_dst_desc,
                                                                                                        @Const
                                                                                                        int[] strides,
                                                                                                        @Const
                                                                                                        int[] dilates,
                                                                                                        @Const
                                                                                                        int[] padding_l,
                                                                                                        @Const
                                                                                                        int[] padding_r,
                                                                                                        @Cast(value="mkldnn_padding_kind_t")
                                                                                                        int padding_kind)

mkldnn_deconvolution_forward_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_deconvolution_forward_desc_init(@Cast(value="mkldnn_deconvolution_desc_t*")
                                                                                         mkldnn_convolution_desc_t conv_desc,
                                                                                         @Cast(value="mkldnn_prop_kind_t")
                                                                                         int prop_kind,
                                                                                         @Cast(value="mkldnn_alg_kind_t")
                                                                                         int alg_kind,
                                                                                         @Const
                                                                                         mkldnn_memory_desc_t src_desc,
                                                                                         @Const
                                                                                         mkldnn_memory_desc_t weights_desc,
                                                                                         @Const
                                                                                         mkldnn_memory_desc_t bias_desc,
                                                                                         @Const
                                                                                         mkldnn_memory_desc_t dst_desc,
                                                                                         @Const
                                                                                         IntPointer strides,
                                                                                         @Const
                                                                                         IntPointer padding_l,
                                                                                         @Const
                                                                                         IntPointer padding_r,
                                                                                         @Cast(value="mkldnn_padding_kind_t")
                                                                                         int padding_kind)

Initializes a deconvolution descriptor \p deconv_desc for forward propagation using \p prop_kind (possible values are #mkldnn_forward_training and #mkldnn_forward_inference), \p alg_kind, memory descriptors, \p strides, \p padding_l, \p padding_r, and \p padding_kind. In order to create a deconvolution without bias, \p bias_desc should either be \c NULL or point to a descriptor with memory format equal to #mkldnn_format_undef. \note If \p padding_r is \c NULL, the padding is supposed to be symmetric. \note Memory descriptors are allowed to be initialized with #mkldnn_any value of \p format_kind. Order of inputs: - src (#mkldnn_query_src_pd, 0) - weights (#mkldnn_query_weights_pd, 0) - bias (#mkldnn_query_weights_pd, 1), if created with bias Order of outputs: - dst (#mkldnn_query_dst_pd, 0)

mkldnn_deconvolution_forward_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_deconvolution_forward_desc_init(@Cast(value="mkldnn_deconvolution_desc_t*")
                                                                                         mkldnn_convolution_desc_t conv_desc,
                                                                                         @Cast(value="mkldnn_prop_kind_t")
                                                                                         int prop_kind,
                                                                                         @Cast(value="mkldnn_alg_kind_t")
                                                                                         int alg_kind,
                                                                                         @Const
                                                                                         mkldnn_memory_desc_t src_desc,
                                                                                         @Const
                                                                                         mkldnn_memory_desc_t weights_desc,
                                                                                         @Const
                                                                                         mkldnn_memory_desc_t bias_desc,
                                                                                         @Const
                                                                                         mkldnn_memory_desc_t dst_desc,
                                                                                         @Const
                                                                                         IntBuffer strides,
                                                                                         @Const
                                                                                         IntBuffer padding_l,
                                                                                         @Const
                                                                                         IntBuffer padding_r,
                                                                                         @Cast(value="mkldnn_padding_kind_t")
                                                                                         int padding_kind)

mkldnn_deconvolution_forward_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_deconvolution_forward_desc_init(@Cast(value="mkldnn_deconvolution_desc_t*")
                                                                                         mkldnn_convolution_desc_t conv_desc,
                                                                                         @Cast(value="mkldnn_prop_kind_t")
                                                                                         int prop_kind,
                                                                                         @Cast(value="mkldnn_alg_kind_t")
                                                                                         int alg_kind,
                                                                                         @Const
                                                                                         mkldnn_memory_desc_t src_desc,
                                                                                         @Const
                                                                                         mkldnn_memory_desc_t weights_desc,
                                                                                         @Const
                                                                                         mkldnn_memory_desc_t bias_desc,
                                                                                         @Const
                                                                                         mkldnn_memory_desc_t dst_desc,
                                                                                         @Const
                                                                                         int[] strides,
                                                                                         @Const
                                                                                         int[] padding_l,
                                                                                         @Const
                                                                                         int[] padding_r,
                                                                                         @Cast(value="mkldnn_padding_kind_t")
                                                                                         int padding_kind)

mkldnn_dilated_deconvolution_forward_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_dilated_deconvolution_forward_desc_init(@Cast(value="mkldnn_deconvolution_desc_t*")
                                                                                                 mkldnn_convolution_desc_t conv_desc,
                                                                                                 @Cast(value="mkldnn_prop_kind_t")
                                                                                                 int prop_kind,
                                                                                                 @Cast(value="mkldnn_alg_kind_t")
                                                                                                 int alg_kind,
                                                                                                 @Const
                                                                                                 mkldnn_memory_desc_t src_desc,
                                                                                                 @Const
                                                                                                 mkldnn_memory_desc_t weights_desc,
                                                                                                 @Const
                                                                                                 mkldnn_memory_desc_t bias_desc,
                                                                                                 @Const
                                                                                                 mkldnn_memory_desc_t dst_desc,
                                                                                                 @Const
                                                                                                 IntPointer strides,
                                                                                                 @Const
                                                                                                 IntPointer dilates,
                                                                                                 @Const
                                                                                                 IntPointer padding_l,
                                                                                                 @Const
                                                                                                 IntPointer padding_r,
                                                                                                 @Cast(value="mkldnn_padding_kind_t")
                                                                                                 int padding_kind)

Initializes a dilated deconvolution descriptor \p deconv_desc for forward propagation using \p prop_kind (possible values are #mkldnn_forward_training and #mkldnn_forward_inference), \p alg_kind, memory descriptors, \p strides, \p dilates, \p padding_l, \p padding_r, and \p padding_kind. In order to create a dilated deconvolution without bias, \p bias_desc should either be \c NULL or point to a descriptor with memory format equal to #mkldnn_format_undef. \note If \p padding_r is \c NULL, the padding is supposed to be symmetric. \note Memory descriptors are allowed to be initialized with #mkldnn_any value of \p format_kind. Order of inputs: - src (#mkldnn_query_src_pd, 0) - weights (#mkldnn_query_weights_pd, 0) - bias (#mkldnn_query_weights_pd, 1), if created with bias Order of outputs: - dst (#mkldnn_query_dst_pd, 0)

mkldnn_dilated_deconvolution_forward_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_dilated_deconvolution_forward_desc_init(@Cast(value="mkldnn_deconvolution_desc_t*")
                                                                                                 mkldnn_convolution_desc_t conv_desc,
                                                                                                 @Cast(value="mkldnn_prop_kind_t")
                                                                                                 int prop_kind,
                                                                                                 @Cast(value="mkldnn_alg_kind_t")
                                                                                                 int alg_kind,
                                                                                                 @Const
                                                                                                 mkldnn_memory_desc_t src_desc,
                                                                                                 @Const
                                                                                                 mkldnn_memory_desc_t weights_desc,
                                                                                                 @Const
                                                                                                 mkldnn_memory_desc_t bias_desc,
                                                                                                 @Const
                                                                                                 mkldnn_memory_desc_t dst_desc,
                                                                                                 @Const
                                                                                                 IntBuffer strides,
                                                                                                 @Const
                                                                                                 IntBuffer dilates,
                                                                                                 @Const
                                                                                                 IntBuffer padding_l,
                                                                                                 @Const
                                                                                                 IntBuffer padding_r,
                                                                                                 @Cast(value="mkldnn_padding_kind_t")
                                                                                                 int padding_kind)

mkldnn_dilated_deconvolution_forward_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_dilated_deconvolution_forward_desc_init(@Cast(value="mkldnn_deconvolution_desc_t*")
                                                                                                 mkldnn_convolution_desc_t conv_desc,
                                                                                                 @Cast(value="mkldnn_prop_kind_t")
                                                                                                 int prop_kind,
                                                                                                 @Cast(value="mkldnn_alg_kind_t")
                                                                                                 int alg_kind,
                                                                                                 @Const
                                                                                                 mkldnn_memory_desc_t src_desc,
                                                                                                 @Const
                                                                                                 mkldnn_memory_desc_t weights_desc,
                                                                                                 @Const
                                                                                                 mkldnn_memory_desc_t bias_desc,
                                                                                                 @Const
                                                                                                 mkldnn_memory_desc_t dst_desc,
                                                                                                 @Const
                                                                                                 int[] strides,
                                                                                                 @Const
                                                                                                 int[] dilates,
                                                                                                 @Const
                                                                                                 int[] padding_l,
                                                                                                 @Const
                                                                                                 int[] padding_r,
                                                                                                 @Cast(value="mkldnn_padding_kind_t")
                                                                                                 int padding_kind)

mkldnn_deconvolution_backward_data_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_deconvolution_backward_data_desc_init(@Cast(value="mkldnn_deconvolution_desc_t*")
                                                                                               mkldnn_convolution_desc_t conv_desc,
                                                                                               @Cast(value="mkldnn_alg_kind_t")
                                                                                               int alg_kind,
                                                                                               @Const
                                                                                               mkldnn_memory_desc_t diff_src_desc,
                                                                                               @Const
                                                                                               mkldnn_memory_desc_t weights_desc,
                                                                                               @Const
                                                                                               mkldnn_memory_desc_t diff_dst_desc,
                                                                                               @Const
                                                                                               IntPointer strides,
                                                                                               @Const
                                                                                               IntPointer padding_l,
                                                                                               @Const
                                                                                               IntPointer padding_r,
                                                                                               @Cast(value="mkldnn_padding_kind_t")
                                                                                               int padding_kind)

Initializes a deconvolution descriptor \p conv_desc for backward propagation with respect to data using \p alg_kind, memory descriptors, \p strides, \p padding_l, \p padding_r, and \p padding_kind. \note Memory descriptors are allowed to be initialized with #mkldnn_any value of \p format_kind. Order of inputs: - diff_dst (#mkldnn_query_diff_dst_pd, 0) - weights (#mkldnn_query_weights_pd, 0) Order of outputs: - diff_src (#mkldnn_query_diff_src_pd, 0)

mkldnn_deconvolution_backward_data_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_deconvolution_backward_data_desc_init(@Cast(value="mkldnn_deconvolution_desc_t*")
                                                                                               mkldnn_convolution_desc_t conv_desc,
                                                                                               @Cast(value="mkldnn_alg_kind_t")
                                                                                               int alg_kind,
                                                                                               @Const
                                                                                               mkldnn_memory_desc_t diff_src_desc,
                                                                                               @Const
                                                                                               mkldnn_memory_desc_t weights_desc,
                                                                                               @Const
                                                                                               mkldnn_memory_desc_t diff_dst_desc,
                                                                                               @Const
                                                                                               IntBuffer strides,
                                                                                               @Const
                                                                                               IntBuffer padding_l,
                                                                                               @Const
                                                                                               IntBuffer padding_r,
                                                                                               @Cast(value="mkldnn_padding_kind_t")
                                                                                               int padding_kind)

mkldnn_deconvolution_backward_data_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_deconvolution_backward_data_desc_init(@Cast(value="mkldnn_deconvolution_desc_t*")
                                                                                               mkldnn_convolution_desc_t conv_desc,
                                                                                               @Cast(value="mkldnn_alg_kind_t")
                                                                                               int alg_kind,
                                                                                               @Const
                                                                                               mkldnn_memory_desc_t diff_src_desc,
                                                                                               @Const
                                                                                               mkldnn_memory_desc_t weights_desc,
                                                                                               @Const
                                                                                               mkldnn_memory_desc_t diff_dst_desc,
                                                                                               @Const
                                                                                               int[] strides,
                                                                                               @Const
                                                                                               int[] padding_l,
                                                                                               @Const
                                                                                               int[] padding_r,
                                                                                               @Cast(value="mkldnn_padding_kind_t")
                                                                                               int padding_kind)

mkldnn_dilated_deconvolution_backward_data_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_dilated_deconvolution_backward_data_desc_init(@Cast(value="mkldnn_deconvolution_desc_t*")
                                                                                                       mkldnn_convolution_desc_t conv_desc,
                                                                                                       @Cast(value="mkldnn_alg_kind_t")
                                                                                                       int alg_kind,
                                                                                                       @Const
                                                                                                       mkldnn_memory_desc_t diff_src_desc,
                                                                                                       @Const
                                                                                                       mkldnn_memory_desc_t weights_desc,
                                                                                                       @Const
                                                                                                       mkldnn_memory_desc_t diff_dst_desc,
                                                                                                       @Const
                                                                                                       IntPointer strides,
                                                                                                       @Const
                                                                                                       IntPointer dilates,
                                                                                                       @Const
                                                                                                       IntPointer padding_l,
                                                                                                       @Const
                                                                                                       IntPointer padding_r,
                                                                                                       @Cast(value="mkldnn_padding_kind_t")
                                                                                                       int padding_kind)

Initializes a dilated deconvolution descriptor \p conv_desc for backward propagation with respect to data using \p alg_kind, memory descriptors, \p strides, \p dilates, \p padding_l, \p padding_r, and \p padding_kind. \note Memory descriptors are allowed to be initialized with #mkldnn_any value of \p format_kind. Order of inputs: - diff_dst (#mkldnn_query_diff_dst_pd, 0) - weights (#mkldnn_query_weights_pd, 0) Order of outputs: - diff_src (#mkldnn_query_diff_src_pd, 0)

mkldnn_dilated_deconvolution_backward_data_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_dilated_deconvolution_backward_data_desc_init(@Cast(value="mkldnn_deconvolution_desc_t*")
                                                                                                       mkldnn_convolution_desc_t conv_desc,
                                                                                                       @Cast(value="mkldnn_alg_kind_t")
                                                                                                       int alg_kind,
                                                                                                       @Const
                                                                                                       mkldnn_memory_desc_t diff_src_desc,
                                                                                                       @Const
                                                                                                       mkldnn_memory_desc_t weights_desc,
                                                                                                       @Const
                                                                                                       mkldnn_memory_desc_t diff_dst_desc,
                                                                                                       @Const
                                                                                                       IntBuffer strides,
                                                                                                       @Const
                                                                                                       IntBuffer dilates,
                                                                                                       @Const
                                                                                                       IntBuffer padding_l,
                                                                                                       @Const
                                                                                                       IntBuffer padding_r,
                                                                                                       @Cast(value="mkldnn_padding_kind_t")
                                                                                                       int padding_kind)

mkldnn_dilated_deconvolution_backward_data_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_dilated_deconvolution_backward_data_desc_init(@Cast(value="mkldnn_deconvolution_desc_t*")
                                                                                                       mkldnn_convolution_desc_t conv_desc,
                                                                                                       @Cast(value="mkldnn_alg_kind_t")
                                                                                                       int alg_kind,
                                                                                                       @Const
                                                                                                       mkldnn_memory_desc_t diff_src_desc,
                                                                                                       @Const
                                                                                                       mkldnn_memory_desc_t weights_desc,
                                                                                                       @Const
                                                                                                       mkldnn_memory_desc_t diff_dst_desc,
                                                                                                       @Const
                                                                                                       int[] strides,
                                                                                                       @Const
                                                                                                       int[] dilates,
                                                                                                       @Const
                                                                                                       int[] padding_l,
                                                                                                       @Const
                                                                                                       int[] padding_r,
                                                                                                       @Cast(value="mkldnn_padding_kind_t")
                                                                                                       int padding_kind)

mkldnn_deconvolution_backward_weights_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_deconvolution_backward_weights_desc_init(@Cast(value="mkldnn_deconvolution_desc_t*")
                                                                                                  mkldnn_convolution_desc_t conv_desc,
                                                                                                  @Cast(value="mkldnn_alg_kind_t")
                                                                                                  int alg_kind,
                                                                                                  @Const
                                                                                                  mkldnn_memory_desc_t src_desc,
                                                                                                  @Const
                                                                                                  mkldnn_memory_desc_t diff_weights_desc,
                                                                                                  @Const
                                                                                                  mkldnn_memory_desc_t diff_bias_desc,
                                                                                                  @Const
                                                                                                  mkldnn_memory_desc_t diff_dst_desc,
                                                                                                  @Const
                                                                                                  IntPointer strides,
                                                                                                  @Const
                                                                                                  IntPointer padding_l,
                                                                                                  @Const
                                                                                                  IntPointer padding_r,
                                                                                                  @Cast(value="mkldnn_padding_kind_t")
                                                                                                  int padding_kind)

Initializes a deconvolution descriptor \p conv_desc for backward propagation with respect to weights using \p alg_kind, memory descriptors, \p strides, \p padding_l, \p padding_r, and \p padding_kind. \note Memory descriptors are allowed to be initialized with #mkldnn_any value of \p format_kind. Order of inputs: - src (#mkldnn_query_src_pd, 0) - diff_dst (#mkldnn_query_diff_dst_pd, 0) Order of outputs: - diff_weights (#mkldnn_query_diff_weights_pd, 0) - diff_bias (#mkldnn_query_diff_weights_pd, 1), if created with bias

mkldnn_deconvolution_backward_weights_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_deconvolution_backward_weights_desc_init(@Cast(value="mkldnn_deconvolution_desc_t*")
                                                                                                  mkldnn_convolution_desc_t conv_desc,
                                                                                                  @Cast(value="mkldnn_alg_kind_t")
                                                                                                  int alg_kind,
                                                                                                  @Const
                                                                                                  mkldnn_memory_desc_t src_desc,
                                                                                                  @Const
                                                                                                  mkldnn_memory_desc_t diff_weights_desc,
                                                                                                  @Const
                                                                                                  mkldnn_memory_desc_t diff_bias_desc,
                                                                                                  @Const
                                                                                                  mkldnn_memory_desc_t diff_dst_desc,
                                                                                                  @Const
                                                                                                  IntBuffer strides,
                                                                                                  @Const
                                                                                                  IntBuffer padding_l,
                                                                                                  @Const
                                                                                                  IntBuffer padding_r,
                                                                                                  @Cast(value="mkldnn_padding_kind_t")
                                                                                                  int padding_kind)

mkldnn_deconvolution_backward_weights_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_deconvolution_backward_weights_desc_init(@Cast(value="mkldnn_deconvolution_desc_t*")
                                                                                                  mkldnn_convolution_desc_t conv_desc,
                                                                                                  @Cast(value="mkldnn_alg_kind_t")
                                                                                                  int alg_kind,
                                                                                                  @Const
                                                                                                  mkldnn_memory_desc_t src_desc,
                                                                                                  @Const
                                                                                                  mkldnn_memory_desc_t diff_weights_desc,
                                                                                                  @Const
                                                                                                  mkldnn_memory_desc_t diff_bias_desc,
                                                                                                  @Const
                                                                                                  mkldnn_memory_desc_t diff_dst_desc,
                                                                                                  @Const
                                                                                                  int[] strides,
                                                                                                  @Const
                                                                                                  int[] padding_l,
                                                                                                  @Const
                                                                                                  int[] padding_r,
                                                                                                  @Cast(value="mkldnn_padding_kind_t")
                                                                                                  int padding_kind)

mkldnn_dilated_deconvolution_backward_weights_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_dilated_deconvolution_backward_weights_desc_init(@Cast(value="mkldnn_deconvolution_desc_t*")
                                                                                                          mkldnn_convolution_desc_t conv_desc,
                                                                                                          @Cast(value="mkldnn_alg_kind_t")
                                                                                                          int alg_kind,
                                                                                                          @Const
                                                                                                          mkldnn_memory_desc_t src_desc,
                                                                                                          @Const
                                                                                                          mkldnn_memory_desc_t diff_weights_desc,
                                                                                                          @Const
                                                                                                          mkldnn_memory_desc_t diff_bias_desc,
                                                                                                          @Const
                                                                                                          mkldnn_memory_desc_t diff_dst_desc,
                                                                                                          @Const
                                                                                                          IntPointer strides,
                                                                                                          @Const
                                                                                                          IntPointer dilates,
                                                                                                          @Const
                                                                                                          IntPointer padding_l,
                                                                                                          @Const
                                                                                                          IntPointer padding_r,
                                                                                                          @Cast(value="mkldnn_padding_kind_t")
                                                                                                          int padding_kind)

Initializes a dilated deconvolution descriptor \p conv_desc for backward propagation with respect to weights using \p alg_kind, memory descriptors, \p strides, \p dilates, \p padding_l, \p padding_r, and \p padding_kind. \note Memory descriptors are allowed to be initialized with #mkldnn_any value of \p format_kind. Order of inputs: - src (#mkldnn_query_src_pd, 0) - diff_dst (#mkldnn_query_diff_dst_pd, 0) Order of outputs: - diff_weights (#mkldnn_query_diff_weights_pd, 0) - diff_bias (#mkldnn_query_diff_weights_pd, 1), if created with bias

mkldnn_dilated_deconvolution_backward_weights_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_dilated_deconvolution_backward_weights_desc_init(@Cast(value="mkldnn_deconvolution_desc_t*")
                                                                                                          mkldnn_convolution_desc_t conv_desc,
                                                                                                          @Cast(value="mkldnn_alg_kind_t")
                                                                                                          int alg_kind,
                                                                                                          @Const
                                                                                                          mkldnn_memory_desc_t src_desc,
                                                                                                          @Const
                                                                                                          mkldnn_memory_desc_t diff_weights_desc,
                                                                                                          @Const
                                                                                                          mkldnn_memory_desc_t diff_bias_desc,
                                                                                                          @Const
                                                                                                          mkldnn_memory_desc_t diff_dst_desc,
                                                                                                          @Const
                                                                                                          IntBuffer strides,
                                                                                                          @Const
                                                                                                          IntBuffer dilates,
                                                                                                          @Const
                                                                                                          IntBuffer padding_l,
                                                                                                          @Const
                                                                                                          IntBuffer padding_r,
                                                                                                          @Cast(value="mkldnn_padding_kind_t")
                                                                                                          int padding_kind)

mkldnn_dilated_deconvolution_backward_weights_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_dilated_deconvolution_backward_weights_desc_init(@Cast(value="mkldnn_deconvolution_desc_t*")
                                                                                                          mkldnn_convolution_desc_t conv_desc,
                                                                                                          @Cast(value="mkldnn_alg_kind_t")
                                                                                                          int alg_kind,
                                                                                                          @Const
                                                                                                          mkldnn_memory_desc_t src_desc,
                                                                                                          @Const
                                                                                                          mkldnn_memory_desc_t diff_weights_desc,
                                                                                                          @Const
                                                                                                          mkldnn_memory_desc_t diff_bias_desc,
                                                                                                          @Const
                                                                                                          mkldnn_memory_desc_t diff_dst_desc,
                                                                                                          @Const
                                                                                                          int[] strides,
                                                                                                          @Const
                                                                                                          int[] dilates,
                                                                                                          @Const
                                                                                                          int[] padding_l,
                                                                                                          @Const
                                                                                                          int[] padding_r,
                                                                                                          @Cast(value="mkldnn_padding_kind_t")
                                                                                                          int padding_kind)

mkldnn_shuffle_forward_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_shuffle_forward_desc_init(mkldnn_shuffle_desc_t shuffle_desc,
                                                                                   @Cast(value="mkldnn_prop_kind_t")
                                                                                   int prop_kind,
                                                                                   @Const
                                                                                   mkldnn_memory_desc_t data_desc,
                                                                                   int axis,
                                                                                   int group_size)

Initializes a \p shuffle_desc for forward propagation using \p prop_kind, memory descriptor \p data_desc, \p axis, and \p group_size. Order of inputs: - src (#mkldnn_query_src_pd, 0) Order of outputs: - dst (#mkldnn_query_dst_pd, 0)

mkldnn_shuffle_backward_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_shuffle_backward_desc_init(mkldnn_shuffle_desc_t shuffle_desc,
                                                                                    @Const
                                                                                    mkldnn_memory_desc_t diff_data_desc,
                                                                                    int axis,
                                                                                    int group_size)

Initializes a \p shuffle_desc for backward propagation using memory descriptor \p diff_data_desc, \p axis, and \p group_size. Order of inputs: - diff_dst (#mkldnn_query_diff_dst_pd, 0) Order of outputs: - diff_src (#mkldnn_query_diff_src_pd, 0)

mkldnn_eltwise_forward_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_eltwise_forward_desc_init(mkldnn_eltwise_desc_t eltwise_desc,
                                                                                   @Cast(value="mkldnn_prop_kind_t")
                                                                                   int prop_kind,
                                                                                   @Cast(value="mkldnn_alg_kind_t")
                                                                                   int alg_kind,
                                                                                   @Const
                                                                                   mkldnn_memory_desc_t data_desc,
                                                                                   float alpha,
                                                                                   float beta)

Initializes an \p eltwise_desc for forward propagation using \p prop_kind (possible values are #mkldnn_forward_training and #mkldnn_forward_inference), \p alg_kind algorithm, memory descriptor \p data_desc, \p alpha, and \p beta parameters.

See Also:: for details. Order of inputs: - src (#mkldnn_query_src_pd, 0) Order of outputs: - dst (#mkldnn_query_dst_pd, 0)

mkldnn_eltwise_backward_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_eltwise_backward_desc_init(mkldnn_eltwise_desc_t eltwise_desc,
                                                                                    @Cast(value="mkldnn_alg_kind_t")
                                                                                    int alg_kind,
                                                                                    @Const
                                                                                    mkldnn_memory_desc_t diff_data_desc,
                                                                                    @Const
                                                                                    mkldnn_memory_desc_t data_desc,
                                                                                    float alpha,
                                                                                    float beta)

Initializes an \p eltwise_desc for backward propagation using \p alg_kind algorithm memory descriptors \p diff_data_desc and \p data_desc, and the \p alpha and \p beta parameters.

See Also:: for details. Order of inputs: - src (#mkldnn_query_src_pd, 0) - diff_dst (#mkldnn_query_diff_dst_pd, 0) Order of outputs: - diff_src (#mkldnn_query_diff_src_pd, 0)

mkldnn_softmax_forward_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_softmax_forward_desc_init(mkldnn_softmax_desc_t softmax_desc,
                                                                                   @Cast(value="mkldnn_prop_kind_t")
                                                                                   int prop_kind,
                                                                                   @Const
                                                                                   mkldnn_memory_desc_t data_desc,
                                                                                   int softmax_axis)

Initializes a \p softmax_desc for forward propagation using \p prop_kind (possible values are #mkldnn_forward_training and #mkldnn_forward_inference) and memory descriptor \p data_desc. Order of inputs: - src (#mkldnn_query_src_pd, 0) Order of outputs: - dst (#mkldnn_query_dst_pd, 0)

mkldnn_softmax_backward_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_softmax_backward_desc_init(mkldnn_softmax_desc_t softmax_desc,
                                                                                    @Const
                                                                                    mkldnn_memory_desc_t diff_desc,
                                                                                    @Const
                                                                                    mkldnn_memory_desc_t data_desc,
                                                                                    int softmax_axis)

Initializes a \p softmax_desc for backward propagation using memory descriptors \p diff_desc and \p data_desc. Order of inputs: - dst (#mkldnn_query_dst_pd, 0) - diff_dst (#mkldnn_query_diff_dst_pd, 0) Order of outputs: - diff_src (#mkldnn_query_diff_src_pd, 0)

mkldnn_pooling_forward_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_pooling_forward_desc_init(mkldnn_pooling_desc_t pool_desc,
                                                                                   @Cast(value="mkldnn_prop_kind_t")
                                                                                   int prop_kind,
                                                                                   @Cast(value="mkldnn_alg_kind_t")
                                                                                   int alg_kind,
                                                                                   @Const
                                                                                   mkldnn_memory_desc_t src_desc,
                                                                                   @Const
                                                                                   mkldnn_memory_desc_t dst_desc,
                                                                                   @Const
                                                                                   IntPointer strides,
                                                                                   @Const
                                                                                   IntPointer kernel,
                                                                                   @Const
                                                                                   IntPointer padding_l,
                                                                                   @Const
                                                                                   IntPointer padding_r,
                                                                                   @Cast(value="mkldnn_padding_kind_t")
                                                                                   int padding_kind)

Initializes a pooling descriptor \p pool_desc for forward propagation using \p prop_kind (possible values are #mkldnn_forward_training and #mkldnn_forward_inference), \p alg_kind, memory descriptors, and pooling parameters in the spatial domain: \p strides, \p kernel sizes, \p padding_l, \p padding_r, and \p padding_kind. \note If \p padding_r is \c NULL, the padding is supposed to be symmetric. Order of inputs: - src (#mkldnn_query_src_pd, 0) Order of outputs: - dst (#mkldnn_query_dst_pd, 0) - workspace (#mkldnn_query_workspace_pd, 0), if \p alg_kind = #mkldnn_pooling_max and \p prop_kind = #mkldnn_forward_training

mkldnn_pooling_forward_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_pooling_forward_desc_init(mkldnn_pooling_desc_t pool_desc,
                                                                                   @Cast(value="mkldnn_prop_kind_t")
                                                                                   int prop_kind,
                                                                                   @Cast(value="mkldnn_alg_kind_t")
                                                                                   int alg_kind,
                                                                                   @Const
                                                                                   mkldnn_memory_desc_t src_desc,
                                                                                   @Const
                                                                                   mkldnn_memory_desc_t dst_desc,
                                                                                   @Const
                                                                                   IntBuffer strides,
                                                                                   @Const
                                                                                   IntBuffer kernel,
                                                                                   @Const
                                                                                   IntBuffer padding_l,
                                                                                   @Const
                                                                                   IntBuffer padding_r,
                                                                                   @Cast(value="mkldnn_padding_kind_t")
                                                                                   int padding_kind)

mkldnn_pooling_forward_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_pooling_forward_desc_init(mkldnn_pooling_desc_t pool_desc,
                                                                                   @Cast(value="mkldnn_prop_kind_t")
                                                                                   int prop_kind,
                                                                                   @Cast(value="mkldnn_alg_kind_t")
                                                                                   int alg_kind,
                                                                                   @Const
                                                                                   mkldnn_memory_desc_t src_desc,
                                                                                   @Const
                                                                                   mkldnn_memory_desc_t dst_desc,
                                                                                   @Const
                                                                                   int[] strides,
                                                                                   @Const
                                                                                   int[] kernel,
                                                                                   @Const
                                                                                   int[] padding_l,
                                                                                   @Const
                                                                                   int[] padding_r,
                                                                                   @Cast(value="mkldnn_padding_kind_t")
                                                                                   int padding_kind)

mkldnn_pooling_backward_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_pooling_backward_desc_init(mkldnn_pooling_desc_t pool_desc,
                                                                                    @Cast(value="mkldnn_alg_kind_t")
                                                                                    int alg_kind,
                                                                                    @Const
                                                                                    mkldnn_memory_desc_t diff_src_desc,
                                                                                    @Const
                                                                                    mkldnn_memory_desc_t diff_dst_desc,
                                                                                    @Const
                                                                                    IntPointer strides,
                                                                                    @Const
                                                                                    IntPointer kernel,
                                                                                    @Const
                                                                                    IntPointer padding_l,
                                                                                    @Const
                                                                                    IntPointer padding_r,
                                                                                    @Cast(value="mkldnn_padding_kind_t")
                                                                                    int padding_kind)

Initializes a pooling descriptor \p pool_desc for backward propagation using \p alg_kind, memory descriptors, and pooling parameters in the spatial domain: \p strides, \p kernel sizes, \p padding_l, \p padding_r, and \p padding_kind. \note If \p padding_r is \c NULL, the padding is supposed to be symmetric. Order of inputs: - diff_dst (#mkldnn_query_diff_dst_pd, 0) - workspace (#mkldnn_query_workspace_pd, 0), if \p alg_kind = #mkldnn_pooling_max Order of outputs: - diff_src (#mkldnn_query_diff_src_pd, 0)

mkldnn_pooling_backward_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_pooling_backward_desc_init(mkldnn_pooling_desc_t pool_desc,
                                                                                    @Cast(value="mkldnn_alg_kind_t")
                                                                                    int alg_kind,
                                                                                    @Const
                                                                                    mkldnn_memory_desc_t diff_src_desc,
                                                                                    @Const
                                                                                    mkldnn_memory_desc_t diff_dst_desc,
                                                                                    @Const
                                                                                    IntBuffer strides,
                                                                                    @Const
                                                                                    IntBuffer kernel,
                                                                                    @Const
                                                                                    IntBuffer padding_l,
                                                                                    @Const
                                                                                    IntBuffer padding_r,
                                                                                    @Cast(value="mkldnn_padding_kind_t")
                                                                                    int padding_kind)

mkldnn_pooling_backward_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_pooling_backward_desc_init(mkldnn_pooling_desc_t pool_desc,
                                                                                    @Cast(value="mkldnn_alg_kind_t")
                                                                                    int alg_kind,
                                                                                    @Const
                                                                                    mkldnn_memory_desc_t diff_src_desc,
                                                                                    @Const
                                                                                    mkldnn_memory_desc_t diff_dst_desc,
                                                                                    @Const
                                                                                    int[] strides,
                                                                                    @Const
                                                                                    int[] kernel,
                                                                                    @Const
                                                                                    int[] padding_l,
                                                                                    @Const
                                                                                    int[] padding_r,
                                                                                    @Cast(value="mkldnn_padding_kind_t")
                                                                                    int padding_kind)

mkldnn_lrn_forward_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_lrn_forward_desc_init(mkldnn_lrn_desc_t lrn_desc,
                                                                               @Cast(value="mkldnn_prop_kind_t")
                                                                               int prop_kind,
                                                                               @Cast(value="mkldnn_alg_kind_t")
                                                                               int alg_kind,
                                                                               @Const
                                                                               mkldnn_memory_desc_t data_desc,
                                                                               int local_size,
                                                                               float alpha,
                                                                               float beta,
                                                                               float k)

Initializes an \p lrn_desc for forward propagation using \p prop_kind (possible values are #mkldnn_forward_training and #mkldnn_forward_inference), \p alg_kind, memory descriptor \p data_desc, and regularization parameters \p local_size, \p alpha, \p beta, and \p k. Order of inputs: - src (#mkldnn_query_src_pd, 0) Order of outputs: - dst (#mkldnn_query_dst_pd, 0) - workspace (#mkldnn_query_workspace_pd, 0), if the underlying implementation requires

mkldnn_lrn_backward_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_lrn_backward_desc_init(mkldnn_lrn_desc_t lrn_desc,
                                                                                @Cast(value="mkldnn_alg_kind_t")
                                                                                int alg_kind,
                                                                                @Const
                                                                                mkldnn_memory_desc_t diff_data_desc,
                                                                                @Const
                                                                                mkldnn_memory_desc_t data_desc,
                                                                                int local_size,
                                                                                float alpha,
                                                                                float beta,
                                                                                float k)

Initializes an \p lrn_desc for backward propagation using \p alg_kind, memory descriptors \p data_desc and \p diff_data_desc, and regularization parameters \p local_size, \p alpha, \p beta, and \p k. Order of inputs: - src (#mkldnn_query_src_pd, 0) - diff_dst (#mkldnn_query_diff_dst_pd, 0) - workspace (#mkldnn_query_workspace_pd, 0), if the underlying implementation requires Order of outputs: - diff_src (#mkldnn_query_diff_src_pd, 0)

mkldnn_batch_normalization_forward_desc_init
```
@Cast(value="mkldnn_status_t")
public static int mkldnn_batch_normalization_forward_desc_init(mkldnn_batch_normalization_desc_t bnrm_desc,
                                                                                               @Cast(value="mkldnn_prop_kind_t")
                                                                                               int prop_kind,
                                                                                               @Const
                                                                                               mkldnn_memory_desc_t data_desc,
                                                                                               float epsilon,
                                                                                               @Cast(value="unsigned")
                                                                                               int flags)
```
Initializes a batch normalization descriptor \p bnrm_desc for forward propagation using \p prop_kind (possible values are #mkldnn_forward_training and #mkldnn_forward_inference), memory descriptor \p data_desc, normalization parameter \p epsilon, and \p flags set using bit flags of type mkldnn_batch_normalization_desc_t. Order of inputs: - src (#mkldnn_query_src_pd, 0) - mean (#mkldnn_query_src_pd, 1), if #mkldnn_use_global_stats bit-flags is set in \p flags - variance (#mkldnn_query_src_pd, 2), if #mkldnn_use_global_stats bit-flags is set in \p flags - scale_and_shift (#mkldnn_query_weights_pd, 0), if #mkldnn_use_scaleshift bit-flags is set in \p flags Order of outputs: - dst (#mkldnn_query_dst_pd, 0) - mean (#mkldnn_query_dst_pd, 1), if #mkldnn_use_global_stats bit-flags is not set in \p flags \p prop_kind = #mkldnn_forward_training - variance (#mkldnn_query_dst_pd, 2), if #mkldnn_use_global_stats bit-flags is not set in \p flags and \p prop_kind = #mkldnn_forward_training - workspace (#mkldnn_query_workspace_pd, 0), if #mkldnn_fuse_bn_relu bit-flags is set in \p flags and \p prop_kind = #mkldnn_forward_training \note In-place operation is supported; that is, dst points to the same memory as src.

See Also:

mkldnn_batch_normalization_desc_t

mkldnn_batch_normalization_backward_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_batch_normalization_backward_desc_init(mkldnn_batch_normalization_desc_t bnrm_desc,
                                                                                                @Cast(value="mkldnn_prop_kind_t")
                                                                                                int prop_kind,
                                                                                                @Const
                                                                                                mkldnn_memory_desc_t diff_data_desc,
                                                                                                @Const
                                                                                                mkldnn_memory_desc_t data_desc,
                                                                                                float epsilon,
                                                                                                @Cast(value="unsigned")
                                                                                                int flags)

Initializes a batch normalization descriptor \p bnrm_desc for backward propagation with respect to data and scale-shift parameters using memory descriptors \p data_desc and \p diff_data_desc, normalization parameter \p epsilon, and \p flags set using bit flags of type mkldnn_batch_normalization_desc_t. Order of inputs: - src (#mkldnn_query_src_pd, 0) - mean (#mkldnn_query_src_pd, 1) - variance (#mkldnn_query_src_pd, 2) - diff_dst (#mkldnn_query_diff_dst_pd, 0) - scale_and_shift (#mkldnn_query_weights_pd, 0), if #mkldnn_use_scaleshift bit-flags is set in \p flags - workspace (#mkldnn_query_workspace_pd, 0), if #mkldnn_fuse_bn_relu bit-flags is set in \p flags Order of outputs: - diff_src (#mkldnn_query_diff_src_pd, 0) - diff_scale_and_shift (#mkldnn_query_diff_weights_pd, 0), if #mkldnn_use_scaleshift bit-flags is set in \p flags and \p prop_kind = #mkldnn_backward \note in-place operation is supported, i.e. diff_src points to the same memory as diff_dst.

See Also:: mkldnn_batch_normalization_desc_t

mkldnn_inner_product_forward_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_inner_product_forward_desc_init(mkldnn_inner_product_desc_t ip_desc,
                                                                                         @Cast(value="mkldnn_prop_kind_t")
                                                                                         int prop_kind,
                                                                                         @Const
                                                                                         mkldnn_memory_desc_t src_desc,
                                                                                         @Const
                                                                                         mkldnn_memory_desc_t weights_desc,
                                                                                         @Const
                                                                                         mkldnn_memory_desc_t bias_desc,
                                                                                         @Const
                                                                                         mkldnn_memory_desc_t dst_desc)

Initializes an inner product descriptor \p ip_desc for forward propagation using \p prop_kind (possible values are #mkldnn_forward_training and #mkldnn_forward_inference) and memory descriptors. In order to create an inner product without bias, \p bias_desc should be either \c NULL or a pointer to a descriptor with memory format equal to #mkldnn_format_undef. \note Memory descriptors are allowed to be initialized with #mkldnn_any value of \p format_kind. Order of inputs: - src (#mkldnn_query_src_pd, 0) - weights (#mkldnn_query_weights_pd, 0) - bias (#mkldnn_query_weights_pd, 1), if created with bias Order of outputs: - dst (#mkldnn_query_dst_pd, 0)

mkldnn_inner_product_backward_data_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_inner_product_backward_data_desc_init(mkldnn_inner_product_desc_t ip_desc,
                                                                                               @Const
                                                                                               mkldnn_memory_desc_t diff_src_desc,
                                                                                               @Const
                                                                                               mkldnn_memory_desc_t weights_desc,
                                                                                               @Const
                                                                                               mkldnn_memory_desc_t diff_dst_desc)

Initializes an inner product descriptor \p ip_desc for backward propagation with respect to data using memory descriptors. \note Memory descriptors are allowed to be initialized with #mkldnn_any value of \p format_kind. Order of inputs: - diff_dst (#mkldnn_query_diff_dst_pd, 0) - weights (#mkldnn_query_weights_pd, 0) Order of outputs: - diff_src (#mkldnn_query_diff_src_pd, 0)

mkldnn_inner_product_backward_weights_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_inner_product_backward_weights_desc_init(mkldnn_inner_product_desc_t ip_desc,
                                                                                                  @Const
                                                                                                  mkldnn_memory_desc_t src_desc,
                                                                                                  @Const
                                                                                                  mkldnn_memory_desc_t diff_weights_desc,
                                                                                                  @Const
                                                                                                  mkldnn_memory_desc_t diff_bias_desc,
                                                                                                  @Const
                                                                                                  mkldnn_memory_desc_t diff_dst_desc)

Initializes an inner product descriptor \p ip_desc for backward propagation with respect to weights using memory descriptors. \note Memory descriptors are allowed to be initialized with #mkldnn_any value of \p format_kind. Order of inputs: - src (#mkldnn_query_src_pd, 0) - diff_dst (#mkldnn_query_diff_dst_pd, 0) Order of outputs: - diff_weights (#mkldnn_query_diff_weights_pd, 0) - diff_bias (#mkldnn_query_diff_weights_pd, 1), if created with bias

mkldnn_rnn_cell_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_rnn_cell_desc_init(mkldnn_rnn_cell_desc_t rnn_cell_desc,
                                                                            @Cast(value="mkldnn_alg_kind_t")
                                                                            int kind,
                                                                            @Cast(value="mkldnn_alg_kind_t")
                                                                            int f,
                                                                            @Cast(value="unsigned int")
                                                                            int flags,
                                                                            float alpha,
                                                                            float clipping)

Initializes a recurrent cell descriptor \p rnn_cell_desc using \p rnn_cell_desc, \p kind (possible values are #mkldnn_vanilla_rnn, #mkldnn_vanilla_lstm, #mkldnn_vanilla_gru, and #mkldnn_gru_linear_before_reset), \p f (possible values are #mkldnn_eltwise_relu and #mkldnn_eltwise_tanh), \p flags, \p alpha, and \p clipping.

mkldnn_rnn_cell_get_gates_count

public static int mkldnn_rnn_cell_get_gates_count(@Const
                                                  mkldnn_rnn_cell_desc_t rnn_cell_desc)

Returns the number of gates of a particular \p rnn_cell_desc.

mkldnn_rnn_cell_get_states_count

public static int mkldnn_rnn_cell_get_states_count(@Const
                                                   mkldnn_rnn_cell_desc_t rnn_cell_desc)

Returns the number of states of a particular \p rnn_cell_desc.

mkldnn_primitive_attr_set_rnn_data_qparams

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_attr_set_rnn_data_qparams(mkldnn_primitive_attr attr,
                                                                                             float scale,
                                                                                             float shift)

Sets quantization \p scale and \p shift for RNN data tensors. For performance reasons, low precision configuration of RNN primitive expects input activations to have unsigned int8 data type. Scale and shift used to quantize floating point data to unsigned integer must be passed to RNN primitive using attributes. Example usage:


      // rnn parameters
      int l = 2, t = 2, mb = 32, sic = 32, slc = 32, dic = 32, dlc = 32;
      // activations quantization parameters
      float scale = ..., shift = ..;

      mkldnn_primitive_attr_t rnn_attr;
      // create default attributes
      mkldnn_primitive_attr_create(&rnn_attr);

      // set scale and shift for int8 quantization of activation
      mkldnn_primitive_attr_set_rnn_data_qparams(rnn_attr, scale, shift);

      // create & configure rnn op_desc
      mkldnn_rnn_desc_t rnn_d;
      mkldnn_primitive_desc_t rnn_pd;
      mkldnn_primitive_desc_create_v2(&rnn_pd, &rnn_d, attr, NULL);

\note Quantization scale and shift are common for src_layer, src_iter, dst_iter and dst_layer.

mkldnn_primitive_attr_set_rnn_weights_qparams

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_attr_set_rnn_weights_qparams(mkldnn_primitive_attr attr,
                                                                                                int count,
                                                                                                int mask,
                                                                                                @Const
                                                                                                FloatPointer weights_scales)

Sets quantization scales \p weights_scales for RNN weights tensors. Low precision configuration of RNN primitive expects input weights to have signed int8 data type. Scales used to quantize floating point data to signed integer must be passed to RNN primitive using attributes. The \p mask argument defines correspondence between output tensor dimensions and the \p weights_scales array. Set i-th bit of \p mask to 1 to use dedicated scaling factor for each slice of the output tensor over i-th dimension. Set \p mask to 0 to use common scaling factor for the whole output tensor. Example usage:


      // rnn parameters
      int l = 2, t = 2, mb = 32, sic = 32, slc = 32, dic = 32, dlc = 32;
      // unique output scales per output channel
      float weights_scales[dic * n_gates] = { ... };
      // mask that specifies last two dimensions of ldigo format
      int mask = 0x3;

      mkldnn_primitive_attr_t attr;
      // create default attributes
      mkldnn_primitive_attr_create(&attr);

      // set output channel-wise weights scales
      mkldnn_primitive_attr_set_rnn_weights_qparams(attr, dic * n_gates, mask,
              weights_scales);

      // create & configure rnn op_desc
      mkldnn_rnn_desc_t rnn_d;
      mkldnn_primitive_desc_t rnn_pd;
      mkldnn_primitive_desc_create_v2(&rnn_pd, &rnn_d, attr, NULL);

\note The dimension order is always native and does not depend on the actual layout used. For example, 5 dimensional weights always have (l, d, i, g, o) logical dimension ordering. \note Quantization sales are common for weights_layer and weights_iteration \note There is no way to check that \p count corresponds to \p mask until an actual primitive descriptor is created, so it is user's responsibility to set proper values. The following formula must be held:

 \[count = \prod\limits_{d \in mask} output.dims[d]\]

mkldnn_primitive_attr_set_rnn_weights_qparams

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_attr_set_rnn_weights_qparams(mkldnn_primitive_attr attr,
                                                                                                int count,
                                                                                                int mask,
                                                                                                @Const
                                                                                                FloatBuffer weights_scales)

mkldnn_primitive_attr_set_rnn_weights_qparams

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_attr_set_rnn_weights_qparams(mkldnn_primitive_attr attr,
                                                                                                int count,
                                                                                                int mask,
                                                                                                @Const
                                                                                                float[] weights_scales)

mkldnn_rnn_forward_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_rnn_forward_desc_init(mkldnn_rnn_desc_t rnn_desc,
                                                                               @Cast(value="mkldnn_prop_kind_t")
                                                                               int prop_kind,
                                                                               @Const
                                                                               mkldnn_rnn_cell_desc_t rnn_cell_desc,
                                                                               @Cast(value="const mkldnn_rnn_direction_t")
                                                                               int direction,
                                                                               @Const
                                                                               mkldnn_memory_desc_t src_layer_desc,
                                                                               @Const
                                                                               mkldnn_memory_desc_t src_iter_desc,
                                                                               @Const
                                                                               mkldnn_memory_desc_t weights_layer_desc,
                                                                               @Const
                                                                               mkldnn_memory_desc_t weights_iter_desc,
                                                                               @Const
                                                                               mkldnn_memory_desc_t bias_desc,
                                                                               @Const
                                                                               mkldnn_memory_desc_t dst_layer_desc,
                                                                               @Const
                                                                               mkldnn_memory_desc_t dst_iter_desc)

Initializes a rnn descriptor \p rnn_desc for forward propagation using \p prop_kind, \p rnn_cell_desc, \p direction, and memory descriptors. \note If \p prop_kind equals #mkldnn_forward_training, you must query a workspace memory descriptor before creating the primitive. \p src_iter_desc, \p bias_desc, and \p dst_iter_desc are allowed to either be \c NULL or point to a zero memory descriptor, which would indicate that the RNN primitive should not use them. \note All memory descriptors except \p src_iter_desc are allowed to be initialized with #mkldnn_any value of \p format_kind. Order of inputs: - src_layer (#mkldnn_query_src_pd, 0) - src_iter (#mkldnn_query_src_pd, 1), if used - weights_layer (#mkldnn_query_weights_pd, 0) - weights_iter (#mkldnn_query_weights_pd, 1) - bias (#mkldnn_query_weights_pd, 2), if used Order of outputs: - dst_layer (#mkldnn_query_dst_pd, 0) - dst_iter (#mkldnn_query_dst_pd, 1), if used - workspace (#mkldnn_query_workspace_pd, 0), if \p prop_kind equals #mkldnn_forward_training

mkldnn_rnn_backward_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_rnn_backward_desc_init(mkldnn_rnn_desc_t rnn_desc,
                                                                                @Cast(value="mkldnn_prop_kind_t")
                                                                                int prop_kind,
                                                                                @Const
                                                                                mkldnn_rnn_cell_desc_t rnn_cell_desc,
                                                                                @Cast(value="const mkldnn_rnn_direction_t")
                                                                                int direction,
                                                                                @Const
                                                                                mkldnn_memory_desc_t src_layer_desc,
                                                                                @Const
                                                                                mkldnn_memory_desc_t src_iter_desc,
                                                                                @Const
                                                                                mkldnn_memory_desc_t weights_layer_desc,
                                                                                @Const
                                                                                mkldnn_memory_desc_t weights_iter_desc,
                                                                                @Const
                                                                                mkldnn_memory_desc_t bias_desc,
                                                                                @Const
                                                                                mkldnn_memory_desc_t dst_layer_desc,
                                                                                @Const
                                                                                mkldnn_memory_desc_t dst_iter_desc,
                                                                                @Const
                                                                                mkldnn_memory_desc_t diff_src_layer_desc,
                                                                                @Const
                                                                                mkldnn_memory_desc_t diff_src_iter_desc,
                                                                                @Const
                                                                                mkldnn_memory_desc_t diff_weights_layer_desc,
                                                                                @Const
                                                                                mkldnn_memory_desc_t diff_weights_iter_desc,
                                                                                @Const
                                                                                mkldnn_memory_desc_t diff_bias_desc,
                                                                                @Const
                                                                                mkldnn_memory_desc_t diff_dst_layer,
                                                                                @Const
                                                                                mkldnn_memory_desc_t diff_dst_iter_desc)

Initializes a rnn descriptor \p rnn_desc for backward propagation using \p prop_kind, \p rnn_cell_desc, \p direction, and memory descriptors. \note All memory descriptors are allowed to be initialized with #mkldnn_any value of \p format_kind. \p src_iter_desc (simultaneously with \p diff_src_iter_desc), \p bias_desc (simultaneously with \p diff_bias_desc), and \p dst_iter_desc (simultaneously with \p diff_src_iter_desc) are allowed to either be \c NULL or point to a zero memory descriptor, which would indicate that the RNN primitive should not use them. Order of inputs: - src_layer (#mkldnn_query_src_pd, 0) - src_iter (#mkldnn_query_src_pd, 1), if used - weights_layer (#mkldnn_query_weights_pd, 0) - weights_iter (#mkldnn_query_weights_pd, 1) - bias (#mkldnn_query_weights_pd, 2), if used - dst_layer (#mkldnn_query_dst_pd, 0) - dst_iter (#mkldnn_query_dst_pd, 1), if used - diff_dst_layer (#mkldnn_query_diff_dst_pd, 0) - diff_dst_iter (#mkldnn_query_diff_dst_pd, 1), if used - workspace (#mkldnn_query_workspace_pd, 0) Order of outputs: - diff_src_layer (#mkldnn_query_diff_src_pd, 0) - diff_src_iter (#mkldnn_query_diff_src_pd, 1), if used - diff_weights_layer (#mkldnn_query_diff_weights_pd, 0) - diff_weights_iter (#mkldnn_query_diff_weights_pd, 1) - diff_bias (#mkldnn_query_diff_weights_pd, 2), if used

mkldnn_engine_get_count

@Cast(value="size_t")
public static long mkldnn_engine_get_count(@Cast(value="mkldnn_engine_kind_t")
                                                                  int kind)

Returns the number of engines of a particular \p kind.

mkldnn_engine_create

@Cast(value="mkldnn_status_t")
public static int mkldnn_engine_create(@ByPtrPtr
                                                                       mkldnn_engine engine,
                                                                       @Cast(value="mkldnn_engine_kind_t")
                                                                       int kind,
                                                                       @Cast(value="size_t")
                                                                       long index)

Creates an \p engine of particular \p kind and \p index.

mkldnn_engine_create

@Cast(value="mkldnn_status_t")
public static int mkldnn_engine_create(@Cast(value="mkldnn_engine_t*")
                                                                       PointerPointer engine,
                                                                       @Cast(value="mkldnn_engine_kind_t")
                                                                       int kind,
                                                                       @Cast(value="size_t")
                                                                       long index)

mkldnn_engine_get_kind

@Cast(value="mkldnn_status_t")
public static int mkldnn_engine_get_kind(mkldnn_engine engine,
                                                                         @Cast(value="mkldnn_engine_kind_t*")
                                                                         IntPointer kind)

Returns the kind of an \p engine.

mkldnn_engine_get_kind

@Cast(value="mkldnn_status_t")
public static int mkldnn_engine_get_kind(mkldnn_engine engine,
                                                                         @Cast(value="mkldnn_engine_kind_t*")
                                                                         IntBuffer kind)

mkldnn_engine_get_kind

@Cast(value="mkldnn_status_t")
public static int mkldnn_engine_get_kind(mkldnn_engine engine,
                                                                         @Cast(value="mkldnn_engine_kind_t*")
                                                                         int[] kind)

mkldnn_engine_destroy

@Cast(value="mkldnn_status_t")
public static int mkldnn_engine_destroy(mkldnn_engine engine)

Destroys an \p engine.

mkldnn_stream_create

@Cast(value="mkldnn_status_t")
public static int mkldnn_stream_create(@ByPtrPtr
                                                                       mkldnn_stream stream,
                                                                       @Cast(value="mkldnn_stream_kind_t")
                                                                       int stream_kind)

Creates an execution \p stream of \p stream_kind.

mkldnn_stream_create

@Cast(value="mkldnn_status_t")
public static int mkldnn_stream_create(@Cast(value="mkldnn_stream_t*")
                                                                       PointerPointer stream,
                                                                       @Cast(value="mkldnn_stream_kind_t")
                                                                       int stream_kind)

mkldnn_stream_submit

@Cast(value="mkldnn_status_t")
public static int mkldnn_stream_submit(mkldnn_stream stream,
                                                                       @Cast(value="size_t")
                                                                       long n,
                                                                       @ByPtrPtr
                                                                       mkldnn_primitive primitives,
                                                                       @ByPtrPtr
                                                                       mkldnn_primitive error_primitive)

Submits \p primitives to an execution \p stream. The number of primitives is \p n. All or none of the primitives can be lazy. In case of an error, returns the offending \p error_primitive if it is not \c NULL.

mkldnn_stream_submit

@Cast(value="mkldnn_status_t")
public static int mkldnn_stream_submit(mkldnn_stream stream,
                                                                       @Cast(value="size_t")
                                                                       long n,
                                                                       @Cast(value="mkldnn_primitive_t*")
                                                                       PointerPointer primitives,
                                                                       @Cast(value="mkldnn_primitive_t*")
                                                                       PointerPointer error_primitive)

mkldnn_stream_wait

@Cast(value="mkldnn_status_t")
public static int mkldnn_stream_wait(mkldnn_stream stream,
                                                                     int block,
                                                                     @ByPtrPtr
                                                                     mkldnn_primitive error_primitive)

Waits for all primitives in the execution \p stream to finish. Returns immediately if \p block is zero. In case of an error, returns the offending \p error_primitive if it is not \c NULL.

mkldnn_stream_wait

@Cast(value="mkldnn_status_t")
public static int mkldnn_stream_wait(mkldnn_stream stream,
                                                                     int block,
                                                                     @Cast(value="mkldnn_primitive_t*")
                                                                     PointerPointer error_primitive)

mkldnn_stream_rerun

@Cast(value="mkldnn_status_t")
public static int mkldnn_stream_rerun(mkldnn_stream stream,
                                                                      @ByPtrPtr
                                                                      mkldnn_primitive error_primitive)

Reruns all the primitives within the \p stream. In case of an error, returns the offending \p error_primitive if it is not \c NULL.

mkldnn_stream_rerun

@Cast(value="mkldnn_status_t")
public static int mkldnn_stream_rerun(mkldnn_stream stream,
                                                                      @Cast(value="mkldnn_primitive_t*")
                                                                      PointerPointer error_primitive)

mkldnn_stream_destroy

@Cast(value="mkldnn_status_t")
public static int mkldnn_stream_destroy(mkldnn_stream stream)

Destroys an execution \p stream.

mkldnn_set_verbose
```
@Cast(value="mkldnn_status_t")
public static int mkldnn_set_verbose(int level)
```
Sets verbosity level (print information to stdout). Possible levels are: - 0 -- no verbose output (default) - 1 -- primitive information at execution - 2 -- primitive information at creation and execution \note Dumping information might affect performance. This setting overrides the MKLDNN_VERBOSE environment variable.

mkldnn_set_jit_dump
```
@Cast(value="mkldnn_status_t")
public static int mkldnn_set_jit_dump(int dump)
```
Sets jit dump control. dump equals: - zero -- turn jit dump off (default) - non-zero -- turn jit dump on \note This setting overrides the MKLDNN_JIT_DUMP environment variable.

mkldnn_version
```
@Const
public static mkldnn_version_t mkldnn_version()
```
Gets library version information. Version information includes: - major -- major version number - minor -- minor version number - patch -- patch release number - hash -- git commit hash

mkldnn_sgemm

@Cast(value="mkldnn_status_t")
public static int mkldnn_sgemm(@Cast(value="const char*")
                                                               BytePointer transa,
                                                               @Cast(value="const char*")
                                                               BytePointer transb,
                                                               @Const
                                                               IntPointer M,
                                                               @Const
                                                               IntPointer N,
                                                               @Const
                                                               IntPointer K,
                                                               @Const
                                                               FloatPointer alpha,
                                                               @Const
                                                               FloatPointer A,
                                                               @Const
                                                               IntPointer lda,
                                                               @Const
                                                               FloatPointer B,
                                                               @Const
                                                               IntPointer ldb,
                                                               @Const
                                                               FloatPointer beta,
                                                               FloatPointer C,
                                                               @Const
                                                               IntPointer ldc)

SGEMM performs matrix-matrix multiplication operation C := alpha*op( A )*op( B ) + beta*C, where op( X ) is one of op( X ) = X or op( X ) = X**T, alpha and beta are scalars, and A, B and C are matrices, with op( A ) an m by k matrix, op( B ) a k by n matrix and C an m by n matrix. \note The API is different compared with the standard BLAS routine because it returns mkldnn_status_t for error handling. XERBLA is not supported: no error message will be printed in case of incorrect parameters.

mkldnn_sgemm

@Cast(value="mkldnn_status_t")
public static int mkldnn_sgemm(String transa,
                                                               String transb,
                                                               @Const
                                                               IntBuffer M,
                                                               @Const
                                                               IntBuffer N,
                                                               @Const
                                                               IntBuffer K,
                                                               @Const
                                                               FloatBuffer alpha,
                                                               @Const
                                                               FloatBuffer A,
                                                               @Const
                                                               IntBuffer lda,
                                                               @Const
                                                               FloatBuffer B,
                                                               @Const
                                                               IntBuffer ldb,
                                                               @Const
                                                               FloatBuffer beta,
                                                               FloatBuffer C,
                                                               @Const
                                                               IntBuffer ldc)

mkldnn_sgemm

@Cast(value="mkldnn_status_t")
public static int mkldnn_sgemm(@Cast(value="const char*")
                                                               BytePointer transa,
                                                               @Cast(value="const char*")
                                                               BytePointer transb,
                                                               @Const
                                                               int[] M,
                                                               @Const
                                                               int[] N,
                                                               @Const
                                                               int[] K,
                                                               @Const
                                                               float[] alpha,
                                                               @Const
                                                               float[] A,
                                                               @Const
                                                               int[] lda,
                                                               @Const
                                                               float[] B,
                                                               @Const
                                                               int[] ldb,
                                                               @Const
                                                               float[] beta,
                                                               float[] C,
                                                               @Const
                                                               int[] ldc)

mkldnn_sgemm

@Cast(value="mkldnn_status_t")
public static int mkldnn_sgemm(String transa,
                                                               String transb,
                                                               @Const
                                                               IntPointer M,
                                                               @Const
                                                               IntPointer N,
                                                               @Const
                                                               IntPointer K,
                                                               @Const
                                                               FloatPointer alpha,
                                                               @Const
                                                               FloatPointer A,
                                                               @Const
                                                               IntPointer lda,
                                                               @Const
                                                               FloatPointer B,
                                                               @Const
                                                               IntPointer ldb,
                                                               @Const
                                                               FloatPointer beta,
                                                               FloatPointer C,
                                                               @Const
                                                               IntPointer ldc)

mkldnn_sgemm

@Cast(value="mkldnn_status_t")
public static int mkldnn_sgemm(@Cast(value="const char*")
                                                               BytePointer transa,
                                                               @Cast(value="const char*")
                                                               BytePointer transb,
                                                               @Const
                                                               IntBuffer M,
                                                               @Const
                                                               IntBuffer N,
                                                               @Const
                                                               IntBuffer K,
                                                               @Const
                                                               FloatBuffer alpha,
                                                               @Const
                                                               FloatBuffer A,
                                                               @Const
                                                               IntBuffer lda,
                                                               @Const
                                                               FloatBuffer B,
                                                               @Const
                                                               IntBuffer ldb,
                                                               @Const
                                                               FloatBuffer beta,
                                                               FloatBuffer C,
                                                               @Const
                                                               IntBuffer ldc)

mkldnn_sgemm

@Cast(value="mkldnn_status_t")
public static int mkldnn_sgemm(String transa,
                                                               String transb,
                                                               @Const
                                                               int[] M,
                                                               @Const
                                                               int[] N,
                                                               @Const
                                                               int[] K,
                                                               @Const
                                                               float[] alpha,
                                                               @Const
                                                               float[] A,
                                                               @Const
                                                               int[] lda,
                                                               @Const
                                                               float[] B,
                                                               @Const
                                                               int[] ldb,
                                                               @Const
                                                               float[] beta,
                                                               float[] C,
                                                               @Const
                                                               int[] ldc)

mkldnn_gemm_s8u8s32

@Cast(value="mkldnn_status_t")
public static int mkldnn_gemm_s8u8s32(@Cast(value="const char*")
                                                                      BytePointer transa,
                                                                      @Cast(value="const char*")
                                                                      BytePointer transb,
                                                                      @Cast(value="const char*")
                                                                      BytePointer offsetc,
                                                                      @Const
                                                                      IntPointer M,
                                                                      @Const
                                                                      IntPointer N,
                                                                      @Const
                                                                      IntPointer K,
                                                                      @Const
                                                                      FloatPointer alpha,
                                                                      @Const
                                                                      BytePointer A,
                                                                      @Const
                                                                      IntPointer lda,
                                                                      @Const
                                                                      BytePointer ao,
                                                                      @Cast(value="const uint8_t*")
                                                                      BytePointer B,
                                                                      @Const
                                                                      IntPointer ldb,
                                                                      @Const
                                                                      BytePointer bo,
                                                                      @Const
                                                                      FloatPointer beta,
                                                                      IntPointer c,
                                                                      @Const
                                                                      IntPointer ldc,
                                                                      @Const
                                                                      IntPointer co)

gemm_s8u8s32 and gemm_s8s8s32 perform a matrix-matrix multiplication operation and add the result to a scalar-matrix product. For the final result, a vector is added to each row or column of the output matrix. The operation is defined as: C := alpha*(op(A) + A_offset) * (op(B) + B_offset) + beta*C + C_offset where op( X ) = X or op( X ) = X**T, A_offset is an m-by-k matrix with every element equal to the value oa, B_offset is an k-by-n matrix with every element equal to the value ob, C_offset is an m-by-n matrix defined by the oc array, size len: if offsetc = F: len must be at least 1 if offsetc = C: len must be at least max(1, m) if offsetc = R: len must be at least max(1, n) alpha and beta are scalars, and A, B and C are matrices, with op( A ) an m-by-k matrix, op( B ) a k-by-n matrix and C an m-by-n matrix. \note The API is different compared with the standard BLAS routine because it returns mkldnn_status_t for error handling. XERBLA is not supported: no error message will be printed in case of incorrect parameters.

mkldnn_gemm_s8u8s32

@Cast(value="mkldnn_status_t")
public static int mkldnn_gemm_s8u8s32(String transa,
                                                                      String transb,
                                                                      String offsetc,
                                                                      @Const
                                                                      IntBuffer M,
                                                                      @Const
                                                                      IntBuffer N,
                                                                      @Const
                                                                      IntBuffer K,
                                                                      @Const
                                                                      FloatBuffer alpha,
                                                                      @Const
                                                                      ByteBuffer A,
                                                                      @Const
                                                                      IntBuffer lda,
                                                                      @Const
                                                                      ByteBuffer ao,
                                                                      @Cast(value="const uint8_t*")
                                                                      ByteBuffer B,
                                                                      @Const
                                                                      IntBuffer ldb,
                                                                      @Const
                                                                      ByteBuffer bo,
                                                                      @Const
                                                                      FloatBuffer beta,
                                                                      IntBuffer c,
                                                                      @Const
                                                                      IntBuffer ldc,
                                                                      @Const
                                                                      IntBuffer co)

mkldnn_gemm_s8u8s32

@Cast(value="mkldnn_status_t")
public static int mkldnn_gemm_s8u8s32(@Cast(value="const char*")
                                                                      BytePointer transa,
                                                                      @Cast(value="const char*")
                                                                      BytePointer transb,
                                                                      @Cast(value="const char*")
                                                                      BytePointer offsetc,
                                                                      @Const
                                                                      int[] M,
                                                                      @Const
                                                                      int[] N,
                                                                      @Const
                                                                      int[] K,
                                                                      @Const
                                                                      float[] alpha,
                                                                      @Const
                                                                      byte[] A,
                                                                      @Const
                                                                      int[] lda,
                                                                      @Const
                                                                      byte[] ao,
                                                                      @Cast(value="const uint8_t*")
                                                                      byte[] B,
                                                                      @Const
                                                                      int[] ldb,
                                                                      @Const
                                                                      byte[] bo,
                                                                      @Const
                                                                      float[] beta,
                                                                      int[] c,
                                                                      @Const
                                                                      int[] ldc,
                                                                      @Const
                                                                      int[] co)

mkldnn_gemm_s8u8s32

@Cast(value="mkldnn_status_t")
public static int mkldnn_gemm_s8u8s32(String transa,
                                                                      String transb,
                                                                      String offsetc,
                                                                      @Const
                                                                      IntPointer M,
                                                                      @Const
                                                                      IntPointer N,
                                                                      @Const
                                                                      IntPointer K,
                                                                      @Const
                                                                      FloatPointer alpha,
                                                                      @Const
                                                                      BytePointer A,
                                                                      @Const
                                                                      IntPointer lda,
                                                                      @Const
                                                                      BytePointer ao,
                                                                      @Cast(value="const uint8_t*")
                                                                      BytePointer B,
                                                                      @Const
                                                                      IntPointer ldb,
                                                                      @Const
                                                                      BytePointer bo,
                                                                      @Const
                                                                      FloatPointer beta,
                                                                      IntPointer c,
                                                                      @Const
                                                                      IntPointer ldc,
                                                                      @Const
                                                                      IntPointer co)

mkldnn_gemm_s8u8s32

@Cast(value="mkldnn_status_t")
public static int mkldnn_gemm_s8u8s32(@Cast(value="const char*")
                                                                      BytePointer transa,
                                                                      @Cast(value="const char*")
                                                                      BytePointer transb,
                                                                      @Cast(value="const char*")
                                                                      BytePointer offsetc,
                                                                      @Const
                                                                      IntBuffer M,
                                                                      @Const
                                                                      IntBuffer N,
                                                                      @Const
                                                                      IntBuffer K,
                                                                      @Const
                                                                      FloatBuffer alpha,
                                                                      @Const
                                                                      ByteBuffer A,
                                                                      @Const
                                                                      IntBuffer lda,
                                                                      @Const
                                                                      ByteBuffer ao,
                                                                      @Cast(value="const uint8_t*")
                                                                      ByteBuffer B,
                                                                      @Const
                                                                      IntBuffer ldb,
                                                                      @Const
                                                                      ByteBuffer bo,
                                                                      @Const
                                                                      FloatBuffer beta,
                                                                      IntBuffer c,
                                                                      @Const
                                                                      IntBuffer ldc,
                                                                      @Const
                                                                      IntBuffer co)

mkldnn_gemm_s8u8s32

@Cast(value="mkldnn_status_t")
public static int mkldnn_gemm_s8u8s32(String transa,
                                                                      String transb,
                                                                      String offsetc,
                                                                      @Const
                                                                      int[] M,
                                                                      @Const
                                                                      int[] N,
                                                                      @Const
                                                                      int[] K,
                                                                      @Const
                                                                      float[] alpha,
                                                                      @Const
                                                                      byte[] A,
                                                                      @Const
                                                                      int[] lda,
                                                                      @Const
                                                                      byte[] ao,
                                                                      @Cast(value="const uint8_t*")
                                                                      byte[] B,
                                                                      @Const
                                                                      int[] ldb,
                                                                      @Const
                                                                      byte[] bo,
                                                                      @Const
                                                                      float[] beta,
                                                                      int[] c,
                                                                      @Const
                                                                      int[] ldc,
                                                                      @Const
                                                                      int[] co)

mkldnn_gemm_s8s8s32

@Cast(value="mkldnn_status_t")
public static int mkldnn_gemm_s8s8s32(@Cast(value="const char*")
                                                                      BytePointer transa,
                                                                      @Cast(value="const char*")
                                                                      BytePointer transb,
                                                                      @Cast(value="const char*")
                                                                      BytePointer offsetc,
                                                                      @Const
                                                                      IntPointer M,
                                                                      @Const
                                                                      IntPointer N,
                                                                      @Const
                                                                      IntPointer K,
                                                                      @Const
                                                                      FloatPointer alpha,
                                                                      @Const
                                                                      BytePointer A,
                                                                      @Const
                                                                      IntPointer lda,
                                                                      @Const
                                                                      BytePointer ao,
                                                                      @Const
                                                                      BytePointer B,
                                                                      @Const
                                                                      IntPointer ldb,
                                                                      @Const
                                                                      BytePointer bo,
                                                                      @Const
                                                                      FloatPointer beta,
                                                                      IntPointer c,
                                                                      @Const
                                                                      IntPointer ldc,
                                                                      @Const
                                                                      IntPointer co)

mkldnn_gemm_s8s8s32

@Cast(value="mkldnn_status_t")
public static int mkldnn_gemm_s8s8s32(String transa,
                                                                      String transb,
                                                                      String offsetc,
                                                                      @Const
                                                                      IntBuffer M,
                                                                      @Const
                                                                      IntBuffer N,
                                                                      @Const
                                                                      IntBuffer K,
                                                                      @Const
                                                                      FloatBuffer alpha,
                                                                      @Const
                                                                      ByteBuffer A,
                                                                      @Const
                                                                      IntBuffer lda,
                                                                      @Const
                                                                      ByteBuffer ao,
                                                                      @Const
                                                                      ByteBuffer B,
                                                                      @Const
                                                                      IntBuffer ldb,
                                                                      @Const
                                                                      ByteBuffer bo,
                                                                      @Const
                                                                      FloatBuffer beta,
                                                                      IntBuffer c,
                                                                      @Const
                                                                      IntBuffer ldc,
                                                                      @Const
                                                                      IntBuffer co)

mkldnn_gemm_s8s8s32

@Cast(value="mkldnn_status_t")
public static int mkldnn_gemm_s8s8s32(@Cast(value="const char*")
                                                                      BytePointer transa,
                                                                      @Cast(value="const char*")
                                                                      BytePointer transb,
                                                                      @Cast(value="const char*")
                                                                      BytePointer offsetc,
                                                                      @Const
                                                                      int[] M,
                                                                      @Const
                                                                      int[] N,
                                                                      @Const
                                                                      int[] K,
                                                                      @Const
                                                                      float[] alpha,
                                                                      @Const
                                                                      byte[] A,
                                                                      @Const
                                                                      int[] lda,
                                                                      @Const
                                                                      byte[] ao,
                                                                      @Const
                                                                      byte[] B,
                                                                      @Const
                                                                      int[] ldb,
                                                                      @Const
                                                                      byte[] bo,
                                                                      @Const
                                                                      float[] beta,
                                                                      int[] c,
                                                                      @Const
                                                                      int[] ldc,
                                                                      @Const
                                                                      int[] co)

mkldnn_gemm_s8s8s32

@Cast(value="mkldnn_status_t")
public static int mkldnn_gemm_s8s8s32(String transa,
                                                                      String transb,
                                                                      String offsetc,
                                                                      @Const
                                                                      IntPointer M,
                                                                      @Const
                                                                      IntPointer N,
                                                                      @Const
                                                                      IntPointer K,
                                                                      @Const
                                                                      FloatPointer alpha,
                                                                      @Const
                                                                      BytePointer A,
                                                                      @Const
                                                                      IntPointer lda,
                                                                      @Const
                                                                      BytePointer ao,
                                                                      @Const
                                                                      BytePointer B,
                                                                      @Const
                                                                      IntPointer ldb,
                                                                      @Const
                                                                      BytePointer bo,
                                                                      @Const
                                                                      FloatPointer beta,
                                                                      IntPointer c,
                                                                      @Const
                                                                      IntPointer ldc,
                                                                      @Const
                                                                      IntPointer co)

mkldnn_gemm_s8s8s32

@Cast(value="mkldnn_status_t")
public static int mkldnn_gemm_s8s8s32(@Cast(value="const char*")
                                                                      BytePointer transa,
                                                                      @Cast(value="const char*")
                                                                      BytePointer transb,
                                                                      @Cast(value="const char*")
                                                                      BytePointer offsetc,
                                                                      @Const
                                                                      IntBuffer M,
                                                                      @Const
                                                                      IntBuffer N,
                                                                      @Const
                                                                      IntBuffer K,
                                                                      @Const
                                                                      FloatBuffer alpha,
                                                                      @Const
                                                                      ByteBuffer A,
                                                                      @Const
                                                                      IntBuffer lda,
                                                                      @Const
                                                                      ByteBuffer ao,
                                                                      @Const
                                                                      ByteBuffer B,
                                                                      @Const
                                                                      IntBuffer ldb,
                                                                      @Const
                                                                      ByteBuffer bo,
                                                                      @Const
                                                                      FloatBuffer beta,
                                                                      IntBuffer c,
                                                                      @Const
                                                                      IntBuffer ldc,
                                                                      @Const
                                                                      IntBuffer co)

mkldnn_gemm_s8s8s32

@Cast(value="mkldnn_status_t")
public static int mkldnn_gemm_s8s8s32(String transa,
                                                                      String transb,
                                                                      String offsetc,
                                                                      @Const
                                                                      int[] M,
                                                                      @Const
                                                                      int[] N,
                                                                      @Const
                                                                      int[] K,
                                                                      @Const
                                                                      float[] alpha,
                                                                      @Const
                                                                      byte[] A,
                                                                      @Const
                                                                      int[] lda,
                                                                      @Const
                                                                      byte[] ao,
                                                                      @Const
                                                                      byte[] B,
                                                                      @Const
                                                                      int[] ldb,
                                                                      @Const
                                                                      byte[] bo,
                                                                      @Const
                                                                      float[] beta,
                                                                      int[] c,
                                                                      @Const
                                                                      int[] ldc,
                                                                      @Const
                                                                      int[] co)

convert_to_c

@Namespace(value="mkldnn")
 @Cast(value="mkldnn_primitive_kind_t")
public static int convert_to_c(@Cast(value="mkldnn::primitive::kind")
                                                                                                    int akind)

\addtogroup cpp_api C++ API \{

\addtogroup cpp_api_utils Utils \{

A class that provides the destructor for an Intel(R) MKL-DNN C handle

zero_md

@Namespace(value="mkldnn")
 @ByVal
public static memory.desc zero_md()

null_memory

@Namespace(value="mkldnn")
 @ByVal
public static memory null_memory(@ByVal
                                                                      engine eng)

check_num_parameters

@Namespace(value="mkldnn")
public static void check_num_parameters(@Const
                                                                    mkldnn_primitive_desc aprimitive_desc,
                                                                    int n_inputs,
                                                                    int n_outputs,
                                                                    @StdString
                                                                    BytePointer prim_name)

check_num_parameters

@Namespace(value="mkldnn")
public static void check_num_parameters(@Const
                                                                    mkldnn_primitive_desc aprimitive_desc,
                                                                    int n_inputs,
                                                                    int n_outputs,
                                                                    @StdString
                                                                    String prim_name)

is_null_memory

@Namespace(value="mkldnn")
 @Cast(value="bool")
public static boolean is_null_memory(@Const
                                                                                       mkldnn_primitive aprimitive)

equals

@Namespace(value="mkldnn")
 @Cast(value="bool")
 @Name(value="operator ==")
public static boolean equals(@Cast(value="mkldnn_data_type_t")
                                                                                                            int a,
                                                                                                            @Cast(value="mkldnn::memory::data_type")
                                                                                                            int b)

notEquals

@Namespace(value="mkldnn")
 @Cast(value="bool")
 @Name(value="operator !=")
public static boolean notEquals(@Cast(value="mkldnn_data_type_t")
                                                                                                               int a,
                                                                                                               @Cast(value="mkldnn::memory::data_type")
                                                                                                               int b)

Class mkldnn

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.bytedeco.mkldnn.presets.mkldnn

Methods inherited from class java.lang.Object

Field Detail

mkldnn_success

mkldnn_out_of_memory

mkldnn_try_again

mkldnn_invalid_arguments

mkldnn_not_ready

mkldnn_unimplemented

mkldnn_iterator_ends

mkldnn_runtime_error

mkldnn_not_required

mkldnn_data_type_undef

mkldnn_f32

mkldnn_s32

mkldnn_s16

mkldnn_s8

mkldnn_u8

mkldnn_round_nearest

mkldnn_round_down

mkldnn_format_undef

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

mkldnn_nCw8c

mkldnn_nCw16c

mkldnn_nChw8c

mkldnn_nChw16c

mkldnn_nCdhw8c

mkldnn_nCdhw16c

mkldnn_Owi8o

mkldnn_OIw8i8o

mkldnn_OIw8o8i

mkldnn_OIw16i16o

mkldnn_OIw16o16i

mkldnn_Oiw16o

mkldnn_Owi16o

mkldnn_OIw8i16o2i

mkldnn_OIw8o16i2o

mkldnn_IOw16o16i

mkldnn_hwio_s8s8

mkldnn_oIhw8i

mkldnn_oIhw16i

mkldnn_OIhw8i8o

mkldnn_OIhw16i16o

mkldnn_OIhw4i16o4i

mkldnn_OIhw4i16o4i_s8s8