/******************************************************************************* * Copyright 2016-2018 Intel Corporation * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. *******************************************************************************/ #ifndef MKLDNN_HPP #define MKLDNN_HPP #ifndef DOXYGEN_SHOULD_SKIP_THIS #include #include #include #include #include #include #include "mkldnn.h" #endif namespace mkldnn { /// @addtogroup cpp_api C++ API /// @{ /// @addtogroup cpp_api_utils Utils /// @{ /// A class that provides the destructor for an Intel(R) MKL-DNN C handle template class handle_traits {}; /// A class for wrapping an Intel(R) MKL-DNN handle. It is used as the base /// class for primitive (#mkldnn_primitive_t), engine (#mkldnn_engine_t), and /// stream (#mkldnn_stream_t) handles. An object of the #mkldnn::handle class /// can be passed by value. This class enables wrapping: /// - Newly constructed handles. /// @n In this case, the constructed handle uses reference counting provided /// by @p std::shared_ptr with a proper deleter function specified through /// the @p handle_traits class. /// - Pre-existing handles returned by the Intel(R) MKL-DNN C API (for /// example, through mkldnn_primitive_get_primitive_desc()). /// @n In this case, an Intel(R) MKL-DNN C API handle is wrapped without a /// deleter because it is assumed that the handle wrapper for the original /// object deletes the handle (this model is similar to @p std::weak_ptr). template > class handle { private: std::shared_ptr::type> _data; handle(const handle &&) = delete; handle &operator=(const handle &&other) = delete; protected: bool operator==(const T other) const { return other == _data.get(); } bool operator!=(const T other) const { return !(*this == other); } public: /// Constructs a C handle wrapper. /// @param t The C handle to wrap. /// @param weak A flag to specify whether to construct a weak wrapper. handle(T t = 0, bool weak = false): _data(0) { reset(t, weak); } handle(const handle &other): _data(other._data) {} handle &operator=(const handle &other) { _data = other._data; return *this; } /// Resets the value of a C handle. /// @param t The new value of the C handle. /// @param weak A flag to specify whether the wrapper should be weak. void reset(T t, bool weak = false) { auto dummy_destructor = [](T) { return decltype(traits::destructor(0))(0); }; _data.reset(t, weak ? dummy_destructor : traits::destructor); } /// Returns the value of the underlying C handle. T get() const { return _data.get(); } bool operator==(const handle &other) const { return other._data.get() == _data.get(); } bool operator!=(const handle &other) const { return !(*this == other); } }; #ifndef DOXYGEN_SHOULD_SKIP_THIS template <> struct handle_traits { static constexpr auto destructor = &mkldnn_memory_destroy; }; template <> struct handle_traits { static constexpr auto destructor = &mkldnn_primitive_desc_destroy; }; template <> struct handle_traits { static constexpr auto destructor = &mkldnn_primitive_destroy; }; template <> struct handle_traits { static constexpr auto destructor = &mkldnn_primitive_desc_iterator_destroy; }; #endif struct memory; struct primitive_desc; /// Base class for all computational primitives. class primitive: public handle { friend struct error; friend struct stream; using handle::handle; public: /// A proxy to C primitive kind enum enum class kind { undefined_primitive = mkldnn_undefined_primitive, reorder = mkldnn_reorder, concat = mkldnn_concat, sum = mkldnn_sum, convolution = mkldnn_convolution, deconvolution = mkldnn_deconvolution, shuffle = mkldnn_shuffle, eltwise = mkldnn_eltwise, softmax = mkldnn_softmax, pooling = mkldnn_pooling, lrn = mkldnn_lrn, batch_normalization = mkldnn_batch_normalization, inner_product = mkldnn_inner_product, rnn = mkldnn_rnn, }; primitive(const_mkldnn_primitive_desc_t c_pd); primitive(const primitive_desc &pd); /// Returns the descriptor of the underlying C API primitive. inline const_mkldnn_primitive_desc_t get_primitive_desc() const; // TODO: use the C++ API wrapper structure. void execute(struct stream &astream, const std::unordered_map &args) const; }; inline mkldnn_primitive_kind_t convert_to_c(primitive::kind akind) { return static_cast(akind); } /// Intel(R) MKL-DNN exception class. /// /// This class captures the status returned by the failed C API function, error /// message, and, optionally, handle of the primitive that caused the error. struct error: public std::exception { mkldnn_status_t status; const char *message; /// Constructs an error instance. /// /// @param astatus The error status returned by the C API. /// @param amessage The error message. error(mkldnn_status_t astatus, const char *amessage) : status(astatus), message(amessage) {} /// A convenience function for wrapping calls to the C API. Checks the /// return status and throws an #error in case of failure. /// /// @param status The error status returned by the C API. /// @param message The error message. static void wrap_c_api(mkldnn_status_t status, const char *message) { if (status != mkldnn_success) throw error(status, message); } }; const_mkldnn_primitive_desc_t primitive::get_primitive_desc() const { const_mkldnn_primitive_desc_t pd; error::wrap_c_api(mkldnn_primitive_get_primitive_desc(get(), &pd), "could not get primitive descriptor by primitive"); return pd; } /// @} /// @addtogroup cpp_api_enums Common data types and enumerations /// A proxy to @ref c_api_types in @ref c_api. /// /// @{ enum scratchpad_mode { scratchpad_mode_library = mkldnn_scratchpad_mode_library, scratchpad_mode_user = mkldnn_scratchpad_mode_user, }; inline mkldnn_scratchpad_mode_t convert_to_c(scratchpad_mode mode) { return static_cast(mode); } enum padding_kind { zero = mkldnn_padding_zero }; inline mkldnn_padding_kind_t convert_to_c(padding_kind kind) { return static_cast(kind); } enum prop_kind { forward_training = mkldnn_forward_training, forward_scoring = mkldnn_forward_scoring, forward_inference = mkldnn_forward_inference, forward = mkldnn_forward, backward = mkldnn_backward, backward_data = mkldnn_backward_data, backward_weights = mkldnn_backward_weights, backward_bias = mkldnn_backward_bias }; inline mkldnn_prop_kind_t convert_to_c(prop_kind kind) { return static_cast(kind); } enum algorithm { algorithm_undef = mkldnn_alg_kind_undef, convolution_auto = mkldnn_convolution_auto, convolution_direct = mkldnn_convolution_direct, convolution_winograd = mkldnn_convolution_winograd, deconvolution_direct = mkldnn_deconvolution_direct, deconvolution_winograd = mkldnn_deconvolution_winograd, eltwise_relu = mkldnn_eltwise_relu, eltwise_tanh = mkldnn_eltwise_tanh, eltwise_elu = mkldnn_eltwise_elu, eltwise_square = mkldnn_eltwise_square, eltwise_abs = mkldnn_eltwise_abs, eltwise_sqrt = mkldnn_eltwise_sqrt, eltwise_linear = mkldnn_eltwise_linear, eltwise_bounded_relu = mkldnn_eltwise_bounded_relu, eltwise_soft_relu = mkldnn_eltwise_soft_relu, eltwise_logistic = mkldnn_eltwise_logistic, lrn_across_channels = mkldnn_lrn_across_channels, lrn_within_channel = mkldnn_lrn_within_channel, pooling_max = mkldnn_pooling_max, pooling_avg = mkldnn_pooling_avg, pooling_avg_include_padding = mkldnn_pooling_avg_include_padding, pooling_avg_exclude_padding = mkldnn_pooling_avg_exclude_padding, vanilla_rnn = mkldnn_vanilla_rnn, vanilla_lstm = mkldnn_vanilla_lstm, vanilla_gru = mkldnn_vanilla_gru, gru_linear_before_reset = mkldnn_gru_linear_before_reset }; inline mkldnn_alg_kind_t convert_to_c(algorithm aalgorithm) { return static_cast(aalgorithm); } enum batch_normalization_flag { use_global_stats = mkldnn_use_global_stats, use_scale_shift = mkldnn_use_scaleshift, fuse_bn_relu = mkldnn_fuse_bn_relu }; inline mkldnn_batch_normalization_flag_t convert_to_c( batch_normalization_flag aflag) { return static_cast(aflag); } enum rnn_direction { unidirectional_left2right = mkldnn_unidirectional_left2right, unidirectional_right2left = mkldnn_unidirectional_right2left, unidirectional = mkldnn_unidirectional, bidirectional_concat = mkldnn_bidirectional_concat, bidirectional_sum = mkldnn_bidirectional_sum, }; inline mkldnn_rnn_direction_t convert_to_c(rnn_direction adir) { return static_cast(adir); } enum query { undef = mkldnn_query_undef, query_engine = mkldnn_query_engine, primitive_kind = mkldnn_query_primitive_kind, num_of_inputs_s32 = mkldnn_query_num_of_inputs_s32, num_of_outputs_s32 = mkldnn_query_num_of_outputs_s32, time_estimate_f64 = mkldnn_query_time_estimate_f64, memory_consumption_s64 = mkldnn_query_memory_consumption_s64, query_scratchpad_engine = mkldnn_query_scratchpad_engine, impl_info_str = mkldnn_query_impl_info_str, op_d = mkldnn_query_op_d, convolution_d = mkldnn_query_convolution_d, deconvolution_d = mkldnn_query_deconvolution_d, shuffle_d = mkldnn_query_shuffle_d, eltwise_d = mkldnn_query_eltwise_d, softmax_d = mkldnn_query_softmax_d, pooling_d = mkldnn_query_pooling_d, lrn_d = mkldnn_query_lrn_d, batch_normalization_d = mkldnn_query_batch_normalization_d, inner_product_d = mkldnn_query_inner_product_d, rnn_d = mkldnn_query_rnn_d, src_md = mkldnn_query_src_md, diff_src_md = mkldnn_query_diff_src_md, weights_md = mkldnn_query_weights_md, diff_weights_md = mkldnn_query_diff_weights_md, dst_md = mkldnn_query_dst_md, diff_dst_md = mkldnn_query_diff_dst_md, workspace_md = mkldnn_query_workspace_md, scratchpad_md = mkldnn_query_scratchpad_md, }; inline mkldnn_query_t convert_to_c(query aquery) { return static_cast(aquery); } /// @} /// @addtogroup cpp_api_attr Attributes /// An extension for controlling primitive behavior. /// /// @sa @ref c_api_attributes in @ref c_api /// @{ #ifndef DOXYGEN_SHOULD_SKIP_THIS template <> struct handle_traits { static constexpr auto destructor = &mkldnn_post_ops_destroy; }; #endif struct post_ops: public handle { post_ops() { mkldnn_post_ops_t result; error::wrap_c_api(mkldnn_post_ops_create(&result), "could not create post operation sequence"); reset(result); } int len() const { return mkldnn_post_ops_len(get()); } primitive::kind kind(int index) const { error::wrap_c_api( index < len() ? mkldnn_success : mkldnn_invalid_arguments, "post_ops index is out of range"); return static_cast(mkldnn_post_ops_get_kind(get(), index)); } void append_sum(float scale = 1.) { error::wrap_c_api(mkldnn_post_ops_append_sum(get(), scale), "could not append sum"); } void get_params_sum(int index, float &scale) const { error::wrap_c_api(mkldnn_post_ops_get_params_sum(get(), index, &scale), "could not get sum params"); } void append_eltwise(float scale, algorithm alg, float alpha, float beta) { error::wrap_c_api(mkldnn_post_ops_append_eltwise(get(), scale, convert_to_c(alg), alpha, beta), "could not append eltwise"); } void get_params_eltwise(int index, float &scale, algorithm &alg, float &alpha, float &beta) const { mkldnn_alg_kind_t c_alg; error::wrap_c_api(mkldnn_post_ops_get_params_eltwise(get(), index, &scale, &c_alg, &alpha, &beta), "could not get eltwise params"); alg = static_cast(c_alg); } }; #ifndef DOXYGEN_SHOULD_SKIP_THIS template <> struct handle_traits { static constexpr auto destructor = &mkldnn_primitive_attr_destroy; }; #endif struct primitive_attr: public handle { primitive_attr() { mkldnn_primitive_attr_t result; error::wrap_c_api(mkldnn_primitive_attr_create(&result), "could not create a primitive attr"); reset(result); } scratchpad_mode get_scratchpad_mode() const { mkldnn_scratchpad_mode_t result; error::wrap_c_api(mkldnn_primitive_attr_get_scratchpad_mode( get(), &result), "could not get scratchpad mode"); return scratchpad_mode(result); } void set_scratchpad_mode(scratchpad_mode mode) { error::wrap_c_api(mkldnn_primitive_attr_set_scratchpad_mode( get(), mkldnn::convert_to_c(mode)), "could not set scratchpad mode"); } void get_output_scales(int &mask, std::vector &scales) const { mkldnn_dim_t count; int c_mask; const float *c_scales; error::wrap_c_api(mkldnn_primitive_attr_get_output_scales(get(), &count, &c_mask, &c_scales), "could not get int output scales"); scales.resize(count); mask = c_mask; for (mkldnn_dim_t c = 0; c < count; ++c) scales[c] = c_scales[c]; } void set_output_scales(int mask, const std::vector &scales) { error::wrap_c_api(mkldnn_primitive_attr_set_output_scales(get(), (mkldnn_dim_t)scales.size(), mask, &scales[0]), "could not set int output scales"); } const post_ops get_post_ops() const { post_ops result; const_mkldnn_post_ops_t c_result; error::wrap_c_api(mkldnn_primitive_attr_get_post_ops(get(), &c_result), "could not get post operation sequence"); result.reset(const_cast(c_result), true); return result; } void set_post_ops(post_ops ops) { error::wrap_c_api(mkldnn_primitive_attr_set_post_ops(get(), ops.get()), "could not set post operation sequence"); } void set_rnn_data_qparams(const float scale, const float shift) { error::wrap_c_api(mkldnn_primitive_attr_set_rnn_data_qparams(get(), scale, shift), "could not set rnn data int scale/shift"); } void set_rnn_weights_qparams(int mask, const std::vector &scales) { error::wrap_c_api(mkldnn_primitive_attr_set_rnn_weights_qparams(get(), (int)scales.size(), mask, &scales[0]), "could not set rnn weights int scales"); } }; /// @} /// @addtogroup cpp_api_engine Engine /// Engine operations. /// /// @sa @ref c_api_engine in @ref c_api /// @{ #ifndef DOXYGEN_SHOULD_SKIP_THIS template <> struct handle_traits { static constexpr auto destructor = &mkldnn_engine_destroy; }; #endif /// An execution engine. struct engine: public handle { friend class primitive; // gcc bug??? using handle::handle; /// Kinds of engines. enum kind { /// An unspecified engine any = mkldnn_any_engine, /// CPU engine cpu = mkldnn_cpu, }; /// Returns the number of engines of a certain kind. /// /// @param akind The kind of engines to count. static size_t get_count(kind akind) { return mkldnn_engine_get_count(convert_to_c(akind)); } /// Constructs an engine. /// /// @param akind The kind of engine to construct. /// @param index The index of the engine. Must be less than the value /// returned by #get_count() for this particular kind of engine. engine(kind akind, size_t index) { mkldnn_engine_t aengine; error::wrap_c_api( mkldnn_engine_create(&aengine, convert_to_c(akind), index), "could not create an engine"); reset(aengine); } explicit engine(const mkldnn_engine_t& aengine) : handle(aengine, true) {} engine(const handle &pd) { mkldnn_engine_t engine_q; error::wrap_c_api( mkldnn_primitive_desc_query(pd.get(), mkldnn::convert_to_c(query_engine), 0, &engine_q), "could not get engine from primitive_desc"); reset(engine_q, true); } template static engine query(const primitive_desc &pd) { mkldnn_engine_t engine_q; error::wrap_c_api( mkldnn_primitive_desc_query(pd.get(), mkldnn::convert_to_c(query_engine), 0, &engine_q), "could not get engine from primitive_desc"); return engine(engine_q); } private: static mkldnn_engine_kind_t convert_to_c(kind akind) { return static_cast(akind); } }; /// @} /// @addtogroup cpp_api_stream Stream /// Execution stream operations /// /// @sa @ref c_api_stream in @ref c_api /// @{ #ifndef DOXYGEN_SHOULD_SKIP_THIS template <> struct handle_traits { static constexpr auto destructor = &mkldnn_stream_destroy; }; #endif struct stream: public handle { using handle::handle; enum: unsigned { default_flags = mkldnn_stream_default_flags, }; /// Constructs a stream. stream(const engine &aengine, unsigned flags = static_cast(default_flags)) { mkldnn_stream_t astream; error::wrap_c_api(mkldnn_stream_create(&astream, aengine.get(), flags), "could not create a stream"); reset(astream); } }; /// @} /// @addtogroup cpp_api_memory_related Memory and memory related operations /// @{ /// @addtogroup cpp_api_memory Memory /// A primitive to describe and store data. /// /// For more information, refer to @ref c_api_memory in @ref c_api. /// @{ /// Memory that describes the data. struct memory: public handle { public: typedef mkldnn_dim_t dim; typedef std::vector dims; template static void validate_dims(const std::vector &v) { if (v.size() > MKLDNN_MAX_NDIMS) throw error(mkldnn_invalid_arguments, "invalid dimensions"); } /// Data type specification. See #mkldnn_data_type_t for a detailed /// description. enum data_type { data_undef = mkldnn_data_type_undef, f32 = mkldnn_f32, s32 = mkldnn_s32, s8 = mkldnn_s8, u8 = mkldnn_u8, }; /// Memory format tag specification. See #mkldnn_format_tag_t /// for a detailed description. enum format_tag { format_tag_undef = mkldnn_format_tag_undef, any = mkldnn_format_tag_any, a = mkldnn_a, ab = mkldnn_ab, abc = mkldnn_abc, abcd = mkldnn_abcd, abcde = mkldnn_abcde, abcdef = mkldnn_abcdef, abdec = mkldnn_abdec, acb = mkldnn_acb, acbde = mkldnn_acbde, acdb = mkldnn_acdb, acdeb = mkldnn_acdeb, ba = mkldnn_ba, bac = mkldnn_bac, bacd = mkldnn_bacd, bcda = mkldnn_bcda, cba = mkldnn_cba, cdba = mkldnn_cdba, cdeba = mkldnn_cdeba, decab = mkldnn_decab, Abc16a = mkldnn_Abc16a, ABc16a16b = mkldnn_ABc16a16b, aBc16b = mkldnn_aBc16b, ABc16b16a = mkldnn_ABc16b16a, Abc4a = mkldnn_Abc4a, aBc4b = mkldnn_aBc4b, ABc4b16a4b = mkldnn_ABc4b16a4b, ABc4b4a = mkldnn_ABc4b4a, ABc8a16b2a = mkldnn_ABc8a16b2a, ABc8a8b = mkldnn_ABc8a8b, aBc8b = mkldnn_aBc8b, ABc8b16a2b = mkldnn_ABc8b16a2b, ABc8b8a = mkldnn_ABc8b8a, Abcd16a = mkldnn_Abcd16a, ABcd16a16b = mkldnn_ABcd16a16b, aBcd16b = mkldnn_aBcd16b, ABcd16b16a = mkldnn_ABcd16b16a, aBCd16b16c = mkldnn_aBCd16b16c, aBCd16c16b = mkldnn_aBCd16c16b, Abcd4a = mkldnn_Abcd4a, aBcd4b = mkldnn_aBcd4b, ABcd4b16a4b = mkldnn_ABcd4b16a4b, ABcd4b4a = mkldnn_ABcd4b4a, aBCd4c16b4c = mkldnn_aBCd4c16b4c, aBCd4c4b = mkldnn_aBCd4c4b, ABcd8a16b2a = mkldnn_ABcd8a16b2a, ABcd8a8b = mkldnn_ABcd8a8b, aBcd8b = mkldnn_aBcd8b, ABcd8b16a2b = mkldnn_ABcd8b16a2b, aBCd8b16c2b = mkldnn_aBCd8b16c2b, ABcd8b8a = mkldnn_ABcd8b8a, aBCd8b8c = mkldnn_aBCd8b8c, aBCd8c16b2c = mkldnn_aBCd8c16b2c, aBCd8c8b = mkldnn_aBCd8c8b, Abcde16a = mkldnn_Abcde16a, ABcde16a16b = mkldnn_ABcde16a16b, aBcde16b = mkldnn_aBcde16b, ABcde16b16a = mkldnn_ABcde16b16a, aBCde16b16c = mkldnn_aBCde16b16c, aBCde16c16b = mkldnn_aBCde16c16b, aBCde2c8b4c = mkldnn_aBCde2c8b4c, Abcde4a = mkldnn_Abcde4a, aBcde4b = mkldnn_aBcde4b, ABcde4b4a = mkldnn_ABcde4b4a, aBCde4b4c = mkldnn_aBCde4b4c, aBCde4c16b4c = mkldnn_aBCde4c16b4c, aBCde4c4b = mkldnn_aBCde4c4b, Abcde8a = mkldnn_Abcde8a, ABcde8a8b = mkldnn_ABcde8a8b, aBcde8b = mkldnn_aBcde8b, ABcde8b16a2b = mkldnn_ABcde8b16a2b, aBCde8b16c2b = mkldnn_aBCde8b16c2b, ABcde8b8a = mkldnn_ABcde8b8a, aBCde8b8c = mkldnn_aBCde8b8c, aBCde8c16b2c = mkldnn_aBCde8c16b2c, aBCde8c8b = mkldnn_aBCde8c8b, aBcdef16b = mkldnn_aBcdef16b, aBCdef16b16c = mkldnn_aBCdef16b16c, aBCdef16c16b = mkldnn_aBCdef16c16b, aBcdef4b = mkldnn_aBcdef4b, aBCdef4c4b = mkldnn_aBCdef4c4b, aBCdef8b8c = mkldnn_aBCdef8b8c, aBCdef8c16b2c = mkldnn_aBCdef8c16b2c, aBCdef8c8b = mkldnn_aBCdef8c8b, aBdc16b = mkldnn_aBdc16b, aBdc4b = mkldnn_aBdc4b, aBdc8b = mkldnn_aBdc8b, aBdec16b = mkldnn_aBdec16b, aBdec4b = mkldnn_aBdec4b, aBdec8b = mkldnn_aBdec8b, aBdefc16b = mkldnn_aBdefc16b, aBdefc4b = mkldnn_aBdefc4b, aBdefc8b = mkldnn_aBdefc8b, Acb16a = mkldnn_Acb16a, Acb4a = mkldnn_Acb4a, Acb8a = mkldnn_Acb8a, aCBd16b16c = mkldnn_aCBd16b16c, aCBde16b16c = mkldnn_aCBde16b16c, Acdb16a = mkldnn_Acdb16a, Acdb4a = mkldnn_Acdb4a, Acdb8a = mkldnn_Acdb8a, Acdeb16a = mkldnn_Acdeb16a, Acdeb4a = mkldnn_Acdeb4a, Acdeb8a = mkldnn_Acdeb8a, BAc16a16b = mkldnn_BAc16a16b, BAcd16a16b = mkldnn_BAcd16a16b, format_tag_last = mkldnn_format_tag_last, x = mkldnn_x, nc = mkldnn_nc, cn = mkldnn_cn, ncw = mkldnn_ncw, nwc = mkldnn_nwc, nchw = mkldnn_nchw, nhwc = mkldnn_nhwc, chwn = mkldnn_chwn, ncdhw = mkldnn_ncdhw, ndhwc = mkldnn_ndhwc, oi = mkldnn_oi, io = mkldnn_io, oiw = mkldnn_oiw, wio = mkldnn_wio, oihw = mkldnn_oihw, hwio = mkldnn_hwio, ihwo = mkldnn_ihwo, iohw = mkldnn_iohw, oidhw = mkldnn_oidhw, dhwio = mkldnn_dhwio, goiw = mkldnn_goiw, goihw = mkldnn_goihw, hwigo = mkldnn_hwigo, giohw = mkldnn_giohw, goidhw = mkldnn_goidhw, tnc = mkldnn_tnc, ntc = mkldnn_ntc, ldsnc = mkldnn_ldsnc, ldigo = mkldnn_ldigo, ldgoi = mkldnn_ldgoi, ldgo = mkldnn_ldgo, nCdhw16c = mkldnn_nCdhw16c, nCdhw4c = mkldnn_nCdhw4c, nCdhw8c = mkldnn_nCdhw8c, nChw16c = mkldnn_nChw16c, nChw4c = mkldnn_nChw4c, nChw8c = mkldnn_nChw8c, nCw16c = mkldnn_nCw16c, nCw4c = mkldnn_nCw4c, nCw8c = mkldnn_nCw8c, IOw16o16i = mkldnn_IOw16o16i, OIw16i16o = mkldnn_OIw16i16o, OIw16o16i = mkldnn_OIw16o16i, Oiw16o = mkldnn_Oiw16o, OIw4i16o4i = mkldnn_OIw4i16o4i, OIw4i4o = mkldnn_OIw4i4o, Oiw4o = mkldnn_Oiw4o, OIw8i16o2i = mkldnn_OIw8i16o2i, OIw8i8o = mkldnn_OIw8i8o, OIw8o16i2o = mkldnn_OIw8o16i2o, OIw8o8i = mkldnn_OIw8o8i, Owi16o = mkldnn_Owi16o, Owi4o = mkldnn_Owi4o, Owi8o = mkldnn_Owi8o, IOhw16o16i = mkldnn_IOhw16o16i, Ohwi16o = mkldnn_Ohwi16o, Ohwi4o = mkldnn_Ohwi4o, Ohwi8o = mkldnn_Ohwi8o, OIhw16i16o = mkldnn_OIhw16i16o, OIhw16o16i = mkldnn_OIhw16o16i, Oihw16o = mkldnn_Oihw16o, OIhw4i16o4i = mkldnn_OIhw4i16o4i, OIhw4i4o = mkldnn_OIhw4i4o, Oihw4o = mkldnn_Oihw4o, OIhw8i16o2i = mkldnn_OIhw8i16o2i, OIhw8i8o = mkldnn_OIhw8i8o, OIhw8o16i2o = mkldnn_OIhw8o16i2o, OIhw8o8i = mkldnn_OIhw8o8i, Odhwi16o = mkldnn_Odhwi16o, Odhwi4o = mkldnn_Odhwi4o, Odhwi8o = mkldnn_Odhwi8o, OIdhw16i16o = mkldnn_OIdhw16i16o, OIdhw16o16i = mkldnn_OIdhw16o16i, Oidhw16o = mkldnn_Oidhw16o, OIdhw4i4o = mkldnn_OIdhw4i4o, Oidhw4o = mkldnn_Oidhw4o, OIdhw8i16o2i = mkldnn_OIdhw8i16o2i, OIdhw8i8o = mkldnn_OIdhw8i8o, OIdhw8o8i = mkldnn_OIdhw8o8i, gIOw16o16i = mkldnn_gIOw16o16i, gOIw16i16o = mkldnn_gOIw16i16o, gOIw16o16i = mkldnn_gOIw16o16i, gOiw16o = mkldnn_gOiw16o, gOIw4i16o4i = mkldnn_gOIw4i16o4i, gOIw4i4o = mkldnn_gOIw4i4o, gOiw4o = mkldnn_gOiw4o, gOIw8i16o2i = mkldnn_gOIw8i16o2i, gOIw8i8o = mkldnn_gOIw8i8o, gOIw8o16i2o = mkldnn_gOIw8o16i2o, gOIw8o8i = mkldnn_gOIw8o8i, gOwi16o = mkldnn_gOwi16o, gOwi4o = mkldnn_gOwi4o, gOwi8o = mkldnn_gOwi8o, gIOhw16o16i = mkldnn_gIOhw16o16i, gOhwi16o = mkldnn_gOhwi16o, gOhwi4o = mkldnn_gOhwi4o, gOhwi8o = mkldnn_gOhwi8o, Goihw16g = mkldnn_Goihw16g, gOIhw16i16o = mkldnn_gOIhw16i16o, gOIhw16o16i = mkldnn_gOIhw16o16i, gOihw16o = mkldnn_gOihw16o, gOIhw2i8o4i = mkldnn_gOIhw2i8o4i, gOIhw4i16o4i = mkldnn_gOIhw4i16o4i, gOIhw4i4o = mkldnn_gOIhw4i4o, gOIhw4o4i = mkldnn_gOIhw4o4i, gOihw4o = mkldnn_gOihw4o, Goihw8g = mkldnn_Goihw8g, gOIhw8i16o2i = mkldnn_gOIhw8i16o2i, gOIhw8i8o = mkldnn_gOIhw8i8o, gOIhw8o16i2o = mkldnn_gOIhw8o16i2o, gOIhw8o8i = mkldnn_gOIhw8o8i, gOdhwi16o = mkldnn_gOdhwi16o, gOdhwi4o = mkldnn_gOdhwi4o, gOdhwi8o = mkldnn_gOdhwi8o, gOIdhw16i16o = mkldnn_gOIdhw16i16o, gOIdhw16o16i = mkldnn_gOIdhw16o16i, gOidhw16o = mkldnn_gOidhw16o, gOIdhw4i4o = mkldnn_gOIdhw4i4o, gOidhw4o = mkldnn_gOidhw4o, gOIdhw8i16o2i = mkldnn_gOIdhw8i16o2i, gOIdhw8i8o = mkldnn_gOIdhw8i8o, gOIdhw8o8i = mkldnn_gOIdhw8o8i, }; /// A memory descriptor. struct desc { friend struct memory; /// The underlying C API data structure. mkldnn_memory_desc_t data; /// Constructs a zero memory descriptor desc(): data() {} /// Constructs a memory descriptor. /// /// @param adims Data dimensions /// @param adata_type Data precision/type. /// @param aformat Data layout format tag. desc(const dims &adims, data_type adata_type, format_tag aformat) { validate_dims(adims); error::wrap_c_api(mkldnn_memory_desc_init_by_tag(&data, (int)adims.size(), adims.size() == 0 ? nullptr : &adims[0], convert_to_c(adata_type), convert_to_c(aformat)), "could not initialize a memory descriptor"); } /// Constructs a memory descriptor from a C API data structure. /// /// @param adata A C API #mkldnn_memory_desc_t structure. desc(const mkldnn_memory_desc_t &adata): data(adata) {} /// Constructs a sub-memory descriptor // /// @param adims Sizes of a sub-memory /// @param offsets Offsets of a sub-memory desc submemory_desc(const dims &adims, const dims &offsets) { mkldnn_memory_desc_t sub_md; error::wrap_c_api(mkldnn_memory_desc_init_submemory(&sub_md, &data, &adims[0], &offsets[0]), "could not initialize a sub-memory"); return desc(sub_md); } /// Returns the number of bytes required to allocate the memory described /// including the padding area. size_t get_size() const { return mkldnn_memory_desc_get_size(&data); } bool operator==(const desc &other) const { return mkldnn_memory_desc_equal(&data, &other.data) != 0; } bool operator!=(const desc &other) const { return !operator==(other); } }; /// Constructs a memory. /// /// @param md Memory descriptor. /// @param aengine Engine. /// @param ahandle Native handle. memory(const desc &md, const engine &aengine, void *ahandle) { mkldnn_memory_t result; error::wrap_c_api(mkldnn_memory_create(&result, &md.data, aengine.get(), ahandle), "could not create a memory"); reset(result); } /// Constructs a memory. /// /// @param md Memory descriptor. /// @param aengine Engine. memory(const desc &md, const engine &aengine) : memory(md, aengine, MKLDNN_NATIVE_HANDLE_ALLOCATE) {} /// Returns the descriptor of the memory. desc get_desc() const { const mkldnn_memory_desc_t *cdesc; error::wrap_c_api(mkldnn_memory_get_memory_desc(get(), &cdesc), "could not get memory descriptor from a memory"); return desc(*cdesc); } /// Returns the engine of the memory. engine get_engine() const { mkldnn_engine_t engine_q; error::wrap_c_api(mkldnn_memory_get_engine(get(), &engine_q), "could not get engine from a memory"); return engine(engine_q); } /// Returns a handle of the data contained in the memory. /// /// On the CPU engine, this is a pointer to the allocated memory. void *get_data_handle() const { void *handle; error::wrap_c_api(mkldnn_memory_get_data_handle(get(), &handle), "could not get native handle"); return handle; } void set_data_handle(void *handle) const { error::wrap_c_api(mkldnn_memory_set_data_handle(get(), handle), "could not set native handle"); } // Must go away or be private: static mkldnn_data_type_t convert_to_c(data_type adata_type) { return static_cast(adata_type); } static mkldnn_format_tag_t convert_to_c(format_tag aformat) { return static_cast(aformat); } }; inline bool operator==(mkldnn_data_type_t a, memory::data_type b) { return a == memory::convert_to_c(b); } inline bool operator!=(mkldnn_data_type_t a, memory::data_type b) { return !(a == b); } inline bool operator==(memory::data_type a, mkldnn_data_type_t b) { return b == a; } inline bool operator!=(memory::data_type a, mkldnn_data_type_t b) { return !(a == b); } inline bool operator==(mkldnn_format_tag_t a, memory::format_tag b) { return a == memory::convert_to_c(b); } inline bool operator!=(mkldnn_format_tag_t a, memory::format_tag b) { return !(a == b); } inline bool operator==(memory::format_tag a, mkldnn_format_tag_t b) { return b == a; } inline bool operator!=(memory::format_tag a, mkldnn_format_tag_t b) { return !(a == b); } /// @} /// @addtogroup cpp_api_reorder Reorder /// A primitive to copy data between memory formats. /// /// @sa @ref c_api_reorder in @ref c_api /// @{ struct reorder : public primitive { struct primitive_desc : public handle { primitive_desc(const engine &src_engine, const memory::desc &src_md, const engine &dst_engine, const memory::desc &dst_md, const primitive_attr &aattr) { mkldnn_primitive_desc_t result; error::wrap_c_api(mkldnn_reorder_primitive_desc_create(&result, src_engine.get(), &src_md.data, dst_engine.get(), &dst_md.data, aattr.get()), "could not create a reorder primitive descriptor"); reset(result); } primitive_desc(const engine &src_engine, const memory::desc &src_md, const engine &dst_engine, const memory::desc &dst_md) { mkldnn_primitive_desc_t result; error::wrap_c_api(mkldnn_reorder_primitive_desc_create(&result, src_engine.get(), &src_md.data, dst_engine.get(), &dst_md.data, nullptr), "could not create a reorder primitive descriptor"); reset(result); } primitive_desc(const memory &src, const memory &dst, const primitive_attr &aattr) { mkldnn_primitive_desc_t result; auto src_md = src.get_desc(); auto dst_md = dst.get_desc(); error::wrap_c_api(mkldnn_reorder_primitive_desc_create(&result, src.get_engine().get(), &src_md.data, dst.get_engine().get(), &dst_md.data, aattr.get()), "could not create a reorder primitive descriptor"); reset(result); } primitive_desc(const memory &src, const memory &dst) { mkldnn_primitive_desc_t result; auto src_md = src.get_desc(); auto dst_md = dst.get_desc(); error::wrap_c_api(mkldnn_reorder_primitive_desc_create(&result, src.get_engine().get(), &src_md.data, dst.get_engine().get(), &dst_md.data, nullptr), "could not create a reorder primitive descriptor"); reset(result); } memory::desc scratchpad_desc() const { const mkldnn_memory_desc_t *cdesc = mkldnn_primitive_desc_query_md( get(), mkldnn::convert_to_c(scratchpad_md), 0); if (cdesc == nullptr) return memory::desc(); return memory::desc(*cdesc); } engine scratchpad_engine() { mkldnn_engine_t engine_q; error::wrap_c_api( mkldnn_primitive_desc_query(get(), mkldnn::convert_to_c(query_scratchpad_engine), 0, &engine_q), "could not get scratchpad engine from reorder primitive_desc"); return engine(engine_q); } engine get_engine() { return engine::query(*this); } }; reorder(const primitive_desc &pd): primitive(pd.get()) {} reorder(const memory &src, const memory &dst): primitive(primitive_desc(src, dst).get()) {} void execute(stream astream, memory &src, memory &dst) { primitive::execute(astream, {{MKLDNN_ARG_FROM, src}, {MKLDNN_ARG_TO, dst}}); } }; /// @} /// @addtogroup cpp_api_concat Concat /// A primitive to concatenate data by arbitrary dimension. /// /// @sa @ref c_api_concat in @ref c_api /// @{ struct concat : public primitive { struct primitive_desc : public handle { std::vector cpp_to_c( const std::vector &srcs) { std::vector c_api_srcs; c_api_srcs.reserve(srcs.size()); for (const auto &s : srcs) c_api_srcs.push_back(s.data); return c_api_srcs; } primitive_desc(const memory::desc &dst, int concat_dimension, const std::vector &srcs, const engine &aengine) { auto c_api_srcs = cpp_to_c(srcs); mkldnn_primitive_desc_t result; error::wrap_c_api(mkldnn_concat_primitive_desc_create( &result, &dst.data, (int)c_api_srcs.size(), concat_dimension, &c_api_srcs[0], nullptr, aengine.get()), "could not create a concat primitive descriptor"); reset(result); } primitive_desc(int concat_dimension, const std::vector &srcs, const engine &aengine) { auto c_api_srcs = cpp_to_c(srcs); mkldnn_primitive_desc_t result; error::wrap_c_api(mkldnn_concat_primitive_desc_create( &result, nullptr, (int)c_api_srcs.size(), concat_dimension, &c_api_srcs[0], nullptr, aengine.get()), "could not create a concat primitive descriptor"); reset(result); } memory::desc dst_desc() const { const mkldnn_memory_desc_t *cdesc = mkldnn_primitive_desc_query_md( get(), mkldnn::convert_to_c(dst_md), 0); error::wrap_c_api( cdesc == nullptr ? mkldnn_runtime_error : mkldnn_success, "could not get a dst memory descriptor"); return memory::desc(*cdesc); } memory::desc scratchpad_desc() const { const mkldnn_memory_desc_t *cdesc = mkldnn_primitive_desc_query_md( get(), mkldnn::convert_to_c(scratchpad_md), 0); if (cdesc == nullptr) return memory::desc(); return memory::desc(*cdesc); } engine get_engine() { return engine::query(*this); } }; concat(const primitive_desc &pd): primitive(pd.get()) {} }; /// @} /// @addtogroup cpp_api_sum Sum /// A primitive to sum data. /// /// @sa @ref c_api_sum in @ref c_api /// @{ struct sum : public primitive { struct primitive_desc : public handle { std::vector cpp_to_c( const std::vector &srcs) { std::vector c_api_srcs; c_api_srcs.reserve(srcs.size()); for (const auto &s : srcs) c_api_srcs.push_back(s.data); return c_api_srcs; } primitive_desc(const memory::desc &dst, const std::vector &scales, const std::vector &srcs, const engine &aengine) { error::wrap_c_api(scales.size() == srcs.size() ? mkldnn_success : mkldnn_invalid_arguments, "number of scales not equal to number of srcs"); auto c_api_srcs = cpp_to_c(srcs); mkldnn_primitive_desc_t result; error::wrap_c_api(mkldnn_sum_primitive_desc_create( &result, &dst.data, (int)c_api_srcs.size(), &scales[0], &c_api_srcs[0], nullptr, aengine.get()), "could not create a sum primitive descriptor"); reset(result); } primitive_desc(const std::vector &scales, const std::vector &srcs, const engine &aengine) { error::wrap_c_api(scales.size() == srcs.size() ? mkldnn_success : mkldnn_invalid_arguments, "number of scales not equal to number of srcs"); auto c_api_srcs = cpp_to_c(srcs); mkldnn_primitive_desc_t result; error::wrap_c_api(mkldnn_sum_primitive_desc_create(&result, nullptr, (int)c_api_srcs.size(), &scales[0], &c_api_srcs[0], nullptr, aengine.get()), "could not create a sum primitive descriptor"); reset(result); } memory::desc dst_desc() const { const mkldnn_memory_desc_t *cdesc = mkldnn_primitive_desc_query_md( get(), mkldnn::convert_to_c(dst_md), 0); error::wrap_c_api( cdesc == nullptr ? mkldnn_runtime_error : mkldnn_success, "could not get a dst memory descriptor"); return memory::desc(*cdesc); } memory::desc scratchpad_desc() const { const mkldnn_memory_desc_t *cdesc = mkldnn_primitive_desc_query_md( get(), mkldnn::convert_to_c(scratchpad_md), 0); if (cdesc == nullptr) return memory::desc(); return memory::desc(*cdesc); } engine get_engine() { return engine::query(*this); } }; sum(const primitive_desc &pd): primitive(pd.get()) {} }; /// @} /// @} /// @addtogroup cpp_api_primitives Primitives /// @{ /// @addtogroup cpp_api_primitive_descriptors Primitive descriptors /// @{ /// A base class for all primitive descriptors. struct primitive_desc : public handle { primitive_desc(const_mkldnn_op_desc_t desc, const primitive_attr *attr, const engine &e, const_mkldnn_primitive_desc_t hint_fwd_pd) { mkldnn_primitive_desc_iterator_t iterator = nullptr; mkldnn_status_t status = mkldnn_primitive_desc_iterator_create( &iterator, desc, attr ? attr->get() : nullptr, e.get(), hint_fwd_pd); error::wrap_c_api(status, "could not create a primitive descriptor iterator"); pd_iterator.reset(iterator); fetch_impl(); } engine get_engine() { return engine::query(*this); } primitive_attr get_primitive_attr() const { const_mkldnn_primitive_attr_t const_cattr; error::wrap_c_api(mkldnn_primitive_desc_get_attr(get(), &const_cattr), "could not get attributes"); mkldnn_primitive_attr_t cattr; error::wrap_c_api(mkldnn_primitive_attr_clone(&cattr, const_cattr), "could not clone attributes"); primitive_attr attr; attr.reset(cattr); return attr; } /// Returns implementation name const char *impl_info_str() const { const char *res; error::wrap_c_api(mkldnn_primitive_desc_query(get(), mkldnn_query_impl_info_str, 0, &res), "could not query implementation info string"); return res; } /// Queries the memory::dim value (same as int64_t) memory::dim query_s64(query q) const { memory::dim res; mkldnn_status_t status = mkldnn_primitive_desc_query(get(), mkldnn::convert_to_c(q), 0, &res); return status == mkldnn_success ? res : 0; } /// Advances the next implementation for the given op descriptor. /// /// Returns: /// - @c true on success /// - @c false if the last implementation reached, and /// the primitive descriptor itself is kept unchanged bool next_impl() { mkldnn_status_t status = mkldnn_primitive_desc_iterator_next( pd_iterator.get()); if (status == mkldnn_iterator_ends) return false; error::wrap_c_api(status, "primitive descriptor iterator next failed"); fetch_impl(); return true; } /// Queries and returns requested memory descriptor. memory::desc query_md(query what, int idx = 0) const { std::vector valid_q{src_md, diff_src_md, weights_md, diff_weights_md, dst_md, diff_dst_md, workspace_md, scratchpad_md}; if (!std::any_of(valid_q.cbegin(), valid_q.cend(), [=](query q) { return what == q; })) throw error(mkldnn_invalid_arguments, "invalid memory query"); const mkldnn_memory_desc_t *cdesc = mkldnn_primitive_desc_query_md( get(), mkldnn::convert_to_c(what), idx); if (cdesc == nullptr) return memory::desc(); return memory::desc(*cdesc); } // register specialized queries, e.g. src_desc() # define REG_QUERY_MD(name, what, idx) \ memory::desc name ## _desc() const { return query_md(what ## _md, idx); } private: handle pd_iterator; void fetch_impl() { mkldnn_primitive_desc_t pd = mkldnn_primitive_desc_iterator_fetch( pd_iterator.get()); error::wrap_c_api(pd != nullptr ? mkldnn_success : mkldnn_runtime_error, "could not fetch a primitive descriptor from the iterator"); reset(pd); } }; /// @} /// @addtogroup cpp_api_convolution Convolution /// A primitive to compute convolution using different algorithms. /// /// @sa @ref c_api_convolution in @ref c_api /// @{ struct convolution_forward: public primitive { struct desc { mkldnn_convolution_desc_t data; desc(prop_kind aprop_kind, algorithm aalgorithm, const memory::desc &src_desc, const memory::desc &weights_desc, const memory::desc &bias_desc, const memory::desc &dst_desc, const memory::dims strides, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind) { memory::validate_dims(strides); memory::validate_dims(padding_l); memory::validate_dims(padding_r); error::wrap_c_api(mkldnn_convolution_forward_desc_init(&data, mkldnn::convert_to_c(aprop_kind), convert_to_c(aalgorithm), &src_desc.data, &weights_desc.data, &bias_desc.data, &dst_desc.data, &strides[0], &padding_l[0], &padding_r[0], mkldnn::convert_to_c(apadding_kind)), "could not create a convolution forward descriptor"); } desc(prop_kind aprop_kind, algorithm aalgorithm, const memory::desc &src_desc, const memory::desc &weights_desc, const memory::desc &dst_desc, const memory::dims strides, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind) { memory::validate_dims(strides); memory::validate_dims(padding_l); memory::validate_dims(padding_r); error::wrap_c_api(mkldnn_convolution_forward_desc_init(&data, mkldnn::convert_to_c(aprop_kind), convert_to_c(aalgorithm), &src_desc.data, &weights_desc.data, nullptr, &dst_desc.data, &strides[0], &padding_l[0], &padding_r[0], mkldnn::convert_to_c(apadding_kind)), "could not create a convolution forward descriptor"); } desc(prop_kind aprop_kind, algorithm aalgorithm, const memory::desc &src_desc, const memory::desc &weights_desc, const memory::desc &bias_desc, const memory::desc &dst_desc, const memory::dims strides, const memory::dims dilates, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind) { memory::validate_dims(strides); memory::validate_dims(dilates); memory::validate_dims(padding_l); memory::validate_dims(padding_r); error::wrap_c_api( mkldnn_dilated_convolution_forward_desc_init(&data, mkldnn::convert_to_c(aprop_kind), convert_to_c(aalgorithm), &src_desc.data, &weights_desc.data, &bias_desc.data, &dst_desc.data, &strides[0], &dilates[0], &padding_l[0], &padding_r[0], mkldnn::convert_to_c(apadding_kind)), "could not create a dilated convolution forward descriptor"); } desc(prop_kind aprop_kind, algorithm aalgorithm, const memory::desc &src_desc, const memory::desc &weights_desc, const memory::desc &dst_desc, const memory::dims strides, const memory::dims dilates, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind) { memory::validate_dims(strides); memory::validate_dims(dilates); memory::validate_dims(padding_l); memory::validate_dims(padding_r); error::wrap_c_api( mkldnn_dilated_convolution_forward_desc_init(&data, mkldnn::convert_to_c(aprop_kind), convert_to_c(aalgorithm), &src_desc.data, &weights_desc.data, nullptr, &dst_desc.data, &strides[0], &dilates[0], &padding_l[0], &padding_r[0], mkldnn::convert_to_c(apadding_kind)), "could not create a dilated convolution forward descriptor"); } }; struct primitive_desc : public mkldnn::primitive_desc { primitive_desc(const desc &desc, const engine &e) : mkldnn::primitive_desc(&desc.data, nullptr, e, nullptr) {} primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e) : mkldnn::primitive_desc(&desc.data, &attr, e, nullptr) {} REG_QUERY_MD(src, src, 0); REG_QUERY_MD(weights, weights, 0); REG_QUERY_MD(bias, weights, 1); REG_QUERY_MD(dst, dst, 0); REG_QUERY_MD(scratchpad, scratchpad, 0); }; convolution_forward(const primitive_desc &pd): primitive(pd) {} }; struct convolution_backward_data : public primitive { struct desc { mkldnn_convolution_desc_t data; desc(algorithm aalgorithm, const memory::desc &diff_src_desc, const memory::desc &weights_desc, const memory::desc &diff_dst_desc, const memory::dims strides, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind) { memory::validate_dims(strides); memory::validate_dims(padding_l); memory::validate_dims(padding_r); error::wrap_c_api(mkldnn_convolution_backward_data_desc_init( &data, convert_to_c(aalgorithm), &diff_src_desc.data, &weights_desc.data, &diff_dst_desc.data, &strides[0], &padding_l[0], &padding_r[0], mkldnn::convert_to_c(apadding_kind)), "could not create a convolution backward data descriptor"); } desc(algorithm aalgorithm, const memory::desc &diff_src_desc, const memory::desc &weights_desc, const memory::desc &diff_dst_desc, const memory::dims strides, const memory::dims dilates, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind) { memory::validate_dims(strides); memory::validate_dims(dilates); memory::validate_dims(padding_l); memory::validate_dims(padding_r); error::wrap_c_api( mkldnn_dilated_convolution_backward_data_desc_init( &data, convert_to_c(aalgorithm), &diff_src_desc.data, &weights_desc.data, &diff_dst_desc.data, &strides[0], &dilates[0], &padding_l[0], &padding_r[0], mkldnn::convert_to_c(apadding_kind)), "could not create a convolution backward data descriptor"); } }; struct primitive_desc : public mkldnn::primitive_desc { primitive_desc(const desc &desc, const engine &e, const convolution_forward::primitive_desc &hint_fwd_pd) : mkldnn::primitive_desc(&desc.data, nullptr, e, hint_fwd_pd.get()) {} primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e, const convolution_forward::primitive_desc &hint_fwd_pd) : mkldnn::primitive_desc(&desc.data, &attr, e, hint_fwd_pd.get()) {} REG_QUERY_MD(diff_src, diff_src, 0); REG_QUERY_MD(weights, weights, 0); REG_QUERY_MD(diff_dst, diff_dst, 0); REG_QUERY_MD(scratchpad, scratchpad, 0); }; convolution_backward_data(const primitive_desc &pd): primitive(pd) {} }; struct convolution_backward_weights : public primitive { struct desc { mkldnn_convolution_desc_t data; desc(algorithm aalgorithm, const memory::desc &src_desc, const memory::desc &diff_weights_desc, const memory::desc &diff_bias_desc, const memory::desc &diff_dst_desc, const memory::dims strides, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind) { memory::validate_dims(strides); memory::validate_dims(padding_l); memory::validate_dims(padding_r); error::wrap_c_api(mkldnn_convolution_backward_weights_desc_init( &data, convert_to_c(aalgorithm), &src_desc.data, &diff_weights_desc.data, &diff_bias_desc.data, &diff_dst_desc.data, &strides[0], &padding_l[0], &padding_r[0], mkldnn::convert_to_c(apadding_kind)), "could not create a convolution backward weights descriptor"); } desc(algorithm aalgorithm, const memory::desc &src_desc, const memory::desc &diff_weights_desc, const memory::desc &diff_dst_desc, const memory::dims strides, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind) { memory::validate_dims(strides); memory::validate_dims(padding_l); memory::validate_dims(padding_r); error::wrap_c_api(mkldnn_convolution_backward_weights_desc_init( &data, convert_to_c(aalgorithm), &src_desc.data, &diff_weights_desc.data, nullptr, &diff_dst_desc.data, &strides[0], &padding_l[0], &padding_r[0], mkldnn::convert_to_c(apadding_kind)), "could not create a convolution backward weights descriptor"); } desc(algorithm aalgorithm, const memory::desc &src_desc, const memory::desc &diff_weights_desc, const memory::desc &diff_bias_desc, const memory::desc &diff_dst_desc, const memory::dims strides, const memory::dims dilates, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind) { memory::validate_dims(strides); memory::validate_dims(dilates); memory::validate_dims(padding_l); memory::validate_dims(padding_r); error::wrap_c_api(mkldnn_dilated_convolution_backward_weights_desc_init( &data, convert_to_c(aalgorithm), &src_desc.data, &diff_weights_desc.data, &diff_bias_desc.data, &diff_dst_desc.data, &strides[0], &dilates[0], &padding_l[0], &padding_r[0], mkldnn::convert_to_c(apadding_kind)), "could not create a convolution backward weights descriptor"); } desc(algorithm aalgorithm, const memory::desc &src_desc, const memory::desc &diff_weights_desc, const memory::desc &diff_dst_desc, const memory::dims strides, const memory::dims dilates, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind) { memory::validate_dims(strides); memory::validate_dims(dilates); memory::validate_dims(padding_l); memory::validate_dims(padding_r); error::wrap_c_api(mkldnn_dilated_convolution_backward_weights_desc_init( &data, convert_to_c(aalgorithm), &src_desc.data, &diff_weights_desc.data, nullptr, &diff_dst_desc.data, &strides[0], &dilates[0], &padding_l[0], &padding_r[0], mkldnn::convert_to_c(apadding_kind)), "could not create a convolution backward weights descriptor"); } }; struct primitive_desc : public mkldnn::primitive_desc { primitive_desc(const desc &desc, const engine &e, const convolution_forward::primitive_desc &hint_fwd_pd) : mkldnn::primitive_desc(&desc.data, nullptr, e, hint_fwd_pd.get()) {} primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e, const convolution_forward::primitive_desc &hint_fwd_pd) : mkldnn::primitive_desc(&desc.data, &attr, e, hint_fwd_pd.get()) {} REG_QUERY_MD(src, src, 0); REG_QUERY_MD(diff_weights, diff_weights, 0); REG_QUERY_MD(diff_bias, diff_weights, 1); REG_QUERY_MD(diff_dst, diff_dst, 0); REG_QUERY_MD(scratchpad, scratchpad, 0); }; convolution_backward_weights(const primitive_desc &pd): primitive(pd) {} }; /// @} // /// @addtogroup cpp_api_deconvolution Deconvolution /// A primitive to compute deconvolution using different algorithms. /// /// @sa @ref c_api_deconvolution in @ref c_api /// @{ struct deconvolution_forward: public primitive { struct desc { mkldnn_deconvolution_desc_t data; desc(prop_kind aprop_kind, algorithm aalgorithm, const memory::desc &src_desc, const memory::desc &weights_desc, const memory::desc &bias_desc, const memory::desc &dst_desc, const memory::dims strides, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind) { memory::validate_dims(strides); memory::validate_dims(padding_l); memory::validate_dims(padding_r); error::wrap_c_api(mkldnn_deconvolution_forward_desc_init(&data, mkldnn::convert_to_c(aprop_kind), convert_to_c(aalgorithm), &src_desc.data, &weights_desc.data, &bias_desc.data, &dst_desc.data, &strides[0], &padding_l[0], &padding_r[0], mkldnn::convert_to_c(apadding_kind)), "could not create a deconvolution forward descriptor"); } desc(prop_kind aprop_kind, algorithm aalgorithm, const memory::desc &src_desc, const memory::desc &weights_desc, const memory::desc &dst_desc, const memory::dims strides, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind) { memory::validate_dims(strides); memory::validate_dims(padding_l); memory::validate_dims(padding_r); error::wrap_c_api(mkldnn_deconvolution_forward_desc_init(&data, mkldnn::convert_to_c(aprop_kind), convert_to_c(aalgorithm), &src_desc.data, &weights_desc.data, nullptr, &dst_desc.data, &strides[0], &padding_l[0], &padding_r[0], mkldnn::convert_to_c(apadding_kind)), "could not create a deconvolution forward descriptor"); } desc(prop_kind aprop_kind, algorithm aalgorithm, const memory::desc &src_desc, const memory::desc &weights_desc, const memory::desc &bias_desc, const memory::desc &dst_desc, const memory::dims strides, const memory::dims dilates, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind) { memory::validate_dims(strides); memory::validate_dims(dilates); memory::validate_dims(padding_l); memory::validate_dims(padding_r); error::wrap_c_api(mkldnn_dilated_deconvolution_forward_desc_init(&data, mkldnn::convert_to_c(aprop_kind), convert_to_c(aalgorithm), &src_desc.data, &weights_desc.data, &bias_desc.data, &dst_desc.data, &strides[0], &dilates[0], &padding_l[0], &padding_r[0], mkldnn::convert_to_c(apadding_kind)), "could not create a dilated deconvolution forward descriptor"); } desc(prop_kind aprop_kind, algorithm aalgorithm, const memory::desc &src_desc, const memory::desc &weights_desc, const memory::desc &dst_desc, const memory::dims strides, const memory::dims dilates, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind) { memory::validate_dims(strides); memory::validate_dims(dilates); memory::validate_dims(padding_l); memory::validate_dims(padding_r); error::wrap_c_api(mkldnn_dilated_deconvolution_forward_desc_init(&data, mkldnn::convert_to_c(aprop_kind), convert_to_c(aalgorithm), &src_desc.data, &weights_desc.data, nullptr, &dst_desc.data, &strides[0], &dilates[0], &padding_l[0], &padding_r[0], mkldnn::convert_to_c(apadding_kind)), "could not create a dilated deconvolution forward descriptor"); } }; struct primitive_desc : public mkldnn::primitive_desc { primitive_desc(const desc &desc, const engine &e) : mkldnn::primitive_desc(&desc.data, nullptr, e, nullptr) {} primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e) : mkldnn::primitive_desc(&desc.data, &attr, e, nullptr) {} REG_QUERY_MD(src, src, 0); REG_QUERY_MD(weights, weights, 0); REG_QUERY_MD(bias, weights, 1); REG_QUERY_MD(dst, dst, 0); REG_QUERY_MD(scratchpad, scratchpad, 0); }; deconvolution_forward(const primitive_desc &pd): primitive(pd) {} }; struct deconvolution_backward_data : public primitive { struct desc { mkldnn_deconvolution_desc_t data; desc(algorithm aalgorithm, const memory::desc &diff_src_desc, const memory::desc &weights_desc, const memory::desc &diff_dst_desc, const memory::dims strides, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind) { memory::validate_dims(strides); memory::validate_dims(padding_l); memory::validate_dims(padding_r); error::wrap_c_api(mkldnn_deconvolution_backward_data_desc_init( &data, convert_to_c(aalgorithm), &diff_src_desc.data, &weights_desc.data, &diff_dst_desc.data, &strides[0], &padding_l[0], &padding_r[0], mkldnn::convert_to_c(apadding_kind)), "could not create a deconvolution backward data descriptor"); } desc(algorithm aalgorithm, const memory::desc &diff_src_desc, const memory::desc &weights_desc, const memory::desc &diff_dst_desc, const memory::dims strides, const memory::dims dilates, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind) { memory::validate_dims(strides); memory::validate_dims(dilates); memory::validate_dims(padding_l); memory::validate_dims(padding_r); error::wrap_c_api(mkldnn_dilated_deconvolution_backward_data_desc_init( &data, convert_to_c(aalgorithm), &diff_src_desc.data, &weights_desc.data, &diff_dst_desc.data, &strides[0], &dilates[0], &padding_l[0], &padding_r[0], mkldnn::convert_to_c(apadding_kind)), "could not create a dilated deconvolution backward data descriptor"); } }; struct primitive_desc : public mkldnn::primitive_desc { primitive_desc(const desc &desc, const engine &e, const deconvolution_forward::primitive_desc &hint_fwd_pd) : mkldnn::primitive_desc(&desc.data, nullptr, e, hint_fwd_pd.get()) {} primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e, const deconvolution_forward::primitive_desc &hint_fwd_pd) : mkldnn::primitive_desc(&desc.data, &attr, e, hint_fwd_pd.get()) {} REG_QUERY_MD(diff_src, diff_src, 0); REG_QUERY_MD(weights, weights, 0); REG_QUERY_MD(diff_dst, diff_dst, 0); REG_QUERY_MD(scratchpad, scratchpad, 0); }; deconvolution_backward_data(const primitive_desc &pd): primitive(pd) {} }; struct deconvolution_backward_weights : public primitive { struct desc { mkldnn_deconvolution_desc_t data; desc(algorithm aalgorithm, const memory::desc &src_desc, const memory::desc &diff_weights_desc, const memory::desc &diff_bias_desc, const memory::desc &diff_dst_desc, const memory::dims strides, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind) { memory::validate_dims(strides); memory::validate_dims(padding_l); memory::validate_dims(padding_r); error::wrap_c_api(mkldnn_deconvolution_backward_weights_desc_init( &data, convert_to_c(aalgorithm), &src_desc.data, &diff_weights_desc.data, &diff_bias_desc.data, &diff_dst_desc.data, &strides[0], &padding_l[0], &padding_r[0], mkldnn::convert_to_c(apadding_kind)), "could not create a deconvolution backward weights descriptor"); } desc(algorithm aalgorithm, const memory::desc &src_desc, const memory::desc &diff_weights_desc, const memory::desc &diff_dst_desc, const memory::dims strides, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind) { memory::validate_dims(strides); memory::validate_dims(padding_l); memory::validate_dims(padding_r); error::wrap_c_api(mkldnn_deconvolution_backward_weights_desc_init( &data, convert_to_c(aalgorithm), &src_desc.data, &diff_weights_desc.data, nullptr, &diff_dst_desc.data, &strides[0], &padding_l[0], &padding_r[0], mkldnn::convert_to_c(apadding_kind)), "could not create a deconvolution backward weights descriptor"); } desc(algorithm aalgorithm, const memory::desc &src_desc, const memory::desc &diff_weights_desc, const memory::desc &diff_bias_desc, const memory::desc &diff_dst_desc, const memory::dims strides, const memory::dims dilates, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind) { memory::validate_dims(strides); memory::validate_dims(dilates); memory::validate_dims(padding_l); memory::validate_dims(padding_r); error::wrap_c_api(mkldnn_dilated_deconvolution_backward_weights_desc_init( &data, convert_to_c(aalgorithm), &src_desc.data, &diff_weights_desc.data, &diff_bias_desc.data, &diff_dst_desc.data, &strides[0], &dilates[0], &padding_l[0], &padding_r[0], mkldnn::convert_to_c(apadding_kind)), "could not create a dilated deconvolution backward weights descriptor"); } desc(algorithm aalgorithm, const memory::desc &src_desc, const memory::desc &diff_weights_desc, const memory::desc &diff_dst_desc, const memory::dims strides, const memory::dims dilates, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind) { memory::validate_dims(strides); memory::validate_dims(dilates); memory::validate_dims(padding_l); memory::validate_dims(padding_r); error::wrap_c_api(mkldnn_dilated_deconvolution_backward_weights_desc_init( &data, convert_to_c(aalgorithm), &src_desc.data, &diff_weights_desc.data, nullptr, &diff_dst_desc.data, &strides[0], &dilates[0], &padding_l[0], &padding_r[0], mkldnn::convert_to_c(apadding_kind)), "could not create a dilated deconvolution backward weights descriptor"); } }; struct primitive_desc : public mkldnn::primitive_desc { primitive_desc(const desc &desc, const engine &e, const deconvolution_forward::primitive_desc &hint_fwd_pd) : mkldnn::primitive_desc(&desc.data, nullptr, e, hint_fwd_pd.get()) {} primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e, const deconvolution_forward::primitive_desc &hint_fwd_pd) : mkldnn::primitive_desc(&desc.data, &attr, e, hint_fwd_pd.get()) {} REG_QUERY_MD(src, src, 0); REG_QUERY_MD(diff_weights, diff_weights, 0); REG_QUERY_MD(diff_bias, diff_weights, 1); REG_QUERY_MD(diff_dst, diff_dst, 0); REG_QUERY_MD(scratchpad, scratchpad, 0); }; deconvolution_backward_weights(const primitive_desc &pd): primitive(pd) {} }; /// @} /// @addtogroup cpp_api_lrn LRN /// A primitive to perform local response normalization (LRN) across or within /// channels. /// /// @sa @ref c_api_lrn in @ref c_api /// @{ struct lrn_forward : public primitive { struct desc { mkldnn_lrn_desc_t data; desc(prop_kind aprop_kind, algorithm aalgorithm, const memory::desc &src_desc, memory::dim local_size, float alpha, float beta, float k = 1.f) { error::wrap_c_api(mkldnn_lrn_forward_desc_init(&data, mkldnn::convert_to_c(aprop_kind), convert_to_c(aalgorithm), &src_desc.data, local_size, alpha, beta, k), "could not create a lrn forward descriptor"); } }; struct primitive_desc : public mkldnn::primitive_desc { primitive_desc(const desc &desc, const engine &e) : mkldnn::primitive_desc(&desc.data, nullptr, e, nullptr) {} primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e) : mkldnn::primitive_desc(&desc.data, &attr, e, nullptr) {} REG_QUERY_MD(src, src, 0); REG_QUERY_MD(dst, dst, 0); REG_QUERY_MD(workspace, workspace, 0); REG_QUERY_MD(scratchpad, scratchpad, 0); }; lrn_forward(const primitive_desc &pd): primitive(pd) {} }; struct lrn_backward : public primitive { struct desc { mkldnn_lrn_desc_t data; desc(algorithm aalgorithm, const memory::desc &data_desc, const memory::desc &diff_data_desc, memory::dim local_size, float alpha, float beta, float k = 1.f) { error::wrap_c_api(mkldnn_lrn_backward_desc_init(&data, convert_to_c(aalgorithm), &diff_data_desc.data, &data_desc.data, local_size, alpha, beta, k), "could not create a lrn backward descriptor"); } }; struct primitive_desc : public mkldnn::primitive_desc { primitive_desc(const desc &desc, const engine &e, const lrn_forward::primitive_desc &hint_fwd_pd) : mkldnn::primitive_desc(&desc.data, nullptr, e, hint_fwd_pd.get()) {} primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e, const lrn_forward::primitive_desc &hint_fwd_pd) : mkldnn::primitive_desc(&desc.data, &attr, e, hint_fwd_pd.get()) {} REG_QUERY_MD(diff_src, diff_src, 0); REG_QUERY_MD(diff_dst, diff_dst, 0); REG_QUERY_MD(workspace, workspace, 0); REG_QUERY_MD(scratchpad, scratchpad, 0); }; lrn_backward(const primitive_desc &pd): primitive(pd) {} }; /// @} /// @addtogroup cpp_api_pooling Pooling /// A primitive to perform max or average pooling. /// /// @sa @ref c_api_pooling in @ref c_api /// @{ struct pooling_forward : public primitive { struct desc { mkldnn_pooling_desc_t data; desc(prop_kind aprop_kind, algorithm aalgorithm, const memory::desc &src_desc, const memory::desc &dst_desc, const memory::dims strides, const memory::dims kernel, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind) { memory::validate_dims(strides); memory::validate_dims(kernel); memory::validate_dims(padding_l); memory::validate_dims(padding_r); error::wrap_c_api(mkldnn_pooling_forward_desc_init(&data, mkldnn::convert_to_c(aprop_kind), convert_to_c(aalgorithm), &src_desc.data, &dst_desc.data, &strides[0], &kernel[0], &padding_l[0], &padding_r[0], mkldnn::convert_to_c(apadding_kind)), "could not init a forward pooling descriptor"); } }; struct primitive_desc : public mkldnn::primitive_desc { primitive_desc(const desc &desc, const engine &e) : mkldnn::primitive_desc(&desc.data, nullptr, e, nullptr) {} primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e) : mkldnn::primitive_desc(&desc.data, &attr, e, nullptr) {} REG_QUERY_MD(src, src, 0); REG_QUERY_MD(dst, dst, 0); REG_QUERY_MD(workspace, workspace, 0); REG_QUERY_MD(scratchpad, scratchpad, 0); }; pooling_forward(const primitive_desc &pd): primitive(pd) {} }; struct pooling_backward : public primitive { struct desc { mkldnn_pooling_desc_t data; desc(algorithm aalgorithm, const memory::desc &diff_src_desc, const memory::desc &diff_dst_desc, const memory::dims &strides, const memory::dims &kernel, const memory::dims &padding_l, const memory::dims &padding_r, const padding_kind apadding_kind) { memory::validate_dims(strides); memory::validate_dims(kernel); memory::validate_dims(padding_l); memory::validate_dims(padding_r); error::wrap_c_api(mkldnn_pooling_backward_desc_init(&data, convert_to_c(aalgorithm), &diff_src_desc.data, &diff_dst_desc.data, &strides[0], &kernel[0], &padding_l[0], &padding_r[0], mkldnn::convert_to_c(apadding_kind)), "could not init a backward pooling descriptor"); } }; struct primitive_desc : public mkldnn::primitive_desc { primitive_desc(const desc &desc, const engine &e, const pooling_forward::primitive_desc &hint_fwd_pd) : mkldnn::primitive_desc(&desc.data, nullptr, e, hint_fwd_pd.get()) {} primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e, const pooling_forward::primitive_desc &hint_fwd_pd) : mkldnn::primitive_desc(&desc.data, &attr, e, hint_fwd_pd.get()) {} REG_QUERY_MD(diff_src, diff_src, 0); REG_QUERY_MD(diff_dst, diff_dst, 0); REG_QUERY_MD(workspace, workspace, 0); REG_QUERY_MD(scratchpad, scratchpad, 0); }; pooling_backward(const primitive_desc &pd): primitive(pd) {} }; /// @} /// @addtogroup cpp_api_eltwise Eltwise /// A primitive to compute element-wise operations like parametric rectifier /// linear unit (ReLU). /// /// @sa @ref c_api_eltwise in @ref c_api /// @{ struct eltwise_forward : public primitive { struct desc { mkldnn_eltwise_desc_t data; template desc(prop_kind aprop_kind, algorithm alg_kind, const memory::desc &src_desc, T alpha = 0, T beta = 0) { error::wrap_c_api(mkldnn_eltwise_forward_desc_init(&data, mkldnn::convert_to_c(aprop_kind), mkldnn::convert_to_c(alg_kind), &src_desc.data, static_cast(alpha), static_cast(beta)), "could not create a eltwise forward descriptor"); } }; struct primitive_desc : public mkldnn::primitive_desc { primitive_desc(const desc &desc, const engine &e) : mkldnn::primitive_desc(&desc.data, nullptr, e, nullptr) {} primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e) : mkldnn::primitive_desc(&desc.data, &attr, e, nullptr) {} REG_QUERY_MD(src, src, 0); REG_QUERY_MD(dst, dst, 0); REG_QUERY_MD(scratchpad, scratchpad, 0); }; eltwise_forward(const primitive_desc &pd): primitive(pd) {} }; struct eltwise_backward : public primitive { struct desc { mkldnn_eltwise_desc_t data; template desc(algorithm alg_kind, const memory::desc &diff_data_desc, const memory::desc &data_desc, T alpha = 0, T beta = 0) { error::wrap_c_api(mkldnn_eltwise_backward_desc_init(&data, mkldnn::convert_to_c(alg_kind), &diff_data_desc.data, &data_desc.data, static_cast(alpha), static_cast(beta)), "could not create a eltwise backward descriptor"); } }; struct primitive_desc : public mkldnn::primitive_desc { primitive_desc(const desc &desc, const engine &e, const eltwise_forward::primitive_desc &hint_fwd_pd) : mkldnn::primitive_desc(&desc.data, nullptr, e, hint_fwd_pd.get()) {} primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e, const eltwise_forward::primitive_desc &hint_fwd_pd) : mkldnn::primitive_desc(&desc.data, &attr, e, hint_fwd_pd.get()) {} REG_QUERY_MD(src, src, 0); REG_QUERY_MD(diff_src, diff_src, 0); REG_QUERY_MD(diff_dst, diff_dst, 0); REG_QUERY_MD(scratchpad, scratchpad, 0); }; eltwise_backward(const primitive_desc &pd): primitive(pd) {} }; /// @} /// @addtogroup cpp_api_softmax Softmax /// A primitive to perform softmax. /// /// @sa @ref c_api_softmax in @ref c_api /// @{ struct softmax_forward : public primitive { struct desc { mkldnn_softmax_desc_t data; desc(prop_kind aprop_kind, const memory::desc &data_desc, int softmax_axis) { error::wrap_c_api(mkldnn_softmax_forward_desc_init(&data, mkldnn::convert_to_c(aprop_kind), &data_desc.data, softmax_axis), "could not create a softmax forward descriptor"); } }; struct primitive_desc : public mkldnn::primitive_desc { primitive_desc(const desc &desc, const engine &e) : mkldnn::primitive_desc(&desc.data, nullptr, e, nullptr) {} primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e) : mkldnn::primitive_desc(&desc.data, &attr, e, nullptr) {} REG_QUERY_MD(src, src, 0); REG_QUERY_MD(dst, dst, 0); REG_QUERY_MD(scratchpad, scratchpad, 0); }; softmax_forward(const primitive_desc &pd): primitive(pd) {} }; struct softmax_backward : public primitive { struct desc { mkldnn_softmax_desc_t data; desc(const memory::desc &diff_desc, const memory::desc &data_desc, int softmax_axis) { error::wrap_c_api(mkldnn_softmax_backward_desc_init(&data, &diff_desc.data, &data_desc.data, softmax_axis), "could not init a backward softmax descriptor"); } }; struct primitive_desc : public mkldnn::primitive_desc { primitive_desc(const desc &desc, const engine &e, const softmax_forward::primitive_desc &hint_fwd_pd) : mkldnn::primitive_desc(&desc.data, nullptr, e, hint_fwd_pd.get()) {} primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e, const softmax_forward::primitive_desc &hint_fwd_pd) : mkldnn::primitive_desc(&desc.data, &attr, e, hint_fwd_pd.get()) {} REG_QUERY_MD(dst, dst, 0); REG_QUERY_MD(diff_src, diff_src, 0); REG_QUERY_MD(diff_dst, diff_dst, 0); REG_QUERY_MD(workspace, workspace, 0); REG_QUERY_MD(scratchpad, scratchpad, 0); }; softmax_backward(const primitive_desc &pd): primitive(pd) {} }; /// @} /// @addtogroup cpp_api_batch_norm Batch normalization /// A primitive to perform batch normalization. /// /// @sa @ref c_api_batch_normalization in @ref c_api /// @{ struct batch_normalization_forward : public primitive { struct desc { mkldnn_batch_normalization_desc_t data; template desc(prop_kind aprop_kind, const memory::desc &src_desc, T epsilon, unsigned flags) { error::wrap_c_api( mkldnn_batch_normalization_forward_desc_init(&data, mkldnn::convert_to_c(aprop_kind), &src_desc.data, static_cast(epsilon), flags), "could not create a batch normalization forward descriptor"); } }; struct primitive_desc : public mkldnn::primitive_desc { primitive_desc(const desc &desc, const engine &e) : mkldnn::primitive_desc(&desc.data, nullptr, e, nullptr) {} primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e) : mkldnn::primitive_desc(&desc.data, &attr, e, nullptr) {} REG_QUERY_MD(src, src, 0); REG_QUERY_MD(weights, weights, 0); REG_QUERY_MD(dst, dst, 0); REG_QUERY_MD(workspace, workspace, 0); REG_QUERY_MD(scratchpad, scratchpad, 0); memory::desc mean_desc() const { return stat_desc(mean); } memory::desc variance_desc() const { return stat_desc(var); } private: enum { mean = 1, var = 2, }; memory::desc stat_desc(int kind) const { mkldnn_batch_normalization_desc_t *p; error::wrap_c_api(mkldnn_primitive_desc_query( get(), mkldnn::convert_to_c(batch_normalization_d), 0, &p), "could not get a batch-normalization descriptor"); return query_md(p->flags & use_global_stats ? src_md : dst_md, kind); } }; batch_normalization_forward(const primitive_desc &pd): primitive(pd) {} }; struct batch_normalization_backward : public primitive { struct desc { mkldnn_batch_normalization_desc_t data; template desc(prop_kind aprop_kind, const memory::desc &diff_data_desc, const memory::desc &data_desc, T epsilon, unsigned flags) { error::wrap_c_api( mkldnn_batch_normalization_backward_desc_init(&data, mkldnn::convert_to_c(aprop_kind), &diff_data_desc.data, &data_desc.data, static_cast(epsilon), flags), "could not create a batch normalization backward descriptor"); } }; struct primitive_desc : public mkldnn::primitive_desc { primitive_desc(const desc &desc, const engine &e, const batch_normalization_forward::primitive_desc &hint_fwd_pd) : mkldnn::primitive_desc(&desc.data, nullptr, e, hint_fwd_pd.get()) {} primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e, const batch_normalization_forward::primitive_desc &hint_fwd_pd) : mkldnn::primitive_desc(&desc.data, &attr, e, hint_fwd_pd.get()) {} REG_QUERY_MD(src, src, 0); REG_QUERY_MD(mean, src, 1); REG_QUERY_MD(variance, src, 2); REG_QUERY_MD(weights, weights, 0); REG_QUERY_MD(dst, dst, 0); REG_QUERY_MD(diff_dst, diff_dst, 0); REG_QUERY_MD(workspace, workspace, 0); REG_QUERY_MD(diff_src, diff_src, 0); REG_QUERY_MD(diff_weights, diff_weights, 0); REG_QUERY_MD(scratchpad, scratchpad, 0); }; batch_normalization_backward(const primitive_desc &pd): primitive(pd) {} }; /// @} /// @addtogroup cpp_api_inner_product Inner Product /// A primitive to compute an inner product. /// /// @sa @ref c_api_inner_product in @ref c_api /// @{ struct inner_product_forward: public primitive { struct desc { mkldnn_inner_product_desc_t data; desc(prop_kind aprop_kind, const memory::desc &src_desc, const memory::desc &weights_desc, const memory::desc &bias_desc, const memory::desc &dst_desc) { error::wrap_c_api( mkldnn_inner_product_forward_desc_init(&data, mkldnn::convert_to_c(aprop_kind), &src_desc.data, &weights_desc.data, &bias_desc.data, &dst_desc.data), "could not create a inner product forward descriptor"); } desc(prop_kind aprop_kind, const memory::desc &src_desc, const memory::desc &weights_desc, const memory::desc &dst_desc) { error::wrap_c_api( mkldnn_inner_product_forward_desc_init(&data, mkldnn::convert_to_c(aprop_kind), &src_desc.data, &weights_desc.data, nullptr, &dst_desc.data), "could not create a inner product forward descriptor"); } }; struct primitive_desc : public mkldnn::primitive_desc { primitive_desc(const desc &desc, const engine &e) : mkldnn::primitive_desc(&desc.data, nullptr, e, nullptr) {} primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e) : mkldnn::primitive_desc(&desc.data, &attr, e, nullptr) {} REG_QUERY_MD(src, src, 0); REG_QUERY_MD(weights, weights, 0); REG_QUERY_MD(bias, weights, 1); REG_QUERY_MD(dst, dst, 0); REG_QUERY_MD(scratchpad, scratchpad, 0); }; inner_product_forward(const primitive_desc &pd): primitive(pd) {} }; struct inner_product_backward_data: public primitive { struct desc { mkldnn_inner_product_desc_t data; desc(const memory::desc &diff_src_desc, const memory::desc &weights_desc, const memory::desc &diff_dst_desc) { error::wrap_c_api( mkldnn_inner_product_backward_data_desc_init(&data, &diff_src_desc.data, &weights_desc.data, &diff_dst_desc.data), "could not create a inner product backward data descriptor"); } }; struct primitive_desc : public mkldnn::primitive_desc { primitive_desc(const desc &desc, const engine &e, const inner_product_forward::primitive_desc &hint_fwd_pd) : mkldnn::primitive_desc(&desc.data, nullptr, e, hint_fwd_pd.get()) {} primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e, const inner_product_forward::primitive_desc &hint_fwd_pd) : mkldnn::primitive_desc(&desc.data, &attr, e, hint_fwd_pd.get()) {} REG_QUERY_MD(diff_src, diff_src, 0); REG_QUERY_MD(weights, weights, 0); REG_QUERY_MD(diff_dst, diff_dst, 0); REG_QUERY_MD(scratchpad, scratchpad, 0); }; inner_product_backward_data(const primitive_desc &pd): primitive(pd) {} }; struct inner_product_backward_weights: public primitive { struct desc { mkldnn_inner_product_desc_t data; desc(const memory::desc &src_desc, const memory::desc &diff_weights_desc, const memory::desc &diff_bias_desc, const memory::desc &diff_dst_desc) { error::wrap_c_api( mkldnn_inner_product_backward_weights_desc_init( &data, &src_desc.data, &diff_weights_desc.data, &diff_bias_desc.data, &diff_dst_desc.data), "could not create a inner product backward weights descriptor"); } desc(const memory::desc &src_desc, const memory::desc &diff_weights_desc, const memory::desc &diff_dst_desc) { error::wrap_c_api( mkldnn_inner_product_backward_weights_desc_init( &data, &src_desc.data, &diff_weights_desc.data, nullptr, &diff_dst_desc.data), "could not create a inner product backward weights descriptor"); } }; struct primitive_desc : public mkldnn::primitive_desc { primitive_desc(const desc &desc, const engine &e, const inner_product_forward::primitive_desc &hint_fwd_pd) : mkldnn::primitive_desc(&desc.data, nullptr, e, hint_fwd_pd.get()) {} primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e, const inner_product_forward::primitive_desc &hint_fwd_pd) : mkldnn::primitive_desc(&desc.data, &attr, e, hint_fwd_pd.get()) {} REG_QUERY_MD(src, src, 0); REG_QUERY_MD(diff_weights, diff_weights, 0); REG_QUERY_MD(diff_bias, diff_weights, 1); REG_QUERY_MD(diff_dst, diff_dst, 0); REG_QUERY_MD(scratchpad, scratchpad, 0); }; inner_product_backward_weights(const primitive_desc &pd): primitive(pd) {} }; /// @} /// @addtogroup cpp_api_rnn RNN /// A primitive to compute common recurrent layer. /// /// @sa @ref c_api_rnn in @ref c_api /// @{ struct rnn_cell { struct desc { mkldnn_rnn_cell_desc_t c_rnn_cell_; desc(algorithm kind, algorithm activation_f) { error::wrap_c_api(mkldnn_rnn_cell_desc_init(&c_rnn_cell_, mkldnn::convert_to_c(kind), mkldnn::convert_to_c(activation_f), 0U, 0, 0), "could not init an rnn cell descriptor"); } desc(algorithm kind): desc(kind, algorithm::algorithm_undef) {} operator const mkldnn_rnn_cell_desc_t*() const { return &c_rnn_cell_; } algorithm get_cell_kind() const { return algorithm(c_rnn_cell_.cell_kind); } algorithm get_activation() const { return algorithm(c_rnn_cell_.activation_kind); } float get_alpha() const { return c_rnn_cell_.alpha; } void set_alpha(float alpha) { c_rnn_cell_.flags |= mkldnn_rnn_cell_with_relu; c_rnn_cell_.alpha = alpha; } float get_clipping() const { return c_rnn_cell_.clipping; } void set_clipping(float clipping) { c_rnn_cell_.flags |= mkldnn_rnn_cell_with_clipping; c_rnn_cell_.clipping = clipping; } int get_gates_count() const { return mkldnn_rnn_cell_get_gates_count(&c_rnn_cell_); } int get_state_count() const { return mkldnn_rnn_cell_get_states_count(&c_rnn_cell_); } }; }; struct rnn_forward : public primitive { struct desc { mkldnn_rnn_desc_t data; desc(prop_kind aprop_kind, rnn_cell::desc cell, const rnn_direction direction, const memory::desc &src_layer_desc, const memory::desc &src_iter_desc, const memory::desc &weights_layer_desc, const memory::desc &weights_iter_desc, const memory::desc &bias_desc, const memory::desc &dst_layer_desc, const memory::desc &dst_iter_desc ) { error::wrap_c_api(mkldnn_rnn_forward_desc_init(&data, mkldnn::convert_to_c(aprop_kind), cell, mkldnn::convert_to_c(direction), &src_layer_desc.data, &src_iter_desc.data, &weights_layer_desc.data, &weights_iter_desc.data, &bias_desc.data, &dst_layer_desc.data, &dst_iter_desc.data), "could not create an RNN forward descriptor"); } }; struct primitive_desc : public mkldnn::primitive_desc { primitive_desc(const desc &desc, const engine &e) : mkldnn::primitive_desc(&desc.data, nullptr, e, nullptr) {} primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e) : mkldnn::primitive_desc(&desc.data, &attr, e, nullptr) {} REG_QUERY_MD(src_layer, src, 0); REG_QUERY_MD(src_iter, src, 1); REG_QUERY_MD(weights_layer, weights, 0); REG_QUERY_MD(weights_iter, weights, 1); REG_QUERY_MD(bias, weights, 2); REG_QUERY_MD(dst_layer, dst, 0); REG_QUERY_MD(dst_iter, dst, 1); REG_QUERY_MD(workspace, workspace, 0); REG_QUERY_MD(scratchpad, scratchpad, 0); }; rnn_forward(const primitive_desc &pd): primitive(pd) {} }; struct rnn_backward : public primitive { struct desc { mkldnn_rnn_desc_t data; desc(prop_kind aprop_kind, rnn_cell::desc cell, const rnn_direction direction, const memory::desc &src_layer_desc, const memory::desc &src_iter_desc, const memory::desc &weights_layer_desc, const memory::desc &weights_iter_desc, const memory::desc &bias_desc, const memory::desc &dst_layer_desc, const memory::desc &dst_iter_desc, const memory::desc &diff_src_layer_desc, const memory::desc &diff_src_iter_desc, const memory::desc &diff_weights_layer_desc, const memory::desc &diff_weights_iter_desc, const memory::desc &diff_bias_desc, const memory::desc &diff_dst_layer_desc, const memory::desc &diff_dst_iter_desc) { error::wrap_c_api(mkldnn_rnn_backward_desc_init(&data, mkldnn::convert_to_c(aprop_kind), cell, mkldnn::convert_to_c(direction), &src_layer_desc.data, &src_iter_desc.data, &weights_layer_desc.data, &weights_iter_desc.data, &bias_desc.data, &dst_layer_desc.data, &dst_iter_desc.data, &diff_src_layer_desc.data, &diff_src_iter_desc.data, &diff_weights_layer_desc.data, &diff_weights_iter_desc.data, &diff_bias_desc.data, &diff_dst_layer_desc.data, &diff_dst_iter_desc.data), "could not create an RNN backward descriptor"); } }; struct primitive_desc : public mkldnn::primitive_desc { primitive_desc(const desc &desc, const engine &e, const rnn_forward::primitive_desc &hint_fwd_pd) : mkldnn::primitive_desc(&desc.data, nullptr, e, hint_fwd_pd.get()) {} primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e, const rnn_forward::primitive_desc &hint_fwd_pd) : mkldnn::primitive_desc(&desc.data, &attr, e, hint_fwd_pd.get()) {} REG_QUERY_MD(src_layer, src, 0); REG_QUERY_MD(src_iter, src, 1); REG_QUERY_MD(weights_layer, weights, 0); REG_QUERY_MD(weights_iter, weights, 1); REG_QUERY_MD(bias, weights, 2); REG_QUERY_MD(dst_layer, dst, 0); REG_QUERY_MD(dst_iter, dst, 1); REG_QUERY_MD(workspace, workspace, 0); REG_QUERY_MD(diff_src_layer, diff_src, 0); REG_QUERY_MD(diff_src_iter, diff_src, 1); REG_QUERY_MD(diff_weights_layer, diff_weights, 0); REG_QUERY_MD(diff_weights_iter, diff_weights, 1); REG_QUERY_MD(diff_bias, diff_weights, 2); REG_QUERY_MD(diff_dst_layer, diff_dst, 0); REG_QUERY_MD(diff_dst_iter, diff_dst, 1); REG_QUERY_MD(scratchpad, scratchpad, 0); }; // With last iteration (with and without input src_iter) rnn_backward(const primitive_desc &pd): primitive(pd) {} }; /// @} /// @addtogroup cpp_api_shuffle Shuffle /// A primitive to shuffle data along the axis. /// /// @sa @ref c_api_shuffle in @ref c_api /// @{ struct shuffle_forward : public primitive { struct desc { mkldnn_shuffle_desc_t data; desc(prop_kind aprop_kind, const memory::desc &data_desc, int axis, int group_size) { error::wrap_c_api(mkldnn_shuffle_forward_desc_init(&data, mkldnn::convert_to_c(aprop_kind), &data_desc.data, axis, group_size), "could not create a shuffle forward descriptor"); } }; struct primitive_desc : public mkldnn::primitive_desc { primitive_desc(const desc &desc, const engine &e) : mkldnn::primitive_desc(&desc.data, nullptr, e, nullptr) {} REG_QUERY_MD(src, src, 0); REG_QUERY_MD(dst, dst, 0); REG_QUERY_MD(scratchpad, scratchpad, 0); }; shuffle_forward(const primitive_desc &pd): primitive(pd) {} }; struct shuffle_backward : public primitive { struct desc { mkldnn_shuffle_desc_t data; desc(const memory::desc &diff_data_desc, int axis, int group_size) { error::wrap_c_api(mkldnn_shuffle_backward_desc_init(&data, &diff_data_desc.data, axis, group_size), "could not create a shuffle backward descriptor"); } }; struct primitive_desc : public mkldnn::primitive_desc { primitive_desc(const desc &desc, const engine &e, const shuffle_forward::primitive_desc &hint_fwd_pd) : mkldnn::primitive_desc(&desc.data, nullptr, e, hint_fwd_pd.get()) {} REG_QUERY_MD(diff_src, diff_src, 0); REG_QUERY_MD(diff_dst, diff_dst, 0); REG_QUERY_MD(scratchpad, scratchpad, 0); }; shuffle_backward(const primitive_desc &pd): primitive(pd) {} }; /// @} /// @} Primitives /// @} C++ API #undef REG_QUERY_MD // implementation section #ifndef DOXYGEN_SHOULD_SKIP_THIS inline primitive::primitive(const_mkldnn_primitive_desc_t c_pd) { mkldnn_primitive_t result; error::wrap_c_api(mkldnn_primitive_create(&result, c_pd), "could not create a primitive"); reset(result); } inline primitive::primitive(const primitive_desc &pd): primitive(pd.get()) {} inline void primitive::execute(stream &astream, const std::unordered_map &args) const { std::vector c_args; c_args.reserve(args.size()); for (const auto &a: args) c_args.push_back({a.first, a.second.get()}); error::wrap_c_api(mkldnn_primitive_execute(get(), astream.get(), (int)c_args.size(), c_args.data()), "primitive execution fail"); } #endif // DOXYGEN_SHOULD_SKIP_THIS } // namespace mkldnn #endif