From e0ac6366046f669bc4de5daa6e232bb461c2f489 Mon Sep 17 00:00:00 2001 From: Alexandra Sidorova Date: Wed, 17 Nov 2021 22:52:23 +0300 Subject: [PATCH] [CPU] Added dynamism support for StridedSlice (#8532) --- .../nodes/mkldnn_strided_slice_node.cpp | 592 +++++++++--------- .../nodes/mkldnn_strided_slice_node.h | 112 ++-- .../cpu/single_layer_tests/strided_slice.cpp | 587 ++++++++++------- 3 files changed, 700 insertions(+), 591 deletions(-) diff --git a/inference-engine/src/mkldnn_plugin/nodes/mkldnn_strided_slice_node.cpp b/inference-engine/src/mkldnn_plugin/nodes/mkldnn_strided_slice_node.cpp index 7bfab1f904f668..22e0115e5cc787 100644 --- a/inference-engine/src/mkldnn_plugin/nodes/mkldnn_strided_slice_node.cpp +++ b/inference-engine/src/mkldnn_plugin/nodes/mkldnn_strided_slice_node.cpp @@ -27,7 +27,7 @@ using namespace MKLDNNPlugin; using namespace InferenceEngine; using namespace InferenceEngine::details; -static inline size_t parallel_init(size_t start, size_t nDims, const SizeVector& dims, SizeVector& indexes) { +static inline size_t parallel_init(size_t start, size_t nDims, const VectorDims& dims, VectorDims& indexes) { for (int j = nDims - 1; j >= 0; j--) { indexes[j] = start % dims[j]; start = start / dims[j]; @@ -37,14 +37,17 @@ static inline size_t parallel_init(size_t start, size_t nDims, const SizeVector& bool MKLDNNStridedSliceNode::isSupportedOperation(const std::shared_ptr& op, std::string& errorMessage) noexcept { try { - if (isDynamicNgraphNode(op)) { - errorMessage = "Doesn't support op with dynamic shapes"; + auto ss = ov::as_type_ptr(op); + if (!ss) { + errorMessage = "Only opset1 StridedSlice operation is supported"; return false; } - const auto ss = std::dynamic_pointer_cast(op); - if (!ss) { - errorMessage = "Only opset1 StridedSlice operation is supported"; + if (ss->get_input_node_shared_ptr(BEGIN_ID)->get_type_info() != ov::op::v0::Constant::get_type_info_static() || + ss->get_input_node_shared_ptr(END_ID)->get_type_info() != ov::op::v0::Constant::get_type_info_static() || + (ss->get_input_size() == 4 && ss->get_input_node_shared_ptr(STRIDE_ID)->get_type_info() != ov::op::v0::Constant::get_type_info_static())) { + // TODO: Support begin, end, stride inputs for dynamic shapes. + errorMessage = "Only Constant 'begin', 'end' and 'stride' inputs are supported."; return false; } } catch (...) { @@ -56,162 +59,150 @@ bool MKLDNNStridedSliceNode::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 ss = std::dynamic_pointer_cast(op); - - const size_t nDims = std::max(inputShapes[DATA_ID].getRank(), outputShapes[0].getRank()); + if (!isSupportedOperation(op, errorMessage)) { + IE_THROW(NotImplemented) << errorMessage; + } + auto ss = ov::as_type_ptr(op); + if (inputShapes.size() != 3 && inputShapes.size() != 4) { + THROW_ERROR << "has incorrect number of input edges"; + } + if (outputShapes.size() != 1) { + THROW_ERROR << "has incorrect number of output edges"; + } - auto createMask = [&](const std::vector &origMask, const int bit = 0, bool needReverse = false) { - std::vector mask(origMask.begin(), origMask.end()); - if (needReverse) { - for (size_t i = 0; i < mask.size(); i++) - mask[i] = 1 - mask[i]; - } - for (size_t i = mask.size(); i < nDims; ++i) mask.push_back(bit); - return mask; - }; + const size_t inputRank = getInputShapeAtPort(DATA_ID).getRank(); + const size_t outputRank = getOutputShapeAtPort(0).getRank(); - beginMask = createMask(ss->get_begin_mask(), 1, true); - endMask = createMask(ss->get_end_mask(), 1, true); - newAxisMask = createMask(ss->get_new_axis_mask()); - shrinkAxisMask = createMask(ss->get_shrink_axis_mask()); + const size_t nDims = std::max(inputRank, outputRank); - auto origEllipsisMask = ss->get_ellipsis_mask(); - for (const auto &o : origEllipsisMask) { - ellipsisMask.push_back(o); - } - if (ellipsisMask.size() == 0) { - for (size_t i = ellipsisMask.size(); i < nDims; ++i) ellipsisMask.push_back(0); + auto createMask = [&](const std::vector &origMask, const int bit = 0, bool needReverse = false) { + std::vector mask(origMask.begin(), origMask.end()); + if (needReverse) { + for (size_t i = 0; i < mask.size(); i++) + mask[i] = 1 - mask[i]; } - - } else { - IE_THROW(NotImplemented) << errorMessage; - } -} - -void MKLDNNStridedSliceNode::getSupportedDescriptors() { - auto isConstantNode = [](const MKLDNNNodePtr &node) { - return node->getType() == Input && node->isConstant(); + for (size_t i = mask.size(); i < nDims; ++i) mask.push_back(bit); + return mask; }; - params.parametersAreConstant = isConstantNode(getParentEdgesAtPort(BEGIN_ID)[0]->getParent()) && - isConstantNode(getParentEdgesAtPort(END_ID)[0]->getParent()); - - const SizeVector srcDims = inputShapes[DATA_ID].getStaticDims(); - const SizeVector dstDims = outputShapes[0].getStaticDims(); - const size_t nSrcDims = srcDims.size(); - const size_t nDims = std::max(nSrcDims, dstDims.size()); + attrs.beginMask = createMask(ss->get_begin_mask(), 1, true); + attrs.endMask = createMask(ss->get_end_mask(), 1, true); + attrs.newAxisMask = createMask(ss->get_new_axis_mask()); + attrs.shrinkAxisMask = createMask(ss->get_shrink_axis_mask()); - if (getParentEdges().size() != 3 && getParentEdges().size() != 4) - THROW_ERROR << "has incorrect number of input edges"; - if (!getChildEdges().size()) - THROW_ERROR << "has incorrect number of output edges"; + auto origEllipsisMask = ss->get_ellipsis_mask(); + for (const auto &o : origEllipsisMask) { + attrs.ellipsisMask.push_back(o); + } + if (attrs.ellipsisMask.size() == 0) { + for (size_t i = attrs.ellipsisMask.size(); i < nDims; ++i) attrs.ellipsisMask.push_back(0); + } - beginDims = inputShapes[BEGIN_ID].getStaticDims(); - if (beginDims.size() != 1) + attrs.beginDims = getInputShapeAtPort(BEGIN_ID).getStaticDims(); + attrs.endDims = getInputShapeAtPort(END_ID).getStaticDims(); + if (attrs.beginDims.size() != 1) THROW_ERROR << " should have begin vector with 1 dimension"; - - endDims = inputShapes[END_ID].getStaticDims(); - if (endDims.size() != 1) + if (attrs.beginDims.size() != 1) THROW_ERROR << "should have end vector with 1 dimension"; - if (beginDims[0] != endDims[0]) + if (attrs.beginDims[0] != attrs.endDims[0]) THROW_ERROR << "should have begin vector with size equal to end vector size"; if (inputShapes.size() > STRIDE_ID) { - if (!isConstantNode(getParentEdgesAtPort(STRIDE_ID)[0]->getParent())) - params.parametersAreConstant = false; - - strideDims = inputShapes[STRIDE_ID].getStaticDims(); - if (strideDims.size() > 1) + isStrideSpecified = true; + attrs.strideDims = getInputShapeAtPort(STRIDE_ID).getStaticDims(); + if (attrs.strideDims.size() > 1) THROW_ERROR << "should have stride vector with 1 dimension"; - if (beginDims[0] != strideDims[0]) + if (attrs.beginDims[0] != attrs.strideDims[0]) THROW_ERROR << "should have stride vector with size equal to begin vector size"; } +} + +void MKLDNNStridedSliceNode::getSupportedDescriptors() { + const size_t inputRank = getInputShapeAtPort(DATA_ID).getRank(); + const size_t outputRank = getOutputShapeAtPort(0).getRank(); + const size_t nDims = std::max(inputRank, outputRank); int ellipsisMaskCounter = 0; - params.ellipsisPos1 = -1; - for (size_t i = 0; i < ellipsisMask.size(); i++) { - ellipsisMaskCounter += ellipsisMask[i]; - params.ellipsisPos1 = ellipsisMask[i] == 1 && params.ellipsisPos1 == -1 ? i : params.ellipsisPos1; + int ellipsisPos1 = -1; + for (size_t i = 0; i < attrs.ellipsisMask.size(); i++) { + ellipsisMaskCounter += attrs.ellipsisMask[i]; + ellipsisPos1 = attrs.ellipsisMask[i] == 1 && ellipsisPos1 == -1 ? i : ellipsisPos1; } if (ellipsisMaskCounter > 1) THROW_ERROR << "has incorrect 'Ellipsis_mask'. Only one non-zero bit is allowed"; - int newAxis = std::accumulate(newAxisMask.begin(), newAxisMask.end(), 0); - int shrinkAxis = std::accumulate(shrinkAxisMask.begin(), shrinkAxisMask.end(), 0); - params.equalDims = newAxis == 0 && shrinkAxis == 0; + int newAxis = std::accumulate(attrs.newAxisMask.begin(), attrs.newAxisMask.end(), 0); + int shrinkAxis = std::accumulate(attrs.shrinkAxisMask.begin(), attrs.shrinkAxisMask.end(), 0); + attrs.equalDims = newAxis == 0 && shrinkAxis == 0; - if (params.parametersAreConstant) { - auto fillingInParameters = [&](std::vector ¶meter, const size_t type, const size_t size, const int value) { - const auto constNode = std::dynamic_pointer_cast(getParentEdgesAtPort(type)[0]->getParent()); - if (!constNode) { - THROW_ERROR << "can't cast node on " << type << " port to MKLDNNInputNode"; - } - auto blob = constNode->getMemoryPtr(); - if (blob->GetDataType() != mkldnn::memory::data_type::s32) - THROW_ERROR << "supports only parameters input with precision I32"; - const int *ptr = static_cast(blob->GetPtr()); - parameter.assign(ptr, ptr + size); - - if (ellipsisMaskCounter == 0 && size < nDims) { - for (size_t i = size; i < nDims; i++) parameter.push_back(value); - } - }; + auto fillingInParameters = [&](std::vector ¶meter, const size_t type, const size_t size, const int value) { + const auto constNode = std::dynamic_pointer_cast(getParentEdgesAtPort(type)[0]->getParent()); + if (!constNode) { + THROW_ERROR << "can't cast node on " << type << " port to MKLDNNInputNode"; + } + auto blob = constNode->getMemoryPtr(); + if (blob->GetDataType() != mkldnn::memory::data_type::s32) + THROW_ERROR << "supports only parameters input with precision I32"; + const int *ptr = static_cast(blob->GetPtr()); + parameter.assign(ptr, ptr + size); + + if (ellipsisMaskCounter == 0 && size < nDims) { + for (size_t i = size; i < nDims; i++) parameter.push_back(value); + } + }; - if (beginDims.size()) - fillingInParameters(begin, BEGIN_ID, beginDims[0], 0); - if (endDims.size()) - fillingInParameters(end, END_ID, endDims[0], 0); - if (strideDims.size()) - fillingInParameters(stride, STRIDE_ID, strideDims[0], 1); + if (attrs.beginDims.size()) + fillingInParameters(attrs.begin, BEGIN_ID, attrs.beginDims[0], 0); + if (attrs.endDims.size()) + fillingInParameters(attrs.end, END_ID, attrs.endDims[0], 0); + if (attrs.strideDims.size()) + fillingInParameters(attrs.stride, STRIDE_ID, attrs.strideDims[0], 1); - if (nSrcDims > 3 && params.equalDims && ellipsisMaskCounter == 1) - addHiddenDims(nSrcDims); - } + if (inputRank > 3 && attrs.equalDims && ellipsisMaskCounter == 1) + addHiddenDims(inputRank, ellipsisPos1); } -void MKLDNNStridedSliceNode::addHiddenDims(const size_t nSrcDims) { + +void MKLDNNStridedSliceNode::addHiddenDims(const size_t nSrcDims, int ellipsisPos1) { // all masks and input parameters are for planar layouts. So if we use blocked or per channel layout and // there is ellipsis should to add default values in hidden dimensions to know real order of mask or parameter values - size_t afterDims = ellipsisMask.size() - params.ellipsisPos1 - 1; + size_t afterDims = attrs.ellipsisMask.size() - ellipsisPos1 - 1; size_t ellipsisPos2 = nSrcDims - afterDims - 1; auto addHiddenDims = [&](std::vector& data, const int bit = 0) { std::vector temp; - for (size_t i = 0; i < params.ellipsisPos1; i++) + for (size_t i = 0; i < ellipsisPos1; i++) temp.push_back(data[i]); - for (size_t i = params.ellipsisPos1; i < ellipsisPos2 + 1; i++) + for (size_t i = ellipsisPos1; i < ellipsisPos2 + 1; i++) temp.push_back(bit); for (size_t i = 1; i < nSrcDims - ellipsisPos2; i++) - temp.push_back(data[i + params.ellipsisPos1]); + temp.push_back(data[i + ellipsisPos1]); data = temp; }; - addHiddenDims(begin); - addHiddenDims(end); - addHiddenDims(stride, 1); - addHiddenDims(beginMask); - addHiddenDims(endMask); - addHiddenDims(ellipsisMask); - addHiddenDims(newAxisMask); - addHiddenDims(shrinkAxisMask); + addHiddenDims(attrs.begin); + addHiddenDims(attrs.end); + addHiddenDims(attrs.stride, 1); + addHiddenDims(attrs.beginMask); + addHiddenDims(attrs.endMask); + addHiddenDims(attrs.ellipsisMask); + addHiddenDims(attrs.newAxisMask); + addHiddenDims(attrs.shrinkAxisMask); } void MKLDNNStridedSliceNode::initSupportedPrimitiveDescriptors() { if (!supportedPrimitiveDescriptors.empty()) return; - const bool hasStrides = getParentEdges().size() > 3; InferenceEngine::Precision dataPrecision = getOriginalInputPrecisionAtPort(DATA_ID); InferenceEngine::Precision beginPrecision = getOriginalInputPrecisionAtPort(BEGIN_ID); InferenceEngine::Precision endPrecision = getOriginalInputPrecisionAtPort(END_ID); InferenceEngine::Precision stridePrecision; - if (hasStrides) + if (isStrideSpecified) stridePrecision = getOriginalInputPrecisionAtPort(STRIDE_ID); + attrs.dataSize = dataPrecision.size(); - auto srcDims = getInputShapeAtPort(DATA_ID).getStaticDims(); - auto dstDims = getOutputShapeAtPort(0).getStaticDims(); - size_t nDims = srcDims.size(); + size_t nDims = getInputShapeAtPort(DATA_ID).getRank(); NodeConfig config; config.dynBatchSupport = false; @@ -222,18 +213,21 @@ void MKLDNNStridedSliceNode::initSupportedPrimitiveDescriptors() { config.inConfs[DATA_ID].constant = false; config.inConfs[BEGIN_ID].constant = true; config.inConfs[END_ID].constant = true; - if (hasStrides) { + if (isStrideSpecified) { config.inConfs[STRIDE_ID].inPlace = -1; config.inConfs[STRIDE_ID].constant = true; } config.outConfs.resize(1); std::vector supportedTypes; - if (nDims > 2 && params.equalDims) { - auto canUseBlocked = [=](const size_t blockSize) { - auto channelBeginNormalized = begin[1] > 0 ? begin[1] : begin[1] + srcDims[1]; - return srcDims[1] % blockSize == 0 && abs(stride[1]) == 1 && - (channelBeginNormalized > srcDims[1] || channelBeginNormalized % blockSize == 0 || channelBeginNormalized < 0 || beginMask[1] == 0); + if (nDims > 2 && attrs.equalDims) { + auto canUseBlocked = [&](const size_t blockSize) { + const auto& srcDims = getInputShapeAtPort(DATA_ID).getDims(); + if (srcDims[1] == Shape::UNDEFINED_DIM) + return false; + auto channelBeginNormalized = attrs.begin[1] > 0 ? attrs.begin[1] : attrs.begin[1] + srcDims[1]; + return srcDims[1] % blockSize == 0 && abs(attrs.stride[1]) == 1 && + (channelBeginNormalized > srcDims[1] || channelBeginNormalized % blockSize == 0 || channelBeginNormalized < 0 || attrs.beginMask[1] == 0); }; supportedTypes.push_back(LayoutType::nspc); @@ -250,7 +244,7 @@ void MKLDNNStridedSliceNode::initSupportedPrimitiveDescriptors() { config.inConfs[0].desc = itr->second->createSharedDesc(dataPrecision, getInputShapeAtPort(DATA_ID)); config.inConfs[BEGIN_ID].desc = creators.at(LayoutType::ncsp)->createSharedDesc(beginPrecision, getInputShapeAtPort(BEGIN_ID)); config.inConfs[END_ID].desc = creators.at(LayoutType::ncsp)->createSharedDesc(endPrecision, getInputShapeAtPort(END_ID)); - if (hasStrides) + if (isStrideSpecified) config.inConfs[STRIDE_ID].desc = creators.at(LayoutType::ncsp)->createSharedDesc(stridePrecision, getInputShapeAtPort(STRIDE_ID)); config.outConfs[0].desc = itr->second->createSharedDesc(dataPrecision, getOutputShapeAtPort(DATA_ID)); @@ -268,45 +262,39 @@ void MKLDNNStridedSliceNode::createPrimitive() { if (getSelectedPrimitiveDescriptor() == nullptr) THROW_ERROR << "has unidentified preferable primitive descriptor."; - auto srcBlockingDesc = getParentEdgeAt(DATA_ID)->getMemory().GetDescWithType(); - auto dstBlockingDesc = getChildEdgeAt(0)->getMemory().GetDescWithType(); - auto srcOrder = srcBlockingDesc->getOrder(); - params.srcDims = srcBlockingDesc->getBlockDims(); - params.dstDims = dstBlockingDesc->getBlockDims(); - params.srcMemPtr = srcMemPtr; - params.dstMemPtr = dstMemPtr; - params.dataSize = getSelectedPrimitiveDescriptor()->getConfig().inConfs[DATA_ID].desc->getPrecision().size(); - - if (params.parametersAreConstant) { - size_t realNDims = params.dstDims.size(); - if (!getParentEdgeAt(DATA_ID)->getMemory().getDesc().hasLayoutType(LayoutType::ncsp)) - orderParametersByLayouts(); - - SizeVector newSrcDims, newDstDims; - dimsNormalization(newSrcDims, newDstDims); - dimsGluing(realNDims, newSrcDims, newDstDims); - indicesCalculation(); + if (!srcMemPtr->getDesc().hasLayoutType(LayoutType::ncsp)) + orderParametersByLayouts(srcMemPtr); + + if (inputShapesDefined()) { + prepareParams(); + updateLastInputDims(); } } -void MKLDNNStridedSliceNode::orderParametersByLayouts() { - const bool isPerChannelLayout = getParentEdgeAt(DATA_ID)->getMemory().getDesc().hasLayoutType(LayoutType::nspc); - const bool isBlockedLayout = getParentEdgeAt(DATA_ID)->getMemory().getDesc().hasLayoutType(LayoutType::nCsp8c) || - getParentEdgeAt(DATA_ID)->getMemory().getDesc().hasLayoutType(LayoutType::nCsp16c); - auto srcOrder = getParentEdgeAt(DATA_ID)->getMemory().GetDescWithType()->getOrder(); +void MKLDNNStridedSliceNode::orderParametersByLayouts(const MKLDNNMemoryPtr& srcMemPtr) { + size_t blk = 1; + bool isBlockedLayout = false; + if (srcMemPtr->getDesc().hasLayoutType(LayoutType::nCsp16c)) { + isBlockedLayout = true; + blk = 16; + } else if (srcMemPtr->getDesc().hasLayoutType(LayoutType::nCsp8c)) { + isBlockedLayout = true; + blk = 8; + } + const bool isPerChannelLayout = srcMemPtr->getDesc().hasLayoutType(LayoutType::nspc); + auto srcOrder = srcMemPtr->GetDescWithType()->getOrder(); if (isBlockedLayout) { - const size_t blk = params.srcDims.back(); - begin[1] = begin[1] / blk; - end[1] = ceil(end[1] / static_cast(blk)); - begin.push_back(0); - end.push_back(0); - stride.push_back(1); - beginMask.push_back(0); - endMask.push_back(0); - ellipsisMask.push_back(0); - newAxisMask.push_back(0); - shrinkAxisMask.push_back(0); + attrs.begin[1] = attrs.begin[1] / blk; + attrs.end[1] = ceil(attrs.end[1] / static_cast(blk)); + attrs.begin.push_back(0); + attrs.end.push_back(0); + attrs.stride.push_back(1); + attrs.beginMask.push_back(0); + attrs.endMask.push_back(0); + attrs.ellipsisMask.push_back(0); + attrs.newAxisMask.push_back(0); + attrs.shrinkAxisMask.push_back(0); } else if (isPerChannelLayout) { auto sortByOrder = [&](std::vector& data) { std::vector temp(srcOrder.size()); @@ -315,18 +303,38 @@ void MKLDNNStridedSliceNode::orderParametersByLayouts() { data = temp; }; - sortByOrder(begin); - sortByOrder(end); - sortByOrder(stride); - sortByOrder(beginMask); - sortByOrder(endMask); - sortByOrder(ellipsisMask); - sortByOrder(newAxisMask); - sortByOrder(shrinkAxisMask); + sortByOrder(attrs.begin); + sortByOrder(attrs.end); + sortByOrder(attrs.stride); + sortByOrder(attrs.beginMask); + sortByOrder(attrs.endMask); + sortByOrder(attrs.ellipsisMask); + sortByOrder(attrs.newAxisMask); + sortByOrder(attrs.shrinkAxisMask); } } -void MKLDNNStridedSliceNode::dimsNormalization(SizeVector& newSrcDims, SizeVector& newDstDims) { +void MKLDNNStridedSliceNode::prepareParams() { + execPtr = std::make_shared(attrs, + getParentEdgeAt(0)->getMemoryPtr()->GetDescWithType()->getBlockDims(), + getChildEdgeAt(0)->getMemoryPtr()->GetDescWithType()->getBlockDims()); +} + +MKLDNNStridedSliceNode::StridedSliceExecutor::StridedSliceExecutor(const StridedSliceAttributes& attrs, + const VectorDims& srcBlockedDims, + const VectorDims& dstBlockedDims) { + StridedSliceParams params; + params.srcBlockedDims = srcBlockedDims; + params.dstBlockedDims = dstBlockedDims; + params.attrs = attrs; + + size_t realNDims = params.dstBlockedDims.size(); + dimsNormalization(params); + dimsGluing(params, realNDims); + indicesCalculation(params); +} + +void MKLDNNStridedSliceNode::StridedSliceExecutor::dimsNormalization(StridedSliceParams& params) { // creating new src and dst dimensions and parameters of the same size using masks // // example 1: before srcDims = [5, 6, 8, 3, 2], begin = [1, 0], end = [4, 0], stride = [1, 1] @@ -352,66 +360,67 @@ void MKLDNNStridedSliceNode::dimsNormalization(SizeVector& newSrcDims, SizeVecto dim = dim >= 0 ? dim : shift + dim; }; + VectorDims newSrcDims, newDstDims; std::vector beginTemp; std::vector endTemp; std::vector strideTemp; size_t srcIdx = 0; - for (size_t axis = 0; axis < begin.size(); ++axis) { - if (ellipsisMask[axis] == 1) { + for (size_t axis = 0; axis < params.attrs.begin.size(); ++axis) { + if (params.attrs.ellipsisMask[axis] == 1) { int nNewAxisAfterEllipses = 0; int nSrcAxisBeforeEllipses = 0; for (size_t i = 0; i < axis; ++i) { - if (newAxisMask[i] != 1) + if (params.attrs.newAxisMask[i] != 1) nSrcAxisBeforeEllipses++; } - for (size_t i = axis + 1; i < begin.size(); ++i) { - if (newAxisMask[i] == 1) + for (size_t i = axis + 1; i < params.attrs.begin.size(); ++i) { + if (params.attrs.newAxisMask[i] == 1) nNewAxisAfterEllipses++; } - size_t nSrcAxisAfterEllipses = (begin.size() - axis - nNewAxisAfterEllipses - 1); - size_t nHiddenDims = params.srcDims.size() - nSrcAxisAfterEllipses - nSrcAxisBeforeEllipses; + size_t nSrcAxisAfterEllipses = (params.attrs.begin.size() - axis - nNewAxisAfterEllipses - 1); + size_t nHiddenDims = params.srcBlockedDims.size() - nSrcAxisAfterEllipses - nSrcAxisBeforeEllipses; for (size_t i = 0; i < nHiddenDims; ++i) { - newSrcDims.push_back(params.srcDims[srcIdx]); - newDstDims.push_back(params.srcDims[srcIdx]); + newSrcDims.push_back(params.srcBlockedDims[srcIdx]); + newDstDims.push_back(params.srcBlockedDims[srcIdx]); beginTemp.push_back(0); - endTemp.push_back(params.srcDims[srcIdx] - 1); + endTemp.push_back(params.srcBlockedDims[srcIdx] - 1); strideTemp.push_back(1); srcIdx++; } } else { - if (newAxisMask[axis] == 1) { + if (params.attrs.newAxisMask[axis] == 1) { beginTemp.push_back(0); endTemp.push_back(0); strideTemp.push_back(1); newSrcDims.push_back(1); newDstDims.push_back(1); - } else if (shrinkAxisMask[axis] == 1) { - int b = beginMask[axis] == 1 ? begin[axis] : 0; - correcting(b, params.srcDims[srcIdx]); - clipping(b, 0, params.srcDims[srcIdx]); + } else if (params.attrs.shrinkAxisMask[axis] == 1) { + int b = params.attrs.beginMask[axis] == 1 ? params.attrs.begin[axis] : 0; + correcting(b, params.srcBlockedDims[srcIdx]); + clipping(b, 0, params.srcBlockedDims[srcIdx]); beginTemp.push_back(b); endTemp.push_back(b); strideTemp.push_back(1); - newSrcDims.push_back(params.srcDims[srcIdx]); + newSrcDims.push_back(params.srcBlockedDims[srcIdx]); newDstDims.push_back(1); srcIdx++; } else { - int b = beginMask[axis] == 1 ? begin[axis] : (stride[axis] > 0 ? 0 : -1); - correcting(b, params.srcDims[srcIdx]); - clipping(b, 0, params.srcDims[srcIdx]); + int b = params.attrs.beginMask[axis] == 1 ? params.attrs.begin[axis] : (params.attrs.stride[axis] > 0 ? 0 : -1); + correcting(b, params.srcBlockedDims[srcIdx]); + clipping(b, 0, params.srcBlockedDims[srcIdx]); - int e = endMask[axis] == 1 ? (stride[axis] > 0 ? end[axis] - 1 : end[axis] + 1) : - (stride[axis] > 0 ? -1 : 0); - correcting(e, params.srcDims[srcIdx]); - clipping(e, 0, params.srcDims[srcIdx]); + int e = params.attrs.endMask[axis] == 1 ? (params.attrs.stride[axis] > 0 ? params.attrs.end[axis] - 1 : params.attrs.end[axis] + 1) : + (params.attrs.stride[axis] > 0 ? -1 : 0); + correcting(e, params.srcBlockedDims[srcIdx]); + clipping(e, 0, params.srcBlockedDims[srcIdx]); beginTemp.push_back(b); endTemp.push_back(e); - strideTemp.push_back(stride[axis]); - newSrcDims.push_back(params.srcDims[srcIdx]); + strideTemp.push_back(params.attrs.stride[axis]); + newSrcDims.push_back(params.srcBlockedDims[srcIdx]); newDstDims.push_back(ceil(static_cast(abs(e - b) + 1) / static_cast(abs(strideTemp.back())))); srcIdx++; @@ -419,36 +428,36 @@ void MKLDNNStridedSliceNode::dimsNormalization(SizeVector& newSrcDims, SizeVecto } } - begin = beginTemp; - end = endTemp; - stride = strideTemp; + params.attrs.begin = beginTemp; + params.attrs.end = endTemp; + params.attrs.stride = strideTemp; - params.dstDims = newDstDims; - params.srcDims = newSrcDims; + params.dstBlockedDims = newDstDims; + params.srcBlockedDims = newSrcDims; params.dstStrides.resize(newDstDims.size()); params.srcStrides.resize(newSrcDims.size()); params.dstStrides[params.dstStrides.size() - 1] = params.srcStrides[params.srcStrides.size() - 1] = 1; for (int i = newDstDims.size() - 2; i >= 0; --i) { - params.dstStrides[i] = params.dstStrides[i + 1] * params.dstDims[i + 1]; - params.srcStrides[i] = params.srcStrides[i + 1] * params.srcDims[i + 1]; + params.dstStrides[i] = params.dstStrides[i + 1] * params.dstBlockedDims[i + 1]; + params.srcStrides[i] = params.srcStrides[i + 1] * params.srcBlockedDims[i + 1]; } } -void MKLDNNStridedSliceNode::dimsGluing(const size_t realNDims, const SizeVector& newSrcDims, const SizeVector& newDstDims) { +void MKLDNNStridedSliceNode::StridedSliceExecutor::dimsGluing(StridedSliceParams& params, const size_t realNDims) { // gluing of dimensions if there aren't begin, end and stride != 1 on this axis // example: before gluing srcDims = [5, 6, 8, 3, 2], begin = [1, 0, 0, 0, 0], stride = [1, 1, 2, 1, 1], dstDims = [4, 6, 4, 3, 2] // after gluing srcDims = [30, 8, 6], begin = [6, 0, 0], stride = [1, 2, 1], dstDims = [24, 4, 6] - std::pair secondDim = { 0, begin.size() }; - SizeVector indexes(1, 0); - for (int idx = 0; idx < begin.size(); idx++) { - if (begin[idx] != 0 || end[idx] != params.srcDims[idx] - 1 || stride[idx] != 1) { + std::pair secondDim = { 0, params.attrs.begin.size() }; + VectorDims indexes(1, 0); + for (int idx = 0; idx < params.attrs.begin.size(); idx++) { + if (params.attrs.begin[idx] != 0 || params.attrs.end[idx] != params.srcBlockedDims[idx] - 1 || params.attrs.stride[idx] != 1) { indexes.push_back(std::max(idx - 1, 0)); - indexes.push_back(stride[idx] == 1 ? idx : idx + 1); + indexes.push_back(params.attrs.stride[idx] == 1 ? idx : idx + 1); if (idx != 0 && secondDim.first == 0) secondDim.first = idx; - else if (idx != 0 && secondDim.second == begin.size()) + else if (idx != 0 && secondDim.second == params.attrs.begin.size()) secondDim.second = idx; } } @@ -458,111 +467,113 @@ void MKLDNNStridedSliceNode::dimsGluing(const size_t realNDims, const SizeVector secondDim.first = 1; } + const VectorDims srcBlockedDimsBefore = params.srcBlockedDims; + const VectorDims dstBlockedDimsBefore = params.dstBlockedDims; const size_t nGluingLastDims = params.dstStrides[std::max(static_cast(indexes.back() - 1), 0)]; - const bool vLastDim = indexes.back() < begin.size(); - indexes[indexes.size() - 1] = vLastDim ? indexes.back() : begin.size() - 1; - indexes.push_back(begin.size() - 1); + const bool vLastDim = indexes.back() < params.attrs.begin.size(); + indexes[indexes.size() - 1] = vLastDim ? indexes.back() : params.attrs.begin.size() - 1; + indexes.push_back(params.attrs.begin.size() - 1); for (int idx = indexes.size() - 1; idx >= 0; idx -= 2) { if (indexes[idx - 1] < indexes[idx]) { for (size_t jdx = indexes[idx]; jdx > indexes[idx - 1]; --jdx) { - params.dstDims[indexes[idx - 1]] *= params.dstDims[jdx]; - params.srcDims[indexes[idx - 1]] *= params.srcDims[jdx]; - params.dstStrides[indexes[idx - 1]] /= params.dstDims[jdx]; - params.srcStrides[indexes[idx - 1]] /= params.srcDims[jdx]; + params.dstBlockedDims[indexes[idx - 1]] *= params.dstBlockedDims[jdx]; + params.srcBlockedDims[indexes[idx - 1]] *= params.srcBlockedDims[jdx]; + params.dstStrides[indexes[idx - 1]] /= params.dstBlockedDims[jdx]; + params.srcStrides[indexes[idx - 1]] /= params.srcBlockedDims[jdx]; - begin[indexes[idx - 1]] *= params.dstDims[jdx]; + params.attrs.begin[indexes[idx - 1]] *= params.dstBlockedDims[jdx]; } const size_t beginShift = indexes[idx - 1] + 1; const size_t endShift = indexes[idx] + 1; - params.dstDims.erase(params.dstDims.begin() + beginShift, params.dstDims.begin() + endShift); - params.srcDims.erase(params.srcDims.begin() + beginShift, params.srcDims.begin() + endShift); + params.dstBlockedDims.erase(params.dstBlockedDims.begin() + beginShift, params.dstBlockedDims.begin() + endShift); + params.srcBlockedDims.erase(params.srcBlockedDims.begin() + beginShift, params.srcBlockedDims.begin() + endShift); params.dstStrides.erase(params.dstStrides.begin() + beginShift, params.dstStrides.begin() + endShift); params.srcStrides.erase(params.srcStrides.begin() + beginShift, params.srcStrides.begin() + endShift); - begin.erase(begin.begin() + beginShift, begin.begin() + endShift); - stride.erase(stride.begin() + beginShift, stride.begin() + endShift); + params.attrs.begin.erase(params.attrs.begin.begin() + beginShift, params.attrs.begin.begin() + endShift); + params.attrs.stride.erase(params.attrs.stride.begin() + beginShift, params.attrs.stride.begin() + endShift); } } - params.workAmount = params.dstDims[0] * params.dstStrides[0] / nGluingLastDims; - params.lastDstDim = nGluingLastDims * params.dataSize; - params.nDimsForWork = params.dstDims.size() - static_cast(vLastDim); + workAmount = params.dstBlockedDims[0] * params.dstStrides[0] / nGluingLastDims; + lastDstDim = nGluingLastDims * params.attrs.dataSize; + params.nDimsForWork = params.dstBlockedDims.size() - static_cast(vLastDim); if (params.nDimsForWork == 1 && realNDims > 2) { - const size_t realSrcDim = newSrcDims[secondDim.first]; - const size_t realDstDim = newDstDims[secondDim.first]; + const size_t realSrcDim = srcBlockedDimsBefore[secondDim.first]; + const size_t realDstDim = dstBlockedDimsBefore[secondDim.first]; params.dstStrides.insert(params.dstStrides.begin() + 1, params.dstStrides[0] / realDstDim); params.srcStrides.insert(params.srcStrides.begin() + 1, params.srcStrides[0] / realSrcDim); for (size_t idx = secondDim.first + 1; idx < secondDim.second; idx++) - begin[1] /= newDstDims[idx]; + params.attrs.begin[1] /= dstBlockedDimsBefore[idx]; const size_t maxThreads = parallel_get_max_threads(); - if (params.dstDims[0] < maxThreads) { - params.dstDims[1] /= realDstDim; - params.srcDims[1] /= realSrcDim; - params.dstDims.insert(params.dstDims.begin() + 1, realDstDim); - params.srcDims.insert(params.srcDims.begin() + 1, realSrcDim); + if (params.dstBlockedDims[0] < maxThreads) { + params.dstBlockedDims[1] /= realDstDim; + params.srcBlockedDims[1] /= realSrcDim; + params.dstBlockedDims.insert(params.dstBlockedDims.begin() + 1, realDstDim); + params.srcBlockedDims.insert(params.srcBlockedDims.begin() + 1, realSrcDim); } - if (params.dstDims.size() > 2) - params.lastDstDim /= newDstDims[secondDim.first]; + if (params.dstBlockedDims.size() > 2) + lastDstDim /= dstBlockedDimsBefore[secondDim.first]; } // some parameter calculations for common execution - params.isOptimized = params.nDimsForWork == 1 && params.dstDims.size() > 1; + params.isOptimized = params.nDimsForWork == 1 && params.dstBlockedDims.size() > 1; if (params.isOptimized) { - if (params.dstDims.size() == 2) - params.dstDims[1] = 1; + if (params.dstBlockedDims.size() == 2) + params.dstBlockedDims[1] = 1; - params.workAmount = params.dstDims[0] * params.dstDims[1]; - params.srcShift = (begin[0] * params.srcStrides[0] + begin[1] * params.srcStrides[1]) * params.dataSize; + workAmount = params.dstBlockedDims[0] * params.dstBlockedDims[1]; + srcShift = (params.attrs.begin[0] * params.srcStrides[0] + params.attrs.begin[1] * params.srcStrides[1]) * params.attrs.dataSize; } else { - params.srcShift = stride.back() == 1 && stride.size() > 1 ? - begin[params.nDimsForWork] * params.srcStrides[params.nDimsForWork] * params.dataSize : 0; + srcShift = params.attrs.stride.back() == 1 && params.attrs.stride.size() > 1 ? + params.attrs.begin[params.nDimsForWork] * params.srcStrides[params.nDimsForWork] * params.attrs.dataSize : 0; } } -void MKLDNNStridedSliceNode::indicesCalculation() { +void MKLDNNStridedSliceNode::StridedSliceExecutor::indicesCalculation(const StridedSliceParams& params) { // indices calculation before execution for the best performance - params.srcIndices.resize(params.workAmount, 0); - params.dstIndices.resize(params.workAmount, 0); + srcIndices.resize(workAmount, 0); + dstIndices.resize(workAmount, 0); // should choose more optimal thread count const size_t nthr = parallel_get_max_threads(); - params.nThreads = nthr > params.workAmount ? params.workAmount : nthr; + nThreads = nthr > workAmount ? workAmount : nthr; if (params.isOptimized) { - indicesCalculationForOptimized(); + indicesCalculationForOptimized(params); return; } - auto getSrcIdx = [this](const SizeVector& indexes){ + auto getSrcIdx = [&](const VectorDims& indexes){ size_t srcIdx = 0; for (int i = 0; i < params.nDimsForWork; ++i) - srcIdx += (begin[i] + indexes[i] * stride[i]) * params.srcStrides[i]; - return srcIdx * params.dataSize; + srcIdx += (params.attrs.begin[i] + indexes[i] * params.attrs.stride[i]) * params.srcStrides[i]; + return srcIdx * params.attrs.dataSize; }; - parallel_nt(params.nThreads, [&](const int ithr, const int nthr) { + parallel_nt(nThreads, [&](const int ithr, const int nthr) { size_t start = 0, end = 0; - SizeVector coords(params.nDimsForWork, 0); - splitter(params.workAmount, nthr, ithr, start, end); - parallel_init(start, params.nDimsForWork, params.dstDims, coords); + VectorDims coords(params.nDimsForWork, 0); + splitter(workAmount, nthr, ithr, start, end); + parallel_init(start, params.nDimsForWork, params.dstBlockedDims, coords); size_t srcIdx = getSrcIdx(coords); for (size_t j = start; j < end; ++j) { - params.dstIndices[j] = j * params.lastDstDim; - params.srcIndices[j] = srcIdx; + dstIndices[j] = j * lastDstDim; + srcIndices[j] = srcIdx; bool out = false; for (int k = params.nDimsForWork - 1; k >= 0; k--) { coords[k]++; - if (coords[k] < params.dstDims[k]) { - srcIdx += stride[k] * params.srcStrides[k] * params.dataSize; + if (coords[k] < params.dstBlockedDims[k]) { + srcIdx += params.attrs.stride[k] * params.srcStrides[k] * params.attrs.dataSize; break; } @@ -576,74 +587,47 @@ void MKLDNNStridedSliceNode::indicesCalculation() { }); } -void MKLDNNStridedSliceNode::indicesCalculationForOptimized() { - const size_t dstIdx0 = params.dstStrides[0] * params.dataSize; - const size_t dstIdx1 = params.dstStrides[1] * params.dataSize; - const size_t srcIdx0 = stride[0] * params.srcStrides[0] * params.dataSize; - const size_t srcIdx1 = stride[1] * params.srcStrides[1] * params.dataSize; +void MKLDNNStridedSliceNode::StridedSliceExecutor::indicesCalculationForOptimized(const StridedSliceParams& params) { + const size_t dstIdx0 = params.dstStrides[0] * params.attrs.dataSize; + const size_t dstIdx1 = params.dstStrides[1] * params.attrs.dataSize; + const size_t srcIdx0 = params.attrs.stride[0] * params.srcStrides[0] * params.attrs.dataSize; + const size_t srcIdx1 = params.attrs.stride[1] * params.srcStrides[1] * params.attrs.dataSize; - for (size_t i0 = 0; i0 < params.dstDims[0]; i0++) { - const size_t idx = i0 * params.dstDims[1]; + for (size_t i0 = 0; i0 < params.dstBlockedDims[0]; i0++) { + const size_t idx = i0 * params.dstBlockedDims[1]; - params.dstIndices[idx] = i0 * dstIdx0; - params.srcIndices[idx] = i0 * srcIdx0; + dstIndices[idx] = i0 * dstIdx0; + srcIndices[idx] = i0 * srcIdx0; - for (size_t i1 = 1; i1 < params.dstDims[1]; i1++) { - params.dstIndices[idx + i1] = params.dstIndices[idx] + i1 * dstIdx1; - params.srcIndices[idx + i1] = params.srcIndices[idx] + i1 * srcIdx1; + for (size_t i1 = 1; i1 < params.dstBlockedDims[1]; i1++) { + dstIndices[idx + i1] = dstIndices[idx] + i1 * dstIdx1; + srcIndices[idx + i1] = srcIndices[idx] + i1 * srcIdx1; } } } -void MKLDNNStridedSliceNode::execute(mkldnn::stream strm) { - if (!params.parametersAreConstant) { - auto srcDims = getParentEdgeAt(DATA_ID)->getMemory().getStaticDims(); - auto dstDims = getChildEdgesAtPort(DATA_ID)[0]->getMemory().getStaticDims(); - const size_t nDims = std::max(srcDims.size(), dstDims.size()); - const size_t ellipsisMaskCounter = std::accumulate(ellipsisMask.begin(), ellipsisMask.end(), 0); - - auto fillingInParameters = [&](std::vector ¶meter, const size_t type, const size_t size, const int value) { - const int *ptr = reinterpret_cast(this->getParentEdgeAt(type)->getMemoryPtr()->GetPtr()); - parameter.assign(ptr, ptr + size); - - if (ellipsisMaskCounter == 0 && size < nDims) { - for (size_t i = size; i < nDims; i++) parameter.push_back(value); - } - }; - - if (beginDims.size()) - fillingInParameters(begin, BEGIN_ID, beginDims[0], 0); - if (endDims.size()) - fillingInParameters(end, END_ID, endDims[0], 0); - if (strideDims.size()) - fillingInParameters(stride, STRIDE_ID, strideDims[0], 1); - - if (srcDims.size() > 3 && params.equalDims && ellipsisMaskCounter != 0) - addHiddenDims(srcDims.size()); - - if (!getParentEdgeAt(DATA_ID)->getMemory().getDesc().hasLayoutType(LayoutType::ncsp)) - orderParametersByLayouts(); - - SizeVector newSrcDims, newDstDims; - dimsNormalization(newSrcDims, newDstDims); - dimsGluing(dstDims.size(), newSrcDims, newDstDims); - indicesCalculation(); - } +void MKLDNNStridedSliceNode::StridedSliceExecutor::exec(const uint8_t* srcData, uint8_t* dstData) { + const uint8_t* srcShiftedData = srcData + srcShift; + parallel_nt(nThreads, [&](const int ithr, const int nthr) { + size_t start = 0, end = 0; + splitter(workAmount, nthr, ithr, start, end); - stridedSlice(); + for (size_t iwork = start; iwork < end; ++iwork) + cpu_memcpy(&dstData[dstIndices[iwork]], &srcShiftedData[srcIndices[iwork]], lastDstDim); + }); } -inline void MKLDNNStridedSliceNode::stridedSlice() { - const uint8_t* srcData = reinterpret_cast(params.srcMemPtr->GetPtr()) + params.srcShift; - uint8_t* dstData = reinterpret_cast(params.dstMemPtr->GetPtr()); +void MKLDNNStridedSliceNode::execute(mkldnn::stream strm) { + if (!execPtr) + THROW_ERROR << "doesn't have compiled executor!"; - parallel_nt(params.nThreads, [&](const int ithr, const int nthr) { - size_t start = 0, end = 0; - splitter(params.workAmount, nthr, ithr, start, end); + const uint8_t* srcData = reinterpret_cast(getParentEdgeAt(0)->getMemoryPtr()->GetPtr()); + uint8_t* dstData = reinterpret_cast(getChildEdgeAt(0)->getMemoryPtr()->GetPtr()); + execPtr->exec(srcData, dstData); +} - for (size_t iwork = start; iwork < end; ++iwork) - cpu_memcpy(&dstData[params.dstIndices[iwork]], &srcData[params.srcIndices[iwork]], params.lastDstDim); - }); +void MKLDNNStridedSliceNode::executeDynamicImpl(mkldnn::stream strm) { + execute(strm); } bool MKLDNNStridedSliceNode::created() const { diff --git a/inference-engine/src/mkldnn_plugin/nodes/mkldnn_strided_slice_node.h b/inference-engine/src/mkldnn_plugin/nodes/mkldnn_strided_slice_node.h index 8883311903d010..128520f488be62 100644 --- a/inference-engine/src/mkldnn_plugin/nodes/mkldnn_strided_slice_node.h +++ b/inference-engine/src/mkldnn_plugin/nodes/mkldnn_strided_slice_node.h @@ -15,6 +15,7 @@ class MKLDNNStridedSliceNode : public MKLDNNNode { public: MKLDNNStridedSliceNode(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; @@ -24,58 +25,71 @@ class MKLDNNStridedSliceNode : public MKLDNNNode { return false; } - static bool isSupportedOperation(const std::shared_ptr& op, std::string& errorMessage) noexcept; + void prepareParams() override; + +protected: + void executeDynamicImpl(mkldnn::stream strm) override; private: - inline void stridedSlice(); - - void addHiddenDims(const size_t nSrcDims); - void orderParametersByLayouts(); - void dimsNormalization(InferenceEngine::SizeVector& newSrcDims, InferenceEngine::SizeVector& newDstDims); - void dimsGluing(const size_t realNDims, const InferenceEngine::SizeVector& newSrcDims, const InferenceEngine::SizeVector& newDstDims); - void indicesCalculation(); - void indicesCalculationForOptimized(); - - const size_t DATA_ID = 0; - const size_t BEGIN_ID = 1; - const size_t END_ID = 2; - const size_t STRIDE_ID = 3; - - std::vector begin; - std::vector end; - std::vector stride; - - std::vector beginMask; - std::vector endMask; - std::vector ellipsisMask; - std::vector newAxisMask; - std::vector shrinkAxisMask; - - InferenceEngine::SizeVector beginDims; - InferenceEngine::SizeVector endDims; - InferenceEngine::SizeVector strideDims; - - struct { - MKLDNNMemoryPtr srcMemPtr = nullptr; - MKLDNNMemoryPtr dstMemPtr = nullptr; - InferenceEngine::SizeVector srcDims; - InferenceEngine::SizeVector dstDims; - InferenceEngine::SizeVector srcStrides; - InferenceEngine::SizeVector dstStrides; - InferenceEngine::SizeVector srcIndices; - InferenceEngine::SizeVector dstIndices; - int ellipsisPos1 = -1; - int ellipsisPos2 = 0; - size_t nThreads = 0; - size_t nDimsForWork = 0; - size_t workAmount = 0; - size_t lastDstDim = 0; - size_t dataSize = 0; - size_t srcShift = 0; - bool isOptimized = false; + void addHiddenDims(const size_t nSrcDims, int ellipsisPos1); + void orderParametersByLayouts(const MKLDNNMemoryPtr& srcMemPtr); + + struct StridedSliceAttributes { + std::vector begin; + std::vector end; + std::vector stride; + + std::vector beginMask; + std::vector endMask; + std::vector ellipsisMask; + std::vector newAxisMask; + std::vector shrinkAxisMask; + + VectorDims beginDims; + VectorDims endDims; + VectorDims strideDims; + bool equalDims = false; - bool parametersAreConstant = true; - } params; + size_t dataSize = 1lu; + } attrs; + + struct StridedSliceExecutor { + StridedSliceExecutor(const StridedSliceAttributes& attrs, const VectorDims& srcBlockedDims, const VectorDims& dstBlockedDims); + void exec(const uint8_t* srcData, uint8_t* dstData); + ~StridedSliceExecutor() = default; + + private: + struct StridedSliceParams { + StridedSliceAttributes attrs; + VectorDims srcBlockedDims; + VectorDims dstBlockedDims; + VectorDims srcStrides; + VectorDims dstStrides; + size_t nDimsForWork = 0lu; + bool isOptimized = false; + }; + + void dimsNormalization(StridedSliceParams& params); + void dimsGluing(StridedSliceParams& params, const size_t realNDims); + void indicesCalculation(const StridedSliceParams& params); + void indicesCalculationForOptimized(const StridedSliceParams& params); + + VectorDims srcIndices; + VectorDims dstIndices; + size_t nThreads = 0lu; + size_t workAmount = 0lu; + size_t lastDstDim = 0lu; + size_t srcShift = 0lu; + }; + using executorPtr = std::shared_ptr; + executorPtr execPtr = nullptr; + + bool isStrideSpecified = false; + + static constexpr size_t DATA_ID = 0; + static constexpr size_t BEGIN_ID = 1; + static constexpr size_t END_ID = 2; + static constexpr size_t STRIDE_ID = 3; }; } // namespace MKLDNNPlugin diff --git a/inference-engine/tests/functional/plugin/cpu/single_layer_tests/strided_slice.cpp b/inference-engine/tests/functional/plugin/cpu/single_layer_tests/strided_slice.cpp index 8eb16ed7d4d669..7d0660debda7eb 100644 --- a/inference-engine/tests/functional/plugin/cpu/single_layer_tests/strided_slice.cpp +++ b/inference-engine/tests/functional/plugin/cpu/single_layer_tests/strided_slice.cpp @@ -5,70 +5,80 @@ #include #include "ngraph_functions/builders.hpp" #include "test_utils/cpu_test_utils.hpp" +#include "shared_test_classes/base/ov_subgraph.hpp" using namespace InferenceEngine; using namespace CPUTestUtils; using namespace LayerTestsDefinitions; +using namespace ov; +using namespace test; namespace CPULayerTestsDefinitions { +struct StridedSliceParams { + std::vector begin; + std::vector end; + std::vector strides; + std::vector beginMask; + std::vector endMask; + std::vector newAxisMask; + std::vector shrinkAxisMask; + std::vector ellipsisAxisMask; +}; + typedef std::tuple< - StridedSliceSpecificParams, - InferenceEngine::Precision, // Net precision - std::string, // Device name - std::map, // Additional network configuration + InputShape, // Input shapes + StridedSliceParams, + ElementType, // Element type CPUSpecificParams> StridedSliceLayerCPUTestParamSet; class StridedSliceLayerCPUTest : public testing::WithParamInterface, - virtual public LayerTestsUtils::LayerTestsCommon, public CPUTestsBase { + virtual public SubgraphBaseTest, public CPUTestsBase { public: static std::string getTestCaseName(testing::TestParamInfo obj) { - StridedSliceSpecificParams params; - InferenceEngine::Precision netPrc; - std::string targetName; - std::map additionalConfig; + InputShape shapes; + StridedSliceParams params; + ElementType elementType; CPUSpecificParams cpuParams; - std::tie(params, netPrc, targetName, additionalConfig, cpuParams) = obj.param; - - std::ostringstream result; - result << "inShape=" << CommonTestUtils::vec2str(params.inputShape) << "_"; - result << "netPRC=" << netPrc.name() << "_"; - result << "begin=" << CommonTestUtils::vec2str(params.begin) << "_"; - result << "end=" << CommonTestUtils::vec2str(params.end) << "_"; - result << "stride=" << CommonTestUtils::vec2str(params.strides) << "_"; - result << "begin_m=" << CommonTestUtils::vec2str(params.beginMask) << "_"; - result << "end_m=" << CommonTestUtils::vec2str(params.endMask) << "_"; - result << "new_axis_m=" << (params.newAxisMask.empty() ? "def" : CommonTestUtils::vec2str(params.newAxisMask)) << "_"; - result << "shrink_m=" << (params.shrinkAxisMask.empty() ? "def" : CommonTestUtils::vec2str(params.shrinkAxisMask)) << "_"; - result << "ellipsis_m=" << (params.ellipsisAxisMask.empty() ? "def" : CommonTestUtils::vec2str(params.ellipsisAxisMask)) << "_"; - result << "trgDev=" << targetName; - result << CPUTestsBase::getTestCaseName(cpuParams); - - return result.str(); + std::tie(shapes, params, elementType, cpuParams) = obj.param; + + std::ostringstream results; + results << "IS=" << CommonTestUtils::partialShape2str({shapes.first}) << "_"; + results << "TS="; + for (const auto& item : shapes.second) { + results << CommonTestUtils::vec2str(item) << "_"; + } + results << "netPRC=" << elementType << "_"; + results << "begin=" << CommonTestUtils::vec2str(params.begin) << "_"; + results << "end=" << CommonTestUtils::vec2str(params.end) << "_"; + results << "stride=" << CommonTestUtils::vec2str(params.strides) << "_"; + results << "begin_m=" << CommonTestUtils::vec2str(params.beginMask) << "_"; + results << "end_m=" << CommonTestUtils::vec2str(params.endMask) << "_"; + results << "new_axis_m=" << (params.newAxisMask.empty() ? "def" : CommonTestUtils::vec2str(params.newAxisMask)) << "_"; + results << "shrink_m=" << (params.shrinkAxisMask.empty() ? "def" : CommonTestUtils::vec2str(params.shrinkAxisMask)) << "_"; + results << "ellipsis_m=" << (params.ellipsisAxisMask.empty() ? "def" : CommonTestUtils::vec2str(params.ellipsisAxisMask)) << "_"; + results << CPUTestsBase::getTestCaseName(cpuParams); + + return results.str(); } protected: void SetUp() override { - StridedSliceSpecificParams ssParams; - InferenceEngine::Precision netPrecision; - std::map additionalConfig; + InputShape shapes; + StridedSliceParams ssParams; + ElementType elementType; CPUSpecificParams cpuParams; - std::tie(ssParams, netPrecision, targetDevice, additionalConfig, cpuParams) = this->GetParam(); - inPrc = outPrc = netPrecision; + std::tie(shapes, ssParams, elementType, cpuParams) = this->GetParam(); std::tie(inFmts, outFmts, priority, selectedType) = cpuParams; - configuration.insert(additionalConfig.begin(), additionalConfig.end()); - - auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision); - auto params = ngraph::builder::makeParams(ngPrc, {ssParams.inputShape}); - auto paramOuts = ngraph::helpers::convert2OutputVector( - ngraph::helpers::castOps2Nodes(params)); - auto ss = ngraph::builder::makeStridedSlice(paramOuts[0], ssParams.begin, ssParams.end, ssParams.strides, ngPrc, ssParams.beginMask, - ssParams.endMask, ssParams.newAxisMask, ssParams.shrinkAxisMask, ssParams.ellipsisAxisMask); - selectedType = std::string("ref_") + inPrc.name(); + selectedType = selectedType + "_" + InferenceEngine::details::convertPrecision(inType).name(); + targetDevice = CommonTestUtils::DEVICE_CPU; + init_input_shapes({shapes}); + auto params = ngraph::builder::makeDynamicParams(elementType, inputDynamicShapes); + auto ss = ngraph::builder::makeStridedSlice(params[0], ssParams.begin, ssParams.end, ssParams.strides, elementType, ssParams.beginMask, + ssParams.endMask, ssParams.newAxisMask, ssParams.shrinkAxisMask, ssParams.ellipsisAxisMask); ss->get_rt_info() = getCPUInfo(); - ngraph::ResultVector results{std::make_shared(ss)}; function = std::make_shared(results, params, "StridedSlice"); } @@ -77,8 +87,9 @@ class StridedSliceLayerCPUTest : public testing::WithParamInterface additional_config; +const std::vector inputPrecisions = { + ElementType::f32, + ElementType::bf16, + ElementType::i8 +}; + +const std::vector inputShapesDynamic2D = { + {{-1, -1}, + {{32, 20}, {16, 16}, {24, 16}}}, + + {{-1, 16}, + {{16, 16}, {20, 16}, {32, 16}}}, + + {{{16, 32}, {16, 32}}, + {{16, 32}, {32, 16}, {24, 24}}}, +}; -const std::vector inputPrecisions = { - InferenceEngine::Precision::FP32, - InferenceEngine::Precision::BF16, - InferenceEngine::Precision::I8 +const std::vector paramsPlain2D = { + StridedSliceParams{ { 0, 10 }, { 16, 16 }, { 1, 1 }, { 0, 0 }, { 0, 0 }, { }, { }, { } }, + StridedSliceParams{ { 2, 5 }, { 16, 8 }, { 1, 1 }, { 0, 0 }, { 0, 0 }, { }, { }, { } }, + StridedSliceParams{ { 2, 5 }, { 16, 16 }, { 1, 2 }, { 0, 1 }, { 1, 0 }, { }, { }, { } }, + StridedSliceParams{ { 0, 0 }, { 16, 16 }, { 2, 1 }, { 0, 0 }, { 1, 0 }, { }, { }, { } }, }; -const std::vector testCasesPlain2D = { - StridedSliceSpecificParams{ { 32, 32 }, { 0, 20 }, { 32, 30 }, { 1, 1 }, - { 0, 0 }, { 0, 0 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 32, 20 }, { 2, 10 }, { 32, 20 }, { 1, 1 }, - { 0, 0 }, { 0, 0 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 32, 20 }, { 2, 10 }, { 32, 20 }, { 1, 2 }, - { 0, 1 }, { 1, 0 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 32, 20 }, { 2, 10 }, { 32, 20 }, { 2, 1 }, - { 0, 0 }, { 1, 0 }, { }, { }, { } }, +INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_Plain_Static_2D, StridedSliceLayerCPUTest, + ::testing::Combine( + ::testing::ValuesIn(static_shapes_to_test_representation({{32, 20}})), + ::testing::ValuesIn(paramsPlain2D), + ::testing::ValuesIn(inputPrecisions), + ::testing::Values(emptyCPUSpec)), + StridedSliceLayerCPUTest::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_Plain_Dynamic_2D, StridedSliceLayerCPUTest, + ::testing::Combine( + ::testing::ValuesIn(inputShapesDynamic2D), + ::testing::ValuesIn(paramsPlain2D), + ::testing::ValuesIn(inputPrecisions), + ::testing::Values(emptyCPUSpec)), + StridedSliceLayerCPUTest::getTestCaseName); + +const std::vector testCasesCommon4D = { + StridedSliceParams{ { 0, 2, 5, 4 }, { 1, 4, 28, 27 }, { 1, 1, 1, 1 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { }, { }, { } }, + StridedSliceParams{ { 0, 1, 0, 0 }, { 1, 3, 32, 20 }, { 1, 1, 1, 1 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { }, { }, { } }, + StridedSliceParams{ { 0, 0, 10, 0 }, { 1, 3, 20, 20 }, { 1, 1, 1, 1 }, { 0, 0, 0, 0 }, { 0, 1, 0, 0 }, { }, { }, { } }, + StridedSliceParams{ { 0, 0, 20, 20 }, { 1, 5, 25, 26 }, { 1, 1, 1, 2 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { }, { }, { } }, + StridedSliceParams{ { 0, 0, 0, 20 }, { 1, 2, 30, 30 }, { 1, 1, 2, 1 }, { 0, 0, 0, 1 }, { 0, 1, 0, 1 }, { }, { }, { } }, + StridedSliceParams{ { 0, 0, 2, 10 }, { 1, 3, 32, 20 }, { 1, 1, 1, 1 }, { 0, 0, 1, 1 }, { 0, 0, 0, 0 }, { }, { }, { } }, + StridedSliceParams{ { 0, 1, 0, 10 }, { 1, 5, 32, 30 }, { 1, 1, 1, 1 }, { 0, 1, 0, 0 }, { 0, 0, 0, 0 }, { }, { }, { } }, + StridedSliceParams{ { 0, 1, 2, 10 }, { 1, 5, 32, 18 }, { 1, 1, 1, 2 }, { 0, 0, 1, 0 }, { 0, 0, 0, 1 }, { }, { }, { } }, + StridedSliceParams{ { 0, 0, 2, 10 }, { 1, 8, 32, 18 }, { 1, 2, 1, 2 }, { 0, 0, 1, 0 }, { 0, 0, 0, 1 }, { }, { }, { } }, + StridedSliceParams{ { 0, 0, 10 }, { 0, 32, 18 }, { 1, 1, 1 }, { 1, 1, 0 }, { 1, 1, 0 }, { }, { }, { 1, 0, 0 } }, + StridedSliceParams{ { 0, 0, 10 }, { 1, 0, 20 }, { 1, 1, 1 }, { 1, 1, 0 }, { 0, 1, 1 }, { }, { }, { 0, 1, 0 } }, + StridedSliceParams{ { 0, 4, 10 }, { 1, 8, 0 }, { 1, 1, 1 }, { 1, 0, 1 }, { 1, 1, 1 }, { }, { }, { 0, 0, 1 } } }; -const auto StridedSliceParamsPlain2D = ::testing::Combine( - ::testing::ValuesIn(testCasesPlain2D), - ::testing::ValuesIn(inputPrecisions), - ::testing::Values(CommonTestUtils::DEVICE_CPU), - ::testing::Values(additional_config), - ::testing::Values(emptyCPUSpec)); - -INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_Plain_2D, StridedSliceLayerCPUTest, StridedSliceParamsPlain2D, StridedSliceLayerCPUTest::getTestCaseName); - -const std::vector testCasesCommon4D = { - StridedSliceSpecificParams{ { 1, 5, 32, 32 }, { 0, 2, 5, 4 }, { 1, 4, 28, 27 }, { 1, 1, 1, 1 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 1, 5, 32, 20 }, { 0, 1, 0, 0 }, { 1, 3, 32, 20 }, { 1, 1, 1, 1 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 2, 5, 32, 20 }, { 0, 0, 10, 0 }, { 1, 3, 20, 20 }, { 1, 1, 1, 1 }, - { 0, 0, 0, 0 }, { 0, 1, 0, 0 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 1, 5, 32, 32 }, { 0, 0, 20, 20 }, { 1, 5, 25, 26 }, { 1, 1, 1, 2 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 2, 5, 32, 32 }, { 0, 0, 0, 20 }, { 1, 2, 30, 30 }, { 1, 1, 2, 1 }, - { 0, 0, 0, 1 }, { 0, 1, 0, 1 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 1, 5, 32, 20 }, { 0, 0, 2, 10 }, { 1, 3, 32, 20 }, { 1, 1, 1, 1 }, - { 0, 0, 1, 1 }, { 0, 0, 0, 0 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 2, 5, 32, 32 }, { 0, 1, 0, 10 }, { 1, 5, 32, 30 }, { 1, 1, 1, 1 }, - { 0, 1, 0, 0 }, { 0, 0, 0, 0 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 1, 5, 32, 20 }, { 0, 1, 2, 10 }, { 1, 5, 32, 18 }, { 1, 1, 1, 2 }, - { 0, 0, 1, 0 }, { 0, 0, 0, 1 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 2, 8, 32, 20 }, { 0, 0, 2, 10 }, { 1, 8, 32, 18 }, { 1, 2, 1, 2 }, - { 0, 0, 1, 0 }, { 0, 0, 0, 1 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 2, 8, 32, 20 }, { 0, 0, 10 }, { 0, 32, 18 }, { 1, 1, 1 }, - { 1, 1, 0 }, { 1, 1, 0 }, { }, { }, { 1, 0, 0 } }, - StridedSliceSpecificParams{ { 2, 8, 32, 20 }, { 0, 0, 10 }, { 1, 0, 20 }, { 1, 1, 1 }, - { 1, 1, 0 }, { 0, 1, 1 }, { }, { }, { 0, 1, 0 } }, - StridedSliceSpecificParams{ { 2, 8, 32, 20 }, { 0, 4, 10 }, { 2, 8, 0 }, { 1, 1, 1 }, - { 1, 0, 1 }, { 1, 1, 1 }, { }, { }, { 0, 0, 1 } } +const std::vector inputShapesStatic4D = { + { 1, 5, 32, 32 }, { 2, 5, 32, 48 } +}; + +const std::vector inputShapesDynamic4D = { + {{-1, -1, -1, -1}, + {{ 1, 5, 32, 32 }, { 2, 5, 32, 32 }, { 1, 5, 64, 64 }}}, + + {{-1, 5, -1, -1}, + {{ 1, 5, 32, 32 }, { 2, 5, 32, 32 }, { 3, 5, 32, 36 }}}, + + {{{1, 5}, 5, {32, 64}, {32, 64}}, + {{ 2, 5, 32, 32 }, { 1, 5, 48, 32 }, { 5, 5, 32, 32 }}}, }; const std::vector CPUParamsCommon4D = { @@ -155,44 +181,68 @@ const std::vector CPUParamsCommon4D = { cpuParams_nhwc, }; -const auto StridedSliceParamsCommon4D = ::testing::Combine( - ::testing::ValuesIn(testCasesCommon4D), - ::testing::ValuesIn(inputPrecisions), - ::testing::Values(CommonTestUtils::DEVICE_CPU), - ::testing::Values(additional_config), - ::testing::ValuesIn(CPUParamsCommon4D)); - -INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_Common_4D, StridedSliceLayerCPUTest, StridedSliceParamsCommon4D, StridedSliceLayerCPUTest::getTestCaseName); - -const std::vector testCasesBlocked4D = { - StridedSliceSpecificParams{ { 1, 16, 32, 32 }, { 0, 0, 5, 4 }, { 1, 16, 28, 27 }, { 1, 1, 1, 1 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 2, 32, 10, 10 }, { 0, 16, 0, 0 }, { 1, 32, 10, 10 }, { 1, 1, 1, 1 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 1, 16, 32, 20 }, { 0, 0, 10, 0 }, { 1, 16, 20, 10 }, { 1, 1, 1, 1 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 1 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 2, 32, 32, 32 }, { 0, 0, 20, 20 }, { 1, 32, 25, 25 }, { 1, 1, 1, 1 }, - { 0, 1, 0, 0 }, { 0, 1, 0, 0 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 1, 48, 32, 32 }, { 0, 16, 0, 20 }, { 1, 32, 32, 30 }, { 1, 1, 1, 2 }, - { 1, 0, 1, 0 }, { 1, 0, 1, 0 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 2, 32, 32, 20 }, { 0, 16, 2, 10 }, { 1, 32, 32, 20 }, { 1, 1, 2, 1 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 2, 64, 32, 20 }, { 0, 16, 0, 0 }, { 2, 64, 32, 20 }, { 1, 1, 1, 1 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 2, 64, 32, 20 }, { 0, 32, 0, 0 }, { 2, 50, 32, 20 }, { 1, 1, 1, 1 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 2, 64, 32, 20 }, { 0, 0, 0, 0 }, { 2, 12, 32, 20 }, { 1, 1, 1, 1 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 1, 64, 32, 20 }, { 0, -16, 0, 10 }, { 2, 100, 32, 20 }, { 1, 1, 1, 1 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 2, 32, 32, 20 }, { 0, -16, 0, 0 }, { 2, -4, 32, 20 }, { 1, 1, 1, 1 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 2, 32, 32, 20 }, { 0, -32, 0, 0 }, { 2, -12, 32, 20 }, { 1, 1, 1, 1 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 2, 32, 32, 20 }, { 0, 10 }, { 0, 20 }, { 1, 1 }, - { 1, 0 }, { 1, 0 }, { }, { }, { 1, 0 } }, - StridedSliceSpecificParams{ { 2, 32, 32, 20 }, { 0, 16, 0 }, { 2, 32, 0 }, { 1, 1, 1 }, - { 1, 0, 1 }, { 1, 1, 1 }, { }, { }, { 0, 0, 1 } }, +INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_Common_Static_4D, StridedSliceLayerCPUTest, + ::testing::Combine( + ::testing::ValuesIn(static_shapes_to_test_representation(inputShapesStatic4D)), + ::testing::ValuesIn(testCasesCommon4D), + ::testing::ValuesIn(inputPrecisions), + ::testing::ValuesIn(CPUParamsCommon4D)), + StridedSliceLayerCPUTest::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_Common_Dynamic_4D, StridedSliceLayerCPUTest, + ::testing::Combine( + ::testing::ValuesIn(inputShapesDynamic4D), + ::testing::ValuesIn(testCasesCommon4D), + ::testing::ValuesIn(inputPrecisions), + ::testing::ValuesIn(CPUParamsCommon4D)), + StridedSliceLayerCPUTest::getTestCaseName); + +const std::vector testCasesBlocked4DSubset1 = { + StridedSliceParams{ { 0, 0, 0, 0 }, { 1, 32, 32, 32 }, { 1, 1, 1, 1 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { }, { }, { } }, + StridedSliceParams{ { 0, 0, 16, 0 }, { 1, 32, 32, 32 }, { 1, 1, 1, 1 }, { 0, 0, 0, 0 }, { 0, 0, 0, 1 }, { }, { }, { } }, + StridedSliceParams{ { 0, 0, 0, 0 }, { 1, 32, 32, 16 }, { 1, 1, 1, 1 }, { 0, 0, 0, 0 }, { 0, 0, 0, 1 }, { }, { }, { } }, + StridedSliceParams{ { 0, 0, 0, 0 }, { 1, 16, 32, 32 }, { 1, 1, 1, 1 }, { 0, 0, 0, 0 }, { 0, 0, 0, 1 }, { }, { }, { } }, +}; + +const std::vector testCasesBlocked4DSubset2 = { + StridedSliceParams{ { 0, 0, 5, 4 }, { 1, 16, 28, 27 }, { 1, 1, 1, 1 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { }, { }, { } }, + StridedSliceParams{ { 0, 16, 0, 0 }, { 1, 32, 10, 10 }, { 1, 1, 1, 1 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { }, { }, { } }, + StridedSliceParams{ { 0, 0, 10, 0 }, { 1, 16, 20, 10 }, { 1, 1, 1, 1 }, { 0, 0, 0, 0 }, { 0, 0, 0, 1 }, { }, { }, { } }, + StridedSliceParams{ { 0, 0, 20, 20 }, { 1, 32, 25, 25 }, { 1, 1, 1, 1 }, { 0, 1, 0, 0 }, { 0, 1, 0, 0 }, { }, { }, { } }, + StridedSliceParams{ { 0, 16, 0, 20 }, { 1, 32, 32, 30 }, { 1, 1, 1, 2 }, { 1, 0, 1, 0 }, { 1, 0, 1, 0 }, { }, { }, { } }, + StridedSliceParams{ { 0, 16, 2, 10 }, { 1, 32, 32, 20 }, { 1, 1, 2, 1 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { }, { }, { } }, + StridedSliceParams{ { 0, 16, 0, 0 }, { 2, 64, 32, 20 }, { 1, 1, 1, 1 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { }, { }, { } }, + StridedSliceParams{ { 0, 32, 0, 0 }, { 2, 50, 32, 20 }, { 1, 1, 1, 1 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { }, { }, { } }, + StridedSliceParams{ { 0, 0, 0, 0 }, { 2, 12, 32, 20 }, { 1, 1, 1, 1 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { }, { }, { } }, + StridedSliceParams{ { 0, -16, 0, 10 }, { 2, 100, 32, 20 }, { 1, 1, 1, 1 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { }, { }, { } }, + StridedSliceParams{ { 0, -16, 0, 0 }, { 2, -4, 32, 20 }, { 1, 1, 1, 1 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { }, { }, { } }, + StridedSliceParams{ { 0, -32, 0, 0 }, { 2, -12, 32, 20 }, { 1, 1, 1, 1 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { }, { }, { } }, + StridedSliceParams{ { 0, 10 }, { 0, 20 }, { 1, 1 }, { 1, 0 }, { 1, 0 }, { }, { }, { 1, 0 } }, + StridedSliceParams{ { 0, 16, 0 }, { 2, 32, 0 }, { 1, 1, 1 }, { 1, 0, 1 }, { 1, 1, 1 }, { }, { }, { 0, 0, 1 } }, +}; + +const std::vector inputShapesBlockedStatic4DSubset1 = { + { 1, 32, 32, 32 }, { 1, 32, 32, 64 } +}; + +const std::vector inputShapesBlockedStatic4DSubset2 = { + { 1, 64, 32, 32 }, { 1, 64, 32, 64 } +}; + +const std::vector inputShapesBlockedDynamic4DSubset1 = { + {{-1, 32, -1, -1}, + {{ 1, 32, 32, 32 }, { 2, 32, 32, 32 }, { 3, 32, 32, 48 }}}, + + {{{1, 5}, 32, {32, 64}, {32, 64}}, + {{ 2, 32, 32, 32 }, { 1, 32, 48, 32 }, { 5, 32, 32, 48 }}}, +}; + +const std::vector inputShapesBlockedDynamic4DSubset2 = { + {{-1, 64, -1, -1}, + {{ 1, 64, 64, 32 }, { 2, 64, 32, 32 }, { 3, 64, 32, 48 }}}, + + {{{1, 5}, 64, {32, 64}, {32, 64}}, + {{ 2, 64, 32, 32 }, { 1, 64, 48, 32 }, { 1, 64, 64, 64 }}}, }; const std::vector CPUParamsBlocked4D = { @@ -200,42 +250,62 @@ const std::vector CPUParamsBlocked4D = { cpuParams_nChw8c, }; -const auto StridedSliceParamsBlocked4D = ::testing::Combine( - ::testing::ValuesIn(testCasesBlocked4D), - ::testing::ValuesIn(inputPrecisions), - ::testing::Values(CommonTestUtils::DEVICE_CPU), - ::testing::Values(additional_config), - ::testing::ValuesIn(CPUParamsBlocked4D)); - -INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_Blocked_4D, StridedSliceLayerCPUTest, StridedSliceParamsBlocked4D, StridedSliceLayerCPUTest::getTestCaseName); - -const std::vector testCasesCommon5D = { - StridedSliceSpecificParams{ { 1, 5, 20, 32, 32 }, { 0, 2, 0, 5, 4 }, { 1, 4, 5, 28, 27 }, { 1, 1, 1, 1, 1 }, - { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 2, 5, 20, 32, 20 }, { 0, 0, 10, 0, 0 }, { 1, 5, 20, 32, 20 }, { 1, 1, 1, 1, 1 }, - { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 1, 5, 20, 32, 20 }, { 0, 1, 10, 0, 0 }, { 1, 3, 20, 32, 20 }, { 1, 1, 1, 1, 1 }, - { 0, 1, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 1, 5, 20, 32, 32 }, { 0, 0, 0, 20, 20 }, { 1, 5, 20, 30, 26 }, { 1, 1, 1, 2, 2 }, - { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 2, 5, 20, 32, 32 }, { 0, 0, 10, 0, 20 }, { 1, 2, 20, 30, 30 }, { 1, 1, 2, 1, 1 }, - { 0, 0, 0, 0, 1 }, { 0, 1, 0, 1, 0 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 1, 5, 20, 32, 32 }, { 0, 0, 2, 10, 0 }, { 1, 5, 10, 32, 20 }, { 1, 1, 1, 1, 1 }, - { 0, 0, 1, 1, 0 }, { 0, 0, 0, 0, 1 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 2, 5, 20, 32, 32 }, { 0, 1, 0, 10, 0 }, { 1, 5, 20, 32, 32 }, { 1, 1, 1, 1, 1 }, - { 0, 1, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 1, 5, 20, 32, 32 }, { 0, 0, 0, 0, 0 }, { 1, 5, 10, 16, 16 }, { 1, 1, 2, 1, 1 }, - { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 2, 8, 20, 32, 32 }, { 0, 2, 0, 0, 0 }, { 1, 8, 10, 16, 16 }, { 1, 2, 1, 1, 2 }, - { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 2, 8, 20, 32, 32 }, { 0, 2, 0, 0, 16 }, { 2, 8, 20, 32, 32 }, { 1, 2, 1, 1, 1 }, - { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 2, 8, 10, 10, 10 }, { 0, 5 }, { 0, 10 }, { 1, 1 }, - { 1, 0 }, { 1, 0 }, { }, { }, { 1, 0 } }, - StridedSliceSpecificParams{ { 2, 8, 10, 10, 10 }, { 0, 0, 5 }, { 0, 0, 10 }, { 1, 1, 1 }, - { 1, 1, 0 }, { 1, 1, 0 }, { }, { }, { 0, 1, 0 } }, - StridedSliceSpecificParams{ { 2, 8, 10, 10, 10 }, { 0, 2, 0 }, { 2, 8, 0 }, { 1, 1, 1 }, - { 1, 0, 1 }, { 1, 1, 1 }, { }, { }, { 0, 0, 1 } } +INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_Common_Static_4D_Subset1, StridedSliceLayerCPUTest, + ::testing::Combine( + ::testing::ValuesIn(static_shapes_to_test_representation(inputShapesBlockedStatic4DSubset1)), + ::testing::ValuesIn(testCasesBlocked4DSubset1), + ::testing::ValuesIn(inputPrecisions), + ::testing::ValuesIn(CPUParamsBlocked4D)), + StridedSliceLayerCPUTest::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_Common_Dynamic_4D_Subset1, StridedSliceLayerCPUTest, + ::testing::Combine( + ::testing::ValuesIn(inputShapesBlockedDynamic4DSubset1), + ::testing::ValuesIn(testCasesBlocked4DSubset1), + ::testing::ValuesIn(inputPrecisions), + ::testing::ValuesIn(CPUParamsBlocked4D)), + StridedSliceLayerCPUTest::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_Common_Static_4D_Subset2, StridedSliceLayerCPUTest, + ::testing::Combine( + ::testing::ValuesIn(static_shapes_to_test_representation(inputShapesBlockedStatic4DSubset2)), + ::testing::ValuesIn(testCasesBlocked4DSubset2), + ::testing::ValuesIn(inputPrecisions), + ::testing::ValuesIn(CPUParamsBlocked4D)), + StridedSliceLayerCPUTest::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_Common_Dynamic_4D_Subset2, StridedSliceLayerCPUTest, + ::testing::Combine( + ::testing::ValuesIn(inputShapesBlockedDynamic4DSubset2), + ::testing::ValuesIn(testCasesBlocked4DSubset2), + ::testing::ValuesIn(inputPrecisions), + ::testing::ValuesIn(CPUParamsBlocked4D)), + StridedSliceLayerCPUTest::getTestCaseName); + +const std::vector testCasesCommon5D = { + StridedSliceParams{ { 0, 2, 0, 5, 4 }, { 1, 4, 5, 28, 27 }, { 1, 1, 1, 1, 1 }, { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { }, { }, { } }, + StridedSliceParams{ { 0, 0, 10, 0, 0 }, { 1, 5, 20, 32, 20 }, { 1, 1, 1, 1, 1 }, { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { }, { }, { } }, + StridedSliceParams{ { 0, 1, 10, 0, 0 }, { 1, 3, 20, 32, 20 }, { 1, 1, 1, 1, 1 }, { 0, 1, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { }, { }, { } }, + StridedSliceParams{ { 0, 0, 0, 20, 20 }, { 1, 5, 20, 30, 26 }, { 1, 1, 1, 2, 2 }, { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { }, { }, { } }, + StridedSliceParams{ { 0, 0, 10, 0, 20 }, { 1, 2, 20, 30, 30 }, { 1, 1, 2, 1, 1 }, { 0, 0, 0, 0, 1 }, { 0, 1, 0, 1, 0 }, { }, { }, { } }, + StridedSliceParams{ { 0, 0, 2, 10, 0 }, { 1, 5, 10, 32, 20 }, { 1, 1, 1, 1, 1 }, { 0, 0, 1, 1, 0 }, { 0, 0, 0, 0, 1 }, { }, { }, { } }, + StridedSliceParams{ { 0, 1, 0, 10, 0 }, { 1, 5, 20, 32, 32 }, { 1, 1, 1, 1, 1 }, { 0, 1, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { }, { }, { } }, + StridedSliceParams{ { 0, 0, 0, 0, 0 }, { 1, 5, 10, 16, 16 }, { 1, 1, 2, 1, 1 }, { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { }, { }, { } }, +}; + +const std::vector inputShapesStatic5D = { + { 1, 5, 20, 32, 32 }, { 2, 5, 32, 32, 32 } +}; + +const std::vector inputShapesDynamic5D = { + {{-1, -1, -1, -1, -1}, + {{ 1, 5, 32, 32, 32 }, { 1, 5, 32, 32, 48 }, { 1, 5, 64, 64, 64 }, { 1, 10, 32, 32, 32 }}}, + + {{-1, 5, -1, -1, -1}, + {{ 1, 5, 32, 32, 48 }, { 1, 5, 32, 48, 32 }, { 1, 5, 48, 32, 32 }}}, + + {{{1, 5}, 5, {32, 64}, {32, 64}, {32, 64}}, + {{ 2, 5, 32, 32, 32 }, { 1, 5, 48, 32, 32 }, { 5, 5, 32, 32, 48 }}}, }; const std::vector CPUParamsCommon5D = { @@ -243,46 +313,68 @@ const std::vector CPUParamsCommon5D = { cpuParams_ndhwc, }; -const auto StridedSliceParamsCommon5D = ::testing::Combine( - ::testing::ValuesIn(testCasesCommon5D), - ::testing::ValuesIn(inputPrecisions), - ::testing::Values(CommonTestUtils::DEVICE_CPU), - ::testing::Values(additional_config), - ::testing::ValuesIn(CPUParamsCommon5D)); - -INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_Common_5D, StridedSliceLayerCPUTest, StridedSliceParamsCommon5D, StridedSliceLayerCPUTest::getTestCaseName); - -const std::vector testCasesBlocked5D = { - StridedSliceSpecificParams{ { 1, 16, 20, 32, 32 }, { 0, 0, 0, 5, 4 }, { 1, 16, 5, 28, 27 }, { 1, 1, 1, 1, 1 }, - { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 2, 32, 20, 32, 20 }, { 0, 0, 10, 0, 0 }, { 1, 16, 20, 32, 20 }, { 1, 1, 1, 1, 1 }, - { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 1, 16, 20, 32, 20 }, { 0, 0, 10, 0, 0 }, { 1, 16, 20, 32, 20 }, { 1, 1, 1, 1, 1 }, - { 0, 0, 0, 0, 0 }, { 0, 1, 0, 0, 0 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 2, 16, 20, 32, 32 }, { 0, 0, 0, 20, 20 }, { 1, 16, 20, 30, 26 }, { 1, 1, 1, 2, 2 }, - { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 1, 16, 20, 32, 32 }, { 0, 0, 10, 0, 20 }, { 1, 16, 20, 30, 30 }, { 1, 1, 2, 1, 1 }, - { 0, 0, 0, 0, 1 }, { 0, 1, 0, 1, 0 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 2, 16, 20, 32, 32 }, { 0, 0, 2, 10, 0 }, { 1, 16, 10, 32, 20 }, { 1, 1, 1, 1, 1 }, - { 0, 0, 1, 1, 0 }, { 0, 0, 0, 0, 1 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 1, 16, 20, 32, 32 }, { 0, 0, 0, 10, 0 }, { 1, 8, 20, 32, 32 }, { 1, 1, 1, 1, 1 }, - { 0, 1, 0, 0, 0 }, { 0, 1, 0, 0, 0 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 2, 16, 20, 32, 32 }, { 0, 0, 0, 0, 0 }, { 1, 16, 10, 16, 16 }, { 1, 1, 2, 1, 1 }, - { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 2, 64, 20, 10, 10 }, { 0, 0, 0, 0, 0 }, { 1, 25, 20, 10, 10 }, { 1, 1, 1, 1, 1 }, - { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 2, 64, 20, 10, 10 }, { 0, 16, 0, 0, 0 }, { 1, 25, 20, 10, 10 }, { 1, 1, 1, 1, 1 }, - { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 2, 64, 20, 10, 10 }, { 0, 16, 0, 0, 0 }, { 1, 64, 20, 10, 10 }, { 1, 1, 1, 1, 1 }, - { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 2, 64, 20, 10, 10 }, { 0, 0, 0, 0, 0 }, { 2, 25, 20, 10, 10 }, { 1, 1, 1, 1, 1 }, - { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 2, 64, 20, 10, 10 }, { 0, 0, 0, 0, 0 }, { 2, 60, 20, 10, 10 }, { 1, 1, 1, 1, 1 }, - { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 2, 64, 20, 10, 10 }, { 0, 32, 0, 0, 0 }, { 2, 40, 20, 10, 10 }, { 1, 1, 1, 1, 1 }, - { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 2, 64, 20, 10, 10 }, { 0, 16, 0, 0, 0 }, { 2, 64, 20, 10, 10 }, { 1, 1, 1, 1, 1 }, - { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { }, { }, { } } +INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_Common_Static_5D, StridedSliceLayerCPUTest, + ::testing::Combine( + ::testing::ValuesIn(static_shapes_to_test_representation(inputShapesStatic5D)), + ::testing::ValuesIn(testCasesCommon5D), + ::testing::ValuesIn(inputPrecisions), + ::testing::ValuesIn(CPUParamsCommon5D)), + StridedSliceLayerCPUTest::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_Common_Dynamic_5D, StridedSliceLayerCPUTest, + ::testing::Combine( + ::testing::ValuesIn(inputShapesDynamic5D), + ::testing::ValuesIn(testCasesCommon5D), + ::testing::ValuesIn(inputPrecisions), + ::testing::ValuesIn(CPUParamsCommon5D)), + StridedSliceLayerCPUTest::getTestCaseName); + +const std::vector testCasesBlocked5DSubset1 = { + StridedSliceParams{ { 0, 0, 0, 5, 4 }, { 1, 16, 5, 28, 27 }, { 1, 1, 1, 1, 1 }, { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { }, { }, { } }, + StridedSliceParams{ { 0, 0, 10, 0, 0 }, { 1, 16, 20, 32, 20 }, { 1, 1, 1, 1, 1 }, { 0, 0, 0, 0, 0 }, { 0, 1, 0, 0, 0 }, { }, { }, { } }, + StridedSliceParams{ { 0, 0, 0, 20, 20 }, { 1, 16, 20, 30, 26 }, { 1, 1, 1, 2, 2 }, { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { }, { }, { } }, + StridedSliceParams{ { 0, 0, 10, 0, 20 }, { 1, 16, 20, 30, 30 }, { 1, 1, 2, 1, 1 }, { 0, 0, 0, 0, 1 }, { 0, 1, 0, 1, 0 }, { }, { }, { } }, + StridedSliceParams{ { 0, 0, 2, 10, 0 }, { 1, 16, 10, 32, 20 }, { 1, 1, 1, 1, 1 }, { 0, 0, 1, 1, 0 }, { 0, 0, 0, 0, 1 }, { }, { }, { } }, + StridedSliceParams{ { 0, 0, 0, 10, 0 }, { 1, 8, 20, 32, 32 }, { 1, 1, 1, 1, 1 }, { 0, 1, 0, 0, 0 }, { 0, 1, 0, 0, 0 }, { }, { }, { } }, + StridedSliceParams{ { 0, 0, 0, 0, 0 }, { 1, 16, 10, 16, 16 }, { 1, 1, 2, 1, 1 }, { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { }, { }, { } }, +}; + +const std::vector testCasesBlocked5DSubset2 = { + StridedSliceParams{ { 0, 0, 0, 5, 4 }, { 1, 16, 5, 28, 27 }, { 1, 1, 1, 1, 1 }, { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { }, { }, { } }, + StridedSliceParams{ { 0, 0, 10, 0, 0 }, { 1, 16, 20, 32, 20 }, { 1, 1, 1, 1, 1 }, { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { }, { }, { } }, + StridedSliceParams{ { 0, 0, 10, 0, 0 }, { 1, 16, 20, 32, 20 }, { 1, 1, 1, 1, 1 }, { 0, 0, 0, 0, 0 }, { 0, 1, 0, 0, 0 }, { }, { }, { } }, + StridedSliceParams{ { 0, 0, 0, 20, 20 }, { 1, 16, 20, 30, 26 }, { 1, 1, 1, 2, 2 }, { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { }, { }, { } }, + StridedSliceParams{ { 0, 0, 10, 0, 20 }, { 1, 16, 20, 30, 30 }, { 1, 1, 2, 1, 1 }, { 0, 0, 0, 0, 1 }, { 0, 1, 0, 1, 0 }, { }, { }, { } }, + StridedSliceParams{ { 0, 0, 2, 10, 0 }, { 1, 16, 10, 32, 20 }, { 1, 1, 1, 1, 1 }, { 0, 0, 1, 1, 0 }, { 0, 0, 0, 0, 1 }, { }, { }, { } }, + StridedSliceParams{ { 0, 0, 0, 10, 0 }, { 1, 8, 20, 32, 32 }, { 1, 1, 1, 1, 1 }, { 0, 1, 0, 0, 0 }, { 0, 1, 0, 0, 0 }, { }, { }, { } }, + StridedSliceParams{ { 0, 0, 0, 0, 0 }, { 1, 16, 10, 16, 16 }, { 1, 1, 2, 1, 1 }, { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { }, { }, { } }, + StridedSliceParams{ { 0, 0, 0, 0, 0 }, { 1, 25, 20, 10, 10 }, { 1, 1, 1, 1, 1 }, { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { }, { }, { } }, + StridedSliceParams{ { 0, 16, 0, 0, 0 }, { 1, 25, 20, 10, 10 }, { 1, 1, 1, 1, 1 }, { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { }, { }, { } }, + StridedSliceParams{ { 0, 16, 0, 0, 0 }, { 1, 64, 20, 10, 10 }, { 1, 1, 1, 1, 1 }, { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { }, { }, { } }, +}; + +const std::vector inputShapesBlockedStatic5DSubset1 = { + { 1, 16, 32, 32, 32 }, { 2, 16, 32, 32, 32 }, { 2, 32, 32, 32, 32 } +}; + +const std::vector inputShapesBlockedStatic5DSubset2 = { + { 1, 64, 32, 32, 32 }, { 2, 64, 32, 64, 32 }, { 2, 64, 32, 32, 32 } +}; + +const std::vector inputShapesBlockedDynamic5DSubset1 = { + {{-1, 16, -1, -1, -1}, + {{ 1, 16, 32, 32, 32 }, { 2, 16, 32, 32, 32 }, { 2, 16, 32, 32, 32 }}}, + + {{{1, 5}, 16, {16, 32}, {16, 32}, {16, 32}}, + {{ 1, 16, 32, 32, 32 }, { 2, 16, 32, 32, 32 }, { 1, 16, 20, 32, 32 }}}, +}; + +const std::vector inputShapesBlockedDynamic5DSubset2 = { + {{-1, 64, -1, -1, -1}, + {{ 1, 64, 64, 32, 32 }, { 2, 64, 32, 32, 32 }, { 3, 64, 32, 48, 32 }}}, + + {{{1, 5}, 64, {16, 32}, {16, 32}, {16, 32}}, + {{ 1, 64, 32, 32, 32 }, { 2, 64, 32, 32, 32 }, { 1, 64, 20, 32, 32 }}}, }; const std::vector CPUParamsBlocked5D = { @@ -290,50 +382,69 @@ const std::vector CPUParamsBlocked5D = { cpuParams_nCdhw8c, }; -const auto StridedSliceParamsBlocked5D = ::testing::Combine( - ::testing::ValuesIn(testCasesBlocked5D), - ::testing::ValuesIn(inputPrecisions), - ::testing::Values(CommonTestUtils::DEVICE_CPU), - ::testing::Values(additional_config), - ::testing::ValuesIn(CPUParamsBlocked5D)); - -INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_Blocked_5D, StridedSliceLayerCPUTest, StridedSliceParamsBlocked5D, StridedSliceLayerCPUTest::getTestCaseName); +INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_Common_Static_5D_Subset1, StridedSliceLayerCPUTest, + ::testing::Combine( + ::testing::ValuesIn(static_shapes_to_test_representation(inputShapesBlockedStatic5DSubset1)), + ::testing::ValuesIn(testCasesBlocked5DSubset1), + ::testing::ValuesIn(inputPrecisions), + ::testing::ValuesIn(CPUParamsBlocked5D)), + StridedSliceLayerCPUTest::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_Common_Dynamic_5D_Subset1, StridedSliceLayerCPUTest, + ::testing::Combine( + ::testing::ValuesIn(inputShapesBlockedDynamic5DSubset1), + ::testing::ValuesIn(testCasesBlocked5DSubset1), + ::testing::ValuesIn(inputPrecisions), + ::testing::ValuesIn(CPUParamsBlocked5D)), + StridedSliceLayerCPUTest::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_Common_Static_5D_Subset2, StridedSliceLayerCPUTest, + ::testing::Combine( + ::testing::ValuesIn(static_shapes_to_test_representation(inputShapesBlockedStatic4DSubset2)), + ::testing::ValuesIn(testCasesBlocked4DSubset2), + ::testing::ValuesIn(inputPrecisions), + ::testing::ValuesIn(CPUParamsBlocked4D)), + StridedSliceLayerCPUTest::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_Common_Dynamic_5D_Subset2, StridedSliceLayerCPUTest, + ::testing::Combine( + ::testing::ValuesIn(inputShapesBlockedDynamic5DSubset2), + ::testing::ValuesIn(testCasesBlocked5DSubset2), + ::testing::ValuesIn(inputPrecisions), + ::testing::ValuesIn(CPUParamsBlocked5D)), + StridedSliceLayerCPUTest::getTestCaseName); /* Descriptors check */ class StridedSliceLayerDescriptorCPUTest : public StridedSliceLayerCPUTest {}; -const std::vector testCasesPlanar4D = { - StridedSliceSpecificParams{ {1, 32, 112, 112 }, { 0, -28, 0, 0 }, { 0, 2147483647, 0, 0 }, { 1, 1, 1, 1 }, { 1, 0, 1, 1 }, - { 1, 0, 1, 1 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } }, - StridedSliceSpecificParams{ { 1, 17, 32, 20 }, { 0, 0, 10, 0 }, { 1, 17, 20, 10 }, { 1, 1, 1, 1 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 1 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 1, 16, 32, 32 }, { 0, 5, 0, 0 }, { 1, 20, 28, 27 }, { 1, 1, 1, 1 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { }, { }, { } }, - StridedSliceSpecificParams{ { 1, 16, 100, 1, 1 }, { 0, -1, 0, 0 }, { 0, 0, 0, 0 }, { 1, 1, 1, 1 }, - { 1, 0, 1, 0 }, { 1, 0, 1, 0 }, { }, { 0, 1, 0, 1 }, {} }, - StridedSliceSpecificParams{ { 2, 3, 4, 5 }, { 0, 0, 0, 0, 0 }, { 0, 2, 3, 4, 5 }, { 1, 1, 1, 1, 1 }, - { 1, 1, 1, 1, 1 }, { 1, 1, 1, 1, 1 }, { 0, 0, 1, 0, 0 }, {}, {} }, -}; - -const auto StridedSliceParamsDescriptorsCheck4D = ::testing::Combine( - ::testing::ValuesIn(testCasesPlanar4D), - ::testing::Values(InferenceEngine::Precision::FP32), - ::testing::Values(CommonTestUtils::DEVICE_CPU), - ::testing::Values(additional_config), - ::testing::Values(cpuParams_nChw8c)); - TEST_P(StridedSliceLayerDescriptorCPUTest, DescriptorsCheck) { SKIP_IF_CURRENT_TEST_IS_DISABLED() - ASSERT_THROW(LoadNetwork(), InferenceEngine::Exception); + ASSERT_THROW(compile_model(), ov::Exception); } -INSTANTIATE_TEST_SUITE_P(smoke_StridedSliceLayerDescriptorCPUTest, - StridedSliceLayerDescriptorCPUTest, - StridedSliceParamsDescriptorsCheck4D, +const std::vector testCasesDescriptors = { + StridedSliceParams{ { 0, -4, 0, 0 }, { 0, 2147483647, 0, 0 }, { 1, 1, 1, 1 }, { 1, 0, 1, 1 }, { 1, 0, 1, 1 }, { }, { }, { } }, + StridedSliceParams{ { 0, 5, 0, 0 }, { 1, 20, 28, 27 }, { 1, 1, 1, 1 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { }, { }, { } }, + StridedSliceParams{ { 0, 0, 0, 0 }, { 1, 2147483647, 32, 32 }, { 1, 2, 1, 1 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { }, { }, { } }, + StridedSliceParams{ { 0, 0, 0, 0 }, { 1, 2147483647, 32, 32 }, { 1, 2, 1, 1 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { }, {0, 1, 0, 0 }, { } }, + StridedSliceParams{ { 0, 0, 0, 0 }, { 1, 2147483647, 32, 32 }, { 1, 2, 1, 1 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, {0, 0, 1, 0 }, { }, { } }, +}; + +const std::vector inputShapesDescriptors = { + {{}, {{ 1, 16, 32, 32 }}}, + {{}, {{ 1, 17, 32, 32 }}}, + {{1, -1, 32, 32}, {{ 1, 16, 32, 32 }, { 1, 32, 32, 32 }}} +}; + +INSTANTIATE_TEST_SUITE_P(smoke_StridedSliceLayerDescriptorCPUTest, StridedSliceLayerDescriptorCPUTest, + ::testing::Combine( + ::testing::ValuesIn(inputShapesDescriptors), + ::testing::ValuesIn(testCasesDescriptors), + ::testing::Values(ElementType::f32), + ::testing::Values(cpuParams_nChw8c)), StridedSliceLayerDescriptorCPUTest::getTestCaseName); } // namespace } // namespace CPULayerTestsDefinitions -