}
//---------------------------------------------------------------
-void ValidateNoInputs(const WorkloadInfo& workloadInfo, std::string const& descName)
+void ValidateNumInputs(const WorkloadInfo& workloadInfo, std::string const& descName, const unsigned int expectedSize)
{
- if (workloadInfo.m_InputTensorInfos.size() != 0)
+ if (workloadInfo.m_InputTensorInfos.size() != expectedSize)
{
throw InvalidArgumentException(descName +
- ": Requires no inputs. " +
- to_string(workloadInfo.m_InputTensorInfos.size()) + " has been provided.");
- }
-}
-
-//---------------------------------------------------------------
-void ValidateSingleInput(const WorkloadInfo& workloadInfo, std::string const& descName)
-{
- if (workloadInfo.m_InputTensorInfos.size() != 1)
- {
- throw InvalidArgumentException(descName +
- ": Requires exactly one input. " +
- to_string(workloadInfo.m_InputTensorInfos.size()) + " has been provided." );
- }
-}
-
-//---------------------------------------------------------------
-void ValidateTwoInputs(const WorkloadInfo& workloadInfo, std::string const& descName)
-{
- if (workloadInfo.m_InputTensorInfos.size() != 2)
- {
- throw InvalidArgumentException(descName +
- ": Requires exactly two workloadInfo.m_InputTensorInfos. " +
+ ": Requires exactly " + to_string(expectedSize) + "input(s). " +
to_string(workloadInfo.m_InputTensorInfos.size()) + " have been provided.");
}
}
//---------------------------------------------------------------
-void ValidateSingleOutput(const WorkloadInfo& workloadInfo, std::string const& descName)
+void ValidateNumOutputs(const WorkloadInfo& workloadInfo, std::string const& descName, const unsigned int expectedSize)
{
- if (workloadInfo.m_OutputTensorInfos.size() != 1)
+ if (workloadInfo.m_OutputTensorInfos.size() != expectedSize)
{
throw InvalidArgumentException(descName +
- ": Requires exactly one output. " +
+ ": Requires exactly " + to_string(expectedSize) + " output(s). " +
to_string(workloadInfo.m_OutputTensorInfos.size()) + " has been provided.");
}
}
}
}
+//---------------------------------------------------------------
+void ValidateDataTypes(const TensorInfo& info,
+ const std::vector<armnn::DataType>& supportedTypes,
+ std::string const& descName)
+{
+ auto iterator = std::find(supportedTypes.begin(), supportedTypes.end(), info.GetDataType());
+ if (iterator == supportedTypes.end())
+ {
+ throw InvalidArgumentException(descName + ": " + " Tensor type is not supported.");
+ }
+}
+
} //namespace
void QueueDescriptor::ValidateInputsOutputs(const std::string& descName,
//---------------------------------------------------------------
void MemCopyQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
{
- ValidateSingleInput(workloadInfo, "MemCopyQueueDescriptor");
- ValidateSingleOutput(workloadInfo, "MemCopyQueueDescriptor");
+ ValidateNumInputs(workloadInfo, "MemCopyQueueDescriptor", 1);
+ ValidateNumOutputs(workloadInfo, "MemCopyQueueDescriptor" , 1);
if (workloadInfo.m_InputTensorInfos.size() != workloadInfo.m_OutputTensorInfos.size())
{
//---------------------------------------------------------------
void ActivationQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
{
- ValidateSingleInput(workloadInfo, "ActivationQueueDescriptor");
- ValidateSingleOutput(workloadInfo, "ActivationQueueDescriptor");
+ ValidateNumInputs(workloadInfo, "ActivationQueueDescriptor", 1);
+ ValidateNumOutputs(workloadInfo, "ActivationQueueDescriptor", 1);
ValidateTensorShapesMatch(workloadInfo.m_InputTensorInfos[0],
workloadInfo.m_OutputTensorInfos[0],
"ActivationQueueDescriptor",
//---------------------------------------------------------------
void SoftmaxQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
{
- ValidateSingleInput(workloadInfo, "SoftmaxQueueDescriptor");
- ValidateSingleOutput(workloadInfo, "SoftmaxQueueDescriptor");
+ ValidateNumInputs(workloadInfo, "SoftmaxQueueDescriptor", 1);
+ ValidateNumOutputs(workloadInfo, "SoftmaxQueueDescriptor", 1);
ValidateTensorShapesMatch(workloadInfo.m_InputTensorInfos[0],
workloadInfo.m_OutputTensorInfos[0],
//---------------------------------------------------------------
void SplitterQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
{
- ValidateSingleInput(workloadInfo, "SplitterQueueDescriptor");
+ ValidateNumInputs(workloadInfo, "SplitterQueueDescriptor", 1);
if (workloadInfo.m_OutputTensorInfos.size() <= 0)
{
//---------------------------------------------------------------
void MergerQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
{
- ValidateSingleOutput(workloadInfo, "MergerQueueDescriptor");
+ ValidateNumOutputs(workloadInfo, "MergerQueueDescriptor", 1);
if (m_Inputs.size() <= 0)
{
//---------------------------------------------------------------
void FullyConnectedQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
{
- ValidateSingleInput(workloadInfo, "FullyConnectedQueueDescriptor");
- ValidateSingleOutput(workloadInfo, "FullyConnectedQueueDescriptor");
+ ValidateNumInputs(workloadInfo, "FullyConnectedQueueDescriptor", 1);
+ ValidateNumOutputs(workloadInfo, "FullyConnectedQueueDescriptor", 1);
ValidateTensorNumDimensions(workloadInfo.m_OutputTensorInfos[0], "FullyConnectedQueueDescriptor", 2, "output");
if (!(workloadInfo.m_InputTensorInfos[0].GetNumDimensions() == 2 ||
//---------------------------------------------------------------
void NormalizationQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
{
- ValidateSingleInput(workloadInfo, "NormalizationQueueDescriptor");
- ValidateSingleOutput(workloadInfo, "NormalizationQueueDescriptor");
+ ValidateNumInputs(workloadInfo, "NormalizationQueueDescriptor", 1);
+ ValidateNumOutputs(workloadInfo, "NormalizationQueueDescriptor", 1);
ValidateTensorShapesMatch(workloadInfo.m_InputTensorInfos[0],
workloadInfo.m_OutputTensorInfos[0],
"NormalizationQueueDescriptor",
void AdditionQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
{
- ValidateTwoInputs(workloadInfo, "AdditionQueueDescriptor");
- ValidateSingleOutput(workloadInfo, "AdditionQueueDescriptor");
+ ValidateNumInputs(workloadInfo, "AdditionQueueDescriptor", 2);
+ ValidateNumOutputs(workloadInfo, "AdditionQueueDescriptor", 1);
ValidateBroadcastTensorShapesMatch(workloadInfo.m_InputTensorInfos[0],
workloadInfo.m_InputTensorInfos[1],
//---------------------------------------------------------------
void MultiplicationQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
{
- ValidateTwoInputs(workloadInfo, "MultiplicationQueueDescriptor");
- ValidateSingleOutput(workloadInfo, "MultiplicationQueueDescriptor");
+ ValidateNumInputs(workloadInfo, "MultiplicationQueueDescriptor", 2);
+ ValidateNumOutputs(workloadInfo, "MultiplicationQueueDescriptor", 1);
ValidateBroadcastTensorShapesMatch(workloadInfo.m_InputTensorInfos[0],
workloadInfo.m_InputTensorInfos[1],
void BatchNormalizationQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
{
- ValidateSingleInput(workloadInfo, "BatchNormalizationQueueDescriptor");
- ValidateSingleOutput(workloadInfo, "BatchNormalizationQueueDescriptor");
+ ValidateNumInputs(workloadInfo, "BatchNormalizationQueueDescriptor", 1);
+ ValidateNumOutputs(workloadInfo, "BatchNormalizationQueueDescriptor", 1);
ValidateTensorShapesMatch(workloadInfo.m_InputTensorInfos[0],
workloadInfo.m_OutputTensorInfos[0],
"BatchNormalizationQueueDescriptor",
void Convolution2dQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
{
- ValidateSingleInput(workloadInfo, "Convolution2dQueueDescriptor");
- ValidateSingleOutput(workloadInfo, "Convolution2dQueueDescriptor");
+ ValidateNumInputs(workloadInfo, "Convolution2dQueueDescriptor", 1);
+ ValidateNumOutputs(workloadInfo, "Convolution2dQueueDescriptor", 1);
ValidateTensorNumDimensions(workloadInfo.m_InputTensorInfos[0], "Convolution2dQueueDescriptor", 4, "input");
ValidateTensorNumDimensions(workloadInfo.m_OutputTensorInfos[0], "Convolution2dQueueDescriptor", 4, "output");
void DepthwiseConvolution2dQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
{
- ValidateSingleInput(workloadInfo, "DepthwiseConvolution2dQueueDescriptor");
- ValidateSingleOutput(workloadInfo, "DepthwiseConvolution2dQueueDescriptor");
+ ValidateNumInputs(workloadInfo, "DepthwiseConvolution2dQueueDescriptor", 1);
+ ValidateNumOutputs(workloadInfo, "DepthwiseConvolution2dQueueDescriptor", 1);
ValidateTensorNumDimensions(
workloadInfo.m_InputTensorInfos[0], "DepthwiseConvolution2dQueueDescriptor", 4, "input");
void PermuteQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
{
- ValidateSingleInput(workloadInfo, "PermuteQueueDescriptor");
- ValidateSingleOutput(workloadInfo, "PermuteQueueDescriptor");
+ ValidateNumInputs(workloadInfo, "PermuteQueueDescriptor", 1);
+ ValidateNumOutputs(workloadInfo, "PermuteQueueDescriptor", 1);
const PermutationVector& mapping = m_Parameters.m_DimMappings;
void Pooling2dQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
{
- ValidateSingleInput(workloadInfo, "Pooling2dQueueDescriptor");
- ValidateSingleOutput(workloadInfo, "Pooling2dQueueDescriptor");
+ ValidateNumInputs(workloadInfo, "Pooling2dQueueDescriptor", 1);
+ ValidateNumOutputs(workloadInfo, "Pooling2dQueueDescriptor", 1);
ValidateTensorNumDimensions(workloadInfo.m_InputTensorInfos[0], "Pooling2dQueueDescriptor", 4, "input");
ValidateTensorNumDimensions(workloadInfo.m_OutputTensorInfos[0], "Pooling2dQueueDescriptor", 4, "output");
void ResizeBilinearQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
{
- ValidateSingleInput(workloadInfo, "ResizeBilinearQueueDescriptor");
- ValidateSingleOutput(workloadInfo, "ResizeBilinearQueueDescriptor");
+ ValidateNumInputs(workloadInfo, "ResizeBilinearQueueDescriptor", 1);
+ ValidateNumOutputs(workloadInfo, "ResizeBilinearQueueDescriptor", 1);
ValidateTensorNumDimensions(workloadInfo.m_InputTensorInfos[0], "ResizeBilinearQueueDescriptor", 4, "input");
ValidateTensorNumDimensions(workloadInfo.m_OutputTensorInfos[0], "ResizeBilinearQueueDescriptor", 4, "output");
void FakeQuantizationQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
{
- ValidateSingleInput(workloadInfo, "FakeQuantizationQueueDescriptor");
- ValidateSingleOutput(workloadInfo, "FakeQuantizationQueueDescriptor");
+ ValidateNumInputs(workloadInfo, "FakeQuantizationQueueDescriptor", 1);
+ ValidateNumOutputs(workloadInfo, "FakeQuantizationQueueDescriptor", 1);
ValidateTensorNumDimensions(workloadInfo.m_InputTensorInfos[0], "FakeQuantizationQueueDescriptor", 2, "input");
ValidateTensorNumDimensions(workloadInfo.m_OutputTensorInfos[0], "FakeQuantizationQueueDescriptor", 2, "output");
void L2NormalizationQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
{
- ValidateSingleInput(workloadInfo, "L2NormalizationQueueDescriptor");
- ValidateSingleOutput(workloadInfo, "L2NormalizationQueueDescriptor");
+ ValidateNumInputs(workloadInfo, "L2NormalizationQueueDescriptor", 1);
+ ValidateNumOutputs(workloadInfo, "L2NormalizationQueueDescriptor", 1);
ValidateTensorNumDimensions(workloadInfo.m_InputTensorInfos[0], "L2NormalizationQueueDescriptor", 4, "input");
ValidateTensorNumDimensions(workloadInfo.m_OutputTensorInfos[0], "L2NormalizationQueueDescriptor", 4, "output");
void ConstantQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
{
- ValidateNoInputs(workloadInfo, "ConstantQueueDescriptor");
- ValidateSingleOutput(workloadInfo, "ConstantQueueDescriptor");
+ ValidateNumInputs(workloadInfo, "ConstantQueueDescriptor", 0);
+ ValidateNumOutputs(workloadInfo, "ConstantQueueDescriptor", 1);
if (!m_LayerOutput)
{
void ReshapeQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
{
- ValidateSingleInput(workloadInfo, "ReshapeQueueDescriptor");
- ValidateSingleOutput(workloadInfo, "ReshapeQueueDescriptor");
+ ValidateNumInputs(workloadInfo, "ReshapeQueueDescriptor", 1);
+ ValidateNumOutputs(workloadInfo, "ReshapeQueueDescriptor", 1);
if (workloadInfo.m_InputTensorInfos[0].GetNumElements() != workloadInfo.m_OutputTensorInfos[0].GetNumElements())
{
void SpaceToBatchNdQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
{
- ValidateSingleInput(workloadInfo, "SpaceToBatchNdQueueDescriptor");
- ValidateSingleOutput(workloadInfo, "SpaceToBatchNdQueueDescriptor");
+ ValidateNumInputs(workloadInfo, "SpaceToBatchNdQueueDescriptor", 1);
+ ValidateNumOutputs(workloadInfo, "SpaceToBatchNdQueueDescriptor", 1);
ValidateTensorNumDimensions(workloadInfo.m_InputTensorInfos[0], "SpaceToBatchNdQueueDescriptor", 4, "input");
ValidateTensorNumDimensions(workloadInfo.m_OutputTensorInfos[0], "SpaceToBatchNdQueueDescriptor", 4, "output");
void FloorQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
{
- ValidateSingleInput(workloadInfo, "FloorQueueDescriptor");
- ValidateSingleOutput(workloadInfo, "FlootQueueDescriptor");
+ ValidateNumInputs(workloadInfo, "FloorQueueDescriptor", 1);
+ ValidateNumOutputs(workloadInfo, "FlootQueueDescriptor", 1);
if (workloadInfo.m_InputTensorInfos[0] != workloadInfo.m_OutputTensorInfos[0])
{
void ConvertFp32ToFp16QueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
{
- ValidateSingleInput(workloadInfo, "ConvertFp32ToFp16QueueDescriptor");
- ValidateSingleOutput(workloadInfo, "ConvertFp32ToFp16QueueDescriptor");
+ ValidateNumInputs(workloadInfo, "ConvertFp32ToFp16QueueDescriptor", 1);
+ ValidateNumOutputs(workloadInfo, "ConvertFp32ToFp16QueueDescriptor", 1);
if (workloadInfo.m_InputTensorInfos[0].GetDataType() != DataType::Float32)
{
void ConvertFp16ToFp32QueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
{
- ValidateSingleInput(workloadInfo, "ConvertFp16ToFp32QueueDescriptor");
- ValidateSingleOutput(workloadInfo, "ConvertFp16ToFp32QueueDescriptor");
+ ValidateNumInputs(workloadInfo, "ConvertFp16ToFp32QueueDescriptor", 1);
+ ValidateNumOutputs(workloadInfo, "ConvertFp16ToFp32QueueDescriptor", 1);
if (workloadInfo.m_InputTensorInfos[0].GetDataType() != DataType::Float16)
{
void DivisionQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
{
- ValidateTwoInputs(workloadInfo, "DivisionQueueDescriptor");
- ValidateSingleOutput(workloadInfo, "DivisionQueueDescriptor");
+ ValidateNumInputs(workloadInfo, "DivisionQueueDescriptor", 2);
+ ValidateNumOutputs(workloadInfo, "DivisionQueueDescriptor", 1);
ValidateBroadcastTensorShapesMatch(workloadInfo.m_InputTensorInfos[0],
workloadInfo.m_InputTensorInfos[1],
void SubtractionQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
{
- ValidateTwoInputs(workloadInfo, "SubtractionQueueDescriptor");
- ValidateSingleOutput(workloadInfo, "SubtractionQueueDescriptor");
+ ValidateNumInputs(workloadInfo, "SubtractionQueueDescriptor", 2);
+ ValidateNumOutputs(workloadInfo, "SubtractionQueueDescriptor", 1);
ValidateBroadcastTensorShapesMatch(workloadInfo.m_InputTensorInfos[0],
workloadInfo.m_InputTensorInfos[1],
void MaximumQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
{
- ValidateTwoInputs(workloadInfo, "MaximumQueueDescriptor");
- ValidateSingleOutput(workloadInfo, "MaximumQueueDescriptor");
+ ValidateNumInputs(workloadInfo, "MaximumQueueDescriptor", 2);
+ ValidateNumOutputs(workloadInfo, "MaximumQueueDescriptor", 1);
ValidateBroadcastTensorShapesMatch(workloadInfo.m_InputTensorInfos[0],
workloadInfo.m_InputTensorInfos[1],
void MeanQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
{
- ValidateSingleInput(workloadInfo, "MeanQueueDescriptor");
- ValidateSingleOutput(workloadInfo, "MeanQueueDescriptor");
+ ValidateNumInputs(workloadInfo, "MeanQueueDescriptor", 1);
+ ValidateNumOutputs(workloadInfo, "MeanQueueDescriptor", 1);
const TensorInfo& input = workloadInfo.m_InputTensorInfos[0];
const TensorInfo& output = workloadInfo.m_OutputTensorInfos[0];
void PadQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
{
- ValidateSingleInput(workloadInfo, "PadQueueDescriptor");
- ValidateSingleOutput(workloadInfo, "PadQueueDescriptor");
+ ValidateNumInputs(workloadInfo, "PadQueueDescriptor", 1);
+ ValidateNumOutputs(workloadInfo, "PadQueueDescriptor", 1);
const TensorInfo& input = workloadInfo.m_InputTensorInfos[0];
const TensorInfo& output = workloadInfo.m_OutputTensorInfos[0];
void QuantizeQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
{
- ValidateSingleInput(workloadInfo, "QuantizeQueueDescriptor");
- ValidateSingleOutput(workloadInfo, "QuantizeQueueDescriptor");
+ ValidateNumInputs(workloadInfo, "QuantizeQueueDescriptor", 1);
+ ValidateNumOutputs(workloadInfo, "QuantizeQueueDescriptor", 1);
if (workloadInfo.m_InputTensorInfos[0].GetDataType() != DataType::Float32)
void BatchToSpaceNdQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
{
- ValidateSingleInput(workloadInfo, "BatchToSpaceNdQueueDescriptor");
- ValidateSingleOutput(workloadInfo, "BatchToSpaceNdQueueDescriptor");
+ ValidateNumInputs(workloadInfo, "BatchToSpaceNdQueueDescriptor", 1);
+ ValidateNumOutputs(workloadInfo, "BatchToSpaceNdQueueDescriptor", 1);
}
void StridedSliceQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
{
- ValidateSingleInput(workloadInfo, "StridedSliceQueueDescriptor");
- ValidateSingleOutput(workloadInfo, "StridedSliceQueueDescriptor");
+ ValidateNumInputs(workloadInfo, "StridedSliceQueueDescriptor", 1);
+ ValidateNumOutputs(workloadInfo, "StridedSliceQueueDescriptor", 1);
const TensorInfo& input = workloadInfo.m_InputTensorInfos[0];
const uint32_t rank = input.GetNumDimensions();
void MinimumQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
{
- ValidateTwoInputs(workloadInfo, "MinimumQueueDescriptor");
- ValidateSingleOutput(workloadInfo, "MinimumQueueDescriptor");
+ ValidateNumInputs(workloadInfo, "MinimumQueueDescriptor", 2);
+ ValidateNumOutputs(workloadInfo, "MinimumQueueDescriptor", 1);
ValidateBroadcastTensorShapesMatch(workloadInfo.m_InputTensorInfos[0],
workloadInfo.m_InputTensorInfos[1],
void DebugQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
{
- ValidateSingleInput(workloadInfo, "DebugQueueDescriptor");
- ValidateSingleOutput(workloadInfo, "DebugQueueDescriptor");
+ ValidateNumInputs(workloadInfo, "DebugQueueDescriptor", 1);
+ ValidateNumOutputs(workloadInfo, "DebugQueueDescriptor", 1);
}
void EqualQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
{
- ValidateTwoInputs(workloadInfo, "EqualQueueDescriptor");
- ValidateSingleOutput(workloadInfo, "EqualQueueDescriptor");
+ ValidateNumInputs(workloadInfo, "EqualQueueDescriptor", 2);
+ ValidateNumOutputs(workloadInfo, "EqualQueueDescriptor", 1);
ValidateBroadcastTensorShapesMatch(workloadInfo.m_InputTensorInfos[0],
workloadInfo.m_InputTensorInfos[1],
void GreaterQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
{
- ValidateTwoInputs(workloadInfo, "GreaterQueueDescriptor");
- ValidateSingleOutput(workloadInfo, "GreaterQueueDescriptor");
+ ValidateNumInputs(workloadInfo, "GreaterQueueDescriptor", 2);
+ ValidateNumOutputs(workloadInfo, "GreaterQueueDescriptor", 1);
ValidateBroadcastTensorShapesMatch(workloadInfo.m_InputTensorInfos[0],
workloadInfo.m_InputTensorInfos[1],
void RsqrtQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
{
- ValidateSingleInput(workloadInfo, "RsqrtQueueDescriptor");
- ValidateSingleOutput(workloadInfo, "RsqrtQueueDescriptor");
+ ValidateNumInputs(workloadInfo, "RsqrtQueueDescriptor", 1);
+ ValidateNumOutputs(workloadInfo, "RsqrtQueueDescriptor", 1);
ValidateTensorShapesMatch(workloadInfo.m_InputTensorInfos[0],
workloadInfo.m_OutputTensorInfos[0],
"RsqrtQueueDescriptor",
void GatherQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
{
- ValidateTwoInputs(workloadInfo, "GatherQueueDescriptor");
- ValidateSingleOutput(workloadInfo, "GatherQueueDescriptor");
+ ValidateNumInputs(workloadInfo, "GatherQueueDescriptor", 2);
+ ValidateNumOutputs(workloadInfo, "GatherQueueDescriptor", 1);
const TensorInfo& indices = workloadInfo.m_InputTensorInfos[1];
void DetectionPostProcessQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
{
- ValidateTwoInputs(workloadInfo, "DetectionPostProcessQueueDescriptor");
+ ValidateNumInputs(workloadInfo, "DetectionPostProcessQueueDescriptor", 2);
if (workloadInfo.m_OutputTensorInfos.size() != 4)
{
void DequantizeQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
{
- ValidateSingleInput(workloadInfo, "DequantizeQueueDescriptor");
- ValidateSingleOutput(workloadInfo, "DequantizeQueueDescriptor");
+ ValidateNumInputs(workloadInfo, "DequantizeQueueDescriptor", 1);
+ ValidateNumOutputs(workloadInfo, "DequantizeQueueDescriptor", 1);
if (workloadInfo.m_InputTensorInfos[0].GetDataType() != DataType::QuantisedAsymm8 &&
workloadInfo.m_InputTensorInfos[0].GetDataType() != DataType::QuantisedSymm16)
void MergeQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
{
- ValidateTwoInputs(workloadInfo, "MergeQueueDescriptor");
- ValidateSingleOutput(workloadInfo, "MergeQueueDescriptor");
+ ValidateNumInputs(workloadInfo, "MergeQueueDescriptor", 2);
+ ValidateNumOutputs(workloadInfo, "MergeQueueDescriptor", 1);
ValidateTensorShapesMatch(workloadInfo.m_InputTensorInfos[0],
workloadInfo.m_InputTensorInfos[1],
ValidateTensorDataType(workloadInfo.m_OutputTensorInfos[0], dataType, "MergeQueueDescriptor", "output");
}
+void SwitchQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
+{
+ ValidateNumInputs(workloadInfo, "SwitchQueueDescriptor", 2);
+ ValidateNumOutputs(workloadInfo, "SwitchQueueDescriptor", 2);
+
+ std::vector<DataType> supportedTypes = {
+ DataType::Float32,
+ DataType::QuantisedAsymm8,
+ DataType::QuantisedSymm16
+ };
+
+ ValidateDataTypes(workloadInfo.m_InputTensorInfos[0],
+ supportedTypes,
+ "SwitchQueueDescriptor");
+
+ ValidateDataTypes(workloadInfo.m_InputTensorInfos[1],
+ supportedTypes,
+ "SwitchQueueDescriptor");
+
+ ValidateDataTypes(workloadInfo.m_OutputTensorInfos[0],
+ supportedTypes,
+ "SwitchQueueDescriptor");
+
+ ValidateTensorShapesMatch(workloadInfo.m_InputTensorInfos[0],
+ workloadInfo.m_OutputTensorInfos[0],
+ "SwitchQueueDescriptor",
+ "input0",
+ "output0");
+
+ ValidateTensorShapesMatch(workloadInfo.m_InputTensorInfos[0],
+ workloadInfo.m_OutputTensorInfos[1],
+ "SwitchQueueDescriptor",
+ "input0",
+ "output1");
+}
+
void PreCompiledQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
{
// This is internally generated so it should not need validation.