diff --git a/inference-engine/src/mkldnn_plugin/nodes/mkldnn_depth_to_space_node.cpp b/inference-engine/src/mkldnn_plugin/nodes/mkldnn_depth_to_space_node.cpp index c341e98a78b..41b8983d362 100644 --- a/inference-engine/src/mkldnn_plugin/nodes/mkldnn_depth_to_space_node.cpp +++ b/inference-engine/src/mkldnn_plugin/nodes/mkldnn_depth_to_space_node.cpp @@ -17,17 +17,11 @@ using namespace MKLDNNPlugin; using namespace InferenceEngine; -using namespace mkldnn; using namespace mkldnn::impl; -using namespace mkldnn::impl::cpu::x64; bool MKLDNNDepthToSpaceNode::isSupportedOperation(const std::shared_ptr& op, std::string& errorMessage) noexcept { try { - if (isDynamicNgraphNode(op)) { - errorMessage = "Doesn't support op with dynamic shapes"; - return false; - } - const auto depthToSpace = std::dynamic_pointer_cast(op); + auto depthToSpace = ov::as_type_ptr(op); if (!depthToSpace) { errorMessage = "Only opset1 DepthToSpace operation is supported"; return false; @@ -46,75 +40,58 @@ bool MKLDNNDepthToSpaceNode::isSupportedOperation(const std::shared_ptr& op, const mkldnn::engine& eng, MKLDNNWeightsSharing::Ptr &cache) : MKLDNNNode(op, eng, cache) { std::string errorMessage; - if (isSupportedOperation(op, errorMessage)) { - const auto depthToSpace = std::dynamic_pointer_cast(op); - - const auto modeNgraph = depthToSpace->get_mode(); - if (modeNgraph == ngraph::op::v0::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST) { - mode = Mode::BLOCKS_FIRST; - } else if (modeNgraph == ngraph::op::v0::DepthToSpace::DepthToSpaceMode::DEPTH_FIRST) { - mode = Mode::DEPTH_FIRST; - } else { - THROW_ERROR << "doesn't support mode: " << ngraph::as_string(modeNgraph); - } - - blockSize = depthToSpace->get_block_size(); - if (blockSize == 0) - THROW_ERROR << "has incorrect block_size parameter is zero!"; - - size_t nSpatialDims = inputShapes[0].getRank() - 2; - blockStep = static_cast(std::pow(blockSize, nSpatialDims)); - } else { + if (!isSupportedOperation(op, errorMessage)) { IE_THROW(NotImplemented) << errorMessage; } -} + if (inputShapes.size() != 1 || outputShapes.size() != 1) + THROW_ERROR << "has incorrect number of input/output edges!"; -void MKLDNNDepthToSpaceNode::getSupportedDescriptors() { - SizeVector srcDims = inputShapes[0].getStaticDims(); - if (srcDims.size() < 3) - THROW_ERROR << "has incorrect number of input dimensions"; - if (srcDims.size() > 5) - THROW_ERROR << "doesn't support dimensions with rank greater than 5"; + auto depthToSpace = ov::as_type_ptr(op); + if (!depthToSpace) + THROW_ERROR << "supports only opset1"; - SizeVector dstDims = outputShapes[0].getStaticDims(); - if (srcDims.size() != dstDims.size()) - THROW_ERROR << "has incorrect number of input/output dimensions"; - - if (srcDims[1] % blockStep) - THROW_ERROR << "has block_size parameter which is incompatible with input tensor channels dimension size"; - - if (srcDims[1] / blockStep != dstDims[1]) - THROW_ERROR << "has incompatible input/output channels"; - - size_t nSpatialDims = srcDims.size() - 2; - for (size_t i = 0; i < nSpatialDims; ++i) { - if (srcDims[i + 2] * blockSize != dstDims[i + 2]) - THROW_ERROR << "has incompatible spatial dims"; + const auto modeNgraph = depthToSpace->get_mode(); + if (modeNgraph == ngraph::op::v0::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST) { + attrs.mode = Mode::BLOCKS_FIRST; + } else if (modeNgraph == ngraph::op::v0::DepthToSpace::DepthToSpaceMode::DEPTH_FIRST) { + attrs.mode = Mode::DEPTH_FIRST; + } else { + THROW_ERROR << "doesn't support mode: " << ngraph::as_string(modeNgraph); } - if (getParentEdges().size() != 1) - THROW_ERROR << "has incorrect number of input edges"; - if (getChildEdges().empty()) - THROW_ERROR << "has incorrect number of output edges"; + attrs.blockSize = depthToSpace->get_block_size(); + if (attrs.blockSize == 0) + THROW_ERROR << "has incorrect block_size parameter is zero!"; + + const size_t srcRank = getInputShapeAtPort(0).getRank(); + const size_t dstRank = getOutputShapeAtPort(0).getRank(); + + if (srcRank < 3) + THROW_ERROR << "has incorrect number of input dimensions"; + if (srcRank > 5) + THROW_ERROR << "doesn't support dimensions with rank greater than 5"; + if (srcRank != dstRank) + THROW_ERROR << "has incorrect number of input/output dimensions"; + + const size_t nSpatialDims = srcRank - 2; + attrs.blockStep = static_cast(std::pow(attrs.blockSize, nSpatialDims)); } +void MKLDNNDepthToSpaceNode::getSupportedDescriptors() {} + void MKLDNNDepthToSpaceNode::initSupportedPrimitiveDescriptors() { if (!supportedPrimitiveDescriptors.empty()) return; InferenceEngine::Precision precision = getOriginalInputPrecisionAtPort(0); - auto srcDims = getInputShapeAtPort(0).getStaticDims(); - const size_t nDims = srcDims.size(); - impl_desc_type impl_type; - if (mayiuse(impl::cpu::x64::avx512_common)) { + impl_desc_type impl_type = impl_desc_type::ref; + if (cpu::x64::mayiuse(cpu::x64::avx512_common)) { impl_type = impl_desc_type::jit_avx512; - } else if (mayiuse(cpu::x64::avx2)) { + } else if (cpu::x64::mayiuse(cpu::x64::avx2)) { impl_type = impl_desc_type::jit_avx2; - } else if (mayiuse(cpu::x64::sse41)) { + } else if (cpu::x64::mayiuse(cpu::x64::sse41)) { impl_type = impl_desc_type::jit_sse42; - } else { - impl_type = impl_desc_type::ref; } NodeConfig config; @@ -126,11 +103,15 @@ void MKLDNNDepthToSpaceNode::initSupportedPrimitiveDescriptors() { config.outConfs[0].inPlace = -1; config.outConfs[0].constant = false; + const auto& inputDataShape = getInputShapeAtPort(0); + const auto& outputDataShape = getOutputShapeAtPort(0); + std::vector supportedTypes; - if (nDims > 2) { + if (inputDataShape.getRank() > 2) { + const auto& srcDims = inputDataShape.getDims(); auto canUseBlocked = [=](const size_t block) { - return srcDims[1] % block == 0 && (srcDims[1] / block) % blockStep == 0 && - (mode == Mode::DEPTH_FIRST ? block % blockStep == 0 : true); + return srcDims[1] != Shape::UNDEFINED_DIM && srcDims[1] % block == 0 && (srcDims[1] / block) % attrs.blockStep == 0 && + (attrs.mode == Mode::DEPTH_FIRST ? block % attrs.blockStep == 0 : true); }; supportedTypes.push_back(LayoutType::nspc); @@ -141,18 +122,18 @@ void MKLDNNDepthToSpaceNode::initSupportedPrimitiveDescriptors() { } supportedTypes.push_back(LayoutType::ncsp); auto creators = BlockedDescCreator::getCommonCreators(); - auto range = BlockedDescCreator::makeFilteredRange(creators, nDims, supportedTypes); + auto range = BlockedDescCreator::makeFilteredRange(creators, inputDataShape.getRank(), supportedTypes); for (auto itr = range.first; itr != range.second; ++itr) { - config.inConfs[0].desc = itr->second->createSharedDesc(precision, getInputShapeAtPort(0)); - config.outConfs[0].desc = itr->second->createSharedDesc(precision, getOutputShapeAtPort(0)); + config.inConfs[0].desc = itr->second->createSharedDesc(precision, inputDataShape); + config.outConfs[0].desc = itr->second->createSharedDesc(precision, outputDataShape); supportedPrimitiveDescriptors.emplace_back(config, impl_type); } } void MKLDNNDepthToSpaceNode::createPrimitive() { - auto &dstMemPtr = getChildEdgeAt(0)->getMemoryPtr(); - auto &srcMemPtr = getParentEdgeAt(0)->getMemoryPtr(); + auto& dstMemPtr = getChildEdgeAt(0)->getMemoryPtr(); + auto& srcMemPtr = getParentEdgeAt(0)->getMemoryPtr(); if (!dstMemPtr || !dstMemPtr->GetPrimitivePtr()) THROW_ERROR << "has not allocated destination memory"; if (!srcMemPtr || !srcMemPtr->GetPrimitivePtr()) @@ -160,24 +141,44 @@ void MKLDNNDepthToSpaceNode::createPrimitive() { if (getSelectedPrimitiveDescriptor() == nullptr) THROW_ERROR << "has unidentified preferable primitive descriptor"; - VectorDims srcDims = srcMemPtr->getStaticDims(); + const auto& memoryDesc = srcMemPtr->getDesc(); + attrs.dataSize = memoryDesc.getPrecision().size(); + attrs.nSpatialDims = memoryDesc.getShape().getRank() - 2; + attrs.layoutType = memoryDesc.hasLayoutType(LayoutType::nCsp16c) ? LayoutType::nCsp16c : + memoryDesc.hasLayoutType(LayoutType::nCsp8c) ? LayoutType::nCsp8c : + memoryDesc.hasLayoutType(LayoutType::nspc) ? LayoutType::nspc : LayoutType::ncsp; - size_t nDims = srcDims.size(); - const size_t nSpatialDims = nDims - 2; - const bool isBlocked = getParentEdgeAt(0)->getMemory().getDesc().hasLayoutType(LayoutType::nCsp8c) || - getParentEdgeAt(0)->getMemory().getDesc().hasLayoutType(LayoutType::nCsp16c); - const size_t reshapedRank = nDims + nSpatialDims + static_cast(isBlocked) + static_cast(isBlocked && mode == Mode::DEPTH_FIRST); + if (inputShapesDefined()) { + if (needPrepareParams()) + prepareParams(); + updateLastInputDims(); + } +} + +void MKLDNNDepthToSpaceNode::prepareParams() { + attrs.srcBlockedDims = getParentEdgeAt(0)->getMemoryPtr()->GetDescWithType()->getBlockDims(); + execPtr = std::make_shared(attrs); +} + +MKLDNNDepthToSpaceNode::DepthToSpaceExecutor::DepthToSpaceExecutor(const DepthToSpaceAttrs& attrs) { + if (!MKLDNNPlugin::one_of(attrs.layoutType, LayoutType::nCsp16c, LayoutType::nCsp8c, LayoutType::nspc, LayoutType::ncsp)) + IE_THROW() << "DepthToSpace executor supports only 'nCsp16c', 'nCsp8c', 'nspc' or 'ncsp' layouts."; + + const bool isBlocked = MKLDNNPlugin::one_of(attrs.layoutType, LayoutType::nCsp16c, LayoutType::nCsp8c); + const bool isChannelsFirst = attrs.layoutType == LayoutType::nspc; + const size_t nDims = attrs.srcBlockedDims.size(); + const size_t reshapedRank = nDims + attrs.nSpatialDims + static_cast(isBlocked && attrs.mode == Mode::DEPTH_FIRST); const size_t lastIdx = reshapedRank - 1; size_t firstSpatialOrder = 2; PermuteParams params; - params.data_size = getSelectedPrimitiveDescriptor()->getConfig().inConfs[0].desc->getPrecision().size(); + params.data_size = attrs.dataSize; params.order.resize(reshapedRank, 0); params.src_block_order.resize(reshapedRank); params.dst_block_order.resize(reshapedRank); params.dst_block_dims.resize(reshapedRank); params.src_block_dims.resize(reshapedRank); - params.src_block_dims[0] = srcDims[0]; + params.src_block_dims[0] = attrs.srcBlockedDims[0]; // reshaping of src dimensions and creating the permutation order for each layout: // new shape: mode = blocks_first [N, block_size, block_size, ..., block_size, C / (block_size ^ K), D1, D2, ..., DK] @@ -186,62 +187,58 @@ void MKLDNNDepthToSpaceNode::createPrimitive() { // mode = depth_first : [0, 1, K + 2, 2, K + 3, 3, K + 4, 4, ..., K + (K + 1), K + 1] // where `k` is number of spatial dimensions - auto reshapeAndSetPermOrder = [&](const size_t idx1, const size_t idx2, const size_t shift, const SizeVector& dims) { - for (size_t i = 0; i < nSpatialDims; i++) { + auto reshapeAndSetPermOrder = [&](const size_t idx1, const size_t idx2, const size_t shift, const VectorDims& dims) { + for (size_t i = 0; i < attrs.nSpatialDims; i++) { params.order[i * 2 + shift] = i + idx1; params.order[i * 2 + shift + 1] = i + idx2; params.src_block_dims[params.order[i * 2 + shift]] = dims[i + shift]; - params.src_block_dims[params.order[i * 2 + shift + 1]] = blockSize; + params.src_block_dims[params.order[i * 2 + shift + 1]] = attrs.blockSize; } }; if (isBlocked) { - VectorDims srcBlockedDims = getParentEdgeAt(0)->getMemory().GetDescWithType()->getBlockDims(); - size_t orderShiftForBlocks, orderShiftForDims; - if (mode == Mode::BLOCKS_FIRST) { + if (attrs.mode == Mode::BLOCKS_FIRST) { orderShiftForBlocks = 1; - orderShiftForDims = nSpatialDims + 2; + orderShiftForDims = attrs.nSpatialDims + 2; - params.src_block_dims[nSpatialDims + 1] = srcBlockedDims[1] / blockStep; - params.src_block_dims[lastIdx] = srcBlockedDims.back(); + params.src_block_dims[attrs.nSpatialDims + 1] = attrs.srcBlockedDims[1] / attrs.blockStep; + params.src_block_dims[lastIdx] = attrs.srcBlockedDims.back(); - params.order[1] = nSpatialDims + 1; + params.order[1] = attrs.nSpatialDims + 1; params.order[lastIdx] = lastIdx; } else { - orderShiftForBlocks = nSpatialDims + 4; + orderShiftForBlocks = attrs.nSpatialDims + 4; orderShiftForDims = 3; - size_t newBlockSize = srcBlockedDims.back() / blockStep; - size_t newBlocksCount = srcBlockedDims[1] / blockStep; + size_t newBlockSize = attrs.srcBlockedDims.back() / attrs.blockStep; + size_t newBlocksCount = attrs.srcBlockedDims[1] / attrs.blockStep; params.src_block_dims[1] = newBlocksCount; - params.src_block_dims[2] = srcBlockedDims[1] / newBlocksCount; - params.src_block_dims[lastIdx - nSpatialDims] = newBlockSize; + params.src_block_dims[2] = attrs.srcBlockedDims[1] / newBlocksCount; + params.src_block_dims[lastIdx - attrs.nSpatialDims] = newBlockSize; params.order[1] = 1; params.order[2] = 3; params.order[lastIdx - 1] = 2; - params.order[lastIdx] = lastIdx - nSpatialDims; + params.order[lastIdx] = lastIdx - attrs.nSpatialDims; } - reshapeAndSetPermOrder(orderShiftForDims, orderShiftForBlocks, firstSpatialOrder, srcBlockedDims); - } else if (getParentEdgeAt(0)->getMemory().getDesc().hasLayoutType(LayoutType::nspc)) { - srcDims.push_back(srcDims[1]); - srcDims.erase(srcDims.begin() + 1); + reshapeAndSetPermOrder(orderShiftForDims, orderShiftForBlocks, firstSpatialOrder, attrs.srcBlockedDims); + } else if (isChannelsFirst) { firstSpatialOrder = 1; - size_t shift = static_cast(mode == DEPTH_FIRST) + nSpatialDims + 1; - params.order[lastIdx] = mode == Mode::DEPTH_FIRST ? nSpatialDims + 1 : lastIdx; - params.src_block_dims[params.order[lastIdx]] = srcDims.back() / blockStep; + size_t shift = static_cast(attrs.mode == DEPTH_FIRST) + attrs.nSpatialDims + 1; + params.order[lastIdx] = attrs.mode == Mode::DEPTH_FIRST ? attrs.nSpatialDims + 1 : lastIdx; + params.src_block_dims[params.order[lastIdx]] = attrs.srcBlockedDims.back() / attrs.blockStep; - reshapeAndSetPermOrder(firstSpatialOrder, shift, firstSpatialOrder, srcDims); + reshapeAndSetPermOrder(firstSpatialOrder, shift, firstSpatialOrder, attrs.srcBlockedDims); } else { - size_t shift = static_cast(mode == DEPTH_FIRST) + 1; - params.order[1] = mode == DEPTH_FIRST ? 1 : nSpatialDims + 1; - params.src_block_dims[params.order[1]] = srcDims[1] / blockStep; + size_t shift = static_cast(attrs.mode == DEPTH_FIRST) + 1; + params.order[1] = attrs.mode == DEPTH_FIRST ? 1 : attrs.nSpatialDims + 1; + params.src_block_dims[params.order[1]] = attrs.srcBlockedDims[1] / attrs.blockStep; - reshapeAndSetPermOrder(nSpatialDims + firstSpatialOrder, shift, firstSpatialOrder, srcDims); + reshapeAndSetPermOrder(attrs.nSpatialDims + firstSpatialOrder, shift, firstSpatialOrder, attrs.srcBlockedDims); } std::iota(params.src_block_order.begin(), params.src_block_order.end(), 0); @@ -252,11 +249,27 @@ void MKLDNNDepthToSpaceNode::createPrimitive() { permuteKernel = std::unique_ptr(new PermuteKernel(params)); } -void MKLDNNDepthToSpaceNode::execute(mkldnn::stream strm) { - const uint8_t* srcData = reinterpret_cast(this->getParentEdgeAt(0)->getMemoryPtr()->GetPtr()); - uint8_t* dstData = reinterpret_cast(this->getChildEdgeAt(0)->getMemoryPtr()->GetPtr()); +void MKLDNNDepthToSpaceNode::DepthToSpaceExecutor::exec(MKLDNNMemoryPtr& srcMemPtr, MKLDNNMemoryPtr& dstMemPtr, const int MB) { + if (!permuteKernel) + IE_THROW() << "Could not execute. Kernel for Transpose node was not compiled."; - permuteKernel->execute(srcData, dstData, batchToProcess()); + const uint8_t* srcData = reinterpret_cast(srcMemPtr->GetPtr()); + uint8_t* dstData = reinterpret_cast(dstMemPtr->GetPtr()); + + permuteKernel->execute(srcData, dstData, MB); +} + +void MKLDNNDepthToSpaceNode::execute(mkldnn::stream strm) { + if (!execPtr) { + THROW_ERROR << "doesn't have a compiled executor."; + } + + int MB = isDynamicNode() ? getParentEdgeAt(0)->getMemoryPtr()->getStaticDims()[0] : batchToProcess(); + execPtr->exec(getParentEdgeAt(0)->getMemoryPtr(), getChildEdgeAt(0)->getMemoryPtr(), MB); +} + +void MKLDNNDepthToSpaceNode::executeDynamicImpl(mkldnn::stream strm) { + execute(strm); } bool MKLDNNDepthToSpaceNode::created() const { diff --git a/inference-engine/src/mkldnn_plugin/nodes/mkldnn_depth_to_space_node.h b/inference-engine/src/mkldnn_plugin/nodes/mkldnn_depth_to_space_node.h index 0ab0b3bd940..f32a540cdc9 100644 --- a/inference-engine/src/mkldnn_plugin/nodes/mkldnn_depth_to_space_node.h +++ b/inference-engine/src/mkldnn_plugin/nodes/mkldnn_depth_to_space_node.h @@ -15,13 +15,17 @@ class MKLDNNDepthToSpaceNode : public MKLDNNNode { public: MKLDNNDepthToSpaceNode(const std::shared_ptr& op, const mkldnn::engine& eng, MKLDNNWeightsSharing::Ptr &cache); + static bool isSupportedOperation(const std::shared_ptr& op, std::string& errorMessage) noexcept; void getSupportedDescriptors() override; void initSupportedPrimitiveDescriptors() override; void createPrimitive() override; void execute(mkldnn::stream strm) override; bool created() const override; - static bool isSupportedOperation(const std::shared_ptr& op, std::string& errorMessage) noexcept; + void prepareParams() override; + +protected: + void executeDynamicImpl(mkldnn::stream strm) override; private: enum Mode { @@ -29,11 +33,26 @@ private: DEPTH_FIRST = 1 }; - Mode mode; - size_t blockSize; - size_t blockStep; + struct DepthToSpaceAttrs { + LayoutType layoutType; + Mode mode; + size_t blockSize = 0lu; + size_t blockStep = 0lu; + size_t dataSize = 1lu; + size_t nSpatialDims = 0lu; + VectorDims srcBlockedDims; + } attrs; - std::unique_ptr permuteKernel; + struct DepthToSpaceExecutor { + DepthToSpaceExecutor(const DepthToSpaceAttrs& attrs); + void exec(MKLDNNMemoryPtr& srcMemPtr, MKLDNNMemoryPtr& dstMemPtr, const int MB); + ~DepthToSpaceExecutor() = default; + + private: + std::unique_ptr permuteKernel; + }; + using executorPtr = std::shared_ptr; + executorPtr execPtr = nullptr; }; } // namespace MKLDNNPlugin diff --git a/inference-engine/tests/functional/plugin/cpu/single_layer_tests/depth_to_space.cpp b/inference-engine/tests/functional/plugin/cpu/single_layer_tests/depth_to_space.cpp index f4d6df8e3b7..4462137911b 100644 --- a/inference-engine/tests/functional/plugin/cpu/single_layer_tests/depth_to_space.cpp +++ b/inference-engine/tests/functional/plugin/cpu/single_layer_tests/depth_to_space.cpp @@ -2,56 +2,78 @@ // SPDX-License-Identifier: Apache-2.0 // -#include +#include "shared_test_classes/single_layer/depth_to_space.hpp" #include "test_utils/cpu_test_utils.hpp" +#include "shared_test_classes/base/ov_subgraph.hpp" + using namespace InferenceEngine; using namespace CPUTestUtils; using namespace ngraph::opset3; +using namespace ov::test; namespace CPULayerTestsDefinitions { -typedef std::tuple< - LayerTestsDefinitions::depthToSpaceParamsTuple, +using DepthToSpaceLayerCPUTestParamSet = std::tuple< + InputShape, // Input shape + ElementType, // Input element type + DepthToSpace::DepthToSpaceMode, // Mode + std::size_t, // Block size CPUSpecificParams -> DepthToSpaceLayerCPUTestParamSet; +>; class DepthToSpaceLayerCPUTest : public testing::WithParamInterface, - virtual public LayerTestsUtils::LayerTestsCommon, public CPUTestsBase { + virtual public ov::test::SubgraphBaseTest, public CPUTestsBase { public: static std::string getTestCaseName(testing::TestParamInfo obj) { - LayerTestsDefinitions::depthToSpaceParamsTuple basicParamsSet; + InputShape shapes; + ElementType inType; + DepthToSpace::DepthToSpaceMode mode; + std::size_t blockSize; CPUSpecificParams cpuParams; - std::tie(basicParamsSet, cpuParams) = obj.param; + std::tie(shapes, inType, mode, blockSize, cpuParams) = obj.param; - std::ostringstream result; - result << LayerTestsDefinitions::DepthToSpaceLayerTest::getTestCaseName( - testing::TestParamInfo(basicParamsSet, 0)); + std::ostringstream results; + results << "IS=" << CommonTestUtils::partialShape2str({shapes.first}) << "_"; + results << "TS="; + for (const auto& item : shapes.second) { + results << CommonTestUtils::vec2str(item) << "_"; + } + results << "Prc=" << inType << "_"; + switch (mode) { + case DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST: + results << "BLOCKS_FIRST_"; + break; + case DepthToSpace::DepthToSpaceMode::DEPTH_FIRST: + results << "DEPTH_FIRST_"; + break; + default: + throw std::runtime_error("Unsupported DepthToSpaceMode"); + } + results << "BS=" << blockSize << "_"; + results << CPUTestsBase::getTestCaseName(cpuParams); - result << CPUTestsBase::getTestCaseName(cpuParams); - - return result.str(); + return results.str(); } protected: void SetUp() override { - LayerTestsDefinitions::depthToSpaceParamsTuple basicParamsSet; - CPUSpecificParams cpuParams; - std::tie(basicParamsSet, cpuParams) = this->GetParam(); - - std::tie(inFmts, outFmts, priority, selectedType) = cpuParams; - - std::vector inputShape; + InputShape shapes; + ElementType inType; DepthToSpace::DepthToSpaceMode mode; std::size_t blockSize; - InferenceEngine::Precision netPrecision; - std::tie(inputShape, netPrecision, mode, blockSize, targetDevice) = basicParamsSet; + CPUSpecificParams cpuParams; + std::tie(shapes, inType, mode, blockSize, cpuParams) = this->GetParam(); - inPrc = outPrc = netPrecision; - selectedType = getPrimitiveType() + "_" + inPrc.name(); - auto inPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision); - auto params = ngraph::builder::makeParams(inPrc, {inputShape}); - auto paramOuts = ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes(params)); - auto d2s = ngraph::builder::makeDepthToSpace(paramOuts[0], mode, blockSize); + std::tie(inFmts, outFmts, priority, selectedType) = cpuParams; + if (selectedType.empty()) { + selectedType = getPrimitiveType(); + } + selectedType = selectedType + "_" + InferenceEngine::details::convertPrecision(inType).name(); + targetDevice = CommonTestUtils::DEVICE_CPU; + init_input_shapes({shapes}); + + auto params = ngraph::builder::makeDynamicParams(inType, inputDynamicShapes); + auto d2s = ngraph::builder::makeDepthToSpace(params[0], mode, blockSize); d2s->get_rt_info() = getCPUInfo(); ngraph::ResultVector results{std::make_shared(d2s)}; function = std::make_shared(results, params, "DepthToSpaceCPU"); @@ -61,35 +83,51 @@ protected: TEST_P(DepthToSpaceLayerCPUTest, CompareWithRefs) { SKIP_IF_CURRENT_TEST_IS_DISABLED() - Run(); - CheckPluginRelatedResults(executableNetwork, "DepthToSpace"); + run(); + // TODO: need to uncomment when this method will be updated + // CheckPluginRelatedResults(executableNetwork, "DepthToSpace"); } namespace { -const auto cpuParams_nChw16c = CPUSpecificParams {{nChw16c}, {nChw16c}, {"jit_avx512"}, {"jit_avx512"}}; -const auto cpuParams_nCdhw16c = CPUSpecificParams {{nCdhw16c}, {nCdhw16c}, {"jit_avx512"}, {"jit_avx512"}}; +const auto cpuParams_nChw16c = CPUSpecificParams {{nChw16c}, {nChw16c}, {}, {}}; +const auto cpuParams_nCdhw16c = CPUSpecificParams {{nCdhw16c}, {nCdhw16c}, {}, {}}; -const auto cpuParams_nChw8c_avx2 = CPUSpecificParams {{nChw8c}, {nChw8c}, {"jit_avx2"}, {"jit_avx2"}}; -const auto cpuParams_nCdhw8c_avx2 = CPUSpecificParams {{nCdhw8c}, {nCdhw8c}, {"jit_avx2"}, {"jit_avx2"}}; +const auto cpuParams_nChw8c = CPUSpecificParams {{nChw8c}, {nChw8c}, {}, {}}; +const auto cpuParams_nCdhw8c = CPUSpecificParams {{nCdhw8c}, {nCdhw8c}, {}, {}}; -const auto cpuParams_nChw8c_sse42 = CPUSpecificParams {{nChw8c}, {nChw8c}, {"jit_sse42"}, {"jit_sse42"}}; -const auto cpuParams_nCdhw8c_sse42 = CPUSpecificParams {{nCdhw8c}, {nCdhw8c}, {"jit_sse42"}, {"jit_sse42"}}; +const auto cpuParams_nhwc = CPUSpecificParams {{nhwc}, {nhwc}, {}, {}}; +const auto cpuParams_ndhwc = CPUSpecificParams {{ndhwc}, {ndhwc}, {}, {}}; -const auto cpuParams_nhwc_avx2 = CPUSpecificParams {{nhwc}, {nhwc}, {"jit_avx2"}, {"jit_avx2"}}; -const auto cpuParams_ndhwc_avx2 = CPUSpecificParams {{ndhwc}, {ndhwc}, {"jit_avx2"}, {"jit_avx2"}}; +const auto cpuParams_nchw = CPUSpecificParams {{nchw}, {nchw}, {}, {}}; +const auto cpuParams_ncdhw = CPUSpecificParams {{ncdhw}, {ncdhw}, {}, {}}; -const auto cpuParams_nhwc_sse42 = CPUSpecificParams {{nhwc}, {nhwc}, {"jit_sse42"}, {"jit_sse42"}}; -const auto cpuParams_ndhwc_sse42 = CPUSpecificParams {{ndhwc}, {ndhwc}, {"jit_sse42"}, {"jit_sse42"}}; +const std::vector CPUParams4D = { + cpuParams_nhwc, + cpuParams_nchw +}; -const auto cpuParams_nhwc_ref = CPUSpecificParams {{nhwc}, {nhwc}, {"ref_any"}, {"ref_any"}}; -const auto cpuParams_ndhwc_ref = CPUSpecificParams {{ndhwc}, {ndhwc}, {"ref_any"}, {"ref_any"}}; +const std::vector CPUParamsBlocked4D = { + cpuParams_nChw16c, + cpuParams_nChw8c, + cpuParams_nhwc +}; +const std::vector CPUParams5D = { + cpuParams_ndhwc, + cpuParams_ncdhw +}; -const std::vector inputPrecisions = { - InferenceEngine::Precision::FP32, - InferenceEngine::Precision::BF16, - InferenceEngine::Precision::I8 +const std::vector CPUParamsBlocked5D = { + cpuParams_nCdhw16c, + cpuParams_nCdhw8c, + cpuParams_ndhwc +}; + +const std::vector inputElementType = { + ElementType::f32, + ElementType::bf16, + ElementType::i8 }; const std::vector depthToSpaceModes = { @@ -97,99 +135,162 @@ const std::vector depthToSpaceModes = { DepthToSpace::DepthToSpaceMode::DEPTH_FIRST }; -const std::vector> inputShapesBS2_4D = { - {1, 64, 1, 1}, {1, 64, 1, 3}, {1, 128, 3, 3}, {2, 128, 1, 1}, {1, 192, 2, 2}, {2, 256, 2, 3}, {1, 512, 2, 1} +/* *========================* Static Shapes Tests *========================* */ + +namespace static_shapes { + +const std::vector inputShapesBS2_4D = { + {1, 64, 1, 1}, + {1, 64, 1, 3}, + {1, 128, 3, 3}, + {2, 128, 1, 1}, + {1, 192, 2, 2}, + {2, 256, 2, 3}, + {1, 512, 2, 1} }; -const std::vector> inputShapesBS3_4D = { - {1, 27, 1, 1}, {1, 27, 2, 3}, {1, 18, 2, 3}, {3, 18, 1, 1}, {2, 18, 3, 1} +const std::vector inputShapesBS3_4D = { + {1, 27, 1, 1}, + {1, 27, 2, 3}, + {1, 18, 2, 3}, + {3, 18, 1, 1}, + {2, 18, 3, 1} }; -const std::vector CPUParamsBS2_4D = { - cpuParams_nChw16c, - cpuParams_nChw8c_avx2, - cpuParams_nChw8c_sse42, - cpuParams_nhwc_avx2, - cpuParams_nhwc_sse42, - cpuParams_nhwc_ref, +INSTANTIATE_TEST_SUITE_P(smoke_CPUDepthToSpaceBS2_4D, DepthToSpaceLayerCPUTest, + testing::Combine( + testing::ValuesIn(static_shapes_to_test_representation(inputShapesBS2_4D)), + testing::ValuesIn(inputElementType), + testing::ValuesIn(depthToSpaceModes), + testing::Values(1, 2), + testing::ValuesIn(filterCPUInfoForDevice(CPUParamsBlocked4D))), + DepthToSpaceLayerCPUTest::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_CPUDepthToSpaceStaticBS3_4D, DepthToSpaceLayerCPUTest, + testing::Combine( + testing::ValuesIn(static_shapes_to_test_representation(inputShapesBS3_4D)), + testing::ValuesIn(inputElementType), + testing::ValuesIn(depthToSpaceModes), + testing::Values(1, 3), + testing::ValuesIn(filterCPUInfoForDevice(CPUParams4D))), + DepthToSpaceLayerCPUTest::getTestCaseName); + +const std::vector inputShapesBS2_5D = { + {1, 128, 1, 1, 1}, + {1, 128, 2, 1, 2}, + {1, 256, 2, 1, 3}, + {2, 256, 3, 1, 1}, + {1, 384, 1, 2, 2}, + {2, 512, 1, 2, 1} }; -const auto depthToSpaceBS2_4DParams = testing::Combine( - testing::Combine( - testing::ValuesIn(inputShapesBS2_4D), - testing::ValuesIn(inputPrecisions), - testing::ValuesIn(depthToSpaceModes), - testing::Values(1, 2), - testing::Values(CommonTestUtils::DEVICE_CPU)), - testing::ValuesIn(filterCPUInfoForDevice(CPUParamsBS2_4D)) -); - -INSTANTIATE_TEST_SUITE_P(smoke_CPUDepthToSpaceBS2_4D, DepthToSpaceLayerCPUTest, depthToSpaceBS2_4DParams, DepthToSpaceLayerCPUTest::getTestCaseName); - -const std::vector CPUParamsBS3_4D = { - cpuParams_nhwc_avx2, - cpuParams_nhwc_sse42, - cpuParams_nhwc_ref, +const std::vector inputShapesBS3_5D = { + {1, 54, 1, 1, 1}, + {1, 54, 2, 1, 2}, + {3, 54, 1, 1, 1}, + {2, 54, 3, 1, 2}, + {1, 54, 3, 2, 2} }; -const auto depthToSpaceBS3_4DParams = testing::Combine( - testing::Combine( - testing::ValuesIn(inputShapesBS3_4D), - testing::ValuesIn(inputPrecisions), - testing::ValuesIn(depthToSpaceModes), - testing::Values(1, 3), - testing::Values(CommonTestUtils::DEVICE_CPU)), - ::testing::ValuesIn(filterCPUInfoForDevice(CPUParamsBS3_4D)) -); +INSTANTIATE_TEST_SUITE_P(smoke_CPUDepthToSpaceStaticBS2_5D, DepthToSpaceLayerCPUTest, + testing::Combine( + testing::ValuesIn(static_shapes_to_test_representation(inputShapesBS2_5D)), + testing::ValuesIn(inputElementType), + testing::ValuesIn(depthToSpaceModes), + testing::Values(1, 2), + testing::ValuesIn(filterCPUInfoForDevice(CPUParamsBlocked5D))), + DepthToSpaceLayerCPUTest::getTestCaseName); -INSTANTIATE_TEST_SUITE_P(smoke_CPUDepthToSpaceBS3_4D, DepthToSpaceLayerCPUTest, depthToSpaceBS3_4DParams, DepthToSpaceLayerCPUTest::getTestCaseName); +INSTANTIATE_TEST_SUITE_P(smoke_CPUDepthToSpaceStaticBS3_5D, DepthToSpaceLayerCPUTest, + testing::Combine( + testing::ValuesIn(static_shapes_to_test_representation(inputShapesBS3_5D)), + testing::ValuesIn(inputElementType), + testing::ValuesIn(depthToSpaceModes), + testing::Values(1, 3), + testing::ValuesIn(filterCPUInfoForDevice(CPUParams5D))), + DepthToSpaceLayerCPUTest::getTestCaseName); -const std::vector> inputShapesBS2_5D = { - {1, 128, 1, 1, 1}, {1, 128, 2, 1, 2}, {1, 256, 2, 1, 3}, {2, 256, 3, 1, 1}, {1, 384, 1, 2, 2}, {2, 512, 1, 2, 1} +} // namespace static_shapes +/* *========================* *==================* *========================* */ + + +/* *========================* Dynamic Shapes Tests *========================* */ +namespace dynamic_shapes { + +const std::vector inputShapes4D = { + {{-1, -1, -1 , -1}, // dynamic + {{2, 36, 1, 1}, {1, 36, 3, 1}, {1, 72, 1, 4}}}, // target + + {{-1, 576, -1 , -1}, // dynamic + {{1, 576, 1, 1}, {1, 576, 2, 2}, {3, 576, 4, 1}}}, // target + + {{{1, 5}, {36, 72}, {1, 16}, {1, 16}}, // dynamic + {{3, 36, 4, 4}, {1, 36, 16, 12}, {3, 72, 8, 8}}}, // target }; -const std::vector> inputShapesBS3_5D = { - {1, 54, 1, 1, 1}, {1, 54, 2, 1, 2}, {3, 54, 1, 1, 1}, {2, 54, 3, 1, 2}, {1, 54, 3, 2, 2} +const std::vector inputShapes5D = { + {{-1, -1, -1, -1, -1}, // dynamic + {{2, 216, 1, 1, 1}, {1, 216, 3, 1, 2}, {1, 432, 2, 3, 1}}}, // target + + {{{1, 3}, {216, 432}, {1, 4}, {1, 4}, {1, 4}}, // dynamic + {{3, 216, 2, 2, 2}, {1, 432, 1, 1, 1}}}, // target }; -const std::vector CPUParamsBS2_5D = { - cpuParams_nCdhw16c, - cpuParams_nCdhw8c_avx2, - cpuParams_nCdhw8c_sse42, - cpuParams_ndhwc_avx2, - cpuParams_ndhwc_sse42, - cpuParams_ndhwc_ref, +const std::vector inputShapesBlocked5D = { + {{-1, 256, -1, -1, -1}, // dynamic + {{1, 256, 1, 1, 1}, {1, 256, 2, 1, 4}, {3, 256, 4, 1, 2}}}, // target + + {{{1, 3}, 256, {1, 3}, {1, 3}, {1, 3}}, // dynamic + {{1, 256, 1, 1, 1}, {1, 256, 2, 1, 3}, {3, 256, 3, 1, 2}}}, // target }; -const auto depthToSpaceBS2_5DParams = testing::Combine( - testing::Combine( - testing::ValuesIn(inputShapesBS2_5D), - testing::ValuesIn(inputPrecisions), - testing::ValuesIn(depthToSpaceModes), - testing::Values(1, 2), - testing::Values(CommonTestUtils::DEVICE_CPU)), - ::testing::ValuesIn(filterCPUInfoForDevice(CPUParamsBS2_5D)) -); +INSTANTIATE_TEST_SUITE_P(smoke_CPUDepthToSpaceDynamic4D, DepthToSpaceLayerCPUTest, + testing::Combine( + testing::ValuesIn(inputShapes4D), + testing::ValuesIn(inputElementType), + testing::ValuesIn(depthToSpaceModes), + testing::Values(1, 2, 3), + testing::ValuesIn(filterCPUInfoForDevice(CPUParams4D))), + DepthToSpaceLayerCPUTest::getTestCaseName); -INSTANTIATE_TEST_SUITE_P(smoke_CPUDepthToSpaceBS2_5D, DepthToSpaceLayerCPUTest, depthToSpaceBS2_5DParams, DepthToSpaceLayerCPUTest::getTestCaseName); +INSTANTIATE_TEST_SUITE_P(smoke_CPUDepthToSpaceDynamicBlocksFirstBlocked4D, DepthToSpaceLayerCPUTest, + testing::Combine( + testing::Values(inputShapes4D[1]), + testing::ValuesIn(inputElementType), + testing::Values(DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST), + testing::Values(1, 2, 3), + testing::ValuesIn(filterCPUInfoForDevice(CPUParamsBlocked4D))), + DepthToSpaceLayerCPUTest::getTestCaseName); -const std::vector CPUParamsBS3_5D = { - cpuParams_ndhwc_avx2, - cpuParams_ndhwc_sse42, - cpuParams_ndhwc_ref, -}; +INSTANTIATE_TEST_SUITE_P(smoke_CPUDepthToSpaceDynamicDepthFirstBlocked4D, DepthToSpaceLayerCPUTest, + testing::Combine( + testing::Values(inputShapes4D[1]), + testing::ValuesIn(inputElementType), + testing::Values(DepthToSpace::DepthToSpaceMode::DEPTH_FIRST), + testing::Values(1, 2), + testing::ValuesIn(filterCPUInfoForDevice(CPUParamsBlocked4D))), + DepthToSpaceLayerCPUTest::getTestCaseName); -const auto depthToSpaceBS3_5DParams = testing::Combine( - testing::Combine( - testing::ValuesIn(inputShapesBS3_5D), - testing::ValuesIn(inputPrecisions), - testing::ValuesIn(depthToSpaceModes), - testing::Values(1, 3), - testing::Values(CommonTestUtils::DEVICE_CPU)), - ::testing::ValuesIn(filterCPUInfoForDevice(CPUParamsBS3_5D)) -); +INSTANTIATE_TEST_SUITE_P(smoke_CPUDepthToSpaceDynamic5D, DepthToSpaceLayerCPUTest, + testing::Combine( + testing::ValuesIn(inputShapes5D), + testing::ValuesIn(inputElementType), + testing::ValuesIn(depthToSpaceModes), + testing::Values(1, 2, 3), + testing::ValuesIn(filterCPUInfoForDevice(CPUParams5D))), + DepthToSpaceLayerCPUTest::getTestCaseName); -INSTANTIATE_TEST_SUITE_P(smoke_CPUDepthToSpaceBS3_5D, DepthToSpaceLayerCPUTest, depthToSpaceBS3_5DParams, DepthToSpaceLayerCPUTest::getTestCaseName); +INSTANTIATE_TEST_SUITE_P(smoke_CPUDepthToSpaceDynamicCPUSpecific5D, DepthToSpaceLayerCPUTest, + testing::Combine( + testing::ValuesIn(inputShapesBlocked5D), + testing::ValuesIn(inputElementType), + testing::ValuesIn(depthToSpaceModes), + testing::Values(1, 2), + testing::ValuesIn(filterCPUInfoForDevice(CPUParamsBlocked5D))), + DepthToSpaceLayerCPUTest::getTestCaseName); + +} // namespace dynamic_shapes +/* *========================* *==================* *========================* */ } // namespace } // namespace CPULayerTestsDefinitions