From 17c2590f8f6789c5ca556552650e5cee4405e8fa Mon Sep 17 00:00:00 2001 From: Tao Lv Date: Thu, 8 Nov 2018 12:20:01 +0800 Subject: [PATCH] Update MKL-DNN dependency (#12953) * update mkldnn and fix conv/deconv * fix * fix indent * fix cmake * fix cmake * fix cpp test for mkldnn * fix typo * fix conficts after merge * debug: remove 5d test * debug: remove 4d test * add comments * debug: remove 2d test * update mklml in ci * fix mklml * Revert "fix mklml" This reverts commit 328a22a373c49aacb914badd0db431bfbc8234f3. * Revert "update mklml in ci" This reverts commit 9ff3687892f85f43b8eac72ba935ceda928ae7e8. * Revert "debug: remove 2d test" This reverts commit 32551b3662fc30d5c9758a86c7664b4f2e367128. * Revert "debug: remove 4d test" This reverts commit 5412d643c2b00ce54c05e7387aca6779dee120d5. * Revert "debug: remove 5d test" This reverts commit 1fe9f8806d29c765e05f91c584799a947af2eb1d. * debug illegal core dump * debug illegal core dump * Revert "debug illegal core dump" This reverts commit 39321d578ae589465c0d4edcae7f92b88fdf3feb. * Revert "debug illegal core dump" This reverts commit 153b068b6d3a18a33f399076d3420ac42f2bc387. * change cmake * pin mkldnn version to 0.17rc * change format number * remove include directories in cmake * fix cpp test * address cpplint complaint * remove comment code * update mkldnn head --- 3rdparty/mkldnn | 2 +- CMakeLists.txt | 6 +- src/operator/nn/mkldnn/mkldnn_base-inl.h | 12 +++ src/operator/nn/mkldnn/mkldnn_base.cc | 3 + src/operator/nn/mkldnn/mkldnn_convolution.cc | 97 +++++++++++++++++-- .../nn/mkldnn/mkldnn_deconvolution.cc | 56 ++++++++++- tests/cpp/include/test_mkldnn.h | 18 +++- tests/cpp/operator/mkldnn_operator_test.cc | 9 +- tests/cpp/operator/mkldnn_test.cc | 6 +- 9 files changed, 181 insertions(+), 28 deletions(-) diff --git a/3rdparty/mkldnn b/3rdparty/mkldnn index 0e7ca738866d..9910b480296a 160000 --- a/3rdparty/mkldnn +++ b/3rdparty/mkldnn @@ -1 +1 @@ -Subproject commit 0e7ca738866d22cc700aa33b8de120b938f910d0 +Subproject commit 9910b480296a0d1496db466531e56729b3922bbf diff --git a/CMakeLists.txt b/CMakeLists.txt index 950756d46be3..5cea683e8f56 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -229,8 +229,10 @@ if(USE_MKLDNN) if(NOT MSVC) set(ARCH_OPT_FLAGS "-mtune=generic") endif() - set(WITH_TEST OFF) - set(WITH_EXAMPLE OFF) + set(WITH_TEST OFF CACHE INTERNAL "" FORCE) + set(WITH_EXAMPLE OFF CACHE INTERNAL "" FORCE) + set(ARCH_OPT_FLAGS "" CACHE INTERNAL "" FORCE) + add_subdirectory(3rdparty/mkldnn) include_directories(3rdparty/mkldnn/include) diff --git a/src/operator/nn/mkldnn/mkldnn_base-inl.h b/src/operator/nn/mkldnn/mkldnn_base-inl.h index 8a2f4a3e5011..d8651c83d0ce 100644 --- a/src/operator/nn/mkldnn/mkldnn_base-inl.h +++ b/src/operator/nn/mkldnn/mkldnn_base-inl.h @@ -208,6 +208,18 @@ static inline int get_mxnet_type(mkldnn_data_type_t dtype) { } } +static inline size_t GetMemDescSize(const mkldnn::memory::desc &md) { + if (md.data.ndims == 0) return 0; + + size_t ret = 1; + for (int i = 0; i < md.data.ndims; i++) { + ret *= md.data.dims[i]; + } + + ret *= mshadow::mshadow_sizeof(get_mxnet_type(md.data.data_type)); + return ret; +} + inline static mkldnn::memory::desc GetMemDesc(const NDArray &arr, int ndim) { mkldnn::memory::dims dims(ndim); for (size_t i = 0; i < dims.size(); i++) dims[i] = arr.shape()[i]; diff --git a/src/operator/nn/mkldnn/mkldnn_base.cc b/src/operator/nn/mkldnn/mkldnn_base.cc index a60d6555c74d..5db51817db9d 100644 --- a/src/operator/nn/mkldnn/mkldnn_base.cc +++ b/src/operator/nn/mkldnn/mkldnn_base.cc @@ -311,9 +311,12 @@ mkldnn_memory_format_t GetDefaultFormat(const mkldnn::memory::desc &desc) { case mkldnn_oihw: case mkldnn_ihwo: case mkldnn_hwio: + case mkldnn_oIhw8i: + case mkldnn_oIhw16i: case mkldnn_OIhw8i8o: case mkldnn_OIhw16i16o: case mkldnn_OIhw4i16o4i: + case mkldnn_OIhw4i16o4i_s8s8: case mkldnn_OIhw8i16o2i: case mkldnn_OIhw8o16i2o: case mkldnn_OIhw8o8i: diff --git a/src/operator/nn/mkldnn/mkldnn_convolution.cc b/src/operator/nn/mkldnn/mkldnn_convolution.cc index 6a70ae40ac8f..9cf1b71880a8 100644 --- a/src/operator/nn/mkldnn/mkldnn_convolution.cc +++ b/src/operator/nn/mkldnn/mkldnn_convolution.cc @@ -85,16 +85,33 @@ mkldnn::convolution_forward::primitive_desc GetConvFwdImpl( attr.set_int_output_round_mode(round_nearest); } + // MKL-DNN introduced padded formats since 0.15 which require more memory + // for computation compared with the actual tensor size. Currently, MKL-DNN + // operators are still reusing those memory from memory planning and the + // memory size may smaller than what MKL-DNN kernels require. So here we need + // select suboptimal kernel for computation according to tensor sizes. if (param.conv_param.dilate.ndim() == 0 && bias == nullptr) { mkldnn::convolution_forward::desc desc(prop, mkldnn::algorithm::convolution_direct, data_md, weight_md, out_md, strides, padding, padding, mkldnn::padding_kind::zero); - return mkldnn::convolution_forward::primitive_desc(desc, attr, engine); + auto conv_pd = mkldnn::convolution_forward::primitive_desc(desc, attr, engine); + while (conv_pd.dst_primitive_desc().get_size() != GetArraySize(output) || + conv_pd.src_primitive_desc().get_size() != GetArraySize(data) || + conv_pd.weights_primitive_desc().get_size() != GetArraySize(weights)) { + CHECK(conv_pd.next_impl()) << "No implementation"; + } + return conv_pd; } else if (param.conv_param.dilate.ndim() == 0) { auto bias_md = GetMemDesc(*bias); mkldnn::convolution_forward::desc desc(prop, mkldnn::algorithm::convolution_direct, data_md, weight_md, bias_md, out_md, strides, padding, padding, mkldnn::padding_kind::zero); - return mkldnn::convolution_forward::primitive_desc(desc, attr, engine); + auto conv_pd = mkldnn::convolution_forward::primitive_desc(desc, attr, engine); + while (conv_pd.dst_primitive_desc().get_size() != GetArraySize(output) || + conv_pd.src_primitive_desc().get_size() != GetArraySize(data) || + conv_pd.weights_primitive_desc().get_size() != GetArraySize(weights)) { + CHECK(conv_pd.next_impl()) << "No implementation"; + } + return conv_pd; } else { mkldnn::memory::dims dilates{0, 0}; dilates[0] = param.conv_param.dilate[0] - 1; @@ -103,14 +120,26 @@ mkldnn::convolution_forward::primitive_desc GetConvFwdImpl( mkldnn::convolution_forward::desc desc(prop, mkldnn::algorithm::convolution_direct, data_md, weight_md, out_md, strides, dilates, padding, padding, mkldnn::padding_kind::zero); - return mkldnn::convolution_forward::primitive_desc(desc, attr, engine); + auto conv_pd = mkldnn::convolution_forward::primitive_desc(desc, attr, engine); + while (conv_pd.dst_primitive_desc().get_size() != GetArraySize(output) || + conv_pd.src_primitive_desc().get_size() != GetArraySize(data) || + conv_pd.weights_primitive_desc().get_size() != GetArraySize(weights)) { + CHECK(conv_pd.next_impl()) << "No implementation"; + } + return conv_pd; } else { auto bias_md = GetMemDesc(*bias); mkldnn::convolution_forward::desc desc(prop, mkldnn::algorithm::convolution_direct, data_md, weight_md, bias_md, out_md, strides, dilates, padding, padding, mkldnn::padding_kind::zero); - return mkldnn::convolution_forward::primitive_desc(desc, attr, engine); + auto conv_pd = mkldnn::convolution_forward::primitive_desc(desc, attr, engine); + while (conv_pd.dst_primitive_desc().get_size() != GetArraySize(output) || + conv_pd.src_primitive_desc().get_size() != GetArraySize(data) || + conv_pd.weights_primitive_desc().get_size() != GetArraySize(weights)) { + CHECK(conv_pd.next_impl()) << "No implementation"; + } + return conv_pd; } } } @@ -131,10 +160,22 @@ static mkldnn::convolution_backward_data::primitive_desc GetConvBwdData( mkldnn::memory::dims padding{0, 0}; padding[0] = param.pad[0]; padding[1] = param.pad[1]; + + // MKL-DNN introduced padded formats since 0.15 which require more memory + // for computation compared with the actual tensor size. Currently, MKL-DNN + // operators are still reusing those memory from memory planning and the + // memory size may smaller than what MKL-DNN kernels require. So here we need + // select suboptimal kernel for computation according to tensor sizes. if (param.dilate.ndim() == 0) { mkldnn::convolution_backward_data::desc desc(mkldnn::algorithm::convolution_direct, data_md, weight_md, out_md, strides, padding, padding, mkldnn::padding_kind::zero); - return mkldnn::convolution_backward_data::primitive_desc(desc, engine, fwd_pd); + auto conv_pd = mkldnn::convolution_backward_data::primitive_desc(desc, engine, fwd_pd); + while (conv_pd.diff_dst_primitive_desc().get_size() != GetArraySize(output) || + conv_pd.diff_src_primitive_desc().get_size() != GetArraySize(data) || + conv_pd.weights_primitive_desc().get_size() != GetArraySize(weights)) { + CHECK(conv_pd.next_impl()) << "No implementation"; + } + return conv_pd; } else { mkldnn::memory::dims dilates{0, 0}; dilates[0] = param.dilate[0] - 1; @@ -142,7 +183,13 @@ static mkldnn::convolution_backward_data::primitive_desc GetConvBwdData( mkldnn::convolution_backward_data::desc desc(mkldnn::algorithm::convolution_direct, data_md, weight_md, out_md, strides, dilates, padding, padding, mkldnn::padding_kind::zero); - return mkldnn::convolution_backward_data::primitive_desc(desc, engine, fwd_pd); + auto conv_pd = mkldnn::convolution_backward_data::primitive_desc(desc, engine, fwd_pd); + while (conv_pd.diff_dst_primitive_desc().get_size() != GetArraySize(output) || + conv_pd.diff_src_primitive_desc().get_size() != GetArraySize(data) || + conv_pd.weights_primitive_desc().get_size() != GetArraySize(weights)) { + CHECK(conv_pd.next_impl()) << "No implementation"; + } + return conv_pd; } } @@ -163,16 +210,34 @@ static mkldnn::convolution_backward_weights::primitive_desc GetConvBwdWeights( mkldnn::memory::dims padding{0, 0}; padding[0] = param.pad[0]; padding[1] = param.pad[1]; + + // MKL-DNN introduced padded formats since 0.15 which require more memory + // for computation compared with the actual tensor size. Currently, MKL-DNN + // operators are still reusing those memory from memory planning and the + // memory size may smaller than what MKL-DNN kernels require. So here we need + // select suboptimal kernel for computation according to tensor sizes. if (param.dilate.ndim() == 0 && bias == nullptr) { mkldnn::convolution_backward_weights::desc desc(mkldnn::algorithm::convolution_direct, data_md, weight_md, out_md, strides, padding, padding, mkldnn::padding_kind::zero); - return mkldnn::convolution_backward_weights::primitive_desc(desc, engine, fwd_pd); + auto conv_pd = mkldnn::convolution_backward_weights::primitive_desc(desc, engine, fwd_pd); + while (conv_pd.diff_dst_primitive_desc().get_size() != GetArraySize(output) || + conv_pd.src_primitive_desc().get_size() != GetArraySize(data) || + conv_pd.diff_weights_primitive_desc().get_size() != GetArraySize(weights)) { + CHECK(conv_pd.next_impl()) << "No implementation"; + } + return conv_pd; } else if (param.dilate.ndim() == 0) { auto bias_md = GetMemDesc(*bias); mkldnn::convolution_backward_weights::desc desc(mkldnn::algorithm::convolution_direct, data_md, weight_md, bias_md, out_md, strides, padding, padding, mkldnn::padding_kind::zero); - return mkldnn::convolution_backward_weights::primitive_desc(desc, engine, fwd_pd); + auto conv_pd = mkldnn::convolution_backward_weights::primitive_desc(desc, engine, fwd_pd); + while (conv_pd.diff_dst_primitive_desc().get_size() != GetArraySize(output) || + conv_pd.src_primitive_desc().get_size() != GetArraySize(data) || + conv_pd.diff_weights_primitive_desc().get_size() != GetArraySize(weights)) { + CHECK(conv_pd.next_impl()) << "No implementation"; + } + return conv_pd; } else { mkldnn::memory::dims dilates{0, 0}; dilates[0] = param.dilate[0] - 1; @@ -181,14 +246,26 @@ static mkldnn::convolution_backward_weights::primitive_desc GetConvBwdWeights( mkldnn::convolution_backward_weights::desc desc(mkldnn::algorithm::convolution_direct, data_md, weight_md, out_md, strides, dilates, padding, padding, mkldnn::padding_kind::zero); - return mkldnn::convolution_backward_weights::primitive_desc(desc, engine, fwd_pd); + auto conv_pd = mkldnn::convolution_backward_weights::primitive_desc(desc, engine, fwd_pd); + while (conv_pd.diff_dst_primitive_desc().get_size() != GetArraySize(output) || + conv_pd.src_primitive_desc().get_size() != GetArraySize(data) || + conv_pd.diff_weights_primitive_desc().get_size() != GetArraySize(weights)) { + CHECK(conv_pd.next_impl()) << "No implementation"; + } + return conv_pd; } else { auto bias_md = GetMemDesc(*bias); mkldnn::convolution_backward_weights::desc desc(mkldnn::algorithm::convolution_direct, data_md, weight_md, bias_md, out_md, strides, dilates, padding, padding, mkldnn::padding_kind::zero); - return mkldnn::convolution_backward_weights::primitive_desc(desc, engine, fwd_pd); + auto conv_pd = mkldnn::convolution_backward_weights::primitive_desc(desc, engine, fwd_pd); + while (conv_pd.diff_dst_primitive_desc().get_size() != GetArraySize(output) || + conv_pd.src_primitive_desc().get_size() != GetArraySize(data) || + conv_pd.diff_weights_primitive_desc().get_size() != GetArraySize(weights)) { + CHECK(conv_pd.next_impl()) << "No implementation"; + } + return conv_pd; } } } diff --git a/src/operator/nn/mkldnn/mkldnn_deconvolution.cc b/src/operator/nn/mkldnn/mkldnn_deconvolution.cc index 54d4f6708524..93032f7c92d6 100644 --- a/src/operator/nn/mkldnn/mkldnn_deconvolution.cc +++ b/src/operator/nn/mkldnn/mkldnn_deconvolution.cc @@ -52,17 +52,34 @@ static mkldnn::convolution_forward::primitive_desc GetDeconvBwd_( bool has_bias, const mkldnn::memory::desc &out_md, const mkldnn::engine &engine, const mkldnn::memory::dims &strides, const mkldnn::memory::dims &padding, const mkldnn::memory::dims &dilates) { + // MKL-DNN introduced padded formats since 0.15 which require more memory + // for computation compared with the actual tensor size. Currently, MKL-DNN + // operators are still reusing those memory from memory planning and the + // memory size may smaller than what MKL-DNN kernels require. So here we need + // select suboptimal kernel for computation according to tensor sizes. if (!has_bias) { mkldnn::convolution_forward::desc desc(mkldnn::prop_kind::forward_training, mkldnn::algorithm::convolution_direct, out_md, weights_md, data_md, strides, dilates, padding, padding, mkldnn::padding_kind::zero); - return mkldnn::convolution_forward::primitive_desc(desc, engine); + auto deconv_pd = mkldnn::convolution_forward::primitive_desc(desc, engine); + while (deconv_pd.dst_primitive_desc().get_size() != GetMemDescSize(data_md) || + deconv_pd.src_primitive_desc().get_size() != GetMemDescSize(out_md) || + deconv_pd.weights_primitive_desc().get_size() != GetMemDescSize(weights_md)) { + CHECK(deconv_pd.next_impl()) << "No implementation"; + } + return deconv_pd; } else { auto bias_md = GetBiasDesc(data_md); mkldnn::convolution_forward::desc desc(mkldnn::prop_kind::forward_training, mkldnn::algorithm::convolution_direct, out_md, weights_md, bias_md, data_md, strides, dilates, padding, padding, mkldnn::padding_kind::zero); - return mkldnn::convolution_forward::primitive_desc(desc, engine); + auto deconv_pd = mkldnn::convolution_forward::primitive_desc(desc, engine); + while (deconv_pd.dst_primitive_desc().get_size() != GetMemDescSize(data_md) || + deconv_pd.src_primitive_desc().get_size() != GetMemDescSize(out_md) || + deconv_pd.weights_primitive_desc().get_size() != GetMemDescSize(weights_md)) { + CHECK(deconv_pd.next_impl()) << "No implementation"; + } + return deconv_pd; } } @@ -90,7 +107,18 @@ static mkldnn::convolution_backward_data::primitive_desc GetDeconvFwdImpl( mkldnn::convolution_backward_data::desc desc(mkldnn::algorithm::convolution_direct, out_md, weight_md, data_md, strides, dilate, padding, padding, mkldnn::padding_kind::zero); - return mkldnn::convolution_backward_data::primitive_desc(desc, engine, bwd_pd); + auto deconv_pd = mkldnn::convolution_backward_data::primitive_desc(desc, engine, bwd_pd); + // MKL-DNN introduced padded formats since 0.15 which require more memory + // for computation compared with the actual tensor size. Currently, MKL-DNN + // operators are still reusing those memory from memory planning and the + // memory size may smaller than what MKL-DNN kernels require. So here we need + // select suboptimal kernel for computation according to tensor sizes. + while (deconv_pd.diff_dst_primitive_desc().get_size() != GetMemDescSize(data_md) || + deconv_pd.diff_src_primitive_desc().get_size() != GetMemDescSize(out_md) || + deconv_pd.weights_primitive_desc().get_size() != GetMemDescSize(weight_md)) { + CHECK(deconv_pd.next_impl()) << "No implementation"; + } + return deconv_pd; } static mkldnn::convolution_forward::primitive_desc GetDeconvBwdDataImpl( @@ -137,16 +165,34 @@ GetDeconvBwdWeightsImpl( mkldnn::memory::dims dilate{0, 0}; dilate[0] = param.dilate[0] - 1; dilate[1] = param.dilate[1] - 1; + + // MKL-DNN introduced padded formats since 0.15 which require more memory + // for computation compared with the actual tensor size. Currently, MKL-DNN + // operators are still reusing those memory from memory planning and the + // memory size may smaller than what MKL-DNN kernels require. So here we need + // select suboptimal kernel for computation according to tensor sizes. if (!has_bias) { mkldnn::convolution_backward_weights::desc desc(mkldnn::algorithm::convolution_direct, out_md, weight_md, data_md, strides, dilate, padding, padding, mkldnn::padding_kind::zero); - return mkldnn::convolution_backward_weights::primitive_desc(desc, engine, fwd_pd); + auto deconv_pd = mkldnn::convolution_backward_weights::primitive_desc(desc, engine, fwd_pd); + while (deconv_pd.diff_dst_primitive_desc().get_size() != GetMemDescSize(data_md) || + deconv_pd.src_primitive_desc().get_size() != GetMemDescSize(out_md) || + deconv_pd.diff_weights_primitive_desc().get_size() != GetMemDescSize(weight_md)) { + CHECK(deconv_pd.next_impl()) << "No implementation"; + } + return deconv_pd; } else { auto bias_md = GetBiasDesc(data_md); mkldnn::convolution_backward_weights::desc desc(mkldnn::algorithm::convolution_direct, out_md, weight_md, bias_md, data_md, strides, dilate, padding, padding, mkldnn::padding_kind::zero); - return mkldnn::convolution_backward_weights::primitive_desc(desc, engine, fwd_pd); + auto deconv_pd = mkldnn::convolution_backward_weights::primitive_desc(desc, engine, fwd_pd); + while (deconv_pd.diff_dst_primitive_desc().get_size() != GetMemDescSize(data_md) || + deconv_pd.src_primitive_desc().get_size() != GetMemDescSize(out_md) || + deconv_pd.diff_weights_primitive_desc().get_size() != GetMemDescSize(weight_md)) { + CHECK(deconv_pd.next_impl()) << "No implementation"; + } + return deconv_pd; } } diff --git a/tests/cpp/include/test_mkldnn.h b/tests/cpp/include/test_mkldnn.h index ef13e4e74211..31fe5c7d7bb5 100644 --- a/tests/cpp/include/test_mkldnn.h +++ b/tests/cpp/include/test_mkldnn.h @@ -116,10 +116,15 @@ inline static std::vector GetMKLDNNFormat(size_t num_dim data_md, weight_md, out_md, strides, padding, padding, mkldnn::padding_kind::zero); mkldnn::convolution_forward::primitive_desc pd(desc, CpuEngine::Get()->get_engine()); - std::vector ret(2); + while (pd.dst_primitive_desc().get_size() != GetMemDescSize(out_md) || + pd.src_primitive_desc().get_size() != GetMemDescSize(data_md) || + pd.weights_primitive_desc().get_size() != GetMemDescSize(weight_md)) { + CHECK(pd.next_impl()) << "No implementation"; + } + + std::vector ret(1); ret[0] = static_cast(pd.dst_primitive_desc().desc().data.format); - ret[1] = static_cast(pd.weights_primitive_desc().desc().data.format); - printf("format: %d, %d\n", ret[0], ret[1]); + printf("format: %d \n", ret[0]); return ret; } else if (num_dims == 5) { mkldnn::memory::dims data_dims{1, 32, 112, 112}; @@ -139,6 +144,12 @@ inline static std::vector GetMKLDNNFormat(size_t num_dim data_md, weight_md, out_md, strides, padding, padding, mkldnn::padding_kind::zero); mkldnn::convolution_forward::primitive_desc pd(desc, CpuEngine::Get()->get_engine()); + while (pd.dst_primitive_desc().get_size() != GetMemDescSize(out_md) || + pd.src_primitive_desc().get_size() != GetMemDescSize(data_md) || + pd.weights_primitive_desc().get_size() != GetMemDescSize(weight_md)) { + CHECK(pd.next_impl()) << "No implementation"; + } + std::vector ret(1); ret[0] = static_cast(pd.weights_primitive_desc().desc().data.format); printf("format: %d\n", ret[0]); @@ -188,7 +199,6 @@ inline static TestArrayShapes GetTestArrayShapes() { std::vector formats = GetMKLDNNFormat(4, dtype); pds.push_back(GetMemPD(s1, dtype, formats[0])); - pds.push_back(GetMemPD(s2, dtype, formats[1])); } { // 5D diff --git a/tests/cpp/operator/mkldnn_operator_test.cc b/tests/cpp/operator/mkldnn_operator_test.cc index d53f17448d41..21b257e40c37 100644 --- a/tests/cpp/operator/mkldnn_operator_test.cc +++ b/tests/cpp/operator/mkldnn_operator_test.cc @@ -214,7 +214,8 @@ OpAttrs GetLRNBackwardsOp() { } void AssertEqual(const std::vector &in_arrs, - const std::vector &out_arrs) { + const std::vector &out_arrs, + float rtol = 1e-5, float atol = 1e-8) { NDArray tmp1 = in_arrs[0]->Reorder2Default(); NDArray tmp2 = out_arrs[0]->Reorder2Default(); EXPECT_EQ(tmp1.shape().Size(), tmp2.shape().Size()); @@ -222,8 +223,10 @@ void AssertEqual(const std::vector &in_arrs, TBlob blob2 = tmp2.data(); mshadow::default_real_t *d1 = static_cast(blob1.dptr_); mshadow::default_real_t *d2 = static_cast(blob2.dptr_); - for (int i = 0; i < tmp1.shape().Size(); i++) - ASSERT_FLOAT_EQ(d1[i], d2[i]); + for (int i = 0; i < tmp1.shape().Size(); i++) { + float abs_err = fabs((d1[i]) - (d2[i])); + ASSERT_LE(abs_err, (atol + rtol * fabs(d2[i]))); + } } void VerifyActResult(const std::vector &in_arrs, diff --git a/tests/cpp/operator/mkldnn_test.cc b/tests/cpp/operator/mkldnn_test.cc index fbb7215b9862..5e7e8d8b205b 100644 --- a/tests/cpp/operator/mkldnn_test.cc +++ b/tests/cpp/operator/mkldnn_test.cc @@ -100,9 +100,9 @@ static void VerifyDefMem(const mkldnn::memory &mem) { TEST(MKLDNN_UTIL_FUNC, MemFormat) { // Check whether the number of format is correct. - CHECK_EQ(mkldnn_format_last, 67); - CHECK_EQ(mkldnn_nchw, 5); - CHECK_EQ(mkldnn_oihw, 15); + CHECK_EQ(mkldnn_format_last, 112); + CHECK_EQ(mkldnn_nchw, 7); + CHECK_EQ(mkldnn_oihw, 16); } static void VerifyMem(const mkldnn::memory &mem) {