mkldnn (JavaCPP Presets for MKL-DNN 0.15-1.4.2 API)

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

All Implemented Interfaces:

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

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`mkldnn.batch_normalization_backward`
`static class`	`mkldnn.batch_normalization_forward` \}
`static class`	`mkldnn.concat` \}
`static class`	`mkldnn.const_mkldnn_op_desc_t` A pointer to any of the operation descriptors (constant variant).
`static class`	`mkldnn.convolution_backward_data`
`static class`	`mkldnn.convolution_backward_weights`
`static class`	`mkldnn.convolution_forward` \}
`static class`	`mkldnn.convolution_relu_forward` Deprecated. consider using convolution_forward with post_ops (e.g. post_ops::append_eltwise(1.f, #eltwise_relu, negative_slope, 0.f)
`static class`	`mkldnn.deconvolution_backward_data`
`static class`	`mkldnn.deconvolution_backward_weights`
`static class`	`mkldnn.deconvolution_forward` \addtogroup cpp_api_deconvolution Deconvolution /** A primitive to compute deconvolution using different algorithms.
`static class`	`mkldnn.eltwise_backward`
`static class`	`mkldnn.eltwise_forward` \}
`static class`	`mkldnn.engine` An execution engine.
`static class`	`mkldnn.error` Intel(R) MKL-DNN exception class.
`static class`	`mkldnn.inner_product_backward_data`
`static class`	`mkldnn.inner_product_backward_weights`
`static class`	`mkldnn.inner_product_forward` \}
`static class`	`mkldnn.lrn_backward`
`static class`	`mkldnn.lrn_forward` \}
`static class`	`mkldnn.memory` \}
`static class`	`mkldnn.memory_primitive_desc_vector`
`static class`	`mkldnn.mkldnn_batch_normalization_desc_t` A descriptor of a Batch Normalization operation.
`static class`	`mkldnn.mkldnn_blocking_desc_t` Generic description of blocked data layout for most memory formats.
`static class`	`mkldnn.mkldnn_convolution_desc_t` A descriptor of a convolution operation.
`static class`	`mkldnn.mkldnn_convolution_relu_desc_t` A descriptor of a convolution followed by relu operation.
`static class`	`mkldnn.mkldnn_eltwise_desc_t` A descriptor of a element-wise operation.
`static class`	`mkldnn.mkldnn_engine` \struct mkldnn_engine \brief An opaque structure to describe an engine.
`static class`	`mkldnn.mkldnn_engine_handle` A class for wrapping an Intel(R) MKL-DNN handle.
`static class`	`mkldnn.mkldnn_inner_product_desc_t` A descriptor of an inner product operation.
`static class`	`mkldnn.mkldnn_lrn_desc_t` A descriptor of a Local Response Normalization (LRN) operation.
`static class`	`mkldnn.mkldnn_memory_desc_t` Memory descriptor.
`static class`	`mkldnn.mkldnn_op_desc_t` A pointer to any of the operation descriptors.
`static class`	`mkldnn.mkldnn_pooling_desc_t` A descriptor of a pooling operation.
`static class`	`mkldnn.mkldnn_post_ops` \struct mkldnn_post_ops \brief An opaque structure for a chain of post operations.
`static class`	`mkldnn.mkldnn_post_ops_handle`
`static class`	`mkldnn.mkldnn_primitive` \struct mkldnn_primitive An opaque structure to describe a primitive.
`static class`	`mkldnn.mkldnn_primitive_at_t` A wrapper structure to specify a particular output of a primitive.
`static class`	`mkldnn.mkldnn_primitive_attr` \struct mkldnn_primitive_attr \brief An opaque structure for primitive descriptor attributes.
`static class`	`mkldnn.mkldnn_primitive_attr_handle`
`static class`	`mkldnn.mkldnn_primitive_desc` \struct mkldnn_primitive_desc \brief An opaque structure to describe a primitive descriptor .
`static class`	`mkldnn.mkldnn_primitive_desc_handle`
`static class`	`mkldnn.mkldnn_primitive_desc_iterator` \struct mkldnn_primitive_desc_iterator \brief An opaque structure to describe a primitive descriptor iterator .
`static class`	`mkldnn.mkldnn_primitive_desc_vector`
`static class`	`mkldnn.mkldnn_primitive_handle`
`static class`	`mkldnn.mkldnn_rnn_cell_desc_t`
`static class`	`mkldnn.mkldnn_rnn_desc_t` A descriptor for an rnn operation
`static class`	`mkldnn.mkldnn_softmax_desc_t` A descriptor of a Softmax operation.
`static class`	`mkldnn.mkldnn_stream` \struct mkldnn_stream An opaque structure to describe an execution stream.
`static class`	`mkldnn.mkldnn_stream_handle`
`static class`	`mkldnn.mkldnn_wino_desc_t` Description of tensor of weights for integer 8bit winograd convolution.
`static class`	`mkldnn.pooling_backward`
`static class`	`mkldnn.pooling_forward` \}
`static class`	`mkldnn.post_ops` \}
`static class`	`mkldnn.primitive` Base class for all computational primitives.
`static class`	`mkldnn.primitive_attr`
`static class`	`mkldnn.primitive_vector`
`static class`	`mkldnn.reorder` \}
`static class`	`mkldnn.rnn_backward`
`static class`	`mkldnn.rnn_cell` \}
`static class`	`mkldnn.rnn_forward`
`static class`	`mkldnn.softmax_backward`
`static class`	`mkldnn.softmax_forward` \}
`static class`	`mkldnn.stream` \} \} Primitives
`static class`	`mkldnn.sum` \}
`static class`	`mkldnn.view` \}

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_d` enum mkldnn::query
`static int`	`convolution_direct` enum mkldnn::algorithm
`static int`	`convolution_relu_d` enum mkldnn::query
`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_direct` enum mkldnn_alg_kind_t
`static int`	`mkldnn_convolution_relu` enum mkldnn_primitive_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_gIOhw16o16i` enum mkldnn_memory_format_t
`static int`	`mkldnn_gOdhwi16o` 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_goihw` enum mkldnn_memory_format_t
`static int`	`mkldnn_Goihw16g` 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_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_gru_linear_before_reset` enum mkldnn_alg_kind_t
`static int`	`mkldnn_hwigo` enum mkldnn_memory_format_t
`static int`	`mkldnn_hwio` 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_IOhw16o16i` 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_memory_format_t
`static int`	`mkldnn_ldigo` enum mkldnn_memory_format_t
`static int`	`mkldnn_ldigo_p` enum mkldnn_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_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_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_Odhwi16o` 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_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_OIdhw8i16o2i` 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_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_omit_stats` enum mkldnn_batch_normalization_flag_t
`static int`	`mkldnn_out_of_memory` enum mkldnn_status_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_convolution_relu_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_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_relu_d` enum mkldnn_query_t
`static int`	`mkldnn_query_rnn_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_relu` enum mkldnn_primitive_kind_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_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_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_aaOIoi` enum mkldnn_wino_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`	`omit_stats` enum mkldnn::batch_normalization_flag
`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`	`relu_d` 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`	`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 Deprecated Methods
Modifier and Type	Method and Description
`static void`	`check_num_parameters(mkldnn.mkldnn_primitive_desc aprimitive_desc, int n_inputs, int n_outputs, BytePointer prim_name)`
`static void`	`check_num_parameters(mkldnn.mkldnn_primitive_desc aprimitive_desc, int n_inputs, int n_outputs, String prim_name)`
`static int`	`convert_to_c(int akind)`
`static boolean`	`equals(int a, int b)`
`static boolean`	`is_null_memory(mkldnn.mkldnn_primitive aprimitive)`
`static int`	`mkldnn_batch_normalization_backward_desc_init(mkldnn.mkldnn_batch_normalization_desc_t bnrm_desc, int prop_kind, mkldnn.mkldnn_memory_desc_t diff_data_desc, mkldnn.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, and normalization parameter \p epsilon and flags (possible values are #mkldnn_use_global_stats and #mkldnn_use_scaleshift).
`static int`	`mkldnn_batch_normalization_forward_desc_init(mkldnn.mkldnn_batch_normalization_desc_t bnrm_desc, int prop_kind, mkldnn.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 or #mkldnn_forward_inference), memory descriptor \p data_desc, normalization parameter \p epsilon and flags (possible values are #mkldnn_use_global_stats and #mkldnn_use_scaleshift).
`static int`	`mkldnn_concat_primitive_desc_create(mkldnn.mkldnn_primitive_desc concat_primitive_desc, mkldnn.mkldnn_memory_desc_t output_desc, int n, int concat_dimension, mkldnn.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_convolution_backward_data_desc_init(mkldnn.mkldnn_convolution_desc_t conv_desc, int alg_kind, mkldnn.mkldnn_memory_desc_t diff_src_desc, mkldnn.mkldnn_memory_desc_t weights_desc, mkldnn.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.mkldnn_convolution_desc_t conv_desc, int alg_kind, mkldnn.mkldnn_memory_desc_t diff_src_desc, mkldnn.mkldnn_memory_desc_t weights_desc, mkldnn.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.mkldnn_convolution_desc_t conv_desc, int alg_kind, mkldnn.mkldnn_memory_desc_t diff_src_desc, mkldnn.mkldnn_memory_desc_t weights_desc, mkldnn.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.mkldnn_convolution_desc_t conv_desc, int alg_kind, mkldnn.mkldnn_memory_desc_t src_desc, mkldnn.mkldnn_memory_desc_t diff_weights_desc, mkldnn.mkldnn_memory_desc_t diff_bias_desc, mkldnn.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.mkldnn_convolution_desc_t conv_desc, int alg_kind, mkldnn.mkldnn_memory_desc_t src_desc, mkldnn.mkldnn_memory_desc_t diff_weights_desc, mkldnn.mkldnn_memory_desc_t diff_bias_desc, mkldnn.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.mkldnn_convolution_desc_t conv_desc, int alg_kind, mkldnn.mkldnn_memory_desc_t src_desc, mkldnn.mkldnn_memory_desc_t diff_weights_desc, mkldnn.mkldnn_memory_desc_t diff_bias_desc, mkldnn.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.mkldnn_convolution_desc_t conv_desc, int prop_kind, int alg_kind, mkldnn.mkldnn_memory_desc_t src_desc, mkldnn.mkldnn_memory_desc_t weights_desc, mkldnn.mkldnn_memory_desc_t bias_desc, mkldnn.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.mkldnn_convolution_desc_t conv_desc, int prop_kind, int alg_kind, mkldnn.mkldnn_memory_desc_t src_desc, mkldnn.mkldnn_memory_desc_t weights_desc, mkldnn.mkldnn_memory_desc_t bias_desc, mkldnn.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.mkldnn_convolution_desc_t conv_desc, int prop_kind, int alg_kind, mkldnn.mkldnn_memory_desc_t src_desc, mkldnn.mkldnn_memory_desc_t weights_desc, mkldnn.mkldnn_memory_desc_t bias_desc, mkldnn.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 or #mkldnn_forward_inference), \p alg_kind, memory descriptors, \p strides, \p padding_l, \p padding_r, and \p padding_kind.
`static int`	`mkldnn_convolution_relu_desc_init(mkldnn.mkldnn_convolution_relu_desc_t conv_relu_desc, mkldnn.mkldnn_convolution_desc_t conv_desc, float negative_slope)` Deprecated. use mkldnn_convolution_desc_init with mkldnn_post_ops_append_eltwise to append ReLU
`static int`	`mkldnn_deconvolution_backward_data_desc_init(mkldnn.mkldnn_convolution_desc_t conv_desc, int alg_kind, mkldnn.mkldnn_memory_desc_t diff_src_desc, mkldnn.mkldnn_memory_desc_t weights_desc, mkldnn.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.mkldnn_convolution_desc_t conv_desc, int alg_kind, mkldnn.mkldnn_memory_desc_t diff_src_desc, mkldnn.mkldnn_memory_desc_t weights_desc, mkldnn.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.mkldnn_convolution_desc_t conv_desc, int alg_kind, mkldnn.mkldnn_memory_desc_t diff_src_desc, mkldnn.mkldnn_memory_desc_t weights_desc, mkldnn.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.mkldnn_convolution_desc_t conv_desc, int alg_kind, mkldnn.mkldnn_memory_desc_t src_desc, mkldnn.mkldnn_memory_desc_t diff_weights_desc, mkldnn.mkldnn_memory_desc_t diff_bias_desc, mkldnn.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.mkldnn_convolution_desc_t conv_desc, int alg_kind, mkldnn.mkldnn_memory_desc_t src_desc, mkldnn.mkldnn_memory_desc_t diff_weights_desc, mkldnn.mkldnn_memory_desc_t diff_bias_desc, mkldnn.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.mkldnn_convolution_desc_t conv_desc, int alg_kind, mkldnn.mkldnn_memory_desc_t src_desc, mkldnn.mkldnn_memory_desc_t diff_weights_desc, mkldnn.mkldnn_memory_desc_t diff_bias_desc, mkldnn.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.mkldnn_convolution_desc_t conv_desc, int prop_kind, int alg_kind, mkldnn.mkldnn_memory_desc_t src_desc, mkldnn.mkldnn_memory_desc_t weights_desc, mkldnn.mkldnn_memory_desc_t bias_desc, mkldnn.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.mkldnn_convolution_desc_t conv_desc, int prop_kind, int alg_kind, mkldnn.mkldnn_memory_desc_t src_desc, mkldnn.mkldnn_memory_desc_t weights_desc, mkldnn.mkldnn_memory_desc_t bias_desc, mkldnn.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.mkldnn_convolution_desc_t conv_desc, int prop_kind, int alg_kind, mkldnn.mkldnn_memory_desc_t src_desc, mkldnn.mkldnn_memory_desc_t weights_desc, mkldnn.mkldnn_memory_desc_t bias_desc, mkldnn.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 or #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.mkldnn_convolution_desc_t conv_desc, int alg_kind, mkldnn.mkldnn_memory_desc_t diff_src_desc, mkldnn.mkldnn_memory_desc_t weights_desc, mkldnn.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.mkldnn_convolution_desc_t conv_desc, int alg_kind, mkldnn.mkldnn_memory_desc_t diff_src_desc, mkldnn.mkldnn_memory_desc_t weights_desc, mkldnn.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.mkldnn_convolution_desc_t conv_desc, int alg_kind, mkldnn.mkldnn_memory_desc_t diff_src_desc, mkldnn.mkldnn_memory_desc_t weights_desc, mkldnn.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.mkldnn_convolution_desc_t conv_desc, int alg_kind, mkldnn.mkldnn_memory_desc_t src_desc, mkldnn.mkldnn_memory_desc_t diff_weights_desc, mkldnn.mkldnn_memory_desc_t diff_bias_desc, mkldnn.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.mkldnn_convolution_desc_t conv_desc, int alg_kind, mkldnn.mkldnn_memory_desc_t src_desc, mkldnn.mkldnn_memory_desc_t diff_weights_desc, mkldnn.mkldnn_memory_desc_t diff_bias_desc, mkldnn.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.mkldnn_convolution_desc_t conv_desc, int alg_kind, mkldnn.mkldnn_memory_desc_t src_desc, mkldnn.mkldnn_memory_desc_t diff_weights_desc, mkldnn.mkldnn_memory_desc_t diff_bias_desc, mkldnn.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.mkldnn_convolution_desc_t conv_desc, int prop_kind, int alg_kind, mkldnn.mkldnn_memory_desc_t src_desc, mkldnn.mkldnn_memory_desc_t weights_desc, mkldnn.mkldnn_memory_desc_t bias_desc, mkldnn.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.mkldnn_convolution_desc_t conv_desc, int prop_kind, int alg_kind, mkldnn.mkldnn_memory_desc_t src_desc, mkldnn.mkldnn_memory_desc_t weights_desc, mkldnn.mkldnn_memory_desc_t bias_desc, mkldnn.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.mkldnn_convolution_desc_t conv_desc, int prop_kind, int alg_kind, mkldnn.mkldnn_memory_desc_t src_desc, mkldnn.mkldnn_memory_desc_t weights_desc, mkldnn.mkldnn_memory_desc_t bias_desc, mkldnn.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 or #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.mkldnn_eltwise_desc_t eltwise_desc, int alg_kind, mkldnn.mkldnn_memory_desc_t diff_data_desc, mkldnn.mkldnn_memory_desc_t data_desc, float alpha, float beta)` Initializes a \p eltwise_desc for backward propagation using \p alg_kind algorithm memory descriptors \p diff_data_desc and \p data_desc, and \p alpha, \p beta parameters.
`static int`	`mkldnn_eltwise_forward_desc_init(mkldnn.mkldnn_eltwise_desc_t eltwise_desc, int prop_kind, int alg_kind, mkldnn.mkldnn_memory_desc_t data_desc, float alpha, float beta)` Initializes a \p eltwise_desc for forward propagation using \p prop_kind (possible values are #mkldnn_forward_training or #mkldnn_forward_inference), \p alg_kind algorithm, memory descriptor \p data_desc, and \p alpha, \p beta parameters.
`static int`	`mkldnn_engine_create(mkldnn.mkldnn_engine engine, int kind, long index)` Creates an \p engine of particular \p kind and \p index.
`static int`	`mkldnn_engine_destroy(mkldnn.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.mkldnn_engine engine, int[] kind)`
`static int`	`mkldnn_engine_get_kind(mkldnn.mkldnn_engine engine, IntBuffer kind)`
`static int`	`mkldnn_engine_get_kind(mkldnn.mkldnn_engine engine, IntPointer kind)` Returns the kind of an \p engine.
`static int`	`mkldnn_inner_product_backward_data_desc_init(mkldnn.mkldnn_inner_product_desc_t ip_desc, mkldnn.mkldnn_memory_desc_t diff_src_desc, mkldnn.mkldnn_memory_desc_t weights_desc, mkldnn.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.mkldnn_inner_product_desc_t ip_desc, mkldnn.mkldnn_memory_desc_t src_desc, mkldnn.mkldnn_memory_desc_t diff_weights_desc, mkldnn.mkldnn_memory_desc_t diff_bias_desc, mkldnn.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.mkldnn_inner_product_desc_t ip_desc, int prop_kind, mkldnn.mkldnn_memory_desc_t src_desc, mkldnn.mkldnn_memory_desc_t weights_desc, mkldnn.mkldnn_memory_desc_t bias_desc, mkldnn.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 or #mkldnn_forward_inference) and memory descriptors.
`static int`	`mkldnn_lrn_backward_desc_init(mkldnn.mkldnn_lrn_desc_t lrn_desc, int alg_kind, mkldnn.mkldnn_memory_desc_t diff_data_desc, mkldnn.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.mkldnn_lrn_desc_t lrn_desc, int prop_kind, int alg_kind, mkldnn.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 or #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.mkldnn_memory_desc_t memory_desc, int ndims, int[] dims, int data_type, int format)`
`static int`	`mkldnn_memory_desc_init(mkldnn.mkldnn_memory_desc_t memory_desc, int ndims, IntBuffer dims, int data_type, int format)`
`static int`	`mkldnn_memory_desc_init(mkldnn.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.mkldnn_primitive memory, Pointer handle)`
`static int`	`mkldnn_memory_get_data_handle(mkldnn.mkldnn_primitive memory, PointerPointer handle)` For a \p memory primitive, returns the data \p handle.
`static int`	`mkldnn_memory_primitive_desc_create(mkldnn.mkldnn_primitive_desc memory_primitive_desc, mkldnn.mkldnn_memory_desc_t memory_desc, mkldnn.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_equal(mkldnn.mkldnn_primitive_desc lhs, mkldnn.mkldnn_primitive_desc rhs)` Compares two descriptors of memory primitives.
`static long`	`mkldnn_memory_primitive_desc_get_size(mkldnn.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.mkldnn_primitive memory, Pointer handle)` For a \p memory primitive, sets the data \p handle.
`static int`	`mkldnn_pooling_backward_desc_init(mkldnn.mkldnn_pooling_desc_t pool_desc, int alg_kind, mkldnn.mkldnn_memory_desc_t diff_src_desc, mkldnn.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.mkldnn_pooling_desc_t pool_desc, int alg_kind, mkldnn.mkldnn_memory_desc_t diff_src_desc, mkldnn.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.mkldnn_pooling_desc_t pool_desc, int alg_kind, mkldnn.mkldnn_memory_desc_t diff_src_desc, mkldnn.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 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.mkldnn_pooling_desc_t pool_desc, int prop_kind, int alg_kind, mkldnn.mkldnn_memory_desc_t src_desc, mkldnn.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.mkldnn_pooling_desc_t pool_desc, int prop_kind, int alg_kind, mkldnn.mkldnn_memory_desc_t src_desc, mkldnn.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.mkldnn_pooling_desc_t pool_desc, int prop_kind, int alg_kind, mkldnn.mkldnn_memory_desc_t src_desc, mkldnn.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 or #mkldnn_forward_inference), \p alg_kind, memory descriptors, and pooling parameters in 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.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 (\sa mkldnn_eltwise_forward_desc_init and mkldnn_eltwise_desc_t).
`static int`	`mkldnn_post_ops_append_sum(mkldnn.mkldnn_post_ops post_ops, float scale)` Appends accumulation (sum) post operation to the \p post_ops.
`static int`	`mkldnn_post_ops_create(mkldnn.mkldnn_post_ops post_ops)` Creates an empty sequence of post operations \p post_ops.
`static int`	`mkldnn_post_ops_destroy(mkldnn.mkldnn_post_ops post_ops)` Deletes a \p post_ops sequence.
`static int`	`mkldnn_post_ops_get_kind(mkldnn.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.mkldnn_post_ops post_ops, int index, float[] scale, int[] alg, float[] alpha, float[] beta)`
`static int`	`mkldnn_post_ops_get_params_eltwise(mkldnn.mkldnn_post_ops post_ops, int index, FloatBuffer scale, IntBuffer alg, FloatBuffer alpha, FloatBuffer beta)`
`static int`	`mkldnn_post_ops_get_params_eltwise(mkldnn.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.mkldnn_post_ops post_ops, int index, float[] scale)`
`static int`	`mkldnn_post_ops_get_params_sum(mkldnn.mkldnn_post_ops post_ops, int index, FloatBuffer scale)`
`static int`	`mkldnn_post_ops_get_params_sum(mkldnn.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.mkldnn_post_ops post_ops)` Returns the \p length of post operations for given \p post_ops.
`static mkldnn.mkldnn_primitive_at_t`	`mkldnn_primitive_at(mkldnn.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.mkldnn_primitive_attr attr, mkldnn.mkldnn_primitive_attr existing_attr)` Makes a copy of an \p existing_attr.
`static int`	`mkldnn_primitive_attr_create(mkldnn.mkldnn_primitive_attr attr)` Creates an empty (default) \p attr attribute.
`static int`	`mkldnn_primitive_attr_destroy(mkldnn.mkldnn_primitive_attr attr)` Deletes an \p attr.
`static int`	`mkldnn_primitive_attr_get_int_output_round_mode(mkldnn.mkldnn_primitive_attr attr, int[] round_mode)`
`static int`	`mkldnn_primitive_attr_get_int_output_round_mode(mkldnn.mkldnn_primitive_attr attr, IntBuffer round_mode)`
`static int`	`mkldnn_primitive_attr_get_int_output_round_mode(mkldnn.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.mkldnn_primitive_attr attr, int[] count, int[] mask, float[] scales)`
`static int`	`mkldnn_primitive_attr_get_output_scales(mkldnn.mkldnn_primitive_attr attr, IntBuffer count, IntBuffer mask, FloatBuffer scales)`
`static int`	`mkldnn_primitive_attr_get_output_scales(mkldnn.mkldnn_primitive_attr attr, IntPointer count, IntPointer mask, FloatPointer scales)`
`static int`	`mkldnn_primitive_attr_get_output_scales(mkldnn.mkldnn_primitive_attr attr, IntPointer count, IntPointer mask, PointerPointer scales)` Returns \p count, correspondence scale \p mask, and 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.mkldnn_primitive_attr attr, mkldnn.mkldnn_post_ops post_ops)` Returns \p post_ops for given attr.
`static int`	`mkldnn_primitive_attr_set_int_output_round_mode(mkldnn.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.mkldnn_primitive_attr attr, int count, int mask, float[] scales)`
`static int`	`mkldnn_primitive_attr_set_output_scales(mkldnn.mkldnn_primitive_attr attr, int count, int mask, FloatBuffer scales)`
`static int`	`mkldnn_primitive_attr_set_output_scales(mkldnn.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.mkldnn_primitive_attr attr, mkldnn.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_create(mkldnn.mkldnn_primitive primitive, mkldnn.mkldnn_primitive_desc primitive_desc, mkldnn.mkldnn_primitive_at_t inputs, mkldnn.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_desc_clone(mkldnn.mkldnn_primitive_desc primitive_desc, mkldnn.mkldnn_primitive_desc existing_primitive_desc)` Makes a copy of a \p primitive_desc.
`static int`	`mkldnn_primitive_desc_create_v2(mkldnn.mkldnn_primitive_desc primitive_desc, mkldnn.const_mkldnn_op_desc_t op_desc, mkldnn.mkldnn_primitive_attr attr, mkldnn.mkldnn_engine engine, mkldnn.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(mkldnn.mkldnn_primitive_desc primitive_desc, mkldnn.const_mkldnn_op_desc_t op_desc, mkldnn.mkldnn_engine engine, mkldnn.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_destroy(mkldnn.mkldnn_primitive_desc primitive_desc)` Deletes a \p primitive_desc.
`static int`	`mkldnn_primitive_desc_get_attr(mkldnn.mkldnn_primitive_desc primitive_desc, mkldnn.mkldnn_primitive_attr attr)` Returns a constant reference to the attribute of a \p primitive_desc.
`static int`	`mkldnn_primitive_desc_iterator_create_v2(mkldnn.mkldnn_primitive_desc_iterator iterator, mkldnn.const_mkldnn_op_desc_t op_desc, mkldnn.mkldnn_primitive_attr attr, mkldnn.mkldnn_engine engine, mkldnn.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(mkldnn.mkldnn_primitive_desc_iterator iterator, mkldnn.const_mkldnn_op_desc_t op_desc, mkldnn.mkldnn_engine engine, mkldnn.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_destroy(mkldnn.mkldnn_primitive_desc_iterator iterator)` Deletes a primitive descriptor \p iterator
`static mkldnn.mkldnn_primitive_desc`	`mkldnn_primitive_desc_iterator_fetch(mkldnn.mkldnn_primitive_desc_iterator iterator)` Fetches current primitive descriptor.
`static int`	`mkldnn_primitive_desc_iterator_next(mkldnn.mkldnn_primitive_desc_iterator iterator)` Iterates over primitive descriptors.
`static mkldnn.mkldnn_memory_desc_t`	`mkldnn_primitive_desc_query_memory_d(mkldnn.mkldnn_primitive_desc primitive_desc)` Queries primitive descriptor for memory descriptor
`static mkldnn.mkldnn_primitive_desc`	`mkldnn_primitive_desc_query_pd(mkldnn.mkldnn_primitive_desc primitive_desc, int what, int index)` Queries primitive descriptor for primitive descriptor
`static int`	`mkldnn_primitive_desc_query_s32(mkldnn.mkldnn_primitive_desc primitive_desc, int what, int index)` Queries primitive descriptor for signed 32bit int
`static int`	`mkldnn_primitive_desc_query(mkldnn.mkldnn_primitive_desc primitive_desc, int what, int index, Pointer result)` Queries primitive descriptor \sa mkldnn_query_t
`static int`	`mkldnn_primitive_destroy(mkldnn.mkldnn_primitive primitive)` Deletes a \p primitive.
`static int`	`mkldnn_primitive_get_input_at(mkldnn.mkldnn_primitive primitive, long index, mkldnn.mkldnn_primitive_at_t input)` For a \p primitive, returns \p input at the \p index position.
`static int`	`mkldnn_primitive_get_output(mkldnn.mkldnn_primitive primitive, long index, mkldnn.mkldnn_primitive output)` For a \p primitive, returns \p output at the \p index position.
`static int`	`mkldnn_primitive_get_primitive_desc(mkldnn.mkldnn_primitive primitive, mkldnn.mkldnn_primitive_desc primitive_desc)` Retrieves a reference to the \p primitive_desc descriptor of given \p primitive.
`static int`	`mkldnn_relu_backward_desc_init(mkldnn.mkldnn_eltwise_desc_t relu_desc, mkldnn.mkldnn_memory_desc_t diff_data_desc, mkldnn.mkldnn_memory_desc_t data_desc, float negative_slope)` Deprecated. use mkldnn_eltwise_backward_desc_init() instead, with \p alpha equals \p negative_slope
`static int`	`mkldnn_relu_forward_desc_init(mkldnn.mkldnn_eltwise_desc_t relu_desc, int prop_kind, mkldnn.mkldnn_memory_desc_t data_desc, float negative_slope)` Deprecated. use mkldnn_eltwise_forward_desc_init() instead, with \p alpha equals \p negative_slope
`static int`	`mkldnn_reorder_primitive_desc_create_v2(mkldnn.mkldnn_primitive_desc reorder_primitive_desc, mkldnn.mkldnn_primitive_desc input, mkldnn.mkldnn_primitive_desc output, mkldnn.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(mkldnn.mkldnn_primitive_desc reorder_primitive_desc, mkldnn.mkldnn_primitive_desc input, mkldnn.mkldnn_primitive_desc output)` Initializes a \p reorder_primitive_desc using descriptors of \p input and \p output memory primitives.
`static int`	mkldnn_rnn_backward_desc_init(mkldnn.mkldnn_rnn_desc_t rnn_desc, int prop_kind, mkldnn.mkldnn_rnn_cell_desc_t rnn_cell_desc, int direction, mkldnn.mkldnn_memory_desc_t src_layer_desc, mkldnn.mkldnn_memory_desc_t src_iter_desc, mkldnn.mkldnn_memory_desc_t weights_layer_desc, mkldnn.mkldnn_memory_desc_t weights_iter_desc, mkldnn.mkldnn_memory_desc_t bias_desc, mkldnn.mkldnn_memory_desc_t dst_layer_desc, mkldnn.mkldnn_memory_desc_t dst_iter_desc, mkldnn.mkldnn_memory_desc_t diff_src_layer_desc, mkldnn.mkldnn_memory_desc_t diff_src_iter_desc, mkldnn.mkldnn_memory_desc_t diff_weights_layer_desc, mkldnn.mkldnn_memory_desc_t diff_weights_iter_desc, mkldnn.mkldnn_memory_desc_t diff_bias_desc, mkldnn.mkldnn_memory_desc_t diff_dst_layer, mkldnn.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.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, #mkldnn_gru_linear_before_reset), \p f (possible values are #mkldnn_eltwise_relu, #mkldnn_eltwise_tanh), \p flags, \p alpha, and \p clipping.
`static int`	`mkldnn_rnn_cell_get_gates_count(mkldnn.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.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.mkldnn_rnn_desc_t rnn_desc, int prop_kind, mkldnn.mkldnn_rnn_cell_desc_t rnn_cell_desc, int direction, mkldnn.mkldnn_memory_desc_t src_layer_desc, mkldnn.mkldnn_memory_desc_t src_iter_desc, mkldnn.mkldnn_memory_desc_t weights_layer_desc, mkldnn.mkldnn_memory_desc_t weights_iter_desc, mkldnn.mkldnn_memory_desc_t bias_desc, mkldnn.mkldnn_memory_desc_t dst_layer_desc, mkldnn.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_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_softmax_backward_desc_init(mkldnn.mkldnn_softmax_desc_t softmax_desc, mkldnn.mkldnn_memory_desc_t diff_desc, mkldnn.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.mkldnn_softmax_desc_t softmax_desc, int prop_kind, mkldnn.mkldnn_memory_desc_t data_desc, int softmax_axis)` Initializes a \p softmax_desc for forward propagation using \p prop_kind (possible value are #mkldnn_forward_training or #mkldnn_forward_inference) and memory descriptor \p data_desc.
`static int`	`mkldnn_stream_create(mkldnn.mkldnn_stream stream, int stream_kind)` Creates an execution \p stream of \p stream_kind.
`static int`	`mkldnn_stream_destroy(mkldnn.mkldnn_stream stream)` Destroys an execution \p stream.
`static int`	`mkldnn_stream_rerun(mkldnn.mkldnn_stream stream, mkldnn.mkldnn_primitive error_primitive)` Reruns all the primitives within the \p stream.
`static int`	`mkldnn_stream_submit(mkldnn.mkldnn_stream stream, long n, mkldnn.mkldnn_primitive primitives, mkldnn.mkldnn_primitive error_primitive)` Submits \p primitives to an execution \p stream.
`static int`	`mkldnn_stream_wait(mkldnn.mkldnn_stream stream, int block, mkldnn.mkldnn_primitive error_primitive)` Waits for all primitives in the execution \p stream to finish.
`static int`	`mkldnn_sum_primitive_desc_create(mkldnn.mkldnn_primitive_desc sum_primitive_desc, mkldnn.mkldnn_memory_desc_t output_desc, int n, float[] scales, mkldnn.mkldnn_primitive_desc input_pds)`
`static int`	`mkldnn_sum_primitive_desc_create(mkldnn.mkldnn_primitive_desc sum_primitive_desc, mkldnn.mkldnn_memory_desc_t output_desc, int n, FloatBuffer scales, mkldnn.mkldnn_primitive_desc input_pds)`
`static int`	`mkldnn_sum_primitive_desc_create(mkldnn.mkldnn_primitive_desc sum_primitive_desc, mkldnn.mkldnn_memory_desc_t output_desc, int n, FloatPointer scales, mkldnn.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_verbose_set(int level)` Sets verbosity level (print information to stdout).
`static int`	`mkldnn_view_primitive_desc_create(mkldnn.mkldnn_primitive_desc view_primitive_desc, mkldnn.mkldnn_primitive_desc memory_primitive_desc, int[] dims, int[] offsets)`
`static int`	`mkldnn_view_primitive_desc_create(mkldnn.mkldnn_primitive_desc view_primitive_desc, mkldnn.mkldnn_primitive_desc memory_primitive_desc, IntBuffer dims, IntBuffer offsets)`
`static int`	`mkldnn_view_primitive_desc_create(mkldnn.mkldnn_primitive_desc view_primitive_desc, mkldnn.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 offset offsets.
`static boolean`	`notEquals(int a, int b)`
`static mkldnn.memory`	`null_memory(mkldnn.engine eng)`
`static mkldnn.memory.desc`	`zero_md()`

Methods inherited from class org.bytedeco.javacpp.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_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_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_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_nCdhw16c
```
public static final int mkldnn_nCdhw16c
```
  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_oihw
```
public static final int mkldnn_oihw
```
  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_hwio
```
public static final int mkldnn_hwio
```
  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_oidhw
```
public static final int mkldnn_oidhw
```
  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_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_OIhw8i16o2i
```
public static final int mkldnn_OIhw8i16o2i
```
  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_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_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_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_gOIhw8i16o2i
```
public static final int mkldnn_gOIhw8i16o2i
```
  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_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_gOhIw16o4i
```
public static final int mkldnn_gOhIw16o4i
```
  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_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_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_ldigo_p
```
public static final int mkldnn_ldigo_p
```
  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_ldgoi_p
```
public static final int mkldnn_ldgoi_p
```
  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_wino_fmt
```
public static final int mkldnn_wino_fmt
```
  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_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_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_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_relu
```
public static final int mkldnn_relu
```
  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_convolution_relu
```
public static final int mkldnn_convolution_relu
```
  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_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_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_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_omit_stats
```
public static final int mkldnn_omit_stats
```
  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_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_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_eltwise_d
```
public static final int mkldnn_query_eltwise_d
```
  enum mkldnn_query_t
  
  See Also:
  
  Constant Field Values
- mkldnn_query_relu_d
```
public static final int mkldnn_query_relu_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_convolution_relu_d
```
public static final int mkldnn_query_convolution_relu_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_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
- omit_stats
```
public static final int omit_stats
```
  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
- 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
- eltwise_d
```
public static final int eltwise_d
```
  enum mkldnn::query
  
  See Also:
  
  Constant Field Values
- relu_d
```
public static final int relu_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
- convolution_relu_d
```
public static final int convolution_relu_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.mkldnn_primitive_desc_iterator iterator,
                                                                                       mkldnn.const_mkldnn_op_desc_t op_desc,
                                                                                       mkldnn.mkldnn_engine engine,
                                                                                       @Const
                                                                                       mkldnn.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_v2

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_desc_iterator_create_v2(@ByPtrPtr
                                                                                          mkldnn.mkldnn_primitive_desc_iterator iterator,
                                                                                          mkldnn.const_mkldnn_op_desc_t op_desc,
                                                                                          @Const
                                                                                          mkldnn.mkldnn_primitive_attr attr,
                                                                                          mkldnn.mkldnn_engine engine,
                                                                                          @Const
                                                                                          mkldnn.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_next
```
@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_desc_iterator_next(mkldnn.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.mkldnn_primitive_desc mkldnn_primitive_desc_iterator_fetch(@Const
                                                                                mkldnn.mkldnn_primitive_desc_iterator iterator)

Fetches current primitive descriptor. \note fetched primitive descriptor should be deleted by user using mkldnn_primitive_desc_destroy() once becomes unneeded

mkldnn_primitive_desc_iterator_destroy

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_desc_iterator_destroy(mkldnn.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.mkldnn_primitive_desc primitive_desc,
                                                                              mkldnn.const_mkldnn_op_desc_t op_desc,
                                                                              mkldnn.mkldnn_engine engine,
                                                                              @Const
                                                                              mkldnn.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 create a primitive descriptor iterator, instantly fetch a primitive_desc and destroy the iterator.

mkldnn_primitive_desc_create_v2

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_desc_create_v2(@ByPtrPtr
                                                                                 mkldnn.mkldnn_primitive_desc primitive_desc,
                                                                                 mkldnn.const_mkldnn_op_desc_t op_desc,
                                                                                 @Const
                                                                                 mkldnn.mkldnn_primitive_attr attr,
                                                                                 mkldnn.mkldnn_engine engine,
                                                                                 @Const
                                                                                 mkldnn.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 create a primitive descriptor iterator, instantly fetch a \p primitive_desc and destroy the iterator.

mkldnn_primitive_desc_clone

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

Makes a copy of a \p primitive_desc.

mkldnn_primitive_desc_get_attr

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

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

mkldnn_primitive_desc_destroy

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_desc_destroy(mkldnn.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.mkldnn_primitive_desc primitive_desc,
                                                                             @Cast(value="mkldnn_query_t")
                                                                             int what,
                                                                             int index,
                                                                             Pointer result)

Queries primitive descriptor \sa mkldnn_query_t

mkldnn_primitive_desc_query_memory_d

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

Queries primitive descriptor for memory descriptor

Returns:: NULL in case of any error

mkldnn_primitive_desc_query_pd

@Const
public static mkldnn.mkldnn_primitive_desc mkldnn_primitive_desc_query_pd(@Const
                                                                                 mkldnn.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

mkldnn_primitive_desc_query_s32

public static int mkldnn_primitive_desc_query_s32(@Const
                                                  mkldnn.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

mkldnn_primitive_create

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

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

mkldnn_primitive_get_primitive_desc

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

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

mkldnn_primitive_get_input_at

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_get_input_at(@Const
                                                                               mkldnn.mkldnn_primitive primitive,
                                                                               @Cast(value="size_t")
                                                                               long index,
                                                                               mkldnn.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.mkldnn_primitive primitive,
                                                                             @Cast(value="size_t")
                                                                             long index,
                                                                             @Const @ByPtrPtr
                                                                             mkldnn.mkldnn_primitive output)

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

mkldnn_primitive_destroy

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

Deletes a \p primitive.

mkldnn_primitive_at

@ByVal
public static mkldnn.mkldnn_primitive_at_t mkldnn_primitive_at(@Const
                                                                      mkldnn.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 parameters 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.mkldnn_primitive_attr attr)

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

mkldnn_primitive_attr_clone

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

Makes a copy of an \p existing_attr.

mkldnn_primitive_attr_destroy

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_attr_destroy(mkldnn.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.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.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.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.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.mkldnn_primitive_attr attr,
                                                                                         IntPointer count,
                                                                                         IntPointer mask,
                                                                                         @Cast(value="const float**")
                                                                                         PointerPointer scales)

Returns \p count, correspondence scale \p mask, and 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 \p scales array points to the internal \p attr field, so user should not modify/destroy \p scales. \warning The lifetime of \p scales is same as \p attr it belongs to, so it is illegal to use the \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.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.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.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.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 correspondence between output tensor dimensions and the \p 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. \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 user's responsibility to set proper values. The following formula must be hold: \f[count = \prod\limits_{d \in mask} output.dims[d]\f]

mkldnn_primitive_attr_set_output_scales

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_attr_set_output_scales(mkldnn.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.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.mkldnn_primitive_attr attr,
                                                                                    @Const @ByPtrPtr
                                                                                    mkldnn.mkldnn_post_ops post_ops)

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

mkldnn_primitive_attr_set_post_ops

@Cast(value="mkldnn_status_t")
public static int mkldnn_primitive_attr_set_post_ops(mkldnn.mkldnn_primitive_attr attr,
                                                                                    @Const
                                                                                    mkldnn.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 of time there is no way to check whether primitive descriptor does or does not support given sequence of post operations. That means that user should handle an error that might happen at mkldnn_primitive_desc_create call.

mkldnn_post_ops_create

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

Creates an empty sequence of post operations \p post_ops.

mkldnn_post_ops_destroy

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

Deletes a \p post_ops sequence.

mkldnn_post_ops_len

public static int mkldnn_post_ops_len(@Const
                                      mkldnn.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.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.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 the cases like residual learning blocks, where the result of convolution is accumulated to the previously computed activations. Scale parameter \p scale might be extremely 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 op (as well as all the others) disregards the original layout of dst, i.e. the layout of the original dst is expected to be the same as the layout of stored dst.

mkldnn_post_ops_get_params_sum

@Cast(value="mkldnn_status_t")
public static int mkldnn_post_ops_get_params_sum(@Const
                                                                                mkldnn.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 return #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.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.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.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 (\sa 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 given parameters.

mkldnn_post_ops_get_params_eltwise

@Cast(value="mkldnn_status_t")
public static int mkldnn_post_ops_get_params_eltwise(@Const
                                                                                    mkldnn.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.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.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.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.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.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.mkldnn_primitive_desc memory_primitive_desc,
                                                                                     @Const
                                                                                     mkldnn.mkldnn_memory_desc_t memory_desc,
                                                                                     mkldnn.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, initialized with #mkldnn_any.

mkldnn_view_primitive_desc_create

@Cast(value="mkldnn_status_t")
public static int mkldnn_view_primitive_desc_create(@ByPtrPtr
                                                                                   mkldnn.mkldnn_primitive_desc view_primitive_desc,
                                                                                   @Const
                                                                                   mkldnn.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 offset offsets. May fail if layout used does not allow obtain desired view. In this case consider using extract primitive

mkldnn_view_primitive_desc_create

@Cast(value="mkldnn_status_t")
public static int mkldnn_view_primitive_desc_create(@ByPtrPtr
                                                                                   mkldnn.mkldnn_primitive_desc view_primitive_desc,
                                                                                   @Const
                                                                                   mkldnn.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.mkldnn_primitive_desc view_primitive_desc,
                                                                                   @Const
                                                                                   mkldnn.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.mkldnn_primitive_desc lhs,
                                                     @Const
                                                     mkldnn.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.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.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.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.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.mkldnn_primitive_desc reorder_primitive_desc,
                                                                                      @Const
                                                                                      mkldnn.mkldnn_primitive_desc input,
                                                                                      @Const
                                                                                      mkldnn.mkldnn_primitive_desc output)

Initializes a \p reorder_primitive_desc using descriptors of \p input and \p output memory primitives.

mkldnn_reorder_primitive_desc_create_v2

@Cast(value="mkldnn_status_t")
public static int mkldnn_reorder_primitive_desc_create_v2(@ByPtrPtr
                                                                                         mkldnn.mkldnn_primitive_desc reorder_primitive_desc,
                                                                                         @Const
                                                                                         mkldnn.mkldnn_primitive_desc input,
                                                                                         @Const
                                                                                         mkldnn.mkldnn_primitive_desc output,
                                                                                         @Const
                                                                                         mkldnn.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.

mkldnn_concat_primitive_desc_create

@Cast(value="mkldnn_status_t")
public static int mkldnn_concat_primitive_desc_create(@ByPtrPtr
                                                                                     mkldnn.mkldnn_primitive_desc concat_primitive_desc,
                                                                                     @Const
                                                                                     mkldnn.mkldnn_memory_desc_t output_desc,
                                                                                     int n,
                                                                                     int concat_dimension,
                                                                                     @Const @ByPtrPtr
                                                                                     mkldnn.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 be specified with #mkldnn_any format -- in this case appropriate memory format would be chosen automatically.

mkldnn_sum_primitive_desc_create

@Cast(value="mkldnn_status_t")
public static int mkldnn_sum_primitive_desc_create(@ByPtrPtr
                                                                                  mkldnn.mkldnn_primitive_desc sum_primitive_desc,
                                                                                  @Const
                                                                                  mkldnn.mkldnn_memory_desc_t output_desc,
                                                                                  int n,
                                                                                  @Const
                                                                                  FloatPointer scales,
                                                                                  @Const @ByPtrPtr
                                                                                  mkldnn.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 be specified with #mkldnn_any format -- in this case appropriate memory format would be chosen automatically.

mkldnn_sum_primitive_desc_create

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

mkldnn_sum_primitive_desc_create

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

mkldnn_convolution_forward_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_convolution_forward_desc_init(mkldnn.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.mkldnn_memory_desc_t src_desc,
                                                                                      @Const
                                                                                      mkldnn.mkldnn_memory_desc_t weights_desc,
                                                                                      @Const
                                                                                      mkldnn.mkldnn_memory_desc_t bias_desc,
                                                                                      @Const
                                                                                      mkldnn.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 or #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 be either \c NULL or point to a descriptor with memory format equals 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.

mkldnn_convolution_forward_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_convolution_forward_desc_init(mkldnn.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.mkldnn_memory_desc_t src_desc,
                                                                                      @Const
                                                                                      mkldnn.mkldnn_memory_desc_t weights_desc,
                                                                                      @Const
                                                                                      mkldnn.mkldnn_memory_desc_t bias_desc,
                                                                                      @Const
                                                                                      mkldnn.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.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.mkldnn_memory_desc_t src_desc,
                                                                                      @Const
                                                                                      mkldnn.mkldnn_memory_desc_t weights_desc,
                                                                                      @Const
                                                                                      mkldnn.mkldnn_memory_desc_t bias_desc,
                                                                                      @Const
                                                                                      mkldnn.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.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.mkldnn_memory_desc_t src_desc,
                                                                                              @Const
                                                                                              mkldnn.mkldnn_memory_desc_t weights_desc,
                                                                                              @Const
                                                                                              mkldnn.mkldnn_memory_desc_t bias_desc,
                                                                                              @Const
                                                                                              mkldnn.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 or #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 be either \c NULL or point to a descriptor with memory format equals 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.

mkldnn_dilated_convolution_forward_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_dilated_convolution_forward_desc_init(mkldnn.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.mkldnn_memory_desc_t src_desc,
                                                                                              @Const
                                                                                              mkldnn.mkldnn_memory_desc_t weights_desc,
                                                                                              @Const
                                                                                              mkldnn.mkldnn_memory_desc_t bias_desc,
                                                                                              @Const
                                                                                              mkldnn.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.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.mkldnn_memory_desc_t src_desc,
                                                                                              @Const
                                                                                              mkldnn.mkldnn_memory_desc_t weights_desc,
                                                                                              @Const
                                                                                              mkldnn.mkldnn_memory_desc_t bias_desc,
                                                                                              @Const
                                                                                              mkldnn.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.mkldnn_convolution_desc_t conv_desc,
                                                                                            @Cast(value="mkldnn_alg_kind_t")
                                                                                            int alg_kind,
                                                                                            @Const
                                                                                            mkldnn.mkldnn_memory_desc_t diff_src_desc,
                                                                                            @Const
                                                                                            mkldnn.mkldnn_memory_desc_t weights_desc,
                                                                                            @Const
                                                                                            mkldnn.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.

mkldnn_convolution_backward_data_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_convolution_backward_data_desc_init(mkldnn.mkldnn_convolution_desc_t conv_desc,
                                                                                            @Cast(value="mkldnn_alg_kind_t")
                                                                                            int alg_kind,
                                                                                            @Const
                                                                                            mkldnn.mkldnn_memory_desc_t diff_src_desc,
                                                                                            @Const
                                                                                            mkldnn.mkldnn_memory_desc_t weights_desc,
                                                                                            @Const
                                                                                            mkldnn.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.mkldnn_convolution_desc_t conv_desc,
                                                                                            @Cast(value="mkldnn_alg_kind_t")
                                                                                            int alg_kind,
                                                                                            @Const
                                                                                            mkldnn.mkldnn_memory_desc_t diff_src_desc,
                                                                                            @Const
                                                                                            mkldnn.mkldnn_memory_desc_t weights_desc,
                                                                                            @Const
                                                                                            mkldnn.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.mkldnn_convolution_desc_t conv_desc,
                                                                                                    @Cast(value="mkldnn_alg_kind_t")
                                                                                                    int alg_kind,
                                                                                                    @Const
                                                                                                    mkldnn.mkldnn_memory_desc_t diff_src_desc,
                                                                                                    @Const
                                                                                                    mkldnn.mkldnn_memory_desc_t weights_desc,
                                                                                                    @Const
                                                                                                    mkldnn.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.

mkldnn_dilated_convolution_backward_data_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_dilated_convolution_backward_data_desc_init(mkldnn.mkldnn_convolution_desc_t conv_desc,
                                                                                                    @Cast(value="mkldnn_alg_kind_t")
                                                                                                    int alg_kind,
                                                                                                    @Const
                                                                                                    mkldnn.mkldnn_memory_desc_t diff_src_desc,
                                                                                                    @Const
                                                                                                    mkldnn.mkldnn_memory_desc_t weights_desc,
                                                                                                    @Const
                                                                                                    mkldnn.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.mkldnn_convolution_desc_t conv_desc,
                                                                                                    @Cast(value="mkldnn_alg_kind_t")
                                                                                                    int alg_kind,
                                                                                                    @Const
                                                                                                    mkldnn.mkldnn_memory_desc_t diff_src_desc,
                                                                                                    @Const
                                                                                                    mkldnn.mkldnn_memory_desc_t weights_desc,
                                                                                                    @Const
                                                                                                    mkldnn.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.mkldnn_convolution_desc_t conv_desc,
                                                                                               @Cast(value="mkldnn_alg_kind_t")
                                                                                               int alg_kind,
                                                                                               @Const
                                                                                               mkldnn.mkldnn_memory_desc_t src_desc,
                                                                                               @Const
                                                                                               mkldnn.mkldnn_memory_desc_t diff_weights_desc,
                                                                                               @Const
                                                                                               mkldnn.mkldnn_memory_desc_t diff_bias_desc,
                                                                                               @Const
                                                                                               mkldnn.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.

mkldnn_convolution_backward_weights_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_convolution_backward_weights_desc_init(mkldnn.mkldnn_convolution_desc_t conv_desc,
                                                                                               @Cast(value="mkldnn_alg_kind_t")
                                                                                               int alg_kind,
                                                                                               @Const
                                                                                               mkldnn.mkldnn_memory_desc_t src_desc,
                                                                                               @Const
                                                                                               mkldnn.mkldnn_memory_desc_t diff_weights_desc,
                                                                                               @Const
                                                                                               mkldnn.mkldnn_memory_desc_t diff_bias_desc,
                                                                                               @Const
                                                                                               mkldnn.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.mkldnn_convolution_desc_t conv_desc,
                                                                                               @Cast(value="mkldnn_alg_kind_t")
                                                                                               int alg_kind,
                                                                                               @Const
                                                                                               mkldnn.mkldnn_memory_desc_t src_desc,
                                                                                               @Const
                                                                                               mkldnn.mkldnn_memory_desc_t diff_weights_desc,
                                                                                               @Const
                                                                                               mkldnn.mkldnn_memory_desc_t diff_bias_desc,
                                                                                               @Const
                                                                                               mkldnn.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.mkldnn_convolution_desc_t conv_desc,
                                                                                                       @Cast(value="mkldnn_alg_kind_t")
                                                                                                       int alg_kind,
                                                                                                       @Const
                                                                                                       mkldnn.mkldnn_memory_desc_t src_desc,
                                                                                                       @Const
                                                                                                       mkldnn.mkldnn_memory_desc_t diff_weights_desc,
                                                                                                       @Const
                                                                                                       mkldnn.mkldnn_memory_desc_t diff_bias_desc,
                                                                                                       @Const
                                                                                                       mkldnn.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.

mkldnn_dilated_convolution_backward_weights_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_dilated_convolution_backward_weights_desc_init(mkldnn.mkldnn_convolution_desc_t conv_desc,
                                                                                                       @Cast(value="mkldnn_alg_kind_t")
                                                                                                       int alg_kind,
                                                                                                       @Const
                                                                                                       mkldnn.mkldnn_memory_desc_t src_desc,
                                                                                                       @Const
                                                                                                       mkldnn.mkldnn_memory_desc_t diff_weights_desc,
                                                                                                       @Const
                                                                                                       mkldnn.mkldnn_memory_desc_t diff_bias_desc,
                                                                                                       @Const
                                                                                                       mkldnn.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.mkldnn_convolution_desc_t conv_desc,
                                                                                                       @Cast(value="mkldnn_alg_kind_t")
                                                                                                       int alg_kind,
                                                                                                       @Const
                                                                                                       mkldnn.mkldnn_memory_desc_t src_desc,
                                                                                                       @Const
                                                                                                       mkldnn.mkldnn_memory_desc_t diff_weights_desc,
                                                                                                       @Const
                                                                                                       mkldnn.mkldnn_memory_desc_t diff_bias_desc,
                                                                                                       @Const
                                                                                                       mkldnn.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.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.mkldnn_memory_desc_t src_desc,
                                                                                        @Const
                                                                                        mkldnn.mkldnn_memory_desc_t weights_desc,
                                                                                        @Const
                                                                                        mkldnn.mkldnn_memory_desc_t bias_desc,
                                                                                        @Const
                                                                                        mkldnn.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 or #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 be either \c NULL or point to a descriptor with memory format equals 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.

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.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.mkldnn_memory_desc_t src_desc,
                                                                                        @Const
                                                                                        mkldnn.mkldnn_memory_desc_t weights_desc,
                                                                                        @Const
                                                                                        mkldnn.mkldnn_memory_desc_t bias_desc,
                                                                                        @Const
                                                                                        mkldnn.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.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.mkldnn_memory_desc_t src_desc,
                                                                                        @Const
                                                                                        mkldnn.mkldnn_memory_desc_t weights_desc,
                                                                                        @Const
                                                                                        mkldnn.mkldnn_memory_desc_t bias_desc,
                                                                                        @Const
                                                                                        mkldnn.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_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.mkldnn_convolution_desc_t conv_desc,
                                                                                              @Cast(value="mkldnn_alg_kind_t")
                                                                                              int alg_kind,
                                                                                              @Const
                                                                                              mkldnn.mkldnn_memory_desc_t diff_src_desc,
                                                                                              @Const
                                                                                              mkldnn.mkldnn_memory_desc_t weights_desc,
                                                                                              @Const
                                                                                              mkldnn.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.

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.mkldnn_convolution_desc_t conv_desc,
                                                                                              @Cast(value="mkldnn_alg_kind_t")
                                                                                              int alg_kind,
                                                                                              @Const
                                                                                              mkldnn.mkldnn_memory_desc_t diff_src_desc,
                                                                                              @Const
                                                                                              mkldnn.mkldnn_memory_desc_t weights_desc,
                                                                                              @Const
                                                                                              mkldnn.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.mkldnn_convolution_desc_t conv_desc,
                                                                                              @Cast(value="mkldnn_alg_kind_t")
                                                                                              int alg_kind,
                                                                                              @Const
                                                                                              mkldnn.mkldnn_memory_desc_t diff_src_desc,
                                                                                              @Const
                                                                                              mkldnn.mkldnn_memory_desc_t weights_desc,
                                                                                              @Const
                                                                                              mkldnn.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_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.mkldnn_convolution_desc_t conv_desc,
                                                                                                 @Cast(value="mkldnn_alg_kind_t")
                                                                                                 int alg_kind,
                                                                                                 @Const
                                                                                                 mkldnn.mkldnn_memory_desc_t src_desc,
                                                                                                 @Const
                                                                                                 mkldnn.mkldnn_memory_desc_t diff_weights_desc,
                                                                                                 @Const
                                                                                                 mkldnn.mkldnn_memory_desc_t diff_bias_desc,
                                                                                                 @Const
                                                                                                 mkldnn.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.

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.mkldnn_convolution_desc_t conv_desc,
                                                                                                 @Cast(value="mkldnn_alg_kind_t")
                                                                                                 int alg_kind,
                                                                                                 @Const
                                                                                                 mkldnn.mkldnn_memory_desc_t src_desc,
                                                                                                 @Const
                                                                                                 mkldnn.mkldnn_memory_desc_t diff_weights_desc,
                                                                                                 @Const
                                                                                                 mkldnn.mkldnn_memory_desc_t diff_bias_desc,
                                                                                                 @Const
                                                                                                 mkldnn.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.mkldnn_convolution_desc_t conv_desc,
                                                                                                 @Cast(value="mkldnn_alg_kind_t")
                                                                                                 int alg_kind,
                                                                                                 @Const
                                                                                                 mkldnn.mkldnn_memory_desc_t src_desc,
                                                                                                 @Const
                                                                                                 mkldnn.mkldnn_memory_desc_t diff_weights_desc,
                                                                                                 @Const
                                                                                                 mkldnn.mkldnn_memory_desc_t diff_bias_desc,
                                                                                                 @Const
                                                                                                 mkldnn.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_eltwise_forward_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_eltwise_forward_desc_init(mkldnn.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.mkldnn_memory_desc_t data_desc,
                                                                                  float alpha,
                                                                                  float beta)

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

mkldnn_eltwise_backward_desc_init

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

Initializes a \p eltwise_desc for backward propagation using \p alg_kind algorithm memory descriptors \p diff_data_desc and \p data_desc, and \p alpha, \p beta parameters. \sa mkldnn_eltwise_desc_t for details

mkldnn_relu_forward_desc_init

@Cast(value="mkldnn_status_t")
 @Deprecated
public static int mkldnn_relu_forward_desc_init(@Cast(value="mkldnn_relu_desc_t*")
                                                                                            mkldnn.mkldnn_eltwise_desc_t relu_desc,
                                                                                            @Cast(value="mkldnn_prop_kind_t")
                                                                                            int prop_kind,
                                                                                            @Const
                                                                                            mkldnn.mkldnn_memory_desc_t data_desc,
                                                                                            float negative_slope)

Deprecated. use mkldnn_eltwise_forward_desc_init() instead, with \p alpha equals \p negative_slope

Initializes a \p relu_desc for forward propagation using \p prop_kind (possible values are #mkldnn_forward_training or #mkldnn_forward_inference), \p negative_slope and memory descriptor \p data_desc.

mkldnn_relu_backward_desc_init

@Cast(value="mkldnn_status_t")
 @Deprecated
public static int mkldnn_relu_backward_desc_init(@Cast(value="mkldnn_relu_desc_t*")
                                                                                             mkldnn.mkldnn_eltwise_desc_t relu_desc,
                                                                                             @Const
                                                                                             mkldnn.mkldnn_memory_desc_t diff_data_desc,
                                                                                             @Const
                                                                                             mkldnn.mkldnn_memory_desc_t data_desc,
                                                                                             float negative_slope)

Deprecated. use mkldnn_eltwise_backward_desc_init() instead, with \p alpha equals \p negative_slope

Initializes a \p relu_desc for backward propagation using \p negative_slope and memory descriptors \p diff_data_desc and \p data_desc.

mkldnn_softmax_forward_desc_init

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

Initializes a \p softmax_desc for forward propagation using \p prop_kind (possible value are #mkldnn_forward_training or #mkldnn_forward_inference) and memory descriptor \p data_desc.

mkldnn_softmax_backward_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_softmax_backward_desc_init(mkldnn.mkldnn_softmax_desc_t softmax_desc,
                                                                                   @Const
                                                                                   mkldnn.mkldnn_memory_desc_t diff_desc,
                                                                                   @Const
                                                                                   mkldnn.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.

mkldnn_pooling_forward_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_pooling_forward_desc_init(mkldnn.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.mkldnn_memory_desc_t src_desc,
                                                                                  @Const
                                                                                  mkldnn.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 or #mkldnn_forward_inference), \p alg_kind, memory descriptors, and pooling parameters in 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 \todo clarify!

mkldnn_pooling_forward_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_pooling_forward_desc_init(mkldnn.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.mkldnn_memory_desc_t src_desc,
                                                                                  @Const
                                                                                  mkldnn.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.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.mkldnn_memory_desc_t src_desc,
                                                                                  @Const
                                                                                  mkldnn.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.mkldnn_pooling_desc_t pool_desc,
                                                                                   @Cast(value="mkldnn_alg_kind_t")
                                                                                   int alg_kind,
                                                                                   @Const
                                                                                   mkldnn.mkldnn_memory_desc_t diff_src_desc,
                                                                                   @Const
                                                                                   mkldnn.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 spatial domain: \p strides, \p kernel sizes, \p padding_l, \p padding_r, and \p padding_kind. \todo clarify!

mkldnn_pooling_backward_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_pooling_backward_desc_init(mkldnn.mkldnn_pooling_desc_t pool_desc,
                                                                                   @Cast(value="mkldnn_alg_kind_t")
                                                                                   int alg_kind,
                                                                                   @Const
                                                                                   mkldnn.mkldnn_memory_desc_t diff_src_desc,
                                                                                   @Const
                                                                                   mkldnn.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.mkldnn_pooling_desc_t pool_desc,
                                                                                   @Cast(value="mkldnn_alg_kind_t")
                                                                                   int alg_kind,
                                                                                   @Const
                                                                                   mkldnn.mkldnn_memory_desc_t diff_src_desc,
                                                                                   @Const
                                                                                   mkldnn.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.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.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 or #mkldnn_forward_inference), \p alg_kind, memory descriptor \p data_desc, and regularization parameters \p local_size, \p alpha, \p beta, and \p k.

mkldnn_lrn_backward_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_lrn_backward_desc_init(mkldnn.mkldnn_lrn_desc_t lrn_desc,
                                                                               @Cast(value="mkldnn_alg_kind_t")
                                                                               int alg_kind,
                                                                               @Const
                                                                               mkldnn.mkldnn_memory_desc_t diff_data_desc,
                                                                               @Const
                                                                               mkldnn.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.

mkldnn_batch_normalization_forward_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_batch_normalization_forward_desc_init(mkldnn.mkldnn_batch_normalization_desc_t bnrm_desc,
                                                                                              @Cast(value="mkldnn_prop_kind_t")
                                                                                              int prop_kind,
                                                                                              @Const
                                                                                              mkldnn.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 or #mkldnn_forward_inference), memory descriptor \p data_desc, normalization parameter \p epsilon and flags (possible values are #mkldnn_use_global_stats and #mkldnn_use_scaleshift). \sa 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.mkldnn_batch_normalization_desc_t bnrm_desc,
                                                                                               @Cast(value="mkldnn_prop_kind_t")
                                                                                               int prop_kind,
                                                                                               @Const
                                                                                               mkldnn.mkldnn_memory_desc_t diff_data_desc,
                                                                                               @Const
                                                                                               mkldnn.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, and normalization parameter \p epsilon and flags (possible values are #mkldnn_use_global_stats and #mkldnn_use_scaleshift). \sa 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.mkldnn_inner_product_desc_t ip_desc,
                                                                                        @Cast(value="mkldnn_prop_kind_t")
                                                                                        int prop_kind,
                                                                                        @Const
                                                                                        mkldnn.mkldnn_memory_desc_t src_desc,
                                                                                        @Const
                                                                                        mkldnn.mkldnn_memory_desc_t weights_desc,
                                                                                        @Const
                                                                                        mkldnn.mkldnn_memory_desc_t bias_desc,
                                                                                        @Const
                                                                                        mkldnn.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 or #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 descriptor with memory format equals to #mkldnn_format_undef. \note memory descriptors are allowed to be initialized with #mkldnn_any value of \p format_kind.

mkldnn_inner_product_backward_data_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_inner_product_backward_data_desc_init(mkldnn.mkldnn_inner_product_desc_t ip_desc,
                                                                                              @Const
                                                                                              mkldnn.mkldnn_memory_desc_t diff_src_desc,
                                                                                              @Const
                                                                                              mkldnn.mkldnn_memory_desc_t weights_desc,
                                                                                              @Const
                                                                                              mkldnn.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.

mkldnn_inner_product_backward_weights_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_inner_product_backward_weights_desc_init(mkldnn.mkldnn_inner_product_desc_t ip_desc,
                                                                                                 @Const
                                                                                                 mkldnn.mkldnn_memory_desc_t src_desc,
                                                                                                 @Const
                                                                                                 mkldnn.mkldnn_memory_desc_t diff_weights_desc,
                                                                                                 @Const
                                                                                                 mkldnn.mkldnn_memory_desc_t diff_bias_desc,
                                                                                                 @Const
                                                                                                 mkldnn.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.

mkldnn_convolution_relu_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_convolution_relu_desc_init(mkldnn.mkldnn_convolution_relu_desc_t conv_relu_desc,
                                                                                   @Const
                                                                                   mkldnn.mkldnn_convolution_desc_t conv_desc,
                                                                                   float negative_slope)

Deprecated. use mkldnn_convolution_desc_init with mkldnn_post_ops_append_eltwise to append ReLU

Initializes a merged convolution-relu descriptor \p conv_relu_desc for forward propagation (supported inference mode only) using convolution descriptor \p conv_desc and ReLU parameter \p negative slope.

mkldnn_rnn_cell_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_rnn_cell_desc_init(mkldnn.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, #mkldnn_gru_linear_before_reset), \p f (possible values are #mkldnn_eltwise_relu, #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.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.mkldnn_rnn_cell_desc_t rnn_cell_desc)

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

mkldnn_rnn_forward_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_rnn_forward_desc_init(mkldnn.mkldnn_rnn_desc_t rnn_desc,
                                                                              @Cast(value="mkldnn_prop_kind_t")
                                                                              int prop_kind,
                                                                              @Const
                                                                              mkldnn.mkldnn_rnn_cell_desc_t rnn_cell_desc,
                                                                              @Cast(value="const mkldnn_rnn_direction_t")
                                                                              int direction,
                                                                              @Const
                                                                              mkldnn.mkldnn_memory_desc_t src_layer_desc,
                                                                              @Const
                                                                              mkldnn.mkldnn_memory_desc_t src_iter_desc,
                                                                              @Const
                                                                              mkldnn.mkldnn_memory_desc_t weights_layer_desc,
                                                                              @Const
                                                                              mkldnn.mkldnn_memory_desc_t weights_iter_desc,
                                                                              @Const
                                                                              mkldnn.mkldnn_memory_desc_t bias_desc,
                                                                              @Const
                                                                              mkldnn.mkldnn_memory_desc_t dst_layer_desc,
                                                                              @Const
                                                                              mkldnn.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 need to query a worskpace memory descriptor before creating the primitive. \note all memory descriptors except \p src_iter_desc are allowed to be initialized with #mkldnn_any value of \p format_kind.

mkldnn_rnn_backward_desc_init

@Cast(value="mkldnn_status_t")
public static int mkldnn_rnn_backward_desc_init(mkldnn.mkldnn_rnn_desc_t rnn_desc,
                                                                               @Cast(value="mkldnn_prop_kind_t")
                                                                               int prop_kind,
                                                                               @Const
                                                                               mkldnn.mkldnn_rnn_cell_desc_t rnn_cell_desc,
                                                                               @Cast(value="const mkldnn_rnn_direction_t")
                                                                               int direction,
                                                                               @Const
                                                                               mkldnn.mkldnn_memory_desc_t src_layer_desc,
                                                                               @Const
                                                                               mkldnn.mkldnn_memory_desc_t src_iter_desc,
                                                                               @Const
                                                                               mkldnn.mkldnn_memory_desc_t weights_layer_desc,
                                                                               @Const
                                                                               mkldnn.mkldnn_memory_desc_t weights_iter_desc,
                                                                               @Const
                                                                               mkldnn.mkldnn_memory_desc_t bias_desc,
                                                                               @Const
                                                                               mkldnn.mkldnn_memory_desc_t dst_layer_desc,
                                                                               @Const
                                                                               mkldnn.mkldnn_memory_desc_t dst_iter_desc,
                                                                               @Const
                                                                               mkldnn.mkldnn_memory_desc_t diff_src_layer_desc,
                                                                               @Const
                                                                               mkldnn.mkldnn_memory_desc_t diff_src_iter_desc,
                                                                               @Const
                                                                               mkldnn.mkldnn_memory_desc_t diff_weights_layer_desc,
                                                                               @Const
                                                                               mkldnn.mkldnn_memory_desc_t diff_weights_iter_desc,
                                                                               @Const
                                                                               mkldnn.mkldnn_memory_desc_t diff_bias_desc,
                                                                               @Const
                                                                               mkldnn.mkldnn_memory_desc_t diff_dst_layer,
                                                                               @Const
                                                                               mkldnn.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.

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.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_get_kind

@Cast(value="mkldnn_status_t")
public static int mkldnn_engine_get_kind(mkldnn.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.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.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.mkldnn_engine engine)

Destroys an \p engine.

mkldnn_stream_create

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

Creates an execution \p stream of \p stream_kind.

mkldnn_stream_submit

@Cast(value="mkldnn_status_t")
public static int mkldnn_stream_submit(mkldnn.mkldnn_stream stream,
                                                                      @Cast(value="size_t")
                                                                      long n,
                                                                      @ByPtrPtr
                                                                      mkldnn.mkldnn_primitive primitives,
                                                                      @ByPtrPtr
                                                                      mkldnn.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_wait

@Cast(value="mkldnn_status_t")
public static int mkldnn_stream_wait(mkldnn.mkldnn_stream stream,
                                                                    int block,
                                                                    @ByPtrPtr
                                                                    mkldnn.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_rerun

@Cast(value="mkldnn_status_t")
public static int mkldnn_stream_rerun(mkldnn.mkldnn_stream stream,
                                                                     @ByPtrPtr
                                                                     mkldnn.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_destroy

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

Destroys an execution \p stream.

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

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 API is different compared to standard BLAS routine as 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)

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)

zero_md

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

null_memory

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

check_num_parameters

@Namespace(value="mkldnn")
public static void check_num_parameters(@Const
                                                                   mkldnn.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.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.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

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.bytedeco.javacpp.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_nchw

mkldnn_nhwc

mkldnn_chwn

mkldnn_nChw8c

mkldnn_nChw16c

mkldnn_ncdhw

mkldnn_ndhwc

mkldnn_nCdhw16c

mkldnn_oi

mkldnn_io

mkldnn_oihw

mkldnn_ihwo

mkldnn_hwio

mkldnn_dhwio

mkldnn_oidhw

mkldnn_OIdhw16i16o

mkldnn_OIdhw16o16i

mkldnn_Oidhw16o

mkldnn_Odhwi16o

mkldnn_OIhw8i8o

mkldnn_OIhw16i16o

mkldnn_OIhw4i16o4i

mkldnn_OIhw8i16o2i

mkldnn_OIdhw8i16o2i

mkldnn_OIhw8o16i2o

mkldnn_OIhw8o8i

mkldnn_OIhw16o16i

mkldnn_IOhw16o16i

mkldnn_Oihw8o

mkldnn_Oihw16o

mkldnn_Ohwi8o

mkldnn_Ohwi16o

mkldnn_OhIw16o4i

mkldnn_goihw

mkldnn_hwigo

mkldnn_gOIhw8i8o

mkldnn_gOIhw16i16o

mkldnn_gOIhw4i16o4i

mkldnn_gOIhw8i16o2i

mkldnn_gOIdhw8i16o2i

mkldnn_gOIhw8o16i2o

mkldnn_gOIhw8o8i

mkldnn_gOIhw16o16i

mkldnn_gIOhw16o16i

mkldnn_gOihw8o

mkldnn_gOihw16o

mkldnn_gOhwi8o

mkldnn_gOhwi16o

mkldnn_Goihw8g

mkldnn_Goihw16g