From 67fd526f8f7c79803d514a6045454049104eced9 Mon Sep 17 00:00:00 2001 From: Matthew Sloyan Date: Wed, 7 Dec 2022 19:28:18 +0000 Subject: Update TOSA Reference Backend IsLayerSupported * Replace current IsLayerSupported checks with ModelRunner for better validation. * Added options to be able to disable the output from the TOSA Reference Model during layer support. * Updated layer support tests to reflect actual support. Signed-off-by: Matthew Sloyan Change-Id: Iaea17343d0ad51b495477024c44a34d9335d1438 --- cmake/GlobalConfig.cmake | 5 + .../tosaCommon/test/OneToOneMappingTests.cpp | 4 +- src/backends/tosaReference/TosaRefLayerSupport.cpp | 380 +++------------------ .../test/TosaRefLayerSupportTests.cpp | 79 +---- 4 files changed, 60 insertions(+), 408 deletions(-) diff --git a/cmake/GlobalConfig.cmake b/cmake/GlobalConfig.cmake index 5bedee92ea..dd20e15076 100644 --- a/cmake/GlobalConfig.cmake +++ b/cmake/GlobalConfig.cmake @@ -26,6 +26,7 @@ option(TF_LITE_GENERATED_PATH "Tensorflow lite generated C++ schema location" OF option(FLATBUFFERS_ROOT "Location where the flatbuffers 'include' and 'lib' folders to be found" Off) option(TOSA_SERIALIZATION_LIB_ROOT "Location where the TOSA Serialization Library 'include' and 'lib' folders can be found" OFF) option(TOSA_REFERENCE_MODEL_ROOT "Location where the TOSA Reference Model 'include' and 'lib' folders can be found" OFF) +option(TOSA_REFERENCE_MODEL_OUTPUT "TOSA Reference Model output is printed during layer support checks" ON) option(DYNAMIC_BACKEND_PATHS "Colon seperated list of paths where to load the dynamic backends from" "") option(SAMPLE_DYNAMIC_BACKEND "Include the sample dynamic backend and its tests in the build" OFF) option(BUILD_GATORD_MOCK "Build the Gatord simulator for external profiling testing." ON) @@ -362,6 +363,10 @@ if(ARMNNTOSAREF) NAMES tosa_reference_model_lib.a tosa_reference_model_lib HINTS ${TOSA_REFERENCE_MODEL_ROOT}/lib /usr/local/lib /usr/lib) message(STATUS "TOSA Reference Model set to ${TOSA_REFERENCE_MODEL_LIB}") + + if(TOSA_REFERENCE_MODEL_OUTPUT) + add_definitions("-DTOSA_REFERENCE_MODEL_OUTPUT=1") + endif() endif() # This is the root for the dynamic backend tests to search for dynamic diff --git a/src/backends/tosaCommon/test/OneToOneMappingTests.cpp b/src/backends/tosaCommon/test/OneToOneMappingTests.cpp index 07ffae41d1..0d19a328d6 100644 --- a/src/backends/tosaCommon/test/OneToOneMappingTests.cpp +++ b/src/backends/tosaCommon/test/OneToOneMappingTests.cpp @@ -384,8 +384,8 @@ TEST_CASE("GetTosaMapping_SliceLayer") std::vector> outputShape = {{ 2, 1, 3 }}; SliceDescriptor descriptor; - descriptor.m_Begin = { 3 }; - descriptor.m_Size = { 3 }; + descriptor.m_Begin = { 1, 0, 0 }; + descriptor.m_Size = { 2, 1, 3 }; TosaSerializationBasicBlock* basicBlock = GetTosaMapping(nullptr, LayerType::Slice, {&inputInfo}, {&outputInfo}, descriptor); diff --git a/src/backends/tosaReference/TosaRefLayerSupport.cpp b/src/backends/tosaReference/TosaRefLayerSupport.cpp index daa27f63dc..928a19c232 100644 --- a/src/backends/tosaReference/TosaRefLayerSupport.cpp +++ b/src/backends/tosaReference/TosaRefLayerSupport.cpp @@ -4,329 +4,20 @@ // #include "TosaRefLayerSupport.hpp" + #include #include #include -#include -#include + +#include +#include #include -#include -#include namespace armnn { -static bool RunTosaLayerChecksSingleDataType(TosaSerializationOperator* op, - const std::vector& inputs, - const std::vector& outputs, - const std::vector& supportedAttributes, - const std::vector& supportedTypes, - Optional reasonIfUnsupported) -{ - bool supported = true; - - std::string opString = TosaOpToString(op->GetOp()); - - // Check Attribute from operator (GetAttribute) - supported &= CheckSupportRule(TosaOperatorAttributeOfAny(op, supportedAttributes), reasonIfUnsupported, - std::string("TOSA Reference Operator: " + opString + - " has an unsupported attribute.").c_str()); - - for (auto input : inputs) - { - std::string dataTypeCode = TosaDTypeToString(input->GetDtype()); - - // Check Dtype from tensor (GetDtype) - supported &= CheckSupportRule(TosaTypeAnyOf(input, supportedTypes), - reasonIfUnsupported, - std::string("TOSA Reference Operator: " + opString + " for input: " + - input->GetName() + " has an unsupported data type: " + - dataTypeCode).c_str()); - - // Check Shape from tensor (GetShape) - supported &= CheckSupportRule(TosaTensorNumDimensionsWithinBounds(input), - reasonIfUnsupported, - std::string("Tosa Reference Operator: " + opString + " for input: " + - input->GetName() + " exceeds MaxNumOfTensorDimensions.").c_str()); - } - - for (auto output : outputs) - { - std::string dataTypeCode = TosaDTypeToString(output->GetDtype()); - - // Check Dtype from tensor (GetDtype) - supported &= CheckSupportRule(TosaTypeAnyOf(output, supportedTypes), - reasonIfUnsupported, - std::string("TOSA Reference Operator: " + opString + " for output: " + - output->GetName() + " has an unsupported data type: " + - dataTypeCode).c_str()); - - // Check Shape from tensor (GetShape) - supported &= CheckSupportRule(TosaTensorNumDimensionsWithinBounds(output), - reasonIfUnsupported, - std::string("Tosa Reference Operator: " + opString + " for output: " + - output->GetName() + " exceeds MaxNumOfTensorDimensions.").c_str()); - } - - return supported; -} - -static bool RunTosaLayerChecksInputOutputDataType(TosaSerializationOperator* op, - const std::vector& inputs, - const std::vector& outputs, - const std::vector& supportedAttributes, - const std::vector>& supportedMappingTypes, - Optional reasonIfUnsupported) -{ - bool supported = true; - - std::string opString = TosaOpToString(op->GetOp()); - - // Check Attribute from operator (GetAttribute) - supported &= CheckSupportRule(TosaOperatorAttributeOfAny(op, supportedAttributes), reasonIfUnsupported, - std::string("TOSA Reference Operator: " + opString + - " has an unsupported attribute.").c_str()); - - supported &= CheckSupportRule(TosaAssertSize(inputs, outputs), reasonIfUnsupported, - std::string("TOSA Reference Operator: " + opString + - " must have 1-to-1 mapping of inputs-to-outputs.").c_str()); - - for (uint32_t i = 0; i < inputs.size(); i++) - { - auto input = inputs[i]; - auto output = outputs[i]; - std::string inputDataTypeCode = TosaDTypeToString(input->GetDtype()); - std::string outputDataTypeCode = TosaDTypeToString(output->GetDtype()); - std::tuple mappingType(input->GetDtype(), output->GetDtype()); - - // Check Dtype from tensor (GetDtype) - supported &= CheckSupportRule(TosaContainerContainsTwoTypes(mappingType, supportedMappingTypes), - reasonIfUnsupported, - std::string("TOSA Reference Operator: " + opString + " for input: " + - input->GetName() + " and output: " + output->GetName() + - " has an unsupported input data type: " + inputDataTypeCode + - " to output data type: " + outputDataTypeCode).c_str()); - - // Check Shape from tensor (GetShape) - supported &= CheckSupportRule(TosaTensorNumDimensionsWithinBounds(input), - reasonIfUnsupported, - std::string("Tosa Reference Operator: " + opString + " for input: " + - input->GetName() + " exceeds MaxNumOfTensorDimensions.").c_str()); - - // Check Shape from tensor (GetShape) - supported &= CheckSupportRule(TosaTensorNumDimensionsWithinBounds(output), - reasonIfUnsupported, - std::string("Tosa Reference Operator: " + opString + " for output: " + - output->GetName() + " exceeds MaxNumOfTensorDimensions.").c_str()); - } - - return supported; -} - -static bool RunTosaLayerChecksInputWeightsOutputDataType( - TosaSerializationOperator* op, - const std::vector& inputs, - const std::vector& outputs, - const std::vector& supportedAttributes, - const std::vector>& supportedMappingTypes, - Optional reasonIfUnsupported) -{ - bool supported = true; - - std::string opString = TosaOpToString(op->GetOp()); - - // Check Attribute from operator (GetAttribute) - supported &= CheckSupportRule(TosaOperatorAttributeOfAny(op, supportedAttributes), reasonIfUnsupported, - std::string("TOSA Reference Operator: " + opString + - " has an unsupported attribute.").c_str()); - - // Check combination of input, weights and output types. - // Bias is the same as output type, so it is covered. - std::tuple mappingTypes(inputs[0]->GetDtype(), inputs[1]->GetDtype(), outputs[0]->GetDtype()); - - // Check Dtype from tensor (GetDtype) - supported &= CheckSupportRule(TosaContainerContainsThreeTypes(mappingTypes, supportedMappingTypes), - reasonIfUnsupported, - std::string("TOSA Reference Operator: " + opString + " for input 0: " + - inputs[0]->GetName() + ", input 1: " + inputs[1]->GetName() + - " and output: " + outputs[0]->GetName() + - " has an unsupported input data type combination.").c_str()); - - for (auto input : inputs) - { - // Check Shape from tensor (GetShape) - supported &= CheckSupportRule(TosaTensorNumDimensionsWithinBounds(input), - reasonIfUnsupported, - std::string("Tosa Reference Operator: " + opString + " for input: " + - input->GetName() + " exceeds MaxNumOfTensorDimensions.").c_str()); - } - - for (auto output : outputs) - { - // Check Shape from tensor (GetShape) - supported &= CheckSupportRule(TosaTensorNumDimensionsWithinBounds(output), - reasonIfUnsupported, - std::string("Tosa Reference Operator: " + opString + " for output: " + - output->GetName() + " exceeds MaxNumOfTensorDimensions.").c_str()); - } - - return supported; -} - - - -static bool IsTosaLayerSupported(TosaSerializationOperator* op, - const std::vector& inputs, - const std::vector& outputs, - Optional reasonIfUnsupported) -{ - switch(op->GetOp()) - { - case tosa::Op_ADD: - { - std::vector supportedAttributes = { Attribute_NONE }; - - // Only Int32, Fp32 and Fp16 are currently supported by the TOSA Reference Model. - std::vector supportedTypes = - { - DType_INT32, - DType_FP16, - DType_FP32 - }; - - // Check the attribute, data types and bounds for inputs and outputs. - return RunTosaLayerChecksSingleDataType( - op, inputs, outputs, supportedAttributes, supportedTypes, reasonIfUnsupported); - } - case tosa::Op_CONST: - { - std::vector supportedAttributes = { Attribute_NONE }; - - std::vector supportedTypes = - { - DType_FP16, - DType_FP32, - DType_UINT8, - DType_INT8, - DType_INT16, - DType_INT32, - DType_BOOL - }; - - // Check the attribute, data types and bounds for inputs and outputs. - return RunTosaLayerChecksSingleDataType( - op, inputs, outputs, supportedAttributes, supportedTypes, reasonIfUnsupported); - } - case tosa::Op_CONV2D: - { - std::vector supportedAttributes = { Attribute_ConvAttribute }; - - std::vector> supportedTypesMapping = - { - std::tuple(DType_FP16, DType_FP16, DType_FP16), - std::tuple(DType_FP16, DType_FP16, DType_FP32), - std::tuple(DType_FP32, DType_FP32, DType_FP32), - std::tuple(DType_INT8, DType_INT8, DType_INT32) - }; - - return RunTosaLayerChecksInputWeightsOutputDataType( - op, inputs, outputs, supportedAttributes, supportedTypesMapping, reasonIfUnsupported); - } - case tosa::Op_AVG_POOL2D: - { - std::vector supportedAttributes = { Attribute_PoolAttribute }; - - std::vector> supportedTypesMapping = - { - std::tuple(DType_FP16, DType_FP16), - std::tuple(DType_FP16, DType_FP32), - std::tuple(DType_FP32, DType_FP32), - std::tuple(DType_INT8, DType_INT32), - std::tuple(DType_INT16, DType_INT32) - }; - - // Check the attribute, data types and bounds for inputs and outputs. - return RunTosaLayerChecksInputOutputDataType( - op, inputs, outputs, supportedAttributes, supportedTypesMapping, reasonIfUnsupported); - } - case tosa::Op_MAX_POOL2D: - { - std::vector supportedAttributes = { Attribute_PoolAttribute }; - - std::vector supportedTypes = - { - DType_FP16, - DType_FP32, - DType_INT8, - DType_INT16 - }; - - // Check the attribute, data types and bounds for inputs and outputs. - return RunTosaLayerChecksSingleDataType( - op, inputs, outputs, supportedAttributes, supportedTypes, reasonIfUnsupported); - } - case tosa::Op_PAD: - { - std::vector supportedAttributes = { Attribute_PadAttribute }; - - std::vector supportedTypes = - { - DType_FP16, - DType_FP32, - DType_INT8, - DType_INT16, - DType_INT32, - DType_BOOL - }; - - // Check the attribute, data types and bounds for inputs and outputs. - return RunTosaLayerChecksSingleDataType( - op, inputs, outputs, supportedAttributes, supportedTypes, reasonIfUnsupported); - } - case tosa::Op_RESHAPE: - { - std::vector supportedAttributes = { Attribute_ReshapeAttribute }; - - std::vector supportedTypes = - { - DType_FP16, - DType_FP32, - DType_INT8, - DType_INT16, - DType_INT32, - DType_BOOL - }; - - // Check the attribute, data types and bounds for inputs and outputs. - return RunTosaLayerChecksSingleDataType( - op, inputs, outputs, supportedAttributes, supportedTypes, reasonIfUnsupported); - } - case tosa::Op_SLICE: - { - std::vector supportedAttributes = { Attribute_SliceAttribute }; - - std::vector supportedTypes = - { - DType_FP16, - DType_FP32, - DType_INT8, - DType_INT16, - DType_INT32, - DType_BOOL - }; - - // Check the attribute, data types and bounds for inputs and outputs. - return RunTosaLayerChecksSingleDataType( - op, inputs, outputs, supportedAttributes, supportedTypes, reasonIfUnsupported); - } - default: - SetValueChecked(reasonIfUnsupported, "Operation is currently unsupported by the TOSA Reference Backend."); - return false; - } -} - bool TosaRefLayerSupport::IsLayerSupported(const LayerType& type, const std::vector& infos, const BaseDescriptor& descriptor, @@ -336,6 +27,7 @@ bool TosaRefLayerSupport::IsLayerSupported(const LayerType& type, { IgnoreUnused(lstmParamsInfo); IgnoreUnused(quantizedLstmInputParamsInfo); + IgnoreUnused(reasonIfUnsupported); std::vector inputInfos; std::vector outputInfos; @@ -385,35 +77,47 @@ bool TosaRefLayerSupport::IsLayerSupported(const LayerType& type, return false; } - // Loop through block and get each tensor and operator - for (long unsigned int i = 0; i < mappings->GetOperators().size(); ++i) - { - // While looping over operators check for op_UNKNOWN which is unsupported - if (mappings->GetOperators()[i]->GetOp() == tosa::Op_UNKNOWN) { return false; } + TosaSerializationHandler handler; - // Loop over operators and get GetInput/OutputTensorNames, loop over resulting names and - // use GetTensorByName to pass pointers to tensors on to the IsTosaLayerSupported() - std::vector inputTensorsVect; - for (const auto& name : mappings->GetOperators()[i]->GetInputTensorNames()) - { - inputTensorsVect.push_back(mappings->GetTensorByName(name)); - } + // Add mappings to main block as the TOSA Reference Model requires the graph to be in one block called main. + auto* block = new TosaSerializationBasicBlock("main", + mappings->GetOperators(), + mappings->GetTensors(), + mappings->GetInputs(), + mappings->GetOutputs()); + handler.GetBlocks().emplace_back(block); - std::vector outputTensorsVect; - for (const auto& name : mappings->GetOperators()[i]->GetOutputTensorNames()) - { - outputTensorsVect.push_back(mappings->GetTensorByName(name)); - } + GraphStatus status; + TosaReference::IModelRunner runner; - if (!IsTosaLayerSupported(mappings->GetOperators()[i], - inputTensorsVect, - outputTensorsVect, - reasonIfUnsupported)) - { - return false; - } +#if !defined(TOSA_REFERENCE_MODEL_OUTPUT) + // There currently isn't a way to disable the output from the TOSA Reference Model, but it does have a file pointer + // to write debug output to, so set this to /dev/null (if it exists on the system) to hide the output. + func_debug_t funcDebug; + + FILE* file = fopen("/dev/null", "w"); + funcDebug.func_debug_file = (file == nullptr) ? stderr : file; + + runner.setFuncDebug(funcDebug); +#endif + + // Initialise the model runner with the TosaSerializationHandler, which runs validation on the mapping. + status = runner.initialize(handler); + +#if !defined(TOSA_REFERENCE_MODEL_OUTPUT) + // Reset FuncDebug as they can persist across multiple IModelRunner instances. + funcDebug.func_debug_file = stderr; + runner.setFuncDebug(funcDebug); +#endif + + if(status == GraphStatus::TOSA_ERROR || status == GraphStatus::TOSA_UNPREDICTABLE) + { + return false; + } + else + { + return true; } - return true; } } // namespace armnn diff --git a/src/backends/tosaReference/test/TosaRefLayerSupportTests.cpp b/src/backends/tosaReference/test/TosaRefLayerSupportTests.cpp index a1bab83e72..0d0cd6eefc 100644 --- a/src/backends/tosaReference/test/TosaRefLayerSupportTests.cpp +++ b/src/backends/tosaReference/test/TosaRefLayerSupportTests.cpp @@ -20,7 +20,7 @@ TEST_SUITE("TosaRefLayerSupported") TEST_CASE("IsLayerSupportedTosaReferenceAddition") { TensorShape shape0 = {1,1,3,4}; - TensorShape shape1 = {4}; + TensorShape shape1 = {1,1,3,4}; TensorShape outShape = {1,1,3,4}; TensorInfo in0(shape0, DataType::Float32); TensorInfo in1(shape1, DataType::Float32); @@ -59,14 +59,6 @@ TEST_CASE("IsLayerSupportedTosaReferenceAdditionUnsupported") reasonIfNotSupported); CHECK(!supported); - REQUIRE(reasonIfNotSupported.find( - "TOSA Reference Operator: Op_ADD for input: input0_") != std::string::npos); - REQUIRE(reasonIfNotSupported.find( - "TOSA Reference Operator: Op_ADD for input: input1_") != std::string::npos); - REQUIRE(reasonIfNotSupported.find( - "TOSA Reference Operator: Op_ADD for output: output0_") != std::string::npos); - REQUIRE(reasonIfNotSupported.find( - "has an unsupported data type: DType_UNKNOWN") != std::string::npos); } TEST_CASE("IsLayerSupportedTosaReferenceConstant") @@ -99,10 +91,6 @@ TEST_CASE("IsLayerSupportedTosaReferenceConstantUnsupported") reasonIfNotSupported); CHECK(!supported); - REQUIRE(reasonIfNotSupported.find( - "TOSA Reference Operator: Op_CONST for output: constant_") != std::string::npos); - REQUIRE(reasonIfNotSupported.find( - "has an unsupported data type: DType_UNKNOWN") != std::string::npos); } TEST_CASE("IsLayerSupportedTosaReferenceConv2d") @@ -148,14 +136,6 @@ TEST_CASE("IsLayerSupportedTosaReferenceConv2dUnsupported") reasonIfNotSupported); CHECK(!supported); - REQUIRE(reasonIfNotSupported.find( - "TOSA Reference Operator: Op_CONV2D for input 0: input0_") != std::string::npos); - REQUIRE(reasonIfNotSupported.find( - "input 1: input1_") != std::string::npos); - REQUIRE(reasonIfNotSupported.find( - "and output: output0_") != std::string::npos); - REQUIRE(reasonIfNotSupported.find( - "has an unsupported input data type combination.") != std::string::npos); } TEST_CASE("IsLayerSupportedTosaReferenceMaxPooling2d") @@ -166,6 +146,12 @@ TEST_CASE("IsLayerSupportedTosaReferenceMaxPooling2d") TensorInfo out(outShape, DataType::Float32); Pooling2dDescriptor desc; + desc.m_PoolHeight = 1; + desc.m_PoolWidth = 1; + desc.m_StrideX = 1; + desc.m_StrideY = 1; + desc.m_PoolType = armnn::PoolingAlgorithm::Max; + TosaRefLayerSupport supportChecker; std::string reasonIfNotSupported; auto supported = supportChecker.IsLayerSupported(LayerType::Pooling2d, @@ -186,29 +172,10 @@ TEST_CASE("IsLayerSupportedTosaReferenceAvgPooling2d_IgnoreValue") TensorInfo out(outShape, DataType::Float32); Pooling2dDescriptor desc; - desc.m_PaddingMethod = PaddingMethod::IgnoreValue; - desc.m_PoolType = PoolingAlgorithm::Average; - - TosaRefLayerSupport supportChecker; - std::string reasonIfNotSupported; - auto supported = supportChecker.IsLayerSupported(LayerType::Pooling2d, - {in, out}, - desc, - EmptyOptional(), - EmptyOptional(), - reasonIfNotSupported); - - CHECK(supported); -} - -TEST_CASE("IsLayerSupportedTosaReferenceAvgPooling2d_InputOutputDatatypeDifferent") -{ - TensorShape inShape = {1,1,3,4}; - TensorShape outShape = {1,1,3,4}; - TensorInfo in(inShape, DataType::QAsymmS8); - TensorInfo out(outShape, DataType::Signed32); - - Pooling2dDescriptor desc; + desc.m_PoolHeight = 1; + desc.m_PoolWidth = 1; + desc.m_StrideX = 1; + desc.m_StrideY = 1; desc.m_PaddingMethod = PaddingMethod::IgnoreValue; desc.m_PoolType = PoolingAlgorithm::Average; @@ -242,12 +209,6 @@ TEST_CASE("IsLayerSupportedTosaReferenceMaxPooling2dUnsupported") reasonIfNotSupported); CHECK(!supported); - REQUIRE(reasonIfNotSupported.find( - "TOSA Reference Operator: Op_MAX_POOL2D for input: input0_") != std::string::npos); - REQUIRE(reasonIfNotSupported.find( - "TOSA Reference Operator: Op_MAX_POOL2D for output: output0_") != std::string::npos); - REQUIRE(reasonIfNotSupported.find( - "has an unsupported data type: DType_UNKNOWN") != std::string::npos); } TEST_CASE("IsLayerSupportedTosaReferenceAvgPooling2dUnsupported_InputOutputDatatypeDifferent") @@ -271,12 +232,6 @@ TEST_CASE("IsLayerSupportedTosaReferenceAvgPooling2dUnsupported_InputOutputDatat reasonIfNotSupported); CHECK(!supported); - REQUIRE(reasonIfNotSupported.find( - "TOSA Reference Operator: Op_AVG_POOL2D for input: intermediate0_") != std::string::npos); - REQUIRE(reasonIfNotSupported.find( - " and output: output0_") != std::string::npos); - REQUIRE(reasonIfNotSupported.find( - " has an unsupported input data type: DType_FP32 to output data type: DType_FP16") != std::string::npos); } TEST_CASE("IsLayerSupportedTosaReferenceReshape") @@ -321,12 +276,6 @@ TEST_CASE("IsLayerSupportedTosaReferenceReshapeUnsupported") reasonIfNotSupported); CHECK(!supported); - REQUIRE(reasonIfNotSupported.find( - "TOSA Reference Operator: Op_RESHAPE for input: input0_") != std::string::npos); - REQUIRE(reasonIfNotSupported.find( - "TOSA Reference Operator: Op_RESHAPE for output: output0_") != std::string::npos); - REQUIRE(reasonIfNotSupported.find( - "has an unsupported data type: DType_UNKNOWN") != std::string::npos); } TEST_CASE("IsLayerSupportedTosaReferenceSlice") @@ -373,12 +322,6 @@ TEST_CASE("IsLayerSupportedTosaReferenceSliceUnsupported") reasonIfNotSupported); CHECK(!supported); - REQUIRE(reasonIfNotSupported.find( - "TOSA Reference Operator: Op_SLICE for input: input0_") != std::string::npos); - REQUIRE(reasonIfNotSupported.find( - "TOSA Reference Operator: Op_SLICE for output: output0_") != std::string::npos); - REQUIRE(reasonIfNotSupported.find( - "has an unsupported data type: DType_UNKNOWN") != std::string::npos); } } -- cgit v1.2.1