c++ api: remove algorithms from primitives to get the same algorithm for forward and backward

Author: igorsafo

include/mkldnn.hpp

@@ -252,7 +252,6 @@ template <> struct handle_traits<c_api::mkldnn_primitive_desc_t> {
 /// Memory primitive that describes the data.
 struct memory: public primitive  {
     private:
-// TODO: check me please
     std::shared_ptr<char> _handle;
 
     public:
@@ -487,6 +486,17 @@ inline c_api::mkldnn_prop_kind_t convert_to_c(prop_kind kind) {
     return static_cast<c_api::mkldnn_prop_kind_t>(kind);
 }
 
+enum algorithm {
+    convolution_direct = c_api::mkldnn_convolution_direct,
+    lrn_across_channels = c_api::mkldnn_lrn_across_channels,
+    lrn_within_channel  = c_api::mkldnn_lrn_within_channel,
+    pooling_max = c_api::mkldnn_pooling_max,
+    pooling_avg = c_api::mkldnn_pooling_avg
+};
+static c_api::mkldnn_alg_kind_t convert_to_c(algorithm aalgorithm) {
+    return static_cast<c_api::mkldnn_alg_kind_t>(aalgorithm);
+}
+
 struct reorder : public primitive {
     struct primitive_desc : public handle<c_api::mkldnn_primitive_desc_t>{
         primitive_desc(const memory::primitive_desc &input,
@@ -697,10 +707,6 @@ struct stream: public handle<c_api::mkldnn_stream_t> {
 };
 
 struct convolution_forward: public primitive {
-    enum algorithm { direct = c_api::mkldnn_convolution_direct };
-    static c_api::mkldnn_alg_kind_t convert_to_c(algorithm aalgorithm) {
-        return static_cast<c_api::mkldnn_alg_kind_t>(aalgorithm);
-    }
     struct desc {
         c_api::mkldnn_convolution_desc_t data;
         desc(prop_kind aprop_kind, algorithm aalgorithm,
@@ -741,7 +747,6 @@ struct convolution_forward: public primitive {
                     "could not create a convolution forward descriptor");
         }
     };
-// TODO: replace nullptr -> hint
     struct primitive_desc : public handle<c_api::mkldnn_primitive_desc_t>{
         primitive_desc(const desc &adesc, const engine &aengine) {
             c_api::mkldnn_primitive_desc_t result;
@@ -827,10 +832,6 @@ struct convolution_forward: public primitive {
 };
 
 struct convolution_backward_data : public primitive {
-    enum algorithm { direct = c_api::mkldnn_convolution_direct };
-    static c_api::mkldnn_alg_kind_t convert_to_c(algorithm aalgorithm) {
-        return static_cast<c_api::mkldnn_alg_kind_t>(aalgorithm);
-    }
     struct desc {
         c_api::mkldnn_convolution_desc_t data;
         desc(algorithm aalgorithm,
@@ -877,10 +878,6 @@ struct convolution_backward_data : public primitive {
 };
 
 struct convolution_backward_weights : public primitive {
-    enum algorithm { direct = c_api::mkldnn_convolution_direct };
-    static c_api::mkldnn_alg_kind_t convert_to_c(algorithm aalgorithm) {
-        return static_cast<c_api::mkldnn_alg_kind_t>(aalgorithm);
-    }
     struct desc {
         c_api::mkldnn_convolution_desc_t data;
         desc(algorithm aalgorithm,
@@ -927,10 +924,6 @@ struct convolution_backward_weights : public primitive {
 };
 
 struct convolution_backward_bias : public primitive {
-    enum algorithm { direct = c_api::mkldnn_convolution_direct };
-    static c_api::mkldnn_alg_kind_t convert_to_c(algorithm aalgorithm) {
-        return static_cast<c_api::mkldnn_alg_kind_t>(aalgorithm);
-    }
     struct desc {
         c_api::mkldnn_convolution_desc_t data;
         desc(algorithm aalgorithm,
@@ -966,13 +959,6 @@ struct convolution_backward_bias : public primitive {
 };
 
 struct lrn_forward : public primitive {
-    enum algorithm {
-        across_channels = c_api::mkldnn_lrn_across_channels,
-        within_channel  = c_api::mkldnn_lrn_within_channel,
-    };
-    static c_api::mkldnn_alg_kind_t convert_to_c(algorithm aalgorithm) {
-        return static_cast<c_api::mkldnn_alg_kind_t>(aalgorithm);
-    }
     struct desc {
         c_api::mkldnn_lrn_desc_t data;
         desc(prop_kind aprop_kind, algorithm aalgorithm,
@@ -1056,13 +1042,6 @@ struct lrn_forward : public primitive {
 };
 
 struct pooling_forward : public primitive {
-    enum algorithm {
-        max = c_api::mkldnn_pooling_max,
-        avg = c_api::mkldnn_pooling_avg
-    };
-    static c_api::mkldnn_alg_kind_t convert_to_c(algorithm aalgorithm) {
-        return static_cast<c_api::mkldnn_alg_kind_t>(aalgorithm);
-    }
     struct desc {
         c_api::mkldnn_pooling_desc_t data;
         desc(prop_kind aprop_kind, algorithm aalgorithm,

tests/gtests/test_convolution_format_any.cpp

@@ -25,7 +25,7 @@ using fmt = memory::format;
 struct conv_any_fmt_test_params {
     prop_kind aprop_kind;
     const engine::kind engine_kind;
-    convolution_forward::algorithm aalgorithm;
+    algorithm aalgorithm;
     fmt src_fmt_in;
     fmt src_fmt_exp;
     fmt weights_fmt_in;
@@ -48,7 +48,7 @@ class convolution_any_fmt_test
 
         ASSERT_TRUE(p.engine_kind == engine::kind::cpu);
         ASSERT_EQ(p.aprop_kind, prop_kind::forward);
-        ASSERT_EQ(p.aalgorithm, convolution_forward::direct);
+        ASSERT_EQ(p.aalgorithm, algorithm::convolution_direct);
         auto eng = engine(p.engine_kind, 0);
         memory::data_type data_type = data_traits<data_t>::data_type;
         ASSERT_EQ(data_type, mkldnn::memory::data_type::f32);
@@ -113,35 +113,35 @@ TEST_P(conv_any_fmt_test_float, TestsConvolutionAnyFmt)
 }
 INSTANTIATE_TEST_CASE_P(TestConvolutionAnyFmtForward, conv_any_fmt_test_float,
         ::testing::Values(conv_any_fmt_test_params_float{ prop_kind::forward,
-                engine::kind::cpu, convolution_forward::direct, fmt::any, fmt::nchw,
+                engine::kind::cpu, algorithm::convolution_direct, fmt::any, fmt::nchw,
                 fmt::any, fmt::oihw, fmt::any, fmt::x, fmt::any, fmt::nchw,
                 { 2, 1, 4, 4, 4, 6, 4, 4, 3, 3, 1, 1, 1, 1 } }));
 
 INSTANTIATE_TEST_CASE_P(
         TestConvolutionAlexnetAnyFmtForwardBlocked, conv_any_fmt_test_float,
         ::testing::Values(
                 conv_any_fmt_test_params_float{ prop_kind::forward,
-                        engine::kind::cpu, convolution_forward::direct, fmt::any,
+                        engine::kind::cpu, algorithm::convolution_direct, fmt::any,
                         fmt::nchw, fmt::any, fmt::Ohwi8o, fmt::any, fmt::x,
                         fmt::any, fmt::nChw8c,
                         { 2, 1, 3, 227, 227, 96, 55, 55, 11, 11, 0, 0, 4, 4 } },
                 conv_any_fmt_test_params_float{ prop_kind::forward,
-                        engine::kind::cpu, convolution_forward::direct, fmt::any,
+                        engine::kind::cpu, algorithm::convolution_direct, fmt::any,
                         fmt::nChw8c, fmt::any, fmt::gOIhw8i8o, fmt::any, fmt::x,
                         fmt::any, fmt::nChw8c,
                         { 2, 2, 96, 27, 27, 256, 27, 27, 5, 5, 2, 2, 1, 1 } },
                 conv_any_fmt_test_params_float{ prop_kind::forward,
-                        engine::kind::cpu, convolution_forward::direct, fmt::any,
+                        engine::kind::cpu, algorithm::convolution_direct, fmt::any,
                         fmt::nChw8c, fmt::any, fmt::OIhw8i8o, fmt::any, fmt::x,
                         fmt::any, fmt::nChw8c,
                         { 2, 1, 256, 13, 13, 384, 13, 13, 3, 3, 1, 1, 1, 1 } },
                 conv_any_fmt_test_params_float{ prop_kind::forward,
-                        engine::kind::cpu, convolution_forward::direct, fmt::any,
+                        engine::kind::cpu, algorithm::convolution_direct, fmt::any,
                         fmt::nChw8c, fmt::any, fmt::gOIhw8i8o, fmt::any, fmt::x,
                         fmt::any, fmt::nChw8c,
                         { 2, 2, 384, 13, 13, 384, 13, 13, 3, 3, 1, 1, 1, 1 } },
                 conv_any_fmt_test_params_float{ prop_kind::forward,
-                        engine::kind::cpu, convolution_forward::direct, fmt::any,
+                        engine::kind::cpu, algorithm::convolution_direct, fmt::any,
                         fmt::nChw8c, fmt::any, fmt::gOIhw8i8o, fmt::any, fmt::x,
                         fmt::any, fmt::nChw8c, { 2, 2, 384, 13, 13, 256, 13, 13,
                                                        3, 3, 1, 1, 1, 1 } }));