[IE][VPU]: Fix NCE hang due to input dimensions exceed HW limitation (#1636)

* Fixed NCE hang due to input dimensions exceed HW limitation
* Added convolution test for big input dimensions

Signed-off-by: wenzengc <wenzeng.chen@intel.com>

diff --git a/inference-engine/src/vpu/graph_transformer/src/middleend/hw/conv_tiling/hw_convolution_tiler.cpp b/inference-engine/src/vpu/graph_transformer/src/middleend/hw/conv_tiling/hw_convolution_tiler.cpp
index aab8a62..ed8221e 100644 (file)
--- a/inference-engine/src/vpu/graph_transformer/src/middleend/hw/conv_tiling/hw_convolution_tiler.cpp
+++ b/inference-engine/src/vpu/graph_transformer/src/middleend/hw/conv_tiling/hw_convolution_tiler.cpp
@@ -631,6 +631,10 @@ std::vector<TilingOption> HWConvolutionTilingSearcher::selectBetterTiling() cons
     const auto outputTileInitial = dirTiling.getOutputTileDims();
     const auto inputTileInitial = dirTiling.getInputTileDims();
 
+    const int maxInputTileDimW = 2048;
+    const int maxInputTileDimH = 2048;
+    const int maxInputTileDimC = 2048;
+
     auto minInputTileDimW = 64;
     auto minInputTileDimH = _convolutionOptions._kernelSizeY;
     if (_convolutionOptions._withPool) {
@@ -646,10 +650,15 @@ std::vector<TilingOption> HWConvolutionTilingSearcher::selectBetterTiling() cons
     for (int numChannelTiles = 1; numChannelTiles <= maxNumChannelTiles; numChannelTiles++) {
         const int tileSizeDimC = divUp(_convolutionOptions._inputDims[Dim::C], numChannelTiles);
 
+        if (tileSizeDimC > maxInputTileDimC)
+            continue;
         // here split and iterate either over input tensors or over output tensors depending on the direction.
         for (int numWidthTiles = 1; numWidthTiles <= maxNumWidthTiles; numWidthTiles++) {
             int tileSizeDimW = divUp(splitOver[Dim::W], numWidthTiles);
 
+            if (tileSizeDimW > maxInputTileDimW)
+                continue;
+
             //
             // Filter-out too small SoW input tiles when loops split input tensors.
             //
@@ -666,6 +675,9 @@ std::vector<TilingOption> HWConvolutionTilingSearcher::selectBetterTiling() cons
             for (int numHeightTiles = 1; numHeightTiles <= maxNumHeightTiles; numHeightTiles++) {
                 int tileSizeDimH = divUp(splitOver[Dim::H], numHeightTiles);
 
+                if (tileSizeDimH > maxInputTileDimH)
+                    continue;
+
                 //
                 // Filter-out too small SoH input tiles when loops split input tensors.
                 //

diff --git a/inference-engine/tests/functional/plugin/myriad/shared_tests_instances/single_layer_tests/convolution.cpp b/inference-engine/tests/functional/plugin/myriad/shared_tests_instances/single_layer_tests/convolution.cpp
index 4afe815..22f5c51 100644 (file)
--- a/inference-engine/tests/functional/plugin/myriad/shared_tests_instances/single_layer_tests/convolution.cpp
+++ b/inference-engine/tests/functional/plugin/myriad/shared_tests_instances/single_layer_tests/convolution.cpp
@@ -50,6 +50,15 @@ const auto conv2DParams_AutoPadValid = ::testing::Combine(
         ::testing::ValuesIn(numOutCannels),
         ::testing::Values(ngraph::op::PadType::VALID)
 );
+const auto conv2DParams_BigDimensionValid = ::testing::Combine(
+        ::testing::ValuesIn(std::vector<std::vector<size_t>>({{1, 1}})),
+        ::testing::ValuesIn(std::vector<std::vector<size_t>>({{1, 1}})),
+        ::testing::Values(std::vector<ptrdiff_t>({0, 0})),
+        ::testing::Values(std::vector<ptrdiff_t>({0, 0})),
+        ::testing::ValuesIn(std::vector<std::vector<size_t>>({{1, 1}})),
+        ::testing::ValuesIn(std::vector<size_t>({64})),
+        ::testing::Values(ngraph::op::PadType::VALID)
+);
 
 INSTANTIATE_TEST_CASE_P(Convolution2D_ExplicitPadding, ConvolutionLayerTest,
                         ::testing::Combine(
@@ -66,6 +75,14 @@ INSTANTIATE_TEST_CASE_P(Convolution2D_AutoPadValid, ConvolutionLayerTest,
                                 ::testing::Values(std::vector<size_t >({1, 3, 30, 30})),
                                 ::testing::Values(CommonTestUtils::DEVICE_MYRIAD)),
                         ConvolutionLayerTest::getTestCaseName);
+INSTANTIATE_TEST_CASE_P(Convolution2D_BigDimensionValid, ConvolutionLayerTest,
+                        ::testing::Combine(
+                                conv2DParams_BigDimensionValid,
+                                ::testing::ValuesIn(netPrecisions),
+                                ::testing::Values(std::vector<size_t >({1, 3, 1, 2500})),
+                                ::testing::Values(CommonTestUtils::DEVICE_MYRIAD)),
+                        ConvolutionLayerTest::getTestCaseName);
+
 /* ============= 3D Convolution ============= */
 // TODO: 3D convolution fails with sigabort
 }  // namespace