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 <matthew.sloyan@arm.com>
Change-Id: Iaea17343d0ad51b495477024c44a34d9335d1438
diff --git a/cmake/GlobalConfig.cmake b/cmake/GlobalConfig.cmake
index 5bedee9..dd20e15 100644
--- a/cmake/GlobalConfig.cmake
+++ b/cmake/GlobalConfig.cmake
@@ -26,6 +26,7 @@
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 @@
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 07ffae4..0d19a32 100644
--- a/src/backends/tosaCommon/test/OneToOneMappingTests.cpp
+++ b/src/backends/tosaCommon/test/OneToOneMappingTests.cpp
@@ -384,8 +384,8 @@
std::vector<std::vector<int32_t>> 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 daa27f6..928a19c 100644
--- a/src/backends/tosaReference/TosaRefLayerSupport.cpp
+++ b/src/backends/tosaReference/TosaRefLayerSupport.cpp
@@ -4,329 +4,20 @@
//
#include "TosaRefLayerSupport.hpp"
+
#include <tosaCommon/TosaMappings.hpp>
#include <armnn/Types.hpp>
#include <armnn/utility/IgnoreUnused.hpp>
-#include <tosaCommon/TosaLayerSupportRules.hpp>
-#include <LayerSupportCommon.hpp>
+
+#include <graph_status.h>
+#include <model_runner.h>
#include <vector>
-#include <array>
-#include <tuple>
namespace armnn
{
-static bool RunTosaLayerChecksSingleDataType(TosaSerializationOperator* op,
- const std::vector<TosaSerializationTensor*>& inputs,
- const std::vector<TosaSerializationTensor*>& outputs,
- const std::vector<Attribute>& supportedAttributes,
- const std::vector<DType>& supportedTypes,
- Optional<string&> 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<TosaSerializationTensor*>& inputs,
- const std::vector<TosaSerializationTensor*>& outputs,
- const std::vector<Attribute>& supportedAttributes,
- const std::vector<std::tuple<DType,DType>>& supportedMappingTypes,
- Optional<string&> 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<DType, DType> 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<TosaSerializationTensor*>& inputs,
- const std::vector<TosaSerializationTensor*>& outputs,
- const std::vector<Attribute>& supportedAttributes,
- const std::vector<std::tuple<DType, DType, DType>>& supportedMappingTypes,
- Optional<string&> 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<DType, DType, DType> 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<TosaSerializationTensor*>& inputs,
- const std::vector<TosaSerializationTensor*>& outputs,
- Optional<string&> reasonIfUnsupported)
-{
- switch(op->GetOp())
- {
- case tosa::Op_ADD:
- {
- std::vector<Attribute> supportedAttributes = { Attribute_NONE };
-
- // Only Int32, Fp32 and Fp16 are currently supported by the TOSA Reference Model.
- std::vector<DType> 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<Attribute> supportedAttributes = { Attribute_NONE };
-
- std::vector<DType> 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<Attribute> supportedAttributes = { Attribute_ConvAttribute };
-
- std::vector<std::tuple<DType, DType, DType>> supportedTypesMapping =
- {
- std::tuple<DType, DType, DType>(DType_FP16, DType_FP16, DType_FP16),
- std::tuple<DType, DType, DType>(DType_FP16, DType_FP16, DType_FP32),
- std::tuple<DType, DType, DType>(DType_FP32, DType_FP32, DType_FP32),
- std::tuple<DType, DType, DType>(DType_INT8, DType_INT8, DType_INT32)
- };
-
- return RunTosaLayerChecksInputWeightsOutputDataType(
- op, inputs, outputs, supportedAttributes, supportedTypesMapping, reasonIfUnsupported);
- }
- case tosa::Op_AVG_POOL2D:
- {
- std::vector<Attribute> supportedAttributes = { Attribute_PoolAttribute };
-
- std::vector<std::tuple<DType, DType>> supportedTypesMapping =
- {
- std::tuple<DType, DType>(DType_FP16, DType_FP16),
- std::tuple<DType, DType>(DType_FP16, DType_FP32),
- std::tuple<DType, DType>(DType_FP32, DType_FP32),
- std::tuple<DType, DType>(DType_INT8, DType_INT32),
- std::tuple<DType, DType>(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<Attribute> supportedAttributes = { Attribute_PoolAttribute };
-
- std::vector<DType> 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<Attribute> supportedAttributes = { Attribute_PadAttribute };
-
- std::vector<DType> 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<Attribute> supportedAttributes = { Attribute_ReshapeAttribute };
-
- std::vector<DType> 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<Attribute> supportedAttributes = { Attribute_SliceAttribute };
-
- std::vector<DType> 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<TensorInfo>& infos,
const BaseDescriptor& descriptor,
@@ -336,6 +27,7 @@
{
IgnoreUnused(lstmParamsInfo);
IgnoreUnused(quantizedLstmInputParamsInfo);
+ IgnoreUnused(reasonIfUnsupported);
std::vector<const TensorInfo*> inputInfos;
std::vector<const TensorInfo*> outputInfos;
@@ -385,35 +77,47 @@
return false;
}
- // Loop through block and get each tensor and operator
- for (long unsigned int i = 0; i < mappings->GetOperators().size(); ++i)
+ TosaSerializationHandler handler;
+
+ // 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);
+
+ GraphStatus status;
+ TosaReference::IModelRunner runner;
+
+#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)
{
- // While looping over operators check for op_UNKNOWN which is unsupported
- if (mappings->GetOperators()[i]->GetOp() == tosa::Op_UNKNOWN) { return false; }
-
- // 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<TosaSerializationTensor*> inputTensorsVect;
- for (const auto& name : mappings->GetOperators()[i]->GetInputTensorNames())
- {
- inputTensorsVect.push_back(mappings->GetTensorByName(name));
- }
-
- std::vector<TosaSerializationTensor*> outputTensorsVect;
- for (const auto& name : mappings->GetOperators()[i]->GetOutputTensorNames())
- {
- outputTensorsVect.push_back(mappings->GetTensorByName(name));
- }
-
- if (!IsTosaLayerSupported(mappings->GetOperators()[i],
- inputTensorsVect,
- outputTensorsVect,
- reasonIfUnsupported))
- {
- return false;
- }
+ return false;
}
- return true;
+ else
+ {
+ return true;
+ }
}
} // namespace armnn
diff --git a/src/backends/tosaReference/test/TosaRefLayerSupportTests.cpp b/src/backends/tosaReference/test/TosaRefLayerSupportTests.cpp
index a1bab83..0d0cd6e 100644
--- a/src/backends/tosaReference/test/TosaRefLayerSupportTests.cpp
+++ b/src/backends/tosaReference/test/TosaRefLayerSupportTests.cpp
@@ -20,7 +20,7 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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);
}
}