OpenI
/
MegEngine
Not watched
1
0
Fork 0
Code
Releases 31 Wiki Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: b8ccc6a211
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'b8ccc6a211'
${ noResults }
MegEngine/src/opr/test/algo_chooser.cpp

410 lines
17 kB
Raw Blame History 

  1. /**

  2.  * \file src/opr/test/algo_chooser.cpp

  3.  * MegEngine is Licensed under the Apache License, Version 2.0 (the "License")

  4.  *

  5.  * Copyright (c) 2014-2021 Megvii Inc. All rights reserved.

  6.  *

  7.  * Unless required by applicable law or agreed to in writing,

  8.  * software distributed under the License is distributed on an

  9.  * "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  10.  */

  11. 

  12. #include "megbrain/comp_node_env.h"

  13. 

  14. #include "megbrain/gopt/inference.h"

  15. #include "megbrain/opr/basic_arith.h"

  16. #include "megbrain/opr/blas.h"

  17. #include "megbrain/opr/dnn/convolution.h"

  18. #include "megbrain/opr/dnn/pooling.h"

  19. #include "megbrain/opr/tensor_manip.h"

  20. #include "megbrain/serialization/opr_shallow_copy.h"

  21. #include "megbrain/serialization/serializer.h"

  22. #include "megbrain/test/autocheck.h"

  23. #include "megbrain/test/helper.h"

  24. #include "megbrain/test/megdnn_helper.h"

  25. #include "megdnn/dtype.h"

  26. #include "megdnn/heuristic_cache.h"

  27. #include "megdnn/oprs/base.h"

  28. 

  29. #include <cmath>

  30. #include <random>

  31. #include <utility>

  32. 

  33. using namespace mgb;

  34. 

  35. namespace {

  36. 

  37. template <typename MgbOpr, int arith>

  38. struct GraphMaker;

  39. 

  40. template <>

  41. struct GraphMaker<opr::Pooling, 1> {

  42.     SymbolVar operator()(

  43.             const std::array<cg::SymbolVar, 1>& inputs, opr::Pooling::Param& param,

  44.             opr::Pooling::ExecutionPolicy& policy) {

  45.         return opr::Pooling::make(inputs[0], param, policy);

  46.     }

  47. };

  48. 

  49. template <typename MgbOpr>

  50. struct GraphMaker<MgbOpr, 2> {

  51.     SymbolVar operator()(

  52.             const std::array<cg::SymbolVar, 2>& inputs, typename MgbOpr::Param& param,

  53.             typename MgbOpr::ExecutionPolicy& policy) {

  54.         return MgbOpr::make(inputs[0], inputs[1], param, policy);

  55.     }

  56. };

  57. 

  58. template <typename MgbOpr>

  59. struct GraphMaker<MgbOpr, 3> {

  60.     SymbolVar operator()(

  61.             const std::array<cg::SymbolVar, 3>& inputs, typename MgbOpr::Param& param,

  62.             typename MgbOpr::ExecutionPolicy& policy) {

  63.         return MgbOpr::make(inputs[0], inputs[1], inputs[2], param, policy, {});

  64.     }

  65. };

  66. 

  67. template <typename MgbOpr>

  68. struct GraphMaker<MgbOpr, 4> {

  69.     SymbolVar operator()(

  70.             const std::array<cg::SymbolVar, 4>& inputs, typename MgbOpr::Param& param,

  71.             typename MgbOpr::ExecutionPolicy& policy) {

  72.         return MgbOpr::make(

  73.                 inputs[0], inputs[1], inputs[2], inputs[3], param, policy, {});

  74.     }

  75. };

  76. 

  77. template <typename MgbOpr>

  78. struct GraphMaker<MgbOpr, 5> {

  79.     SymbolVar operator()(

  80.             const std::array<cg::SymbolVar, 5>& inputs, typename MgbOpr::Param& param,

  81.             typename MgbOpr::ExecutionPolicy& policy) {

  82.         return MgbOpr::make(

  83.                 inputs[0], inputs[1], inputs[2], inputs[3], inputs[4], param, policy,

  84.                 {});

  85.     }

  86. };

  87. 

  88. template <typename MgbOpr, int arith, typename dtype = dtype::Float32>

  89. void test_execution_policy_shallow_copy(

  90.         std::array<TensorShape, arith> shapes, typename MgbOpr::Param param = {}) {

  91.     using Policy = typename MgbOpr::ExecutionPolicy;

  92. 

  93.     Policy policy;

  94.     policy.strategy = Policy::Strategy::PROFILE;

  95. 

  96.     auto cn = CompNode::load("cpu0");

  97.     auto graph0 = ComputingGraph::make(), graph1 = ComputingGraph::make();

  98.     std::array<cg::SymbolVar, arith> inputs0;

  99.     VarNodeArray inputs1;

  100.     for (size_t i = 0; i < arith; ++i) {

  101.         HostTensorND hi{cn, shapes[i], dtype()};

  102.         inputs0[i] = opr::ImmutableTensor::make(*graph0, hi);

  103.         inputs1.push_back(opr::ImmutableTensor::make(*graph1, hi).node());

  104.     }

  105. 

  106.     GraphMaker<MgbOpr, arith> graph_maker;

  107.     auto opr0 = graph_maker(inputs0, param, policy).node()->owner_opr();

  108.     auto opr1 = serialization::copy_opr_shallow(*opr0, inputs1, OperatorNodeConfig{});

  109.     auto m0 = &(opr0->template cast_final<MgbOpr>());

  110.     auto m1 = &(opr1->template cast_final<MgbOpr>());

  111. 

  112.     ASSERT_EQ(policy.strategy, m0->execution_policy().strategy);

  113.     ASSERT_EQ(policy.strategy, m1->execution_policy().strategy);

  114. }

  115. 

  116. #if MGB_CUDA

  117. #if MGB_ENABLE_FASTRUN

  118. 

  119. template <typename MgbOpr, int arith, typename dtype = dtype::Float32>

  120. void test_fastrun_opr(

  121.         std::array<TensorShape, arith> inps0, std::array<TensorShape, arith> inps1,

  122.         size_t expect_nr_cache_set_inp0 = 0, size_t expect_nr_cache_set_inp1 = 0,

  123.         typename MgbOpr::Param param = {}) {

  124.     using Policy = opr::Convolution::ExecutionPolicy;

  125.     using S = Policy::Strategy;

  126.     using InputGenerator = std::function<void(HostTensorND & dest)>;

  127.     using ShapeInpArray = std::array<TensorShape, arith>;

  128.     using CacheMem = std::pair<const void*, size_t>;

  129.     auto on_get = [](const std::string&, const void*, size_t, const void*, size_t) {};

  130. 

  131.     std::vector<std::pair<CacheMem, CacheMem>> cache_set_history;

  132.     auto on_set = [&cache_set_history](

  133.                           const std::string&, const void* key, size_t key_size,

  134.                           const void* val, size_t val_size) {

  135.         cache_set_history.emplace_back(

  136.                 std::make_pair(key, key_size), std::make_pair(val, val_size));

  137.     };

  138. 

  139.     PersistentCacheHook cache_hook{on_get, on_set};

  140. 

  141.     CompNode comp_node = CompNode::load("xpu0");

  142.     GraphMaker<MgbOpr, arith> graph_maker;

  143.     auto run = [&param, &comp_node, &graph_maker](

  144.                        const std::shared_ptr<cg::ComputingGraph>& graph,

  145.                        const ShapeInpArray& shapes) {

  146.         std::array<InputGenerator, arith> inputs_generator;

  147.         std::array<std::shared_ptr<HostTensorND>, arith> inputs;

  148.         for (size_t i = 0; i < arith; ++i) {

  149.             inputs[i] = std::make_shared<HostTensorND>(comp_node, dtype());

  150.         }

  151.         HostTensorGenerator<dtype> gen_host;

  152.         for (size_t i = 0; i < arith; ++i) {

  153.             inputs[i]->resize(shapes[i]);

  154.             *inputs[i] = *gen_host(inputs[i]->shape(), comp_node);

  155.             mgb_assert(inputs[i]->shape().eq_shape(shapes[i]));

  156.         }

  157.         std::array<cg::SymbolVar, arith> sym_in;

  158.         for (size_t i = 0; i < arith; ++i) {

  159.             // to trigger graph trans

  160.             sym_in[i] = opr::Host2DeviceCopy::make(

  161.                     *graph, inputs[i], ssprintf("inp%zu", i));

  162.         }

  163.         Policy policy;

  164.         policy.strategy = S::PROFILE;

  165.         auto out = graph_maker(sym_in, param, policy);

  166. 

  167.         std::unique_ptr<cg::AsyncExecutable> func = graph->compile({{out, {}}});

  168.         func->execute();

  169.     };

  170. 

  171.     std::shared_ptr<cg::ComputingGraph> fastrun_ignore_batchsize_graph =

  172.             ComputingGraph::make();

  173.     fastrun_ignore_batchsize_graph->options().fast_run_config.shared_batch_size = 20;

  174.     run(fastrun_ignore_batchsize_graph, inps0);

  175.     size_t nr_set_inp0 = cache_set_history.size();

  176.     if (expect_nr_cache_set_inp0) {

  177.         ASSERT_EQ(cache_set_history.size(), expect_nr_cache_set_inp0);

  178.     }

  179.     run(fastrun_ignore_batchsize_graph, inps1);

  180.     size_t nr_set_total = expect_nr_cache_set_inp1 + nr_set_inp0;

  181.     ASSERT_EQ(cache_set_history.size(), nr_set_total);

  182. }

  183. #endif  // MGB_ENABLE_FASTRUN

  184. #endif  // MGB_CUDA

  185. 

  186. }  // anonymous namespace

  187. 

  188. #if MGB_CUDA

  189. #if MGB_ENABLE_FASTRUN

  190. TEST(TestOprDNN, FastrunIgnoreBatchSizeConvolution) {

  191.     REQUIRE_GPU(1);

  192.     test_fastrun_opr<opr::Convolution, 2>(

  193.             {TensorShape{12, 3, 36, 36}, TensorShape{4, 3, 3, 3}},

  194.             {TensorShape{1, 3, 36, 36}, TensorShape{4, 3, 3, 3}});

  195. 

  196.     test_fastrun_opr<opr::ConvolutionBackwardData, 3>(

  197.             {TensorShape{4, 5, 3, 2}, TensorShape{12, 4, 23, 29},

  198.              TensorShape{12, 5, 25, 30}},

  199.             {TensorShape{4, 5, 3, 2}, TensorShape{2, 4, 23, 29},

  200.              TensorShape{2, 5, 25, 30}});

  201. 

  202.     test_fastrun_opr<opr::ConvolutionBackwardFilter, 3>(

  203.             {TensorShape{12, 4, 23, 29}, TensorShape{12, 5, 21, 28},

  204.              TensorShape{5, 4, 3, 2}},

  205.             {TensorShape{2, 4, 23, 29}, TensorShape{2, 5, 21, 28},

  206.              TensorShape{5, 4, 3, 2}});

  207. }

  208. 

  209. TEST(TestOprDNN, FastrunIgnoreBatchSizeConvBias) {

  210.     REQUIRE_GPU(1);

  211.     test_fastrun_opr<opr::ConvBias, 3>(

  212.             {TensorShape{20, 16, 50, 50}, TensorShape{24, 16, 3, 3},

  213.              TensorShape{1, 24, 1, 1}},

  214.             {TensorShape{1, 16, 50, 50}, TensorShape{24, 16, 3, 3},

  215.              TensorShape{1, 24, 1, 1}});

  216. }

  217. 

  218. TEST(TestOprDNN, FastrunIgnoreBatchSizeConvolution3D) {

  219.     REQUIRE_GPU(1);

  220.     test_fastrun_opr<opr::Convolution3D, 2>(

  221.             {TensorShape{8, 4, 12, 13, 14}, TensorShape{4, 4, 3, 3, 3}},

  222.             {TensorShape{3, 4, 12, 13, 14}, TensorShape{4, 4, 3, 3, 3}});

  223. 

  224.     test_fastrun_opr<opr::Convolution3DBackwardData, 3>(

  225.             {TensorShape{5, 5, 3, 3, 3}, TensorShape{14, 5, 12, 12, 16},

  226.              TensorShape{14, 5, 14, 14, 18}},

  227.             {TensorShape{5, 5, 3, 3, 3}, TensorShape{4, 5, 12, 12, 16},

  228.              TensorShape{4, 5, 14, 14, 18}});

  229. 

  230.     test_fastrun_opr<opr::Convolution3DBackwardFilter, 3>(

  231.             {TensorShape{64, 16, 18, 18, 18}, TensorShape{64, 16, 18, 18, 18},

  232.              TensorShape{16, 16, 1, 1, 1}},

  233.             {TensorShape{4, 16, 18, 18, 18}, TensorShape{4, 16, 18, 18, 18},

  234.              TensorShape{16, 16, 1, 1, 1}});

  235. }

  236. 

  237. TEST(TestOprDNN, FastrunIgnoreBatchSizeLocalShare) {

  238.     REQUIRE_GPU(1);

  239.     opr::LocalShare::Param local_share_param;

  240.     local_share_param.mode = opr::LocalShare::Param::Mode::CROSS_CORRELATION;

  241.     local_share_param.pad_h = local_share_param.pad_w = 1;

  242.     local_share_param.stride_h = local_share_param.stride_w = 1;

  243.     local_share_param.spatial_groups_h = local_share_param.spatial_groups_w = 2;

  244.     test_fastrun_opr<opr::LocalShareForward, 2>(

  245.             {TensorShape{32, 2, 23, 23}, TensorShape{2, 2, 2, 2, 2, 7}},

  246.             {TensorShape{3, 2, 23, 23}, TensorShape{2, 2, 2, 2, 2, 7}}, 0, 0,

  247.             local_share_param);

  248. 

  249.     test_fastrun_opr<opr::LocalShareBackwardData, 3>(

  250.             {TensorShape{3, 3, 128, 1, 1, 128}, TensorShape{32, 128, 24, 24},

  251.              TensorShape{32, 128, 24, 24}},

  252.             {TensorShape{3, 3, 128, 1, 1, 128}, TensorShape{2, 128, 24, 24},

  253.              TensorShape{2, 128, 24, 24}});

  254. 

  255.     test_fastrun_opr<opr::LocalShareBackwardFilter, 3>(

  256.             {TensorShape{12, 3, 36, 36}, TensorShape{12, 4, 35, 35},

  257.              TensorShape{3, 3, 3, 3, 3, 4}},

  258.             {TensorShape{4, 3, 36, 36}, TensorShape{4, 4, 35, 35},

  259.              TensorShape{3, 3, 3, 3, 3, 4}});

  260. }

  261. 

  262. TEST(TestOprDNN, FastrunIgnoreBatchSizeDeformableConv) {

  263.     REQUIRE_GPU(1);

  264.     test_fastrun_opr<opr::DeformableConvForward, 4>(

  265.             {TensorShape{12, 6, 20, 20}, TensorShape{6, 6, 3, 3},

  266.              TensorShape{12, 18, 18, 18}, TensorShape{12, 9, 18, 18}},

  267.             {TensorShape{4, 6, 20, 20}, TensorShape{6, 6, 3, 3},

  268.              TensorShape{4, 18, 18, 18}, TensorShape{4, 9, 18, 18}});

  269. 

  270.     test_fastrun_opr<opr::DeformableConvBackwardData, 5>(

  271.             {TensorShape{12, 6, 20, 20}, TensorShape{6, 6, 3, 3},

  272.              TensorShape{12, 18, 18, 18}, TensorShape{12, 9, 18, 18},

  273.              TensorShape{12, 6, 18, 18}},

  274.             {TensorShape{4, 6, 20, 20}, TensorShape{6, 6, 3, 3},

  275.              TensorShape{4, 18, 18, 18}, TensorShape{4, 9, 18, 18},

  276.              TensorShape{4, 6, 18, 18}});

  277. 

  278.     test_fastrun_opr<opr::DeformableConvBackwardFilter, 5>(

  279.             {TensorShape{12, 6, 20, 20}, TensorShape{6, 6, 3, 3},

  280.              TensorShape{12, 18, 18, 18}, TensorShape{12, 9, 18, 18},

  281.              TensorShape{12, 6, 18, 18}},

  282.             {TensorShape{4, 6, 20, 20}, TensorShape{6, 6, 3, 3},

  283.              TensorShape{4, 18, 18, 18}, TensorShape{4, 9, 18, 18},

  284.              TensorShape{4, 6, 18, 18}});

  285. }

  286. 

  287. TEST(TestOprDNN, FastrunIgnoreBatchSizeMatrixMul) {

  288.     REQUIRE_GPU(1);

  289.     //! fastrun_shared_batch_size == 20

  290.     //! {20(12), 12(1)}, {12(12), 20(1)} -> {20(12), 20(1)} origin

  291.     //! {12(10), 20(1)}, {12(12), 20(1)} -> {20(12), 20(1)} transA

  292.     //! {12(10), 20(1)}, {20(12), 12(1)} -> {20(12), 20(1)} transA, transB

  293.     //! {20(12), 12(1)}, {20(12), 12(1)} -> {20(12), 20(1)} transB

  294.     //!

  295.     //! {20(12), 12(1)}, {12(12), 20(1)} -> {20(12), 20(1)} origin duplicate

  296.     //! {12(4), 20(1)}, {12(12), 20(1)} -> {20(12), 20(1)} transA

  297.     //! {12(4), 20(1)}, {20(12), 12(1)} -> {20(12), 20(1)} transA, transB

  298.     //! {20(12), 12(1)}, {20(12), 12(1)} -> {20(12), 20(1)} transB duplicate

  299.     test_fastrun_opr<opr::MatrixMul, 2>(

  300.             {TensorShape{10, 12}, TensorShape{12, 12}},

  301.             {TensorShape{4, 12}, TensorShape{12, 12}}, 4, 2);

  302. }

  303. 

  304. TEST(TestOprDNN, FastrunIgnoreBatchSizeBatchedMatrixMul) {

  305.     REQUIRE_GPU(1);

  306. 

  307.     //! fastrun_shared_batch_size == 20

  308.     //! {20(48), 6(8), 8(1)}, {20(32), 8(4), 4(1)} -> {20(24), 6(4), 4(1)} origin

  309.     //! {20(48), 8(6), 6(1)}, {20(32), 8(4), 4(1)} -> {20(24), 6(4), 4(1)} transA

  310.     //! {20(48), 8(6), 6(1)}, {20(32), 4(8), 8(1)} -> {20(24), 6(4), 4(1)} transA,

  311.     //! transB {20(48), 6(8), 8(1)}, {20(32), 4(8), 8(1)} -> {20(24), 6(4), 4(1)} transB

  312.     //!

  313.     //! {20(48), 6(8), 8(1)}, {20(32), 8(4), 4(1)} -> {20(24), 6(4), 4(1)} origin

  314.     //! duplicate {20(48), 8(6), 6(1)}, {20(32), 8(4), 4(1)} -> {20(24), 6(4), 4(1)}

  315.     //! transA duplicate {20(48), 8(6), 6(1)}, {20(32), 4(8), 8(1)} -> {20(24), 6(4),

  316.     //! 4(1)} transA, transB duplicate {20(48), 6(8), 8(1)}, {20(32), 4(8), 8(1)} ->

  317.     //! {20(24), 6(4), 4(1)} transB duplicate

  318.     test_fastrun_opr<opr::BatchedMatrixMul, 2>(

  319.             {TensorShape{12, 6, 8}, TensorShape{12, 8, 4}},

  320.             {TensorShape{4, 6, 8}, TensorShape{4, 8, 4}});

  321. }

  322. 

  323. #endif  // MGB_ENABLE_FASTRUN

  324. #endif  // MGB_CUDA

  325. 

  326. TEST(TestOprDNN, ExecutionPolicyShallowCopyConvolution) {

  327.     test_execution_policy_shallow_copy<opr::Convolution, 2>(

  328.             {TensorShape{12, 3, 36, 36}, TensorShape{4, 3, 3, 3}});

  329. 

  330.     test_execution_policy_shallow_copy<opr::ConvolutionBackwardData, 3>(

  331.             {TensorShape{4, 5, 3, 2}, TensorShape{12, 4, 23, 29},

  332.              TensorShape{12, 5, 25, 30}});

  333. 

  334.     test_execution_policy_shallow_copy<opr::ConvolutionBackwardFilter, 3>(

  335.             {TensorShape{12, 4, 23, 29}, TensorShape{12, 5, 21, 28},

  336.              TensorShape{5, 4, 3, 2}});

  337. }

  338. 

  339. TEST(TestOprDNN, ExecutionPolicyShallowCopyConvBias) {

  340.     test_execution_policy_shallow_copy<opr::ConvBias, 3>(

  341.             {TensorShape{20, 16, 50, 50}, TensorShape{24, 16, 3, 3},

  342.              TensorShape{1, 24, 1, 1}});

  343. }

  344. 

  345. TEST(TestOprDNN, ExecutionPolicyShallowCopyConvolution3D) {

  346.     test_execution_policy_shallow_copy<opr::Convolution3D, 2>(

  347.             {TensorShape{8, 4, 12, 13, 14}, TensorShape{4, 4, 3, 3, 3}});

  348. 

  349.     test_execution_policy_shallow_copy<opr::Convolution3DBackwardData, 3>(

  350.             {TensorShape{5, 5, 3, 3, 3}, TensorShape{14, 5, 12, 12, 16},

  351.              TensorShape{14, 5, 14, 14, 18}});

  352. 

  353.     test_execution_policy_shallow_copy<opr::Convolution3DBackwardFilter, 3>(

  354.             {TensorShape{64, 16, 18, 18, 18}, TensorShape{64, 16, 18, 18, 18},

  355.              TensorShape{16, 16, 1, 1, 1}});

  356. }

  357. 

  358. TEST(TestOprDNN, ExecutionPolicyShallowCopyLocalShare) {

  359.     opr::LocalShare::Param local_share_param;

  360.     local_share_param.mode = opr::LocalShare::Param::Mode::CROSS_CORRELATION;

  361.     local_share_param.pad_h = local_share_param.pad_w = 1;

  362.     local_share_param.stride_h = local_share_param.stride_w = 1;

  363.     local_share_param.spatial_groups_h = local_share_param.spatial_groups_w = 2;

  364.     test_execution_policy_shallow_copy<opr::LocalShareForward, 2>(

  365.             {TensorShape{32, 2, 23, 23}, TensorShape{2, 2, 2, 2, 2, 7}},

  366.             local_share_param);

  367. 

  368.     test_execution_policy_shallow_copy<opr::LocalShareBackwardData, 3>(

  369.             {TensorShape{3, 3, 128, 1, 1, 128}, TensorShape{32, 128, 24, 24},

  370.              TensorShape{32, 128, 24, 24}});

  371. 

  372.     test_execution_policy_shallow_copy<opr::LocalShareBackwardFilter, 3>(

  373.             {TensorShape{12, 3, 36, 36}, TensorShape{12, 4, 35, 35},

  374.              TensorShape{3, 3, 3, 3, 3, 4}});

  375. }

  376. 

  377. TEST(TestOprDNN, ExecutionPolicyShallowCopyDeformableConv) {

  378.     test_execution_policy_shallow_copy<opr::DeformableConvForward, 4>(

  379.             {TensorShape{12, 6, 20, 20}, TensorShape{6, 6, 3, 3},

  380.              TensorShape{12, 18, 18, 18}, TensorShape{12, 9, 18, 18}});

  381. 

  382.     test_execution_policy_shallow_copy<opr::DeformableConvBackwardData, 5>(

  383.             {TensorShape{12, 6, 20, 20}, TensorShape{6, 6, 3, 3},

  384.              TensorShape{12, 18, 18, 18}, TensorShape{12, 9, 18, 18},

  385.              TensorShape{12, 6, 18, 18}});

  386. 

  387.     test_execution_policy_shallow_copy<opr::DeformableConvBackwardFilter, 5>(

  388.             {TensorShape{12, 6, 20, 20}, TensorShape{6, 6, 3, 3},

  389.              TensorShape{12, 18, 18, 18}, TensorShape{12, 9, 18, 18},

  390.              TensorShape{12, 6, 18, 18}});

  391. }

  392. 

  393. TEST(TestOprDNN, ExecutionPolicyShallowCopyMatrixMul) {

  394.     test_execution_policy_shallow_copy<opr::MatrixMul, 2>(

  395.             {TensorShape{10, 12}, TensorShape{12, 12}});

  396. 

  397.     test_execution_policy_shallow_copy<opr::BatchedMatrixMul, 2>(

  398.             {TensorShape{12, 6, 8}, TensorShape{12, 8, 4}});

  399. }

  400. 

  401. TEST(TestOprDNN, ExecutionPolicyShallowCopyPooling) {

  402.     test_execution_policy_shallow_copy<opr::Pooling, 1>({TensorShape{1, 20, 24, 24}});

  403. 

  404.     test_execution_policy_shallow_copy<opr::PoolingBackward, 3>(

  405.             {TensorShape{1, 20, 24, 24}, TensorShape{1, 20, 12, 12},

  406.              TensorShape{1, 20, 12, 12}});

  407. }

  408. 

  409. // vim: syntax=cpp.doxygen foldmethod=marker foldmarker=f{{{,f}}}