From 1dc83febfb76d6a770bdf3ba16c4034a970c2320 Mon Sep 17 00:00:00 2001 From: Nikhil Raj Date: Thu, 16 May 2024 09:47:51 +0100 Subject: IVGCVSW-8260 Update Doxgen Docu for 24.05 Signed-off-by: Nikhil Raj Change-Id: If4bc983bf2793a27ded8e26ac2b29523fc1e4711 --- latest/classarmnn_1_1_ref_layer_support.html | 4999 +++++++++++++------------- 1 file changed, 2561 insertions(+), 2438 deletions(-) (limited to 'latest/classarmnn_1_1_ref_layer_support.html') diff --git a/latest/classarmnn_1_1_ref_layer_support.html b/latest/classarmnn_1_1_ref_layer_support.html index 587482274e..1be064470b 100644 --- a/latest/classarmnn_1_1_ref_layer_support.html +++ b/latest/classarmnn_1_1_ref_layer_support.html @@ -36,7 +36,7 @@ ArmNN
-  24.02 +  24.05
@@ -227,6 +227,8 @@ Public Member Functions   bool IsReverseV2Supported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const   +bool IsScatterNdSupported (const TensorInfo &input, const TensorInfo &indices, const TensorInfo &updates, const TensorInfo &output, const ScatterNdDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const +  bool IsShapeSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const   bool IsSliceSupported (const TensorInfo &input, const TensorInfo &output, const SliceDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const @@ -321,72 +323,72 @@ Additional Inherited Members
-

Definition at line 553 of file RefLayerSupport.cpp.

-
557 {
-
558  bool supported = true;
-
559 
-
560  // Define supported types.
-
561  std::array<DataType,6> supportedTypes = {
-
562  DataType::Float32,
-
563  DataType::Float16,
-
564  DataType::QAsymmS8,
-
565  DataType::QAsymmU8,
-
566  DataType::QSymmS16
-
567  };
-
568 
-
569  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
-
570  "Reference activation: input type not supported.");
-
571 
-
572  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
573  "Reference activation: output type not supported.");
-
574 
-
575  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
-
576  "Reference activation: input and output types mismatched.");
-
577 
-
578  supported &= CheckSupportRule(ShapesAreSameRank(input, output), reasonIfUnsupported,
-
579  "Reference activation: input and output shapes are of different rank.");
-
580 
+

Definition at line 560 of file RefLayerSupport.cpp.

+
564 {
+
565  bool supported = true;
+
566 
+
567  // Define supported types.
+
568  std::array<DataType,6> supportedTypes = {
+
569  DataType::Float32,
+
570  DataType::Float16,
+
571  DataType::QAsymmS8,
+
572  DataType::QAsymmU8,
+
573  DataType::QSymmS16
+
574  };
+
575 
+
576  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
+
577  "Reference activation: input type not supported.");
+
578 
+
579  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
580  "Reference activation: output type not supported.");
581 
-
582  struct ActivationFunctionSupported : public Rule
-
583  {
-
584  ActivationFunctionSupported(const ActivationDescriptor& desc)
-
585  {
-
586  switch(desc.m_Function)
-
587  {
-
588  case ActivationFunction::Abs:
-
589  case ActivationFunction::BoundedReLu:
-
590  case ActivationFunction::Elu:
-
591  case ActivationFunction::Gelu:
-
592  case ActivationFunction::HardSwish:
-
593  case ActivationFunction::LeakyReLu:
-
594  case ActivationFunction::Linear:
-
595  case ActivationFunction::ReLu:
-
596  case ActivationFunction::Sigmoid:
-
597  case ActivationFunction::SoftReLu:
-
598  case ActivationFunction::Sqrt:
-
599  case ActivationFunction::Square:
-
600  case ActivationFunction::TanH:
-
601  {
-
602  m_Res = true;
-
603  break;
-
604  }
-
605  default:
-
606  {
-
607  m_Res = false;
-
608  break;
-
609  }
-
610  }
-
611  }
-
612  };
-
613 
-
614  // Function is supported
-
615  supported &= CheckSupportRule(ActivationFunctionSupported(descriptor), reasonIfUnsupported,
-
616  "Reference activation: function not supported.");
-
617 
-
618  return supported;
-
619 }
+
582  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
+
583  "Reference activation: input and output types mismatched.");
+
584 
+
585  supported &= CheckSupportRule(ShapesAreSameRank(input, output), reasonIfUnsupported,
+
586  "Reference activation: input and output shapes are of different rank.");
+
587 
+
588 
+
589  struct ActivationFunctionSupported : public Rule
+
590  {
+
591  ActivationFunctionSupported(const ActivationDescriptor& desc)
+
592  {
+
593  switch(desc.m_Function)
+
594  {
+
595  case ActivationFunction::Abs:
+
596  case ActivationFunction::BoundedReLu:
+
597  case ActivationFunction::Elu:
+
598  case ActivationFunction::Gelu:
+
599  case ActivationFunction::HardSwish:
+
600  case ActivationFunction::LeakyReLu:
+
601  case ActivationFunction::Linear:
+
602  case ActivationFunction::ReLu:
+
603  case ActivationFunction::Sigmoid:
+
604  case ActivationFunction::SoftReLu:
+
605  case ActivationFunction::Sqrt:
+
606  case ActivationFunction::Square:
+
607  case ActivationFunction::TanH:
+
608  {
+
609  m_Res = true;
+
610  break;
+
611  }
+
612  default:
+
613  {
+
614  m_Res = false;
+
615  break;
+
616  }
+
617  }
+
618  }
+
619  };
+
620 
+
621  // Function is supported
+
622  supported &= CheckSupportRule(ActivationFunctionSupported(descriptor), reasonIfUnsupported,
+
623  "Reference activation: function not supported.");
+
624 
+
625  return supported;
+
626 }
-

References armnn::Abs, armnn::BoundedReLu, armnn::CheckSupportRule(), armnn::Elu, armnn::Float16, armnn::Float32, armnn::Gelu, armnn::HardSwish, armnn::LeakyReLu, armnn::Linear, ActivationDescriptor::m_Function, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, armnn::ReLu, armnn::Sigmoid, armnn::SoftReLu, armnn::Sqrt, armnn::Square, and armnn::TanH.

+

References armnn::Abs, armnn::BoundedReLu, armnn::CheckSupportRule(), armnn::Elu, armnn::Float16, armnn::Float32, armnn::Gelu, armnn::HardSwish, armnn::LeakyReLu, armnn::Linear, ActivationDescriptor::m_Function, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, armnn::ReLu, armnn::Sigmoid, armnn::SoftReLu, armnn::Sqrt, armnn::Square, and armnn::TanH.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -430,41 +432,41 @@ Additional Inherited Members
-

Definition at line 621 of file RefLayerSupport.cpp.

-
625 {
-
626  bool supported = true;
-
627 
-
628  std::array<DataType,7> supportedTypes = {
-
629  DataType::Float32,
-
630  DataType::Float16,
-
631  DataType::QAsymmS8,
-
632  DataType::QAsymmU8,
-
633  DataType::QSymmS16,
-
634  DataType::Signed32
-
635  };
-
636 
-
637  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
-
638  "Reference addition: input 0 is not a supported type.");
-
639 
-
640  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
-
641  "Reference addition: input 1 is not a supported type.");
-
642 
-
643  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
644  "Reference addition: output is not a supported type.");
-
645 
-
646  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
-
647  "Reference addition: input 0 and Input 1 types are mismatched");
-
648 
-
649  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
-
650  "Reference addition: input and output types are mismatched");
-
651 
-
652  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
-
653  "Reference addition: shapes are not suitable for implicit broadcast.");
-
654 
-
655  return supported;
-
656 }
+

Definition at line 628 of file RefLayerSupport.cpp.

+
632 {
+
633  bool supported = true;
+
634 
+
635  std::array<DataType,7> supportedTypes = {
+
636  DataType::Float32,
+
637  DataType::Float16,
+
638  DataType::QAsymmS8,
+
639  DataType::QAsymmU8,
+
640  DataType::QSymmS16,
+
641  DataType::Signed32
+
642  };
+
643 
+
644  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
+
645  "Reference addition: input 0 is not a supported type.");
+
646 
+
647  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
+
648  "Reference addition: input 1 is not a supported type.");
+
649 
+
650  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
651  "Reference addition: output is not a supported type.");
+
652 
+
653  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
+
654  "Reference addition: input 0 and Input 1 types are mismatched");
+
655 
+
656  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
+
657  "Reference addition: input and output types are mismatched");
+
658 
+
659  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
+
660  "Reference addition: shapes are not suitable for implicit broadcast.");
+
661 
+
662  return supported;
+
663 }
-

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

+

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -508,37 +510,37 @@ Additional Inherited Members
-

Definition at line 658 of file RefLayerSupport.cpp.

-
661 {
-
662  IgnoreUnused(descriptor);
-
663 
-
664  std::array<DataType, 8> supportedInputTypes =
-
665  {
-
666  DataType::Float16,
-
667  DataType::Float32,
-
668  DataType::QAsymmS8,
-
669  DataType::QAsymmU8,
-
670  DataType::QSymmS16,
-
671  DataType::Signed32,
-
672  DataType::Signed64
-
673  };
-
674 
-
675  std::array<DataType,2> supportedOutputTypes = {
-
676  DataType::Signed32,
-
677  DataType::Signed64
-
678  };
-
679 
-
680  bool supported = true;
+

Definition at line 665 of file RefLayerSupport.cpp.

+
668 {
+
669  IgnoreUnused(descriptor);
+
670 
+
671  std::array<DataType, 8> supportedInputTypes =
+
672  {
+
673  DataType::Float16,
+
674  DataType::Float32,
+
675  DataType::QAsymmS8,
+
676  DataType::QAsymmU8,
+
677  DataType::QSymmS16,
+
678  DataType::Signed32,
+
679  DataType::Signed64
+
680  };
681 
-
682  supported &= CheckSupportRule(TypeAnyOf(input, supportedInputTypes), reasonIfUnsupported,
-
683  "Reference ArgMinMax: input is not a supported type.");
-
684  supported &= CheckSupportRule(TypeAnyOf(output, supportedOutputTypes), reasonIfUnsupported,
-
685  "Reference ArgMinMax: output type not supported");
+
682  std::array<DataType,2> supportedOutputTypes = {
+
683  DataType::Signed32,
+
684  DataType::Signed64
+
685  };
686 
-
687  return supported;
-
688 }
+
687  bool supported = true;
+
688 
+
689  supported &= CheckSupportRule(TypeAnyOf(input, supportedInputTypes), reasonIfUnsupported,
+
690  "Reference ArgMinMax: input is not a supported type.");
+
691  supported &= CheckSupportRule(TypeAnyOf(output, supportedOutputTypes), reasonIfUnsupported,
+
692  "Reference ArgMinMax: output type not supported");
+
693 
+
694  return supported;
+
695 }
-

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, armnn::Signed32, and armnn::Signed64.

+

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, armnn::Signed32, and armnn::Signed64.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -588,48 +590,48 @@ Additional Inherited Members
-

Definition at line 690 of file RefLayerSupport.cpp.

-
695 {
-
696  IgnoreUnused(descriptor);
-
697 
-
698  std::array<DataType, 6> supportedTypes =
-
699  {
-
700  DataType::Float16,
-
701  DataType::Float32,
-
702  DataType::QAsymmS8,
-
703  DataType::QAsymmU8,
-
704  DataType::QSymmS16
-
705  };
-
706 
-
707  bool supported = true;
-
708 
-
709  supported &= CheckSupportRule(TypeAnyOf(inputX, supportedTypes), reasonIfUnsupported,
-
710  "Reference batch matrix multiplication: input X is not a supported type");
-
711 
-
712  supported &= CheckSupportRule(TypeAnyOf(inputY, supportedTypes), reasonIfUnsupported,
-
713  "Reference batch matrix multiplication: input Y is not a supported type");
-
714 
-
715  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
716  "Reference batch matrix multiplication: output is not a supported type");
-
717 
-
718  supported &= CheckSupportRule(TypesAreEqual(inputX, inputY), reasonIfUnsupported,
-
719  "Reference batch matrix multiplication: input X and input Y types are mismatched");
-
720 
-
721  supported &= CheckSupportRule(TypesAreEqual(inputX, output), reasonIfUnsupported,
-
722  "Reference batch matrix multiplication: inputs and output types are mismatched");
-
723 
-
724  supported &= CheckSupportRule(TensorNumDimensionsAreGreaterOrEqualTo(inputX, 2),
-
725  reasonIfUnsupported,
-
726  "Reference batch matrix multiplication: input X is not of rank 2 or greater");
+

Definition at line 697 of file RefLayerSupport.cpp.

+
702 {
+
703  IgnoreUnused(descriptor);
+
704 
+
705  std::array<DataType, 6> supportedTypes =
+
706  {
+
707  DataType::Float16,
+
708  DataType::Float32,
+
709  DataType::QAsymmS8,
+
710  DataType::QAsymmU8,
+
711  DataType::QSymmS16
+
712  };
+
713 
+
714  bool supported = true;
+
715 
+
716  supported &= CheckSupportRule(TypeAnyOf(inputX, supportedTypes), reasonIfUnsupported,
+
717  "Reference batch matrix multiplication: input X is not a supported type");
+
718 
+
719  supported &= CheckSupportRule(TypeAnyOf(inputY, supportedTypes), reasonIfUnsupported,
+
720  "Reference batch matrix multiplication: input Y is not a supported type");
+
721 
+
722  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
723  "Reference batch matrix multiplication: output is not a supported type");
+
724 
+
725  supported &= CheckSupportRule(TypesAreEqual(inputX, inputY), reasonIfUnsupported,
+
726  "Reference batch matrix multiplication: input X and input Y types are mismatched");
727 
-
728  supported &= CheckSupportRule(TensorNumDimensionsAreGreaterOrEqualTo(inputY, 2),
-
729  reasonIfUnsupported,
-
730  "Reference batch matrix multiplication: input Y is not of rank 2 or greater");
-
731 
-
732  return supported;
-
733 }
+
728  supported &= CheckSupportRule(TypesAreEqual(inputX, output), reasonIfUnsupported,
+
729  "Reference batch matrix multiplication: inputs and output types are mismatched");
+
730 
+
731  supported &= CheckSupportRule(TensorNumDimensionsAreGreaterOrEqualTo(inputX, 2),
+
732  reasonIfUnsupported,
+
733  "Reference batch matrix multiplication: input X is not of rank 2 or greater");
+
734 
+
735  supported &= CheckSupportRule(TensorNumDimensionsAreGreaterOrEqualTo(inputY, 2),
+
736  reasonIfUnsupported,
+
737  "Reference batch matrix multiplication: input Y is not of rank 2 or greater");
+
738 
+
739  return supported;
+
740 }
-

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

+

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -697,46 +699,46 @@ Additional Inherited Members
-

Definition at line 735 of file RefLayerSupport.cpp.

-
743 {
-
744  IgnoreUnused(descriptor);
-
745 
-
746  std::array<DataType, 6> supportedTypes =
-
747  {
-
748  DataType::Float32,
-
749  DataType::Float16,
-
750  DataType::QAsymmS8,
-
751  DataType::QAsymmU8,
-
752  DataType::QSymmS16
-
753  };
-
754 
-
755  bool supported = true;
-
756 
-
757  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
-
758  "Reference batch normalization: input is not a supported type.");
-
759 
-
760  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
761  "Reference batch normalization: output is not a supported type.");
-
762 
-
763  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
-
764  "Reference batch normalization: input and output types are mismatched");
-
765 
-
766  supported &= CheckSupportRule(TypeAnyOf(mean, supportedTypes), reasonIfUnsupported,
-
767  "Reference batch normalization: mean is not a supported type.");
-
768 
-
769  supported &= CheckSupportRule(TypeAnyOf(variance, supportedTypes), reasonIfUnsupported,
-
770  "Reference batch normalization: variance is not a supported type.");
-
771 
-
772  supported &= CheckSupportRule(TypeAnyOf(beta, supportedTypes), reasonIfUnsupported,
-
773  "Reference batch normalization: beta is not a supported type.");
-
774 
-
775  supported &= CheckSupportRule(TypeAnyOf(gamma, supportedTypes), reasonIfUnsupported,
-
776  "Reference batch normalization: gamma is not a supported type.");
-
777 
-
778  return supported;
-
779 }
+

Definition at line 742 of file RefLayerSupport.cpp.

+
750 {
+
751  IgnoreUnused(descriptor);
+
752 
+
753  std::array<DataType, 6> supportedTypes =
+
754  {
+
755  DataType::Float32,
+
756  DataType::Float16,
+
757  DataType::QAsymmS8,
+
758  DataType::QAsymmU8,
+
759  DataType::QSymmS16
+
760  };
+
761 
+
762  bool supported = true;
+
763 
+
764  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
+
765  "Reference batch normalization: input is not a supported type.");
+
766 
+
767  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
768  "Reference batch normalization: output is not a supported type.");
+
769 
+
770  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
+
771  "Reference batch normalization: input and output types are mismatched");
+
772 
+
773  supported &= CheckSupportRule(TypeAnyOf(mean, supportedTypes), reasonIfUnsupported,
+
774  "Reference batch normalization: mean is not a supported type.");
+
775 
+
776  supported &= CheckSupportRule(TypeAnyOf(variance, supportedTypes), reasonIfUnsupported,
+
777  "Reference batch normalization: variance is not a supported type.");
+
778 
+
779  supported &= CheckSupportRule(TypeAnyOf(beta, supportedTypes), reasonIfUnsupported,
+
780  "Reference batch normalization: beta is not a supported type.");
+
781 
+
782  supported &= CheckSupportRule(TypeAnyOf(gamma, supportedTypes), reasonIfUnsupported,
+
783  "Reference batch normalization: gamma is not a supported type.");
+
784 
+
785  return supported;
+
786 }
-

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

+

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -780,39 +782,39 @@ Additional Inherited Members
-

Definition at line 781 of file RefLayerSupport.cpp.

-
785 {
-
786  IgnoreUnused(descriptor);
-
787 
-
788  bool supported = true;
-
789 
-
790  std::string batchToSpaceNdLayerStr = "batchToSpaceNd";
-
791  std::string inputTensorStr = "input";
-
792  std::string outputTensorStr = "output";
-
793 
-
794  // Define supported types.
-
795  std::array<DataType,6> supportedTypes =
-
796  {
-
797  DataType::Float32,
-
798  DataType::Float16,
-
799  DataType::QAsymmS8,
-
800  DataType::QAsymmU8,
-
801  DataType::QSymmS16
-
802  };
-
803 
-
804  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
-
805  "Reference BatchToSpaceNd: input type not supported.");
-
806 
-
807  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
808  "Reference BatchToSpaceNd: output type not supported.");
-
809 
-
810  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
-
811  "Reference BatchToSpaceNd: input and output types mismatched.");
-
812 
-
813  return supported;
-
814 }
+

Definition at line 788 of file RefLayerSupport.cpp.

+
792 {
+
793  IgnoreUnused(descriptor);
+
794 
+
795  bool supported = true;
+
796 
+
797  std::string batchToSpaceNdLayerStr = "batchToSpaceNd";
+
798  std::string inputTensorStr = "input";
+
799  std::string outputTensorStr = "output";
+
800 
+
801  // Define supported types.
+
802  std::array<DataType,6> supportedTypes =
+
803  {
+
804  DataType::Float32,
+
805  DataType::Float16,
+
806  DataType::QAsymmS8,
+
807  DataType::QAsymmU8,
+
808  DataType::QSymmS16
+
809  };
+
810 
+
811  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
+
812  "Reference BatchToSpaceNd: input type not supported.");
+
813 
+
814  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
815  "Reference BatchToSpaceNd: output type not supported.");
+
816 
+
817  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
+
818  "Reference BatchToSpaceNd: input and output types mismatched.");
+
819 
+
820  return supported;
+
821 }
-

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

+

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -856,34 +858,34 @@ Additional Inherited Members
-

Definition at line 816 of file RefLayerSupport.cpp.

-
820 {
-
821  IgnoreUnused(descriptor);
-
822 
-
823  bool supported = true;
-
824 
-
825  std::array<DataType, 8> supportedTypes
-
826  {
-
827  DataType::Float32,
-
828  DataType::Float16,
-
829  DataType::QAsymmS8,
-
830  DataType::QAsymmU8,
-
831  DataType::QSymmS8,
-
832  DataType::QSymmS16,
-
833  DataType::Signed32,
-
834  DataType::Signed64
-
835  };
-
836 
-
837  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
-
838  "BroadcastTo: input type not supported.");
-
839 
-
840  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
841  "BroadcastTo: output type not supported");
-
842 
-
843  return supported;
-
844 }
+

Definition at line 823 of file RefLayerSupport.cpp.

+
827 {
+
828  IgnoreUnused(descriptor);
+
829 
+
830  bool supported = true;
+
831 
+
832  std::array<DataType, 8> supportedTypes
+
833  {
+
834  DataType::Float32,
+
835  DataType::Float16,
+
836  DataType::QAsymmS8,
+
837  DataType::QAsymmU8,
+
838  DataType::QSymmS8,
+
839  DataType::QSymmS16,
+
840  DataType::Signed32,
+
841  DataType::Signed64
+
842  };
+
843 
+
844  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
+
845  "BroadcastTo: input type not supported.");
+
846 
+
847  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
848  "BroadcastTo: output type not supported");
+
849 
+
850  return supported;
+
851 }
-

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, armnn::QSymmS8, armnn::Signed32, and armnn::Signed64.

+

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, armnn::QSymmS8, armnn::Signed32, and armnn::Signed64.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -921,35 +923,35 @@ Additional Inherited Members
-

Definition at line 846 of file RefLayerSupport.cpp.

-
849 {
-
850  std::array<DataType, 10> supportedInputTypes =
-
851  {
-
852  DataType::Float32,
-
853  DataType::Float16,
-
854  DataType::QSymmS8,
-
855  DataType::QAsymmS8,
-
856  DataType::QAsymmU8,
-
857  DataType::QSymmS16,
-
858  DataType::Signed32,
-
859  DataType::Signed64
-
860  };
-
861 
-
862  bool supported = true;
-
863  supported &= CheckSupportRule(TypeAnyOf(input, supportedInputTypes), reasonIfUnsupported,
-
864  "Reference cast: input is not a supported type");
-
865 
-
866 
-
867  supported &= CheckSupportRule(TypeAnyOf(output, supportedInputTypes), reasonIfUnsupported,
-
868  "Reference cast: output is not a supported type");
-
869 
-
870  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
-
871  "Reference cast: input and output shapes have different number of total elements");
+

Definition at line 853 of file RefLayerSupport.cpp.

+
856 {
+
857  std::array<DataType, 10> supportedInputTypes =
+
858  {
+
859  DataType::Float32,
+
860  DataType::Float16,
+
861  DataType::QSymmS8,
+
862  DataType::QAsymmS8,
+
863  DataType::QAsymmU8,
+
864  DataType::QSymmS16,
+
865  DataType::Signed32,
+
866  DataType::Signed64
+
867  };
+
868 
+
869  bool supported = true;
+
870  supported &= CheckSupportRule(TypeAnyOf(input, supportedInputTypes), reasonIfUnsupported,
+
871  "Reference cast: input is not a supported type");
872 
-
873  return supported;
-
874 }
+
873 
+
874  supported &= CheckSupportRule(TypeAnyOf(output, supportedInputTypes), reasonIfUnsupported,
+
875  "Reference cast: output is not a supported type");
+
876 
+
877  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
+
878  "Reference cast: input and output shapes have different number of total elements");
+
879 
+
880  return supported;
+
881 }
-

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, armnn::QSymmS8, armnn::Signed32, and armnn::Signed64.

+

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, armnn::QSymmS8, armnn::Signed32, and armnn::Signed64.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -993,35 +995,35 @@ Additional Inherited Members
-

Definition at line 876 of file RefLayerSupport.cpp.

-
880 {
-
881  IgnoreUnused(descriptor);
-
882  bool supported = true;
-
883 
-
884  // Define supported output and inputs types.
-
885  std::array<DataType, 7> supportedTypes =
-
886  {
-
887  DataType::Float32,
-
888  DataType::Float16,
-
889  DataType::QAsymmS8,
-
890  DataType::QAsymmU8,
-
891  DataType::QSymmS8,
-
892  DataType::QSymmS16
-
893  };
-
894 
-
895  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
-
896  "Reference ChannelShuffle: input is not a supported type.");
-
897 
-
898  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
899  "Reference ChannelShuffle: output is not a supported type.");
-
900 
-
901  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
-
902  "Reference ChannelShuffle: input and output types are mismatched.");
-
903 
-
904  return supported;
-
905 }
+

Definition at line 883 of file RefLayerSupport.cpp.

+
887 {
+
888  IgnoreUnused(descriptor);
+
889  bool supported = true;
+
890 
+
891  // Define supported output and inputs types.
+
892  std::array<DataType, 7> supportedTypes =
+
893  {
+
894  DataType::Float32,
+
895  DataType::Float16,
+
896  DataType::QAsymmS8,
+
897  DataType::QAsymmU8,
+
898  DataType::QSymmS8,
+
899  DataType::QSymmS16
+
900  };
+
901 
+
902  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
+
903  "Reference ChannelShuffle: input is not a supported type.");
+
904 
+
905  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
906  "Reference ChannelShuffle: output is not a supported type.");
+
907 
+
908  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
+
909  "Reference ChannelShuffle: input and output types are mismatched.");
+
910 
+
911  return supported;
+
912 }
-

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::QSymmS8.

+

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::QSymmS8.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -1071,34 +1073,37 @@ Additional Inherited Members
-

Definition at line 908 of file RefLayerSupport.cpp.

-
913 {
-
914  IgnoreUnused(descriptor);
-
915  std::array<DataType, 8> supportedInputTypes =
-
916  {
-
917  DataType::Boolean,
-
918  DataType::Float32,
-
919  DataType::Float16,
-
920  DataType::QAsymmS8,
-
921  DataType::QAsymmU8,
-
922  DataType::QSymmS16,
-
923  DataType::Signed32
-
924  };
-
925 
-
926  bool supported = true;
-
927  supported &= CheckSupportRule(TypeAnyOf(input0, supportedInputTypes), reasonIfUnsupported,
-
928  "Reference comparison: input 0 is not a supported type");
-
929 
-
930  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
-
931  "Reference comparison: input 0 and Input 1 types are mismatched");
+

Definition at line 915 of file RefLayerSupport.cpp.

+
920 {
+
921  IgnoreUnused(descriptor);
+
922  std::array<DataType, 8> supportedInputTypes =
+
923  {
+
924  DataType::Boolean,
+
925  DataType::Float32,
+
926  DataType::Float16,
+
927  DataType::QAsymmS8,
+
928  DataType::QAsymmU8,
+
929  DataType::QSymmS16,
+
930  DataType::Signed32
+
931  };
932 
-
933  supported &= CheckSupportRule(TypeIs(output, DataType::Boolean), reasonIfUnsupported,
-
934  "Reference comparison: output is not of type Boolean");
-
935 
-
936  return supported;
-
937 }
+
933  bool supported = true;
+
934  supported &= CheckSupportRule(TypeAnyOf(input0, supportedInputTypes), reasonIfUnsupported,
+
935  "Reference comparison: input 0 is not a supported type");
+
936 
+
937  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
+
938  "Reference comparison: input 0 and Input 1 types are mismatched");
+
939 
+
940  supported &= CheckSupportRule(TypeIs(output, DataType::Boolean), reasonIfUnsupported,
+
941  "Reference comparison: output is not of type Boolean");
+
942 
+
943  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
+
944  "Reference comparison: shapes are not suitable for implicit broadcast.");
+
945 
+
946  return supported;
+
947 }
-

References armnn::Boolean, armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

+

References armnn::Boolean, armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -1142,37 +1147,36 @@ Additional Inherited Members
-

Definition at line 939 of file RefLayerSupport.cpp.

-
943 {
-
944  IgnoreUnused(descriptor);
-
945 
-
946  bool supported = true;
-
947  std::array<DataType,7> supportedTypes =
-
948  {
-
949  DataType::Float32,
-
950  DataType::Float16,
-
951  DataType::QAsymmS8,
-
952  DataType::QAsymmU8,
-
953  DataType::QSymmS16,
-
954  DataType::Signed32
-
955  };
-
956 
-
957  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
958  "Reference concatenation: output type not supported");
-
959  for (const TensorInfo* input : inputs)
-
960  {
-
961  ARMNN_ASSERT(input != nullptr);
-
962  supported &= CheckSupportRule(TypeAnyOf(*input, supportedTypes), reasonIfUnsupported,
-
963  "Reference concatenation: input type not supported");
-
964 
-
965  supported &= CheckSupportRule(TypesAreEqual(*input, output), reasonIfUnsupported,
-
966  "Reference concatenation: input and output types mismatched.");
-
967  }
-
968 
-
969  return supported;
-
970 }
+

Definition at line 949 of file RefLayerSupport.cpp.

+
953 {
+
954  IgnoreUnused(descriptor);
+
955 
+
956  bool supported = true;
+
957  std::array<DataType,7> supportedTypes =
+
958  {
+
959  DataType::Float32,
+
960  DataType::Float16,
+
961  DataType::QAsymmS8,
+
962  DataType::QAsymmU8,
+
963  DataType::QSymmS16,
+
964  DataType::Signed32
+
965  };
+
966 
+
967  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
968  "Reference concatenation: output type not supported");
+
969  for (const TensorInfo* input : inputs)
+
970  {
+
971  supported &= CheckSupportRule(TypeAnyOf(*input, supportedTypes), reasonIfUnsupported,
+
972  "Reference concatenation: input type not supported");
+
973 
+
974  supported &= CheckSupportRule(TypesAreEqual(*input, output), reasonIfUnsupported,
+
975  "Reference concatenation: input and output types mismatched.");
+
976  }
+
977 
+
978  return supported;
+
979 }
-

References ARMNN_ASSERT, armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

+

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -1204,24 +1208,24 @@ Additional Inherited Members
-

Definition at line 972 of file RefLayerSupport.cpp.

-
974 {
-
975  std::array<DataType,8> supportedTypes =
-
976  {
-
977  DataType::Float16,
-
978  DataType::Float32,
-
979  DataType::QAsymmS8,
-
980  DataType::QAsymmU8,
-
981  DataType::QSymmS8,
-
982  DataType::QSymmS16,
-
983  DataType::Signed32
-
984  };
-
985 
-
986  return CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
987  "Reference constant: output is not a supported type.");
-
988 }
+

Definition at line 981 of file RefLayerSupport.cpp.

+
983 {
+
984  std::array<DataType,8> supportedTypes =
+
985  {
+
986  DataType::Float16,
+
987  DataType::Float32,
+
988  DataType::QAsymmS8,
+
989  DataType::QAsymmU8,
+
990  DataType::QSymmS8,
+
991  DataType::QSymmS16,
+
992  DataType::Signed32
+
993  };
+
994 
+
995  return CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
996  "Reference constant: output is not a supported type.");
+
997 }
-

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, armnn::QSymmS8, and armnn::Signed32.

+

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, armnn::QSymmS8, and armnn::Signed32.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -1259,23 +1263,23 @@ Additional Inherited Members
-

Definition at line 990 of file RefLayerSupport.cpp.

-
993 {
-
994  return (IsSupportedForDataTypeGeneric(reasonIfUnsupported,
-
995  input.GetDataType(),
-
996  &TrueFunc<>,
-
997  &FalseInputFuncF32<>,
-
998  &FalseFuncU8<>,
-
999  &FalseFuncI32<>,
-
1000  &FalseFuncU8<>) &&
-
1001  IsSupportedForDataTypeGeneric(reasonIfUnsupported,
-
1002  output.GetDataType(),
-
1003  &FalseOutputFuncF16<>,
-
1004  &TrueFunc<>,
-
1005  &FalseFuncU8<>,
-
1006  &FalseFuncI32<>,
-
1007  &FalseFuncU8<>));
-
1008 }
+

Definition at line 999 of file RefLayerSupport.cpp.

+
1002 {
+
1003  return (IsSupportedForDataTypeGeneric(reasonIfUnsupported,
+
1004  input.GetDataType(),
+
1005  &TrueFunc<>,
+
1006  &FalseInputFuncF32<>,
+
1007  &FalseFuncU8<>,
+
1008  &FalseFuncI32<>,
+
1009  &FalseFuncU8<>) &&
+
1010  IsSupportedForDataTypeGeneric(reasonIfUnsupported,
+
1011  output.GetDataType(),
+
1012  &FalseOutputFuncF16<>,
+
1013  &TrueFunc<>,
+
1014  &FalseFuncU8<>,
+
1015  &FalseFuncI32<>,
+
1016  &FalseFuncU8<>));
+
1017 }

References TensorInfo::GetDataType(), and armnn::IsSupportedForDataTypeGeneric().

@@ -1315,23 +1319,23 @@ Additional Inherited Members
-

Definition at line 1010 of file RefLayerSupport.cpp.

-
1013 {
-
1014  return (IsSupportedForDataTypeGeneric(reasonIfUnsupported,
-
1015  input.GetDataType(),
-
1016  &FalseInputFuncF16<>,
-
1017  &TrueFunc<>,
-
1018  &FalseFuncU8<>,
-
1019  &FalseFuncI32<>,
-
1020  &FalseFuncU8<>) &&
-
1021  IsSupportedForDataTypeGeneric(reasonIfUnsupported,
-
1022  output.GetDataType(),
-
1023  &TrueFunc<>,
-
1024  &FalseOutputFuncF32<>,
-
1025  &FalseFuncU8<>,
-
1026  &FalseFuncI32<>,
-
1027  &FalseFuncU8<>));
-
1028 }
+

Definition at line 1019 of file RefLayerSupport.cpp.

+
1022 {
+
1023  return (IsSupportedForDataTypeGeneric(reasonIfUnsupported,
+
1024  input.GetDataType(),
+
1025  &FalseInputFuncF16<>,
+
1026  &TrueFunc<>,
+
1027  &FalseFuncU8<>,
+
1028  &FalseFuncI32<>,
+
1029  &FalseFuncU8<>) &&
+
1030  IsSupportedForDataTypeGeneric(reasonIfUnsupported,
+
1031  output.GetDataType(),
+
1032  &TrueFunc<>,
+
1033  &FalseOutputFuncF32<>,
+
1034  &FalseFuncU8<>,
+
1035  &FalseFuncI32<>,
+
1036  &FalseFuncU8<>));
+
1037 }

References TensorInfo::GetDataType(), and armnn::IsSupportedForDataTypeGeneric().

@@ -1389,71 +1393,71 @@ Additional Inherited Members
-

Definition at line 1030 of file RefLayerSupport.cpp.

-
1036 {
-
1037  bool supported = true;
-
1038 
-
1039  // Define supported types.
-
1040  std::array<DataType,7> supportedTypes =
-
1041  {
-
1042  DataType::Float32,
-
1043  DataType::Float16,
-
1044  DataType::QAsymmS8,
-
1045  DataType::QAsymmU8,
-
1046  DataType::QSymmS8,
-
1047  DataType::QSymmS16
-
1048  };
-
1049 
-
1050  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
-
1051  "Reference Convolution2d: input is not a supported type.");
-
1052 
-
1053  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
1054  "Reference Convolution2d: output is not a supported type.");
-
1055 
-
1056  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
-
1057  "Reference Convolution2d: input and output types mismatched.");
+

Definition at line 1039 of file RefLayerSupport.cpp.

+
1045 {
+
1046  bool supported = true;
+
1047 
+
1048  // Define supported types.
+
1049  std::array<DataType,7> supportedTypes =
+
1050  {
+
1051  DataType::Float32,
+
1052  DataType::Float16,
+
1053  DataType::QAsymmS8,
+
1054  DataType::QAsymmU8,
+
1055  DataType::QSymmS8,
+
1056  DataType::QSymmS16
+
1057  };
1058 
-
1059 
-
1060  const DataType inputType = input.GetDataType();
-
1061  if (IsQuantized8BitType(inputType))
-
1062  {
-
1063  std::array<DataType, 3> supportedWeightTypes =
-
1064  {
-
1065  DataType::QAsymmS8,
-
1066  DataType::QAsymmU8,
-
1067  DataType::QSymmS8
-
1068  };
-
1069 
-
1070  supported &= CheckSupportRule(TypeAnyOf(weights, supportedWeightTypes), reasonIfUnsupported,
-
1071  "Reference Convolution2d: weights type not supported for quantized input.");
-
1072  }
-
1073  else
-
1074  {
-
1075  supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
-
1076  "Reference Convolution2d: weights is not a supported type.");
-
1077 
-
1078  supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
-
1079  "Reference Convolution2d: input and weights types mismatched.");
-
1080  }
-
1081 
-
1082  if (biases.has_value())
+
1059  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
+
1060  "Reference Convolution2d: input is not a supported type.");
+
1061 
+
1062  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
1063  "Reference Convolution2d: output is not a supported type.");
+
1064 
+
1065  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
+
1066  "Reference Convolution2d: input and output types mismatched.");
+
1067 
+
1068 
+
1069  const DataType inputType = input.GetDataType();
+
1070  if (IsQuantized8BitType(inputType))
+
1071  {
+
1072  std::array<DataType, 3> supportedWeightTypes =
+
1073  {
+
1074  DataType::QAsymmS8,
+
1075  DataType::QAsymmU8,
+
1076  DataType::QSymmS8
+
1077  };
+
1078 
+
1079  supported &= CheckSupportRule(TypeAnyOf(weights, supportedWeightTypes), reasonIfUnsupported,
+
1080  "Reference Convolution2d: weights type not supported for quantized input.");
+
1081  }
+
1082  else
1083  {
-
1084  std::array<DataType,4> biasesSupportedTypes =
-
1085  {
-
1086  DataType::Float32,
-
1087  DataType::Float16,
-
1088  DataType::Signed32
-
1089  };
+
1084  supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
+
1085  "Reference Convolution2d: weights is not a supported type.");
+
1086 
+
1087  supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
+
1088  "Reference Convolution2d: input and weights types mismatched.");
+
1089  }
1090 
-
1091  supported &= CheckSupportRule(TypeAnyOf(biases.value(), biasesSupportedTypes), reasonIfUnsupported,
-
1092  "Reference Convolution2d: biases is not a supported type.");
-
1093  }
-
1094  IgnoreUnused(descriptor);
-
1095 
-
1096  return supported;
-
1097 }
+
1091  if (biases.has_value())
+
1092  {
+
1093  std::array<DataType,4> biasesSupportedTypes =
+
1094  {
+
1095  DataType::Float32,
+
1096  DataType::Float16,
+
1097  DataType::Signed32
+
1098  };
+
1099 
+
1100  supported &= CheckSupportRule(TypeAnyOf(biases.value(), biasesSupportedTypes), reasonIfUnsupported,
+
1101  "Reference Convolution2d: biases is not a supported type.");
+
1102  }
+
1103  IgnoreUnused(descriptor);
+
1104 
+
1105  return supported;
+
1106 }
-

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, TensorInfo::GetDataType(), OptionalBase::has_value(), armnn::IgnoreUnused(), armnn::IsQuantized8BitType(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, armnn::QSymmS8, armnn::Signed32, and OptionalReferenceSwitch< std::is_reference< T >::value, T >::value().

+

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, TensorInfo::GetDataType(), OptionalBase::has_value(), armnn::IgnoreUnused(), armnn::IsQuantized8BitType(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, armnn::QSymmS8, armnn::Signed32, and OptionalReferenceSwitch< std::is_reference< T >::value, T >::value().

Referenced by RefLayerSupport::IsLayerSupported().

@@ -1509,70 +1513,70 @@ Additional Inherited Members
-

Definition at line 1099 of file RefLayerSupport.cpp.

-
1105 {
-
1106  bool supported = true;
-
1107 
-
1108  // Define supported types.
-
1109  std::array<DataType,7> supportedTypes =
-
1110  {
-
1111  DataType::Float32,
-
1112  DataType::Float16,
-
1113  DataType::QAsymmS8,
-
1114  DataType::QAsymmU8,
-
1115  DataType::QSymmS8,
-
1116  DataType::QSymmS16
-
1117  };
-
1118 
-
1119  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
-
1120  "Reference Convolution3d: input is not a supported type.");
-
1121 
-
1122  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
1123  "Reference Convolution3d: output is not a supported type.");
-
1124 
-
1125  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
-
1126  "Reference Convolution3d: input and output types mismatched.");
+

Definition at line 1108 of file RefLayerSupport.cpp.

+
1114 {
+
1115  bool supported = true;
+
1116 
+
1117  // Define supported types.
+
1118  std::array<DataType,7> supportedTypes =
+
1119  {
+
1120  DataType::Float32,
+
1121  DataType::Float16,
+
1122  DataType::QAsymmS8,
+
1123  DataType::QAsymmU8,
+
1124  DataType::QSymmS8,
+
1125  DataType::QSymmS16
+
1126  };
1127 
-
1128  const DataType inputType = input.GetDataType();
-
1129  if (IsQuantized8BitType(inputType))
-
1130  {
-
1131  std::array<DataType, 3> supportedWeightTypes =
-
1132  {
-
1133  DataType::QAsymmS8,
-
1134  DataType::QAsymmU8,
-
1135  DataType::QSymmS8
-
1136  };
-
1137 
-
1138  supported &= CheckSupportRule(TypeAnyOf(weights, supportedWeightTypes), reasonIfUnsupported,
-
1139  "Reference Convolution3d: weights type not supported for quantized input.");
-
1140  }
-
1141  else
-
1142  {
-
1143  supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
-
1144  "Reference Convolution3d: weights is not a supported type.");
-
1145 
-
1146  supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
-
1147  "Reference Convolution3d: input and weights types mismatched.");
-
1148  }
-
1149 
-
1150  if (biases.has_value())
+
1128  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
+
1129  "Reference Convolution3d: input is not a supported type.");
+
1130 
+
1131  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
1132  "Reference Convolution3d: output is not a supported type.");
+
1133 
+
1134  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
+
1135  "Reference Convolution3d: input and output types mismatched.");
+
1136 
+
1137  const DataType inputType = input.GetDataType();
+
1138  if (IsQuantized8BitType(inputType))
+
1139  {
+
1140  std::array<DataType, 3> supportedWeightTypes =
+
1141  {
+
1142  DataType::QAsymmS8,
+
1143  DataType::QAsymmU8,
+
1144  DataType::QSymmS8
+
1145  };
+
1146 
+
1147  supported &= CheckSupportRule(TypeAnyOf(weights, supportedWeightTypes), reasonIfUnsupported,
+
1148  "Reference Convolution3d: weights type not supported for quantized input.");
+
1149  }
+
1150  else
1151  {
-
1152  std::array<DataType,4> biasesSupportedTypes =
-
1153  {
-
1154  DataType::Float32,
-
1155  DataType::Float16,
-
1156  DataType::Signed32
-
1157  };
+
1152  supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
+
1153  "Reference Convolution3d: weights is not a supported type.");
+
1154 
+
1155  supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
+
1156  "Reference Convolution3d: input and weights types mismatched.");
+
1157  }
1158 
-
1159  supported &= CheckSupportRule(TypeAnyOf(biases.value(), biasesSupportedTypes), reasonIfUnsupported,
-
1160  "Reference Convolution3d: biases is not a supported type.");
-
1161  }
-
1162  IgnoreUnused(descriptor);
-
1163 
-
1164  return supported;
-
1165 }
+
1159  if (biases.has_value())
+
1160  {
+
1161  std::array<DataType,4> biasesSupportedTypes =
+
1162  {
+
1163  DataType::Float32,
+
1164  DataType::Float16,
+
1165  DataType::Signed32
+
1166  };
+
1167 
+
1168  supported &= CheckSupportRule(TypeAnyOf(biases.value(), biasesSupportedTypes), reasonIfUnsupported,
+
1169  "Reference Convolution3d: biases is not a supported type.");
+
1170  }
+
1171  IgnoreUnused(descriptor);
+
1172 
+
1173  return supported;
+
1174 }
-

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, TensorInfo::GetDataType(), OptionalBase::has_value(), armnn::IgnoreUnused(), armnn::IsQuantized8BitType(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, armnn::QSymmS8, armnn::Signed32, and OptionalReferenceSwitch< std::is_reference< T >::value, T >::value().

+

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, TensorInfo::GetDataType(), OptionalBase::has_value(), armnn::IgnoreUnused(), armnn::IsQuantized8BitType(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, armnn::QSymmS8, armnn::Signed32, and OptionalReferenceSwitch< std::is_reference< T >::value, T >::value().

Referenced by RefLayerSupport::IsLayerSupported().

@@ -1610,35 +1614,35 @@ Additional Inherited Members
-

Definition at line 1167 of file RefLayerSupport.cpp.

-
1170 {
-
1171  bool supported = true;
-
1172 
-
1173  std::array<DataType, 8> supportedTypes =
-
1174  {
-
1175  DataType::BFloat16,
-
1176  DataType::Float16,
-
1177  DataType::Float32,
-
1178  DataType::QAsymmS8,
-
1179  DataType::QAsymmU8,
-
1180  DataType::QSymmS8,
-
1181  DataType::QSymmS16,
-
1182  DataType::Signed32
-
1183  };
-
1184 
-
1185  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
-
1186  "Reference for Debug layer: input type not supported");
-
1187 
-
1188  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
1189  "Reference for Debug layer: output type not supported");
-
1190 
-
1191  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
-
1192  "Reference for Debug layer: input and output types are mismatched");
+

Definition at line 1176 of file RefLayerSupport.cpp.

+
1179 {
+
1180  bool supported = true;
+
1181 
+
1182  std::array<DataType, 8> supportedTypes =
+
1183  {
+
1184  DataType::BFloat16,
+
1185  DataType::Float16,
+
1186  DataType::Float32,
+
1187  DataType::QAsymmS8,
+
1188  DataType::QAsymmU8,
+
1189  DataType::QSymmS8,
+
1190  DataType::QSymmS16,
+
1191  DataType::Signed32
+
1192  };
1193 
-
1194  return supported;
-
1195 }
+
1194  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
+
1195  "Reference for Debug layer: input type not supported");
+
1196 
+
1197  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
1198  "Reference for Debug layer: output type not supported");
+
1199 
+
1200  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
+
1201  "Reference for Debug layer: input and output types are mismatched");
+
1202 
+
1203  return supported;
+
1204 }
-

References armnn::BFloat16, armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, armnn::QSymmS8, and armnn::Signed32.

+

References armnn::BFloat16, armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, armnn::QSymmS8, and armnn::Signed32.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -1682,33 +1686,33 @@ Additional Inherited Members
-

Definition at line 1197 of file RefLayerSupport.cpp.

-
1201 {
-
1202  IgnoreUnused(descriptor);
-
1203  bool supported = true;
-
1204 
-
1205  std::array<DataType,6> supportedTypes =
-
1206  {
-
1207  DataType::Float32,
-
1208  DataType::Float16,
-
1209  DataType::QAsymmS8,
-
1210  DataType::QAsymmU8,
-
1211  DataType::QSymmS16
-
1212  };
+

Definition at line 1206 of file RefLayerSupport.cpp.

+
1210 {
+
1211  IgnoreUnused(descriptor);
+
1212  bool supported = true;
1213 
-
1214  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
-
1215  "Reference DepthToSpace: input type not supported");
-
1216 
-
1217  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
1218  "Reference DepthToSpace: output type not supported");
-
1219 
-
1220  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
-
1221  "Reference DepthToSpace: input and output types are mismatched");
+
1214  std::array<DataType,6> supportedTypes =
+
1215  {
+
1216  DataType::Float32,
+
1217  DataType::Float16,
+
1218  DataType::QAsymmS8,
+
1219  DataType::QAsymmU8,
+
1220  DataType::QSymmS16
+
1221  };
1222 
-
1223  return supported;
-
1224 }
+
1223  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
+
1224  "Reference DepthToSpace: input type not supported");
+
1225 
+
1226  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
1227  "Reference DepthToSpace: output type not supported");
+
1228 
+
1229  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
+
1230  "Reference DepthToSpace: input and output types are mismatched");
+
1231 
+
1232  return supported;
+
1233 }
-

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

+

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -1764,73 +1768,73 @@ Additional Inherited Members
-

Definition at line 1226 of file RefLayerSupport.cpp.

-
1232 {
-
1233  IgnoreUnused(descriptor);
-
1234  bool supported = true;
-
1235 
-
1236  // Define supported types.
-
1237  std::array<DataType,7> supportedTypes =
-
1238  {
-
1239  DataType::Float32,
-
1240  DataType::Float16,
-
1241  DataType::QAsymmS8,
-
1242  DataType::QAsymmU8,
-
1243  DataType::QSymmS8,
-
1244  DataType::QSymmS16
-
1245  };
-
1246 
-
1247  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
-
1248  "Reference DepthwiseConvolution2d: input is not a supported type.");
-
1249 
-
1250  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
1251  "Reference DepthwiseConvolution2d: output is not a supported type.");
-
1252 
-
1253  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
-
1254  "Reference DepthwiseConvolution2d: input and output types mismatched.");
+

Definition at line 1235 of file RefLayerSupport.cpp.

+
1241 {
+
1242  IgnoreUnused(descriptor);
+
1243  bool supported = true;
+
1244 
+
1245  // Define supported types.
+
1246  std::array<DataType,7> supportedTypes =
+
1247  {
+
1248  DataType::Float32,
+
1249  DataType::Float16,
+
1250  DataType::QAsymmS8,
+
1251  DataType::QAsymmU8,
+
1252  DataType::QSymmS8,
+
1253  DataType::QSymmS16
+
1254  };
1255 
-
1256  const DataType inputType = input.GetDataType();
-
1257  if (IsQuantized8BitType(inputType))
-
1258  {
-
1259  std::array<DataType, 3> supportedWeightTypes =
-
1260  {
-
1261  DataType::QAsymmS8,
-
1262  DataType::QAsymmU8,
-
1263  DataType::QSymmS8,
-
1264  };
-
1265 
-
1266  supported &= CheckSupportRule(TypeAnyOf(weights, supportedWeightTypes), reasonIfUnsupported,
-
1267  "Reference DepthwiseConvolution2d: weights type not supported for "
-
1268  "quantized input.");
-
1269  }
-
1270  else
-
1271  {
-
1272  supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
-
1273  "Reference DepthwiseConvolution2d: weights is not a supported type.");
+
1256  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
+
1257  "Reference DepthwiseConvolution2d: input is not a supported type.");
+
1258 
+
1259  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
1260  "Reference DepthwiseConvolution2d: output is not a supported type.");
+
1261 
+
1262  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
+
1263  "Reference DepthwiseConvolution2d: input and output types mismatched.");
+
1264 
+
1265  const DataType inputType = input.GetDataType();
+
1266  if (IsQuantized8BitType(inputType))
+
1267  {
+
1268  std::array<DataType, 3> supportedWeightTypes =
+
1269  {
+
1270  DataType::QAsymmS8,
+
1271  DataType::QAsymmU8,
+
1272  DataType::QSymmS8,
+
1273  };
1274 
-
1275  supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
-
1276  "Reference DepthwiseConvolution2d: input and weights types mismatched.");
-
1277  }
-
1278 
-
1279  if (biases.has_value())
+
1275  supported &= CheckSupportRule(TypeAnyOf(weights, supportedWeightTypes), reasonIfUnsupported,
+
1276  "Reference DepthwiseConvolution2d: weights type not supported for "
+
1277  "quantized input.");
+
1278  }
+
1279  else
1280  {
-
1281  std::array<DataType,4> biasesSupportedTypes =
-
1282  {
-
1283  DataType::Float32,
-
1284  DataType::Float16,
-
1285  DataType::Signed32
-
1286  };
-
1287  supported &= CheckSupportRule(TypeAnyOf(biases.value(), biasesSupportedTypes), reasonIfUnsupported,
-
1288  "Reference DepthwiseConvolution2d: biases is not a supported type.");
-
1289  }
-
1290 
-
1291  return supported;
-
1292 
-
1293 }
+
1281  supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
+
1282  "Reference DepthwiseConvolution2d: weights is not a supported type.");
+
1283 
+
1284  supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
+
1285  "Reference DepthwiseConvolution2d: input and weights types mismatched.");
+
1286  }
+
1287 
+
1288  if (biases.has_value())
+
1289  {
+
1290  std::array<DataType,4> biasesSupportedTypes =
+
1291  {
+
1292  DataType::Float32,
+
1293  DataType::Float16,
+
1294  DataType::Signed32
+
1295  };
+
1296  supported &= CheckSupportRule(TypeAnyOf(biases.value(), biasesSupportedTypes), reasonIfUnsupported,
+
1297  "Reference DepthwiseConvolution2d: biases is not a supported type.");
+
1298  }
+
1299 
+
1300  return supported;
+
1301 
+
1302 }
-

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, TensorInfo::GetDataType(), OptionalBase::has_value(), armnn::IgnoreUnused(), armnn::IsQuantized8BitType(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, armnn::QSymmS8, armnn::Signed32, and OptionalReferenceSwitch< std::is_reference< T >::value, T >::value().

+

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, TensorInfo::GetDataType(), OptionalBase::has_value(), armnn::IgnoreUnused(), armnn::IsQuantized8BitType(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, armnn::QSymmS8, armnn::Signed32, and OptionalReferenceSwitch< std::is_reference< T >::value, T >::value().

-

Referenced by RefLayerSupport::IsDilatedDepthwiseConvolutionSupported(), and RefLayerSupport::IsLayerSupported().

+

Referenced by RefLayerSupport::IsDilatedDepthwiseConvolutionSupported(), and RefLayerSupport::IsLayerSupported().

@@ -1866,40 +1870,40 @@ Additional Inherited Members
-

Definition at line 1295 of file RefLayerSupport.cpp.

-
1298 {
-
1299  bool supported = true;
-
1300 
-
1301  std::array<DataType,5> supportedInputTypes = {
-
1302  DataType::QAsymmS8,
-
1303  DataType::QAsymmU8,
-
1304  DataType::QSymmS8,
-
1305  DataType::QSymmS16,
-
1306  DataType::Float16
-
1307  };
-
1308 
-
1309  supported &= CheckSupportRule(TypeAnyOf(input, supportedInputTypes), reasonIfUnsupported,
-
1310  "Reference for Dequantize layer: input type not supported.");
-
1311 
-
1312  supported &= CheckSupportRule(TypeNotPerAxisQuantized(input), reasonIfUnsupported,
-
1313  "Reference for Dequantize layer: per-axis quantized input not supported.");
-
1314 
-
1315  std::array<DataType,3> supportedOutputTypes = {
-
1316  DataType::Float32,
-
1317  DataType::Float16
-
1318  };
-
1319 
-
1320  supported &= CheckSupportRule(TypeAnyOf(output, supportedOutputTypes), reasonIfUnsupported,
-
1321  "Reference for Dequantize layer: output type not supported.");
-
1322 
-
1323  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
-
1324  "Reference for Dequantize layer: input/output shapes have different num total "
-
1325  "elements.");
-
1326 
-
1327  return supported;
-
1328 }
+

Definition at line 1304 of file RefLayerSupport.cpp.

+
1307 {
+
1308  bool supported = true;
+
1309 
+
1310  std::array<DataType,5> supportedInputTypes = {
+
1311  DataType::QAsymmS8,
+
1312  DataType::QAsymmU8,
+
1313  DataType::QSymmS8,
+
1314  DataType::QSymmS16,
+
1315  DataType::Float16
+
1316  };
+
1317 
+
1318  supported &= CheckSupportRule(TypeAnyOf(input, supportedInputTypes), reasonIfUnsupported,
+
1319  "Reference for Dequantize layer: input type not supported.");
+
1320 
+
1321  supported &= CheckSupportRule(TypeNotPerAxisQuantized(input), reasonIfUnsupported,
+
1322  "Reference for Dequantize layer: per-axis quantized input not supported.");
+
1323 
+
1324  std::array<DataType,3> supportedOutputTypes = {
+
1325  DataType::Float32,
+
1326  DataType::Float16
+
1327  };
+
1328 
+
1329  supported &= CheckSupportRule(TypeAnyOf(output, supportedOutputTypes), reasonIfUnsupported,
+
1330  "Reference for Dequantize layer: output type not supported.");
+
1331 
+
1332  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
+
1333  "Reference for Dequantize layer: input/output shapes have different num total "
+
1334  "elements.");
+
1335 
+
1336  return supported;
+
1337 }
-

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::QSymmS8.

+

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::QSymmS8.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -1973,31 +1977,31 @@ Additional Inherited Members
-

Definition at line 1330 of file RefLayerSupport.cpp.

-
1339 {
-
1340  IgnoreUnused(anchors, detectionBoxes, detectionClasses, detectionScores, numDetections, descriptor);
-
1341 
-
1342  bool supported = true;
-
1343 
-
1344  std::array<DataType,6> supportedInputTypes =
-
1345  {
-
1346  DataType::Float32,
-
1347  DataType::Float16,
-
1348  DataType::QAsymmS8,
-
1349  DataType::QAsymmU8,
-
1350  DataType::QSymmS16
-
1351  };
+

Definition at line 1339 of file RefLayerSupport.cpp.

+
1348 {
+
1349  IgnoreUnused(anchors, detectionBoxes, detectionClasses, detectionScores, numDetections, descriptor);
+
1350 
+
1351  bool supported = true;
1352 
-
1353  supported &= CheckSupportRule(TypeAnyOf(boxEncodings, supportedInputTypes), reasonIfUnsupported,
-
1354  "Reference DetectionPostProcess: input 0 is not a supported type.");
-
1355 
-
1356  supported &= CheckSupportRule(TypeAnyOf(scores, supportedInputTypes), reasonIfUnsupported,
-
1357  "Reference DetectionPostProcess: input 1 is not a supported type.");
-
1358 
-
1359  return supported;
-
1360 }
+
1353  std::array<DataType,6> supportedInputTypes =
+
1354  {
+
1355  DataType::Float32,
+
1356  DataType::Float16,
+
1357  DataType::QAsymmS8,
+
1358  DataType::QAsymmU8,
+
1359  DataType::QSymmS16
+
1360  };
+
1361 
+
1362  supported &= CheckSupportRule(TypeAnyOf(boxEncodings, supportedInputTypes), reasonIfUnsupported,
+
1363  "Reference DetectionPostProcess: input 0 is not a supported type.");
+
1364 
+
1365  supported &= CheckSupportRule(TypeAnyOf(scores, supportedInputTypes), reasonIfUnsupported,
+
1366  "Reference DetectionPostProcess: input 1 is not a supported type.");
+
1367 
+
1368  return supported;
+
1369 }
-

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

+

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -2053,12 +2057,12 @@ Additional Inherited Members
-

Definition at line 1362 of file RefLayerSupport.cpp.

-
1368 {
-
1369  return IsDepthwiseConvolutionSupported(input, output, descriptor, weights, biases, reasonIfUnsupported);
-
1370 }
+

Definition at line 1371 of file RefLayerSupport.cpp.

+
1377 {
+
1378  return IsDepthwiseConvolutionSupported(input, output, descriptor, weights, biases, reasonIfUnsupported);
+
1379 }
-

References RefLayerSupport::IsDepthwiseConvolutionSupported().

+

References RefLayerSupport::IsDepthwiseConvolutionSupported().

@@ -2100,41 +2104,41 @@ Additional Inherited Members
-

Definition at line 1372 of file RefLayerSupport.cpp.

-
1376 {
-
1377  bool supported = true;
-
1378 
-
1379  std::array<DataType,7> supportedTypes = {
-
1380  DataType::Float32,
-
1381  DataType::Float16,
-
1382  DataType::QAsymmS8,
-
1383  DataType::QAsymmU8,
-
1384  DataType::QSymmS16,
-
1385  DataType::Signed32
-
1386  };
+

Definition at line 1381 of file RefLayerSupport.cpp.

+
1385 {
+
1386  bool supported = true;
1387 
-
1388  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
-
1389  "Reference division: input 0 is not a supported type.");
-
1390 
-
1391  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
-
1392  "Reference division: input 1 is not a supported type.");
-
1393 
-
1394  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
1395  "Reference division: output is not a supported type.");
+
1388  std::array<DataType,7> supportedTypes = {
+
1389  DataType::Float32,
+
1390  DataType::Float16,
+
1391  DataType::QAsymmS8,
+
1392  DataType::QAsymmU8,
+
1393  DataType::QSymmS16,
+
1394  DataType::Signed32
+
1395  };
1396 
-
1397  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
-
1398  "Reference division: input 0 and Input 1 types are mismatched");
+
1397  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
+
1398  "Reference division: input 0 is not a supported type.");
1399 
-
1400  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
-
1401  "Reference division: input and output types are mismatched");
+
1400  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
+
1401  "Reference division: input 1 is not a supported type.");
1402 
-
1403  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
-
1404  "Reference division: shapes are not suitable for implicit broadcast.");
+
1403  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
1404  "Reference division: output is not a supported type.");
1405 
-
1406  return supported;
-
1407 }
+
1406  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
+
1407  "Reference division: input 0 and Input 1 types are mismatched");
+
1408 
+
1409  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
+
1410  "Reference division: input and output types are mismatched");
+
1411 
+
1412  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
+
1413  "Reference division: shapes are not suitable for implicit broadcast.");
+
1414 
+
1415  return supported;
+
1416 }
-

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

+

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -2178,55 +2182,55 @@ Additional Inherited Members
-

Definition at line 1409 of file RefLayerSupport.cpp.

-
1413 {
-
1414  IgnoreUnused(descriptor);
-
1415 
-
1416  std::array<DataType, 7> supportedTypes =
-
1417  {
-
1418  DataType::Float32,
-
1419  DataType::Float16,
-
1420  DataType::QAsymmS8,
-
1421  DataType::QAsymmU8,
-
1422  DataType::QSymmS16,
-
1423  DataType::Signed32
-
1424  };
-
1425 
-
1426  std::array<DataType, 1> logicalSupportedTypes =
-
1427  {
-
1428  DataType::Boolean
-
1429  };
-
1430 
-
1431  bool supported = true;
-
1432 
-
1433  if (descriptor.m_Operation == UnaryOperation::LogicalNot)
-
1434  {
-
1435  supported &= CheckSupportRule(TypeAnyOf(input, logicalSupportedTypes), reasonIfUnsupported,
-
1436  "Reference elementwise unary: input type not supported");
-
1437 
-
1438  supported &= CheckSupportRule(TypeAnyOf(output, logicalSupportedTypes), reasonIfUnsupported,
-
1439  "Reference elementwise unary: output type not supported");
-
1440  }
-
1441  else
-
1442  {
-
1443  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
-
1444  "Reference elementwise unary: input type not supported");
-
1445 
-
1446  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
1447  "Reference elementwise unary: output type not supported");
-
1448  }
-
1449 
-
1450  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
-
1451  "Reference elementwise unary: input and output types not matching");
-
1452 
-
1453  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
-
1454  "Reference elementwise unary: input and output shapes"
-
1455  "have different number of total elements");
-
1456 
-
1457  return supported;
-
1458 }
+

Definition at line 1418 of file RefLayerSupport.cpp.

+
1422 {
+
1423  IgnoreUnused(descriptor);
+
1424 
+
1425  std::array<DataType, 7> supportedTypes =
+
1426  {
+
1427  DataType::Float32,
+
1428  DataType::Float16,
+
1429  DataType::QAsymmS8,
+
1430  DataType::QAsymmU8,
+
1431  DataType::QSymmS16,
+
1432  DataType::Signed32
+
1433  };
+
1434 
+
1435  std::array<DataType, 1> logicalSupportedTypes =
+
1436  {
+
1437  DataType::Boolean
+
1438  };
+
1439 
+
1440  bool supported = true;
+
1441 
+
1442  if (descriptor.m_Operation == UnaryOperation::LogicalNot)
+
1443  {
+
1444  supported &= CheckSupportRule(TypeAnyOf(input, logicalSupportedTypes), reasonIfUnsupported,
+
1445  "Reference elementwise unary: input type not supported");
+
1446 
+
1447  supported &= CheckSupportRule(TypeAnyOf(output, logicalSupportedTypes), reasonIfUnsupported,
+
1448  "Reference elementwise unary: output type not supported");
+
1449  }
+
1450  else
+
1451  {
+
1452  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
+
1453  "Reference elementwise unary: input type not supported");
+
1454 
+
1455  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
1456  "Reference elementwise unary: output type not supported");
+
1457  }
+
1458 
+
1459  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
+
1460  "Reference elementwise unary: input and output types not matching");
+
1461 
+
1462  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
+
1463  "Reference elementwise unary: input and output shapes"
+
1464  "have different number of total elements");
+
1465 
+
1466  return supported;
+
1467 }
-

References armnn::Boolean, armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::LogicalNot, ElementwiseUnaryDescriptor::m_Operation, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

+

References armnn::Boolean, armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::LogicalNot, ElementwiseUnaryDescriptor::m_Operation, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -2264,23 +2268,23 @@ Additional Inherited Members
-

Definition at line 1460 of file RefLayerSupport.cpp.

-
1463 {
-
1464  IgnoreUnused(descriptor);
-
1465  bool supported = true;
-
1466 
-
1467  std::array<DataType,1> supportedTypes =
-
1468  {
-
1469  DataType::Float32
-
1470  };
-
1471 
-
1472  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
-
1473  "Reference fake quantization: input type not supported.");
-
1474 
-
1475  return supported;
-
1476 }
+

Definition at line 1469 of file RefLayerSupport.cpp.

+
1472 {
+
1473  IgnoreUnused(descriptor);
+
1474  bool supported = true;
+
1475 
+
1476  std::array<DataType,1> supportedTypes =
+
1477  {
+
1478  DataType::Float32
+
1479  };
+
1480 
+
1481  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
+
1482  "Reference fake quantization: input type not supported.");
+
1483 
+
1484  return supported;
+
1485 }
-

References armnn::CheckSupportRule(), armnn::Float32, and armnn::IgnoreUnused().

+

References armnn::CheckSupportRule(), armnn::Float32, and armnn::IgnoreUnused().

Referenced by RefLayerSupport::IsLayerSupported().

@@ -2324,29 +2328,29 @@ Additional Inherited Members
-

Definition at line 1478 of file RefLayerSupport.cpp.

-
1482 {
-
1483  IgnoreUnused(descriptor);
-
1484  IgnoreUnused(output);
-
1485 
-
1486  bool supported = true;
-
1487 
-
1488  std::array<DataType,3> supportedTypes =
-
1489  {
-
1490  DataType::Float32,
-
1491  DataType::Float16,
-
1492  DataType::Signed32
-
1493  };
+

Definition at line 1487 of file RefLayerSupport.cpp.

+
1491 {
+
1492  IgnoreUnused(descriptor);
+
1493  IgnoreUnused(output);
1494 
-
1495  supported &= CheckSupportRule(TypeIs(input, DataType::Signed32), reasonIfUnsupported,
-
1496  "Reference Fill: input type not supported.");
-
1497 
-
1498  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
1499  "Reference Fill: output type not supported.");
-
1500  return supported;
-
1501 }
+
1495  bool supported = true;
+
1496 
+
1497  std::array<DataType,3> supportedTypes =
+
1498  {
+
1499  DataType::Float32,
+
1500  DataType::Float16,
+
1501  DataType::Signed32
+
1502  };
+
1503 
+
1504  supported &= CheckSupportRule(TypeIs(input, DataType::Signed32), reasonIfUnsupported,
+
1505  "Reference Fill: input type not supported.");
+
1506 
+
1507  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
1508  "Reference Fill: output type not supported.");
+
1509  return supported;
+
1510 }
-

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), and armnn::Signed32.

+

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), and armnn::Signed32.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -2384,27 +2388,27 @@ Additional Inherited Members
-

Definition at line 1503 of file RefLayerSupport.cpp.

-
1506 {
-
1507  IgnoreUnused(output);
-
1508  bool supported = true;
-
1509 
-
1510  std::array<DataType,3> supportedTypes =
-
1511  {
-
1512  DataType::Float32,
-
1513  DataType::Float16
-
1514  };
-
1515 
-
1516  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
-
1517  "Reference Floor: input type not supported.");
+

Definition at line 1512 of file RefLayerSupport.cpp.

+
1515 {
+
1516  IgnoreUnused(output);
+
1517  bool supported = true;
1518 
-
1519  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
1520  "Reference Floor: output type not supported.");
-
1521 
-
1522  return supported;
-
1523 }
+
1519  std::array<DataType,3> supportedTypes =
+
1520  {
+
1521  DataType::Float32,
+
1522  DataType::Float16
+
1523  };
+
1524 
+
1525  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
+
1526  "Reference Floor: input type not supported.");
+
1527 
+
1528  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
1529  "Reference Floor: output type not supported.");
+
1530 
+
1531  return supported;
+
1532 }
-

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, and armnn::IgnoreUnused().

+

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, and armnn::IgnoreUnused().

Referenced by RefLayerSupport::IsLayerSupported().

@@ -2460,68 +2464,68 @@ Additional Inherited Members
-

Definition at line 1525 of file RefLayerSupport.cpp.

-
1531 {
-
1532  bool supported = true;
-
1533 
-
1534  // Define supported types.
-
1535  std::array<DataType,6> supportedTypes =
-
1536  {
-
1537  DataType::Float32,
-
1538  DataType::Float16,
-
1539  DataType::QAsymmS8,
-
1540  DataType::QAsymmU8,
-
1541  DataType::QSymmS16
-
1542  };
-
1543 
-
1544  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
-
1545  "Reference Fully Connected: input type not supported.");
-
1546 
-
1547  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
1548  "Reference Fully Connected: output type not supported.");
-
1549 
-
1550  supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
-
1551  "Reference Fully Connected: weights type not supported.");
+

Definition at line 1534 of file RefLayerSupport.cpp.

+
1540 {
+
1541  bool supported = true;
+
1542 
+
1543  // Define supported types.
+
1544  std::array<DataType,6> supportedTypes =
+
1545  {
+
1546  DataType::Float32,
+
1547  DataType::Float16,
+
1548  DataType::QAsymmS8,
+
1549  DataType::QAsymmU8,
+
1550  DataType::QSymmS16
+
1551  };
1552 
-
1553  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
-
1554  "Reference Fully Connected: input and output types mismatched.");
+
1553  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
+
1554  "Reference Fully Connected: input type not supported.");
1555 
-
1556  supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
-
1557  "Reference Fully Connected: weights is not a supported type.");
+
1556  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
1557  "Reference Fully Connected: output type not supported.");
1558 
-
1559  supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
-
1560  "Reference Fully Connected: input and weights types mismatched.");
+
1559  supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
+
1560  "Reference Fully Connected: weights type not supported.");
1561 
-
1562  if (descriptor.m_BiasEnabled)
-
1563  {
-
1564  // Defined supported types for bias
-
1565  std::array<DataType, 5>
-
1566  supportedBiasTypes =
-
1567  {
-
1568  DataType::Float32,
-
1569  DataType::Float16,
-
1570  DataType::Signed32,
-
1571  DataType::QAsymmS8
-
1572  };
-
1573 
-
1574  supported &= CheckSupportRule(TypeAnyOf(biases, supportedBiasTypes), reasonIfUnsupported,
-
1575  "Reference Fully Connected: bias type not supported.");
-
1576 
-
1577  supported &= CheckSupportRule(BiasAndWeightsTypesMatch(biases, weights), reasonIfUnsupported,
-
1578  "Reference Fully Connected: bias and weight types mismatch.");
-
1579 
-
1580  supported &= CheckSupportRule(BiasAndWeightsTypesCompatible(weights, supportedBiasTypes), reasonIfUnsupported,
-
1581  "Reference Fully Connected: bias type inferred from weights is incompatible.");
+
1562  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
+
1563  "Reference Fully Connected: input and output types mismatched.");
+
1564 
+
1565  supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
+
1566  "Reference Fully Connected: weights is not a supported type.");
+
1567 
+
1568  supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
+
1569  "Reference Fully Connected: input and weights types mismatched.");
+
1570 
+
1571  if (descriptor.m_BiasEnabled)
+
1572  {
+
1573  // Defined supported types for bias
+
1574  std::array<DataType, 5>
+
1575  supportedBiasTypes =
+
1576  {
+
1577  DataType::Float32,
+
1578  DataType::Float16,
+
1579  DataType::Signed32,
+
1580  DataType::QAsymmS8
+
1581  };
1582 
-
1583  supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(biases, 1U), reasonIfUnsupported,
-
1584  "Reference Fully Connected: bias must have 1 dimension.");
+
1583  supported &= CheckSupportRule(TypeAnyOf(biases, supportedBiasTypes), reasonIfUnsupported,
+
1584  "Reference Fully Connected: bias type not supported.");
1585 
-
1586  }
-
1587 
-
1588  return supported;
-
1589 }
+
1586  supported &= CheckSupportRule(BiasAndWeightsTypesMatch(biases, weights), reasonIfUnsupported,
+
1587  "Reference Fully Connected: bias and weight types mismatch.");
+
1588 
+
1589  supported &= CheckSupportRule(BiasAndWeightsTypesCompatible(weights, supportedBiasTypes), reasonIfUnsupported,
+
1590  "Reference Fully Connected: bias type inferred from weights is incompatible.");
+
1591 
+
1592  supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(biases, 1U), reasonIfUnsupported,
+
1593  "Reference Fully Connected: bias must have 1 dimension.");
+
1594 
+
1595  }
+
1596 
+
1597  return supported;
+
1598 }
-

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, FullyConnectedDescriptor::m_BiasEnabled, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

+

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, FullyConnectedDescriptor::m_BiasEnabled, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -2565,35 +2569,35 @@ Additional Inherited Members
-

Definition at line 1591 of file RefLayerSupport.cpp.

-
1595 {
-
1596  bool supported = true;
-
1597  std::array<DataType,7> supportedTypes =
-
1598  {
-
1599  DataType::Float32,
-
1600  DataType::Float16,
-
1601  DataType::QAsymmS8,
-
1602  DataType::QAsymmU8,
-
1603  DataType::QSymmS16,
-
1604  DataType::Signed32
-
1605  };
-
1606 
-
1607  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
-
1608  "Reference GatherNd: input type not supported");
-
1609 
-
1610  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
1611  "Reference GatherNd: output type not supported");
-
1612 
-
1613  supported &= CheckSupportRule(TypeIs(input1, DataType::Signed32), reasonIfUnsupported,
-
1614  "Reference GatherNd: indices (input1) type not supported");
+

Definition at line 1600 of file RefLayerSupport.cpp.

+
1604 {
+
1605  bool supported = true;
+
1606  std::array<DataType,7> supportedTypes =
+
1607  {
+
1608  DataType::Float32,
+
1609  DataType::Float16,
+
1610  DataType::QAsymmS8,
+
1611  DataType::QAsymmU8,
+
1612  DataType::QSymmS16,
+
1613  DataType::Signed32
+
1614  };
1615 
-
1616  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
-
1617  "Reference GatherNd: input and output types not matching");
+
1616  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
+
1617  "Reference GatherNd: input type not supported");
1618 
-
1619  return supported;
-
1620 }
+
1619  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
1620  "Reference GatherNd: output type not supported");
+
1621 
+
1622  supported &= CheckSupportRule(TypeIs(input1, DataType::Signed32), reasonIfUnsupported,
+
1623  "Reference GatherNd: indices (input1) type not supported");
+
1624 
+
1625  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
+
1626  "Reference GatherNd: input and output types not matching");
+
1627 
+
1628  return supported;
+
1629 }
-

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

+

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -2643,36 +2647,36 @@ Additional Inherited Members
-

Definition at line 1622 of file RefLayerSupport.cpp.

-
1627 {
-
1628  bool supported = true;
-
1629  std::array<DataType,7> supportedTypes =
-
1630  {
-
1631  DataType::Float32,
-
1632  DataType::Float16,
-
1633  DataType::QAsymmS8,
-
1634  DataType::QAsymmU8,
-
1635  DataType::QSymmS16,
-
1636  DataType::Signed32
-
1637  };
-
1638 
-
1639  IgnoreUnused(descriptor);
-
1640  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
-
1641  "Reference Gather: input type not supported");
-
1642 
-
1643  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
1644  "Reference Gather: output type not supported");
-
1645 
-
1646  supported &= CheckSupportRule(TypeIs(input1, DataType::Signed32), reasonIfUnsupported,
-
1647  "Reference Gather: indices (input1) type not supported");
-
1648 
-
1649  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
-
1650  "Reference Gather: input and output types not matching");
+

Definition at line 1631 of file RefLayerSupport.cpp.

+
1636 {
+
1637  bool supported = true;
+
1638  std::array<DataType,7> supportedTypes =
+
1639  {
+
1640  DataType::Float32,
+
1641  DataType::Float16,
+
1642  DataType::QAsymmS8,
+
1643  DataType::QAsymmU8,
+
1644  DataType::QSymmS16,
+
1645  DataType::Signed32
+
1646  };
+
1647 
+
1648  IgnoreUnused(descriptor);
+
1649  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
+
1650  "Reference Gather: input type not supported");
1651 
-
1652  return supported;
-
1653 }
+
1652  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
1653  "Reference Gather: output type not supported");
+
1654 
+
1655  supported &= CheckSupportRule(TypeIs(input1, DataType::Signed32), reasonIfUnsupported,
+
1656  "Reference Gather: indices (input1) type not supported");
+
1657 
+
1658  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
+
1659  "Reference Gather: input and output types not matching");
+
1660 
+
1661  return supported;
+
1662 }
-

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

+

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -2704,10 +2708,10 @@ Additional Inherited Members
-

Definition at line 1655 of file RefLayerSupport.cpp.

-
1657 {
-
1658  return true;
-
1659 }
+

Definition at line 1664 of file RefLayerSupport.cpp.

+
1666 {
+
1667  return true;
+
1668 }

Referenced by RefLayerSupport::IsLayerSupported().

@@ -2751,35 +2755,35 @@ Additional Inherited Members
-

Definition at line 1661 of file RefLayerSupport.cpp.

-
1665 {
-
1666  IgnoreUnused(descriptor);
-
1667  // Define supported types
-
1668  std::array<DataType, 3> supportedTypes =
-
1669  {
-
1670  DataType::Float32,
-
1671  DataType::Float16
-
1672  };
-
1673 
-
1674  bool supported = true;
-
1675 
-
1676  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
-
1677  "Reference Instance Normalization: input type not supported.");
-
1678 
-
1679  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
1680  "Reference Instance Normalization: output type not supported.");
-
1681 
-
1682  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
-
1683  "Reference Instance Normalization: input and output types mismatched.");
+

Definition at line 1670 of file RefLayerSupport.cpp.

+
1674 {
+
1675  IgnoreUnused(descriptor);
+
1676  // Define supported types
+
1677  std::array<DataType, 3> supportedTypes =
+
1678  {
+
1679  DataType::Float32,
+
1680  DataType::Float16
+
1681  };
+
1682 
+
1683  bool supported = true;
1684 
-
1685  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
-
1686  "Reference Instance Normalization: input and output shapes have different "
-
1687  "num total elements.");
-
1688 
-
1689  return supported;
-
1690 }
+
1685  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
+
1686  "Reference Instance Normalization: input type not supported.");
+
1687 
+
1688  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
1689  "Reference Instance Normalization: output type not supported.");
+
1690 
+
1691  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
+
1692  "Reference Instance Normalization: input and output types mismatched.");
+
1693 
+
1694  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
+
1695  "Reference Instance Normalization: input and output shapes have different "
+
1696  "num total elements.");
+
1697 
+
1698  return supported;
+
1699 }
-

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, and armnn::IgnoreUnused().

+

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, and armnn::IgnoreUnused().

Referenced by RefLayerSupport::IsLayerSupported().

@@ -2823,38 +2827,38 @@ Additional Inherited Members
-

Definition at line 1692 of file RefLayerSupport.cpp.

-
1696 {
-
1697  IgnoreUnused(descriptor);
-
1698  // Define supported types
-
1699  std::array<DataType, 6> supportedTypes =
-
1700  {
-
1701  DataType::Float32,
-
1702  DataType::Float16,
-
1703  DataType::QAsymmS8,
-
1704  DataType::QAsymmU8,
-
1705  DataType::QSymmS16
-
1706  };
-
1707 
-
1708  bool supported = true;
-
1709 
-
1710  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
-
1711  "Reference L2normalization: input type not supported.");
-
1712 
-
1713  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
1714  "Reference L2normalization: output type not supported.");
-
1715 
-
1716  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
-
1717  "Reference L2normalization: input and output types mismatched.");
+

Definition at line 1701 of file RefLayerSupport.cpp.

+
1705 {
+
1706  IgnoreUnused(descriptor);
+
1707  // Define supported types
+
1708  std::array<DataType, 6> supportedTypes =
+
1709  {
+
1710  DataType::Float32,
+
1711  DataType::Float16,
+
1712  DataType::QAsymmS8,
+
1713  DataType::QAsymmU8,
+
1714  DataType::QSymmS16
+
1715  };
+
1716 
+
1717  bool supported = true;
1718 
-
1719  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
-
1720  "Reference L2normalization: input and output shapes have different "
-
1721  "num total elements.");
-
1722 
-
1723  return supported;
-
1724 }
+
1719  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
+
1720  "Reference L2normalization: input type not supported.");
+
1721 
+
1722  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
1723  "Reference L2normalization: output type not supported.");
+
1724 
+
1725  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
+
1726  "Reference L2normalization: input and output types mismatched.");
+
1727 
+
1728  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
+
1729  "Reference L2normalization: input and output shapes have different "
+
1730  "num total elements.");
+
1731 
+
1732  return supported;
+
1733 }
-

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

+

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -3215,201 +3219,208 @@ Additional Inherited Members
356  infos[1],
357  *(PolymorphicDowncast<const ReduceDescriptor*>(&descriptor)),
358  reasonIfUnsupported);
-
359  case LayerType::Slice:
-
360  return IsSliceSupported(infos[0],
-
361  infos[1],
-
362  *(PolymorphicDowncast<const SliceDescriptor*>(&descriptor)),
-
363  reasonIfUnsupported);
-
364  case LayerType::Softmax:
-
365  return IsSoftmaxSupported(infos[0],
-
366  infos[1],
-
367  *(PolymorphicDowncast<const SoftmaxDescriptor*>(&descriptor)),
-
368  reasonIfUnsupported);
-
369  case LayerType::SpaceToBatchNd:
-
370  return IsSpaceToBatchNdSupported(infos[0],
-
371  infos[1],
-
372  *(PolymorphicDowncast<const SpaceToBatchNdDescriptor*>(&descriptor)),
-
373  reasonIfUnsupported);
-
374  case LayerType::SpaceToDepth:
-
375  return IsSpaceToDepthSupported(infos[0],
-
376  infos[1],
-
377  *(PolymorphicDowncast<const SpaceToDepthDescriptor*>(&descriptor)),
-
378  reasonIfUnsupported);
-
379  case LayerType::Splitter:
-
380  {
-
381  std::vector<TensorInfo> outputInfos;
-
382  for (uint32_t i = 1; i < infos.size(); i++)
-
383  {
-
384  outputInfos.push_back(infos[i]);
-
385  }
-
386  return IsSplitterSupported(infos[0],
-
387  {outputInfos.begin(), outputInfos.end()},
-
388  *(PolymorphicDowncast<const ViewsDescriptor*>(&descriptor)),
-
389  reasonIfUnsupported);
-
390  }
-
391  case LayerType::Stack:
-
392  {
-
393  std::vector<const TensorInfo*> inputInfos;
-
394  for (uint32_t i = 0; i < infos.size() - 1; i++)
-
395  {
-
396  inputInfos.push_back(&infos[i]);
-
397  }
-
398  return IsStackSupported(inputInfos,
-
399  infos[infos.size() - 1],
-
400  *(PolymorphicDowncast<const StackDescriptor*>(&descriptor)),
-
401  reasonIfUnsupported);
-
402  }
-
403  case LayerType::StridedSlice:
-
404  return IsStridedSliceSupported(infos[0],
-
405  infos[1],
-
406  *(PolymorphicDowncast<const StridedSliceDescriptor*>(&descriptor)),
-
407  reasonIfUnsupported);
-
408  case LayerType::Subtraction:
-
409  return IsSubtractionSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
-
410  case LayerType::Tile:
-
411  return IsTileSupported(infos[0],
-
412  infos[1],
-
413  *(PolymorphicDowncast<const TileDescriptor*>(&descriptor)),
-
414  reasonIfUnsupported);
-
415  case LayerType::Transpose:
-
416  return IsTransposeSupported(infos[0],
-
417  infos[1],
-
418  *(PolymorphicDowncast<const TransposeDescriptor*>(&descriptor)),
-
419  reasonIfUnsupported);
-
420  case LayerType::TransposeConvolution2d:
-
421  {
-
422  if (infos.size() != 4)
-
423  {
-
424  throw InvalidArgumentException("Invalid number of TransposeConvolution2d TensorInfos. "
-
425  "TensorInfos should be of format: {input, output, weights, biases}.");
-
426  }
-
427 
-
428  auto desc = *(PolymorphicDowncast<const TransposeConvolution2dDescriptor*>(&descriptor));
-
429  if (infos[3] == TensorInfo())
+
359  case LayerType::ScatterNd:
+
360  return IsScatterNdSupported(infos[0],
+
361  infos[1],
+
362  infos[2],
+
363  infos[3],
+
364  *(PolymorphicDowncast<const ScatterNdDescriptor*>(&descriptor)),
+
365  reasonIfUnsupported);
+
366  case LayerType::Slice:
+
367  return IsSliceSupported(infos[0],
+
368  infos[1],
+
369  *(PolymorphicDowncast<const SliceDescriptor*>(&descriptor)),
+
370  reasonIfUnsupported);
+
371  case LayerType::Softmax:
+
372  return IsSoftmaxSupported(infos[0],
+
373  infos[1],
+
374  *(PolymorphicDowncast<const SoftmaxDescriptor*>(&descriptor)),
+
375  reasonIfUnsupported);
+
376  case LayerType::SpaceToBatchNd:
+
377  return IsSpaceToBatchNdSupported(infos[0],
+
378  infos[1],
+
379  *(PolymorphicDowncast<const SpaceToBatchNdDescriptor*>(&descriptor)),
+
380  reasonIfUnsupported);
+
381  case LayerType::SpaceToDepth:
+
382  return IsSpaceToDepthSupported(infos[0],
+
383  infos[1],
+
384  *(PolymorphicDowncast<const SpaceToDepthDescriptor*>(&descriptor)),
+
385  reasonIfUnsupported);
+
386  case LayerType::Splitter:
+
387  {
+
388  std::vector<TensorInfo> outputInfos;
+
389  for (uint32_t i = 1; i < infos.size(); i++)
+
390  {
+
391  outputInfos.push_back(infos[i]);
+
392  }
+
393  return IsSplitterSupported(infos[0],
+
394  {outputInfos.begin(), outputInfos.end()},
+
395  *(PolymorphicDowncast<const ViewsDescriptor*>(&descriptor)),
+
396  reasonIfUnsupported);
+
397  }
+
398  case LayerType::Stack:
+
399  {
+
400  std::vector<const TensorInfo*> inputInfos;
+
401  for (uint32_t i = 0; i < infos.size() - 1; i++)
+
402  {
+
403  inputInfos.push_back(&infos[i]);
+
404  }
+
405  return IsStackSupported(inputInfos,
+
406  infos[infos.size() - 1],
+
407  *(PolymorphicDowncast<const StackDescriptor*>(&descriptor)),
+
408  reasonIfUnsupported);
+
409  }
+
410  case LayerType::StridedSlice:
+
411  return IsStridedSliceSupported(infos[0],
+
412  infos[1],
+
413  *(PolymorphicDowncast<const StridedSliceDescriptor*>(&descriptor)),
+
414  reasonIfUnsupported);
+
415  case LayerType::Subtraction:
+
416  return IsSubtractionSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
+
417  case LayerType::Tile:
+
418  return IsTileSupported(infos[0],
+
419  infos[1],
+
420  *(PolymorphicDowncast<const TileDescriptor*>(&descriptor)),
+
421  reasonIfUnsupported);
+
422  case LayerType::Transpose:
+
423  return IsTransposeSupported(infos[0],
+
424  infos[1],
+
425  *(PolymorphicDowncast<const TransposeDescriptor*>(&descriptor)),
+
426  reasonIfUnsupported);
+
427  case LayerType::TransposeConvolution2d:
+
428  {
+
429  if (infos.size() != 4)
430  {
-
431  return IsTransposeConvolution2dSupported(infos[0],
-
432  infos[1],
-
433  desc,
-
434  infos[2],
-
435  EmptyOptional(),
-
436  reasonIfUnsupported);
-
437  }
-
438  else
-
439  {
-
440  return IsTransposeConvolution2dSupported(infos[0],
-
441  infos[1],
-
442  desc,
-
443  infos[2],
-
444  infos[3],
-
445  reasonIfUnsupported);
-
446  }
-
447  }
-
448  case LayerType::Cast:
-
449  return IsCastSupported(infos[0], infos[1], reasonIfUnsupported);
-
450  case LayerType::ChannelShuffle:
-
451  return IsChannelShuffleSupported(infos[0],
-
452  infos[1],
-
453  *(PolymorphicDowncast<const ChannelShuffleDescriptor*>(&descriptor)),
-
454  reasonIfUnsupported);
-
455  case LayerType::Convolution3d:
-
456  {
-
457  if (infos.size() != 4)
-
458  {
-
459  throw InvalidArgumentException("Invalid number of Convolution3d TensorInfos. "
-
460  "TensorInfos should be of format: {input, output, weights, biases}.");
-
461  }
-
462 
-
463  auto desc = *(PolymorphicDowncast<const Convolution3dDescriptor*>(&descriptor));
-
464  if (infos[3] == TensorInfo())
+
431  throw InvalidArgumentException("Invalid number of TransposeConvolution2d TensorInfos. "
+
432  "TensorInfos should be of format: {input, output, weights, biases}.");
+
433  }
+
434 
+
435  auto desc = *(PolymorphicDowncast<const TransposeConvolution2dDescriptor*>(&descriptor));
+
436  if (infos[3] == TensorInfo())
+
437  {
+
438  return IsTransposeConvolution2dSupported(infos[0],
+
439  infos[1],
+
440  desc,
+
441  infos[2],
+
442  EmptyOptional(),
+
443  reasonIfUnsupported);
+
444  }
+
445  else
+
446  {
+
447  return IsTransposeConvolution2dSupported(infos[0],
+
448  infos[1],
+
449  desc,
+
450  infos[2],
+
451  infos[3],
+
452  reasonIfUnsupported);
+
453  }
+
454  }
+
455  case LayerType::Cast:
+
456  return IsCastSupported(infos[0], infos[1], reasonIfUnsupported);
+
457  case LayerType::ChannelShuffle:
+
458  return IsChannelShuffleSupported(infos[0],
+
459  infos[1],
+
460  *(PolymorphicDowncast<const ChannelShuffleDescriptor*>(&descriptor)),
+
461  reasonIfUnsupported);
+
462  case LayerType::Convolution3d:
+
463  {
+
464  if (infos.size() != 4)
465  {
-
466  return IsConvolution3dSupported(infos[0],
-
467  infos[1],
-
468  desc,
-
469  infos[2],
-
470  EmptyOptional(),
-
471  reasonIfUnsupported);
-
472  }
-
473  else
-
474  {
-
475  return IsConvolution3dSupported(infos[0],
-
476  infos[1],
-
477  desc,
-
478  infos[2],
-
479  infos[3],
-
480  reasonIfUnsupported);
-
481  }
-
482  }
-
483  case LayerType::Debug:
-
484  return IsDebugSupported(infos[0], infos[1], reasonIfUnsupported);
-
485  case LayerType::DetectionPostProcess:
-
486  return IsDetectionPostProcessSupported(infos[0],
-
487  infos[1],
-
488  infos[2],
-
489  infos[3],
-
490  infos[4],
-
491  infos[5],
-
492  infos[6],
-
493  *(PolymorphicDowncast<const DetectionPostProcessDescriptor*>
-
494  (&descriptor)),
-
495  reasonIfUnsupported);
-
496  case LayerType::FakeQuantization:
-
497  return IsFakeQuantizationSupported(infos[0],
-
498  *(PolymorphicDowncast<const FakeQuantizationDescriptor*>(&descriptor)),
-
499  reasonIfUnsupported);
-
500  case LayerType::MemCopy:
-
501  return IsMemCopySupported(infos[0], infos[1], reasonIfUnsupported);
-
502  case LayerType::Rank:
-
503  return IsRankSupported(infos[0], infos[1], reasonIfUnsupported);
-
504  case LayerType::Shape:
-
505  return IsShapeSupported(infos[0], infos[1], reasonIfUnsupported);
-
506  case LayerType::UnidirectionalSequenceLstm:
-
507  {
-
508  if (infos.size() != 6)
-
509  {
-
510  throw InvalidArgumentException("Invalid number of UnidirectionalSequenceLstm TensorInfos. TensorInfos "
-
511  "should be of format: {input, outputStateIn, cellStateIn, "
-
512  "hiddenStateOutputVal, cellStateOutputVal, output}");
-
513  }
-
514  auto desc = *(PolymorphicDowncast<const UnidirectionalSequenceLstmDescriptor*>(&descriptor));
-
515  return IsUnidirectionalSequenceLstmSupported(infos[0],
-
516  infos[1],
-
517  infos[2],
-
518  infos[3],
-
519  infos[4],
-
520  infos[5],
-
521  desc,
-
522  lstmParamsInfo.value(),
-
523  reasonIfUnsupported);
-
524  }
-
525  case LayerType::Pooling3d:
-
526  return IsPooling3dSupported(infos[0],
-
527  infos[1],
-
528  *(PolymorphicDowncast<const Pooling3dDescriptor*>(&descriptor)),
-
529  reasonIfUnsupported);
-
530  case LayerType::Map:
-
531  return true;
-
532  case LayerType::Unmap:
-
533  return true;
-
534  case LayerType::MemImport:
-
535  return LayerSupportBase::IsMemImportSupported(infos[0], infos[1], reasonIfUnsupported);
-
536  case LayerType::Merge:
-
537  return LayerSupportBase::IsMergeSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
-
538  case LayerType::QuantizedLstm:
-
539  return LayerSupportBase::IsQuantizedLstmSupported(infos[0],
-
540  infos[1],
-
541  infos[2],
-
542  infos[3],
-
543  infos[4],
-
544  quantizedLstmInputParamsInfo.value(),
-
545  reasonIfUnsupported);
-
546  default:
-
547  // layers not supported in reference by default:
-
548  // precompiled, standin, switch, fused
-
549  return false;
-
550  }
-
551 }
+
466  throw InvalidArgumentException("Invalid number of Convolution3d TensorInfos. "
+
467  "TensorInfos should be of format: {input, output, weights, biases}.");
+
468  }
+
469 
+
470  auto desc = *(PolymorphicDowncast<const Convolution3dDescriptor*>(&descriptor));
+
471  if (infos[3] == TensorInfo())
+
472  {
+
473  return IsConvolution3dSupported(infos[0],
+
474  infos[1],
+
475  desc,
+
476  infos[2],
+
477  EmptyOptional(),
+
478  reasonIfUnsupported);
+
479  }
+
480  else
+
481  {
+
482  return IsConvolution3dSupported(infos[0],
+
483  infos[1],
+
484  desc,
+
485  infos[2],
+
486  infos[3],
+
487  reasonIfUnsupported);
+
488  }
+
489  }
+
490  case LayerType::Debug:
+
491  return IsDebugSupported(infos[0], infos[1], reasonIfUnsupported);
+
492  case LayerType::DetectionPostProcess:
+
493  return IsDetectionPostProcessSupported(infos[0],
+
494  infos[1],
+
495  infos[2],
+
496  infos[3],
+
497  infos[4],
+
498  infos[5],
+
499  infos[6],
+
500  *(PolymorphicDowncast<const DetectionPostProcessDescriptor*>
+
501  (&descriptor)),
+
502  reasonIfUnsupported);
+
503  case LayerType::FakeQuantization:
+
504  return IsFakeQuantizationSupported(infos[0],
+
505  *(PolymorphicDowncast<const FakeQuantizationDescriptor*>(&descriptor)),
+
506  reasonIfUnsupported);
+
507  case LayerType::MemCopy:
+
508  return IsMemCopySupported(infos[0], infos[1], reasonIfUnsupported);
+
509  case LayerType::Rank:
+
510  return IsRankSupported(infos[0], infos[1], reasonIfUnsupported);
+
511  case LayerType::Shape:
+
512  return IsShapeSupported(infos[0], infos[1], reasonIfUnsupported);
+
513  case LayerType::UnidirectionalSequenceLstm:
+
514  {
+
515  if (infos.size() != 6)
+
516  {
+
517  throw InvalidArgumentException("Invalid number of UnidirectionalSequenceLstm TensorInfos. TensorInfos "
+
518  "should be of format: {input, outputStateIn, cellStateIn, "
+
519  "hiddenStateOutputVal, cellStateOutputVal, output}");
+
520  }
+
521  auto desc = *(PolymorphicDowncast<const UnidirectionalSequenceLstmDescriptor*>(&descriptor));
+
522  return IsUnidirectionalSequenceLstmSupported(infos[0],
+
523  infos[1],
+
524  infos[2],
+
525  infos[3],
+
526  infos[4],
+
527  infos[5],
+
528  desc,
+
529  lstmParamsInfo.value(),
+
530  reasonIfUnsupported);
+
531  }
+
532  case LayerType::Pooling3d:
+
533  return IsPooling3dSupported(infos[0],
+
534  infos[1],
+
535  *(PolymorphicDowncast<const Pooling3dDescriptor*>(&descriptor)),
+
536  reasonIfUnsupported);
+
537  case LayerType::Map:
+
538  return true;
+
539  case LayerType::Unmap:
+
540  return true;
+
541  case LayerType::MemImport:
+
542  return LayerSupportBase::IsMemImportSupported(infos[0], infos[1], reasonIfUnsupported);
+
543  case LayerType::Merge:
+
544  return LayerSupportBase::IsMergeSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
+
545  case LayerType::QuantizedLstm:
+
546  return LayerSupportBase::IsQuantizedLstmSupported(infos[0],
+
547  infos[1],
+
548  infos[2],
+
549  infos[3],
+
550  infos[4],
+
551  quantizedLstmInputParamsInfo.value(),
+
552  reasonIfUnsupported);
+
553  default:
+
554  // layers not supported in reference by default:
+
555  // precompiled, standin, switch, fused
+
556  return false;
+
557  }
+
558 }
-

References armnn::Activation, armnn::Addition, armnn::ArgMinMax, armnn::BatchMatMul, armnn::BatchNormalization, armnn::BatchToSpaceNd, armnn::BroadcastTo, armnn::Cast, armnn::ChannelShuffle, armnn::CheckSupportRule(), armnn::Comparison, armnn::Concat, armnn::Constant, armnn::ConvertFp16ToFp32, armnn::ConvertFp32ToFp16, armnn::Convolution2d, armnn::Convolution3d, armnn::Debug, armnn::DepthToSpace, armnn::DepthwiseConvolution2d, armnn::Dequantize, armnn::DetectionPostProcess, armnn::Division, armnn::ElementwiseBinary, armnn::ElementwiseUnary, armnn::FakeQuantization, armnn::Fill, armnn::Float16, armnn::Float32, armnn::Floor, armnn::FullyConnected, armnn::Gather, armnn::GatherNd, armnn::Input, armnn::InstanceNormalization, RefLayerSupport::IsActivationSupported(), RefLayerSupport::IsAdditionSupported(), RefLayerSupport::IsArgMinMaxSupported(), RefLayerSupport::IsBatchMatMulSupported(), RefLayerSupport::IsBatchNormalizationSupported(), RefLayerSupport::IsBatchToSpaceNdSupported(), RefLayerSupport::IsBroadcastToSupported(), RefLayerSupport::IsCastSupported(), RefLayerSupport::IsChannelShuffleSupported(), RefLayerSupport::IsComparisonSupported(), RefLayerSupport::IsConcatSupported(), RefLayerSupport::IsConstantSupported(), RefLayerSupport::IsConvertFp16ToFp32Supported(), RefLayerSupport::IsConvertFp32ToFp16Supported(), RefLayerSupport::IsConvolution2dSupported(), RefLayerSupport::IsConvolution3dSupported(), RefLayerSupport::IsDebugSupported(), RefLayerSupport::IsDepthToSpaceSupported(), RefLayerSupport::IsDepthwiseConvolutionSupported(), RefLayerSupport::IsDequantizeSupported(), RefLayerSupport::IsDetectionPostProcessSupported(), RefLayerSupport::IsDivisionSupported(), RefLayerSupport::IsElementwiseUnarySupported(), RefLayerSupport::IsFakeQuantizationSupported(), RefLayerSupport::IsFillSupported(), RefLayerSupport::IsFloorSupported(), RefLayerSupport::IsFullyConnectedSupported(), RefLayerSupport::IsGatherNdSupported(), RefLayerSupport::IsGatherSupported(), RefLayerSupport::IsInputSupported(), RefLayerSupport::IsInstanceNormalizationSupported(), RefLayerSupport::IsL2NormalizationSupported(), RefLayerSupport::IsLogicalBinarySupported(), RefLayerSupport::IsLogSoftmaxSupported(), RefLayerSupport::IsLstmSupported(), RefLayerSupport::IsMaximumSupported(), RefLayerSupport::IsMeanSupported(), RefLayerSupport::IsMemCopySupported(), LayerSupportBase::IsMemImportSupported(), LayerSupportBase::IsMergeSupported(), RefLayerSupport::IsMinimumSupported(), RefLayerSupport::IsMultiplicationSupported(), RefLayerSupport::IsNormalizationSupported(), RefLayerSupport::IsOutputSupported(), RefLayerSupport::IsPadSupported(), RefLayerSupport::IsPermuteSupported(), RefLayerSupport::IsPooling2dSupported(), RefLayerSupport::IsPooling3dSupported(), RefLayerSupport::IsPreluSupported(), RefLayerSupport::IsQLstmSupported(), LayerSupportBase::IsQuantizedLstmSupported(), RefLayerSupport::IsQuantizeSupported(), RefLayerSupport::IsRankSupported(), RefLayerSupport::IsReduceSupported(), RefLayerSupport::IsReshapeSupported(), RefLayerSupport::IsResizeSupported(), RefLayerSupport::IsReverseV2Supported(), RefLayerSupport::IsShapeSupported(), RefLayerSupport::IsSliceSupported(), RefLayerSupport::IsSoftmaxSupported(), RefLayerSupport::IsSpaceToBatchNdSupported(), RefLayerSupport::IsSpaceToDepthSupported(), RefLayerSupport::IsSplitterSupported(), RefLayerSupport::IsStackSupported(), RefLayerSupport::IsStridedSliceSupported(), RefLayerSupport::IsSubtractionSupported(), RefLayerSupport::IsTileSupported(), RefLayerSupport::IsTransposeConvolution2dSupported(), RefLayerSupport::IsTransposeSupported(), RefLayerSupport::IsUnidirectionalSequenceLstmSupported(), armnn::L2Normalization, armnn::LogicalBinary, armnn::LogSoftmax, armnn::Lstm, armnn::Map, armnn::Maximum, armnn::Mean, armnn::MemCopy, armnn::MemImport, armnn::Merge, armnn::Minimum, armnn::Multiplication, armnn::Normalization, armnn::Output, armnn::Pad, armnn::Permute, armnn::Pooling2d, armnn::Pooling3d, armnn::Prelu, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QLstm, armnn::QSymmS16, armnn::Quantize, armnn::QuantizedLstm, armnn::Rank, armnn::Reduce, armnn::Reshape, armnn::Resize, armnn::ReverseV2, armnn::Shape, armnn::Signed32, armnn::Slice, armnn::Softmax, armnn::SpaceToBatchNd, armnn::SpaceToDepth, armnn::Splitter, armnn::Stack, armnn::StridedSlice, armnn::Subtraction, armnn::Tile, armnn::Transpose, armnn::TransposeConvolution2d, armnn::UnidirectionalSequenceLstm, armnn::Unmap, and OptionalReferenceSwitch< std::is_reference< T >::value, T >::value().

+

References armnn::Activation, armnn::Addition, armnn::ArgMinMax, armnn::BatchMatMul, armnn::BatchNormalization, armnn::BatchToSpaceNd, armnn::BroadcastTo, armnn::Cast, armnn::ChannelShuffle, armnn::CheckSupportRule(), armnn::Comparison, armnn::Concat, armnn::Constant, armnn::ConvertFp16ToFp32, armnn::ConvertFp32ToFp16, armnn::Convolution2d, armnn::Convolution3d, armnn::Debug, armnn::DepthToSpace, armnn::DepthwiseConvolution2d, armnn::Dequantize, armnn::DetectionPostProcess, armnn::Division, armnn::ElementwiseBinary, armnn::ElementwiseUnary, armnn::FakeQuantization, armnn::Fill, armnn::Float16, armnn::Float32, armnn::Floor, armnn::FullyConnected, armnn::Gather, armnn::GatherNd, armnn::Input, armnn::InstanceNormalization, RefLayerSupport::IsActivationSupported(), RefLayerSupport::IsAdditionSupported(), RefLayerSupport::IsArgMinMaxSupported(), RefLayerSupport::IsBatchMatMulSupported(), RefLayerSupport::IsBatchNormalizationSupported(), RefLayerSupport::IsBatchToSpaceNdSupported(), RefLayerSupport::IsBroadcastToSupported(), RefLayerSupport::IsCastSupported(), RefLayerSupport::IsChannelShuffleSupported(), RefLayerSupport::IsComparisonSupported(), RefLayerSupport::IsConcatSupported(), RefLayerSupport::IsConstantSupported(), RefLayerSupport::IsConvertFp16ToFp32Supported(), RefLayerSupport::IsConvertFp32ToFp16Supported(), RefLayerSupport::IsConvolution2dSupported(), RefLayerSupport::IsConvolution3dSupported(), RefLayerSupport::IsDebugSupported(), RefLayerSupport::IsDepthToSpaceSupported(), RefLayerSupport::IsDepthwiseConvolutionSupported(), RefLayerSupport::IsDequantizeSupported(), RefLayerSupport::IsDetectionPostProcessSupported(), RefLayerSupport::IsDivisionSupported(), RefLayerSupport::IsElementwiseUnarySupported(), RefLayerSupport::IsFakeQuantizationSupported(), RefLayerSupport::IsFillSupported(), RefLayerSupport::IsFloorSupported(), RefLayerSupport::IsFullyConnectedSupported(), RefLayerSupport::IsGatherNdSupported(), RefLayerSupport::IsGatherSupported(), RefLayerSupport::IsInputSupported(), RefLayerSupport::IsInstanceNormalizationSupported(), RefLayerSupport::IsL2NormalizationSupported(), RefLayerSupport::IsLogicalBinarySupported(), RefLayerSupport::IsLogSoftmaxSupported(), RefLayerSupport::IsLstmSupported(), RefLayerSupport::IsMaximumSupported(), RefLayerSupport::IsMeanSupported(), RefLayerSupport::IsMemCopySupported(), LayerSupportBase::IsMemImportSupported(), LayerSupportBase::IsMergeSupported(), RefLayerSupport::IsMinimumSupported(), RefLayerSupport::IsMultiplicationSupported(), RefLayerSupport::IsNormalizationSupported(), RefLayerSupport::IsOutputSupported(), RefLayerSupport::IsPadSupported(), RefLayerSupport::IsPermuteSupported(), RefLayerSupport::IsPooling2dSupported(), RefLayerSupport::IsPooling3dSupported(), RefLayerSupport::IsPreluSupported(), RefLayerSupport::IsQLstmSupported(), LayerSupportBase::IsQuantizedLstmSupported(), RefLayerSupport::IsQuantizeSupported(), RefLayerSupport::IsRankSupported(), RefLayerSupport::IsReduceSupported(), RefLayerSupport::IsReshapeSupported(), RefLayerSupport::IsResizeSupported(), RefLayerSupport::IsReverseV2Supported(), RefLayerSupport::IsScatterNdSupported(), RefLayerSupport::IsShapeSupported(), RefLayerSupport::IsSliceSupported(), RefLayerSupport::IsSoftmaxSupported(), RefLayerSupport::IsSpaceToBatchNdSupported(), RefLayerSupport::IsSpaceToDepthSupported(), RefLayerSupport::IsSplitterSupported(), RefLayerSupport::IsStackSupported(), RefLayerSupport::IsStridedSliceSupported(), RefLayerSupport::IsSubtractionSupported(), RefLayerSupport::IsTileSupported(), RefLayerSupport::IsTransposeConvolution2dSupported(), RefLayerSupport::IsTransposeSupported(), RefLayerSupport::IsUnidirectionalSequenceLstmSupported(), armnn::L2Normalization, armnn::LogicalBinary, armnn::LogSoftmax, armnn::Lstm, armnn::Map, armnn::Maximum, armnn::Mean, armnn::MemCopy, armnn::MemImport, armnn::Merge, armnn::Minimum, armnn::Multiplication, armnn::Normalization, armnn::Output, armnn::Pad, armnn::Permute, armnn::Pooling2d, armnn::Pooling3d, armnn::Prelu, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QLstm, armnn::QSymmS16, armnn::Quantize, armnn::QuantizedLstm, armnn::Rank, armnn::Reduce, armnn::Reshape, armnn::Resize, armnn::ReverseV2, armnn::ScatterNd, armnn::Shape, armnn::Signed32, armnn::Slice, armnn::Softmax, armnn::SpaceToBatchNd, armnn::SpaceToDepth, armnn::Splitter, armnn::Stack, armnn::StridedSlice, armnn::Subtraction, armnn::Tile, armnn::Transpose, armnn::TransposeConvolution2d, armnn::UnidirectionalSequenceLstm, armnn::Unmap, and OptionalReferenceSwitch< std::is_reference< T >::value, T >::value().

@@ -3457,28 +3468,31 @@ Additional Inherited Members
-

Definition at line 1726 of file RefLayerSupport.cpp.

-
1731 {
-
1732  IgnoreUnused(descriptor);
-
1733 
-
1734  std::array<DataType, 1> supportedTypes =
-
1735  {
-
1736  DataType::Boolean
-
1737  };
-
1738 
-
1739  bool supported = true;
-
1740  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
-
1741  "Reference LogicalBinary: input 0 type not supported");
-
1742  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
-
1743  "Reference LogicalBinary: input 1 type not supported");
-
1744 
-
1745  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
-
1746  "Reference LogicalBinary: input and output types do not match");
+

Definition at line 1735 of file RefLayerSupport.cpp.

+
1740 {
+
1741  IgnoreUnused(descriptor);
+
1742 
+
1743  std::array<DataType, 1> supportedTypes =
+
1744  {
+
1745  DataType::Boolean
+
1746  };
1747 
-
1748  return supported;
-
1749 }
+
1748  bool supported = true;
+
1749  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
+
1750  "Reference LogicalBinary: input 0 type not supported");
+
1751  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
+
1752  "Reference LogicalBinary: input 1 type not supported");
+
1753 
+
1754  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
+
1755  "Reference LogicalBinary: input and output types do not match");
+
1756 
+
1757  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
+
1758  "Reference LogicalBinary: shapes are not suitable for implicit broadcast.");
+
1759 
+
1760  return supported;
+
1761 }
-

References armnn::Boolean, armnn::CheckSupportRule(), and armnn::IgnoreUnused().

+

References armnn::Boolean, armnn::CheckSupportRule(), and armnn::IgnoreUnused().

Referenced by RefLayerSupport::IsLayerSupported().

@@ -3522,30 +3536,30 @@ Additional Inherited Members
-

Definition at line 1751 of file RefLayerSupport.cpp.

-
1755 {
-
1756  IgnoreUnused(descriptor);
-
1757 
-
1758  std::array<DataType, 3> supportedTypes =
-
1759  {
-
1760  DataType::Float32,
-
1761  DataType::Float16
-
1762  };
-
1763 
-
1764  bool supported = true;
-
1765  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
-
1766  "Reference LogSoftmax: input type not supported");
-
1767 
-
1768  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
1769  "Reference LogSoftmax: output type not supported");
-
1770 
-
1771  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
-
1772  "Reference LogSoftmax: input and output types do not match");
-
1773 
-
1774  return supported;
-
1775 }
+

Definition at line 1763 of file RefLayerSupport.cpp.

+
1767 {
+
1768  IgnoreUnused(descriptor);
+
1769 
+
1770  std::array<DataType, 3> supportedTypes =
+
1771  {
+
1772  DataType::Float32,
+
1773  DataType::Float16
+
1774  };
+
1775 
+
1776  bool supported = true;
+
1777  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
+
1778  "Reference LogSoftmax: input type not supported");
+
1779 
+
1780  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
1781  "Reference LogSoftmax: output type not supported");
+
1782 
+
1783  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
+
1784  "Reference LogSoftmax: input and output types do not match");
+
1785 
+
1786  return supported;
+
1787 }
-

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, and armnn::IgnoreUnused().

+

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, and armnn::IgnoreUnused().

Referenced by RefLayerSupport::IsLayerSupported().

@@ -3625,109 +3639,109 @@ Additional Inherited Members
-

Definition at line 1777 of file RefLayerSupport.cpp.

-
1787 {
-
1788  IgnoreUnused(descriptor);
-
1789  IgnoreUnused(paramsInfo);
-
1790 
-
1791  bool supported = true;
-
1792 
-
1793  std::array<DataType,3> supportedTypes = {
-
1794  DataType::Float32,
-
1795  DataType::QSymmS16
-
1796  };
-
1797 
-
1798  // check inputs and outputs
-
1799  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
-
1800  "Reference Lstm: input is not a supported type.");
-
1801  supported &= CheckSupportRule(TypesAreEqual(input, outputStateIn), reasonIfUnsupported,
-
1802  "Reference Lstm: input and outputStateIn types are mismatched");
-
1803  supported &= CheckSupportRule(TypesAreEqual(input, cellStateIn), reasonIfUnsupported,
-
1804  "Reference Lstm: input and cellStateIn types are mismatched");
-
1805  supported &= CheckSupportRule(TypesAreEqual(input, scratchBuffer), reasonIfUnsupported,
-
1806  "Reference Lstm: input and scratchBuffer types are mismatched");
-
1807  supported &= CheckSupportRule(TypesAreEqual(input, outputStateOut), reasonIfUnsupported,
-
1808  "Reference Lstm: input and outputStateOut types are mismatched");
-
1809  supported &= CheckSupportRule(TypesAreEqual(input, cellStateOut), reasonIfUnsupported,
-
1810  "Reference Lstm: input and cellStateOut types are mismatched");
-
1811 
-
1812  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
-
1813  "Reference Lstm: input and output types are mismatched");
-
1814  // check layer parameters
-
1815  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputToForgetWeights()), reasonIfUnsupported,
-
1816  "Reference Lstm: input and InputToForgetWeights types are mismatched");
-
1817  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputToCellWeights()), reasonIfUnsupported,
-
1818  "Reference Lstm: input and InputToCellWeights types are mismatched");
-
1819  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputToOutputWeights()), reasonIfUnsupported,
-
1820  "Reference Lstm: input and InputToOutputWeights types are mismatched");
-
1821  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetRecurrentToForgetWeights()), reasonIfUnsupported,
-
1822  "Reference Lstm: input and RecurrentToForgetWeights types are mismatched");
-
1823  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetRecurrentToCellWeights()), reasonIfUnsupported,
-
1824  "Reference Lstm: input and RecurrentToCellWeights types are mismatched");
-
1825  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetRecurrentToOutputWeights()), reasonIfUnsupported,
-
1826  "Reference Lstm: input and RecurrentToOutputWeights types are mismatched");
-
1827  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetForgetGateBias()), reasonIfUnsupported,
-
1828  "Reference Lstm: input and ForgetGateBias types are mismatched");
-
1829  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellBias()), reasonIfUnsupported,
-
1830  "Reference Lstm: input and CellBias types are mismatched");
-
1831  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetOutputGateBias()), reasonIfUnsupported,
-
1832  "Reference Lstm: input and OutputGateBias types are mismatched");
-
1833  if (!descriptor.m_CifgEnabled)
-
1834  {
-
1835  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputToInputWeights()), reasonIfUnsupported,
-
1836  "Reference Lstm: input and InputToInputWeights types are mismatched");
-
1837  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetRecurrentToInputWeights()),
-
1838  reasonIfUnsupported,
-
1839  "Reference Lstm: input and RecurrentToInputWeights types are mismatched");
-
1840  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputGateBias()), reasonIfUnsupported,
-
1841  "Reference Lstm: input and InputGateBias types are mismatched");
-
1842  if (descriptor.m_PeepholeEnabled)
-
1843  {
-
1844  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellToInputWeights()),
-
1845  reasonIfUnsupported,
-
1846  "Reference Lstm: input and CellToInputWeights types are mismatched");
-
1847  }
-
1848  }
-
1849  if (descriptor.m_PeepholeEnabled)
-
1850  {
-
1851  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellToForgetWeights()), reasonIfUnsupported,
-
1852  "Reference Lstm: input and CellToForgetWeights types are mismatched");
-
1853  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellToOutputWeights()), reasonIfUnsupported,
-
1854  "Reference Lstm: input and CellToOutputWeights types are mismatched");
-
1855  }
-
1856  if (descriptor.m_ProjectionEnabled)
-
1857  {
-
1858  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetProjectionWeights()), reasonIfUnsupported,
-
1859  "Reference Lstm: input and mProjectionWeights types are mismatched");
-
1860  if (paramsInfo.m_ProjectionBias != nullptr)
-
1861  {
-
1862  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetProjectionBias()), reasonIfUnsupported,
-
1863  "Reference Lstm: input and ProjectionBias types are mismatched");
-
1864  }
-
1865  }
-
1866  if (descriptor.m_LayerNormEnabled)
-
1867  {
-
1868  if (!descriptor.m_CifgEnabled)
-
1869  {
-
1870  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputLayerNormWeights()),
-
1871  reasonIfUnsupported,
-
1872  "Reference Lstm: input and InputLayerNormWeights types are mismatched");
-
1873  }
-
1874  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetForgetLayerNormWeights()),
-
1875  reasonIfUnsupported,
-
1876  "Reference Lstm: input and ForgetLayerNormWeights types are mismatched");
-
1877  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellLayerNormWeights()),
-
1878  reasonIfUnsupported,
-
1879  "Reference Lstm: input and CellLayerNormWeights types are mismatched");
-
1880  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetOutputLayerNormWeights()),
-
1881  reasonIfUnsupported,
-
1882  "Reference Lstm: input and OutputLayerNormWeights types are mismatched");
-
1883  }
-
1884 
-
1885  return supported;
-
1886 }
+

Definition at line 1789 of file RefLayerSupport.cpp.

+
1799 {
+
1800  IgnoreUnused(descriptor);
+
1801  IgnoreUnused(paramsInfo);
+
1802 
+
1803  bool supported = true;
+
1804 
+
1805  std::array<DataType,3> supportedTypes = {
+
1806  DataType::Float32,
+
1807  DataType::QSymmS16
+
1808  };
+
1809 
+
1810  // check inputs and outputs
+
1811  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
+
1812  "Reference Lstm: input is not a supported type.");
+
1813  supported &= CheckSupportRule(TypesAreEqual(input, outputStateIn), reasonIfUnsupported,
+
1814  "Reference Lstm: input and outputStateIn types are mismatched");
+
1815  supported &= CheckSupportRule(TypesAreEqual(input, cellStateIn), reasonIfUnsupported,
+
1816  "Reference Lstm: input and cellStateIn types are mismatched");
+
1817  supported &= CheckSupportRule(TypesAreEqual(input, scratchBuffer), reasonIfUnsupported,
+
1818  "Reference Lstm: input and scratchBuffer types are mismatched");
+
1819  supported &= CheckSupportRule(TypesAreEqual(input, outputStateOut), reasonIfUnsupported,
+
1820  "Reference Lstm: input and outputStateOut types are mismatched");
+
1821  supported &= CheckSupportRule(TypesAreEqual(input, cellStateOut), reasonIfUnsupported,
+
1822  "Reference Lstm: input and cellStateOut types are mismatched");
+
1823 
+
1824  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
+
1825  "Reference Lstm: input and output types are mismatched");
+
1826  // check layer parameters
+
1827  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputToForgetWeights()), reasonIfUnsupported,
+
1828  "Reference Lstm: input and InputToForgetWeights types are mismatched");
+
1829  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputToCellWeights()), reasonIfUnsupported,
+
1830  "Reference Lstm: input and InputToCellWeights types are mismatched");
+
1831  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputToOutputWeights()), reasonIfUnsupported,
+
1832  "Reference Lstm: input and InputToOutputWeights types are mismatched");
+
1833  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetRecurrentToForgetWeights()), reasonIfUnsupported,
+
1834  "Reference Lstm: input and RecurrentToForgetWeights types are mismatched");
+
1835  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetRecurrentToCellWeights()), reasonIfUnsupported,
+
1836  "Reference Lstm: input and RecurrentToCellWeights types are mismatched");
+
1837  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetRecurrentToOutputWeights()), reasonIfUnsupported,
+
1838  "Reference Lstm: input and RecurrentToOutputWeights types are mismatched");
+
1839  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetForgetGateBias()), reasonIfUnsupported,
+
1840  "Reference Lstm: input and ForgetGateBias types are mismatched");
+
1841  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellBias()), reasonIfUnsupported,
+
1842  "Reference Lstm: input and CellBias types are mismatched");
+
1843  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetOutputGateBias()), reasonIfUnsupported,
+
1844  "Reference Lstm: input and OutputGateBias types are mismatched");
+
1845  if (!descriptor.m_CifgEnabled)
+
1846  {
+
1847  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputToInputWeights()), reasonIfUnsupported,
+
1848  "Reference Lstm: input and InputToInputWeights types are mismatched");
+
1849  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetRecurrentToInputWeights()),
+
1850  reasonIfUnsupported,
+
1851  "Reference Lstm: input and RecurrentToInputWeights types are mismatched");
+
1852  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputGateBias()), reasonIfUnsupported,
+
1853  "Reference Lstm: input and InputGateBias types are mismatched");
+
1854  if (descriptor.m_PeepholeEnabled)
+
1855  {
+
1856  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellToInputWeights()),
+
1857  reasonIfUnsupported,
+
1858  "Reference Lstm: input and CellToInputWeights types are mismatched");
+
1859  }
+
1860  }
+
1861  if (descriptor.m_PeepholeEnabled)
+
1862  {
+
1863  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellToForgetWeights()), reasonIfUnsupported,
+
1864  "Reference Lstm: input and CellToForgetWeights types are mismatched");
+
1865  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellToOutputWeights()), reasonIfUnsupported,
+
1866  "Reference Lstm: input and CellToOutputWeights types are mismatched");
+
1867  }
+
1868  if (descriptor.m_ProjectionEnabled)
+
1869  {
+
1870  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetProjectionWeights()), reasonIfUnsupported,
+
1871  "Reference Lstm: input and mProjectionWeights types are mismatched");
+
1872  if (paramsInfo.m_ProjectionBias != nullptr)
+
1873  {
+
1874  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetProjectionBias()), reasonIfUnsupported,
+
1875  "Reference Lstm: input and ProjectionBias types are mismatched");
+
1876  }
+
1877  }
+
1878  if (descriptor.m_LayerNormEnabled)
+
1879  {
+
1880  if (!descriptor.m_CifgEnabled)
+
1881  {
+
1882  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputLayerNormWeights()),
+
1883  reasonIfUnsupported,
+
1884  "Reference Lstm: input and InputLayerNormWeights types are mismatched");
+
1885  }
+
1886  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetForgetLayerNormWeights()),
+
1887  reasonIfUnsupported,
+
1888  "Reference Lstm: input and ForgetLayerNormWeights types are mismatched");
+
1889  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellLayerNormWeights()),
+
1890  reasonIfUnsupported,
+
1891  "Reference Lstm: input and CellLayerNormWeights types are mismatched");
+
1892  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetOutputLayerNormWeights()),
+
1893  reasonIfUnsupported,
+
1894  "Reference Lstm: input and OutputLayerNormWeights types are mismatched");
+
1895  }
+
1896 
+
1897  return supported;
+
1898 }
-

References armnn::CheckSupportRule(), armnn::Float32, LstmInputParamsInfo::GetCellBias(), LstmInputParamsInfo::GetCellLayerNormWeights(), LstmInputParamsInfo::GetCellToForgetWeights(), LstmInputParamsInfo::GetCellToInputWeights(), LstmInputParamsInfo::GetCellToOutputWeights(), LstmInputParamsInfo::GetForgetGateBias(), LstmInputParamsInfo::GetForgetLayerNormWeights(), LstmInputParamsInfo::GetInputGateBias(), LstmInputParamsInfo::GetInputLayerNormWeights(), LstmInputParamsInfo::GetInputToCellWeights(), LstmInputParamsInfo::GetInputToForgetWeights(), LstmInputParamsInfo::GetInputToInputWeights(), LstmInputParamsInfo::GetInputToOutputWeights(), LstmInputParamsInfo::GetOutputGateBias(), LstmInputParamsInfo::GetOutputLayerNormWeights(), LstmInputParamsInfo::GetProjectionBias(), LstmInputParamsInfo::GetProjectionWeights(), LstmInputParamsInfo::GetRecurrentToCellWeights(), LstmInputParamsInfo::GetRecurrentToForgetWeights(), LstmInputParamsInfo::GetRecurrentToInputWeights(), LstmInputParamsInfo::GetRecurrentToOutputWeights(), armnn::IgnoreUnused(), LstmDescriptor::m_CifgEnabled, LstmDescriptor::m_LayerNormEnabled, LstmDescriptor::m_PeepholeEnabled, LstmInputParamsInfo::m_ProjectionBias, LstmDescriptor::m_ProjectionEnabled, and armnn::QSymmS16.

+

References armnn::CheckSupportRule(), armnn::Float32, LstmInputParamsInfo::GetCellBias(), LstmInputParamsInfo::GetCellLayerNormWeights(), LstmInputParamsInfo::GetCellToForgetWeights(), LstmInputParamsInfo::GetCellToInputWeights(), LstmInputParamsInfo::GetCellToOutputWeights(), LstmInputParamsInfo::GetForgetGateBias(), LstmInputParamsInfo::GetForgetLayerNormWeights(), LstmInputParamsInfo::GetInputGateBias(), LstmInputParamsInfo::GetInputLayerNormWeights(), LstmInputParamsInfo::GetInputToCellWeights(), LstmInputParamsInfo::GetInputToForgetWeights(), LstmInputParamsInfo::GetInputToInputWeights(), LstmInputParamsInfo::GetInputToOutputWeights(), LstmInputParamsInfo::GetOutputGateBias(), LstmInputParamsInfo::GetOutputLayerNormWeights(), LstmInputParamsInfo::GetProjectionBias(), LstmInputParamsInfo::GetProjectionWeights(), LstmInputParamsInfo::GetRecurrentToCellWeights(), LstmInputParamsInfo::GetRecurrentToForgetWeights(), LstmInputParamsInfo::GetRecurrentToInputWeights(), LstmInputParamsInfo::GetRecurrentToOutputWeights(), armnn::IgnoreUnused(), LstmDescriptor::m_CifgEnabled, LstmDescriptor::m_LayerNormEnabled, LstmDescriptor::m_PeepholeEnabled, LstmInputParamsInfo::m_ProjectionBias, LstmDescriptor::m_ProjectionEnabled, and armnn::QSymmS16.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -3771,41 +3785,41 @@ Additional Inherited Members
-

Definition at line 1888 of file RefLayerSupport.cpp.

-
1892 {
-
1893  bool supported = true;
-
1894 
-
1895  std::array<DataType,7> supportedTypes = {
-
1896  DataType::Float32,
-
1897  DataType::Float16,
-
1898  DataType::QAsymmS8,
-
1899  DataType::QAsymmU8,
-
1900  DataType::QSymmS16,
-
1901  DataType::Signed32
-
1902  };
-
1903 
-
1904  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
-
1905  "Reference maximum: input 0 is not a supported type.");
+

Definition at line 1900 of file RefLayerSupport.cpp.

+
1904 {
+
1905  bool supported = true;
1906 
-
1907  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
-
1908  "Reference maximum: input 1 is not a supported type.");
-
1909 
-
1910  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
1911  "Reference maximum: output is not a supported type.");
-
1912 
-
1913  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
-
1914  "Reference maximum: input 0 and Input 1 types are mismatched");
+
1907  std::array<DataType,7> supportedTypes = {
+
1908  DataType::Float32,
+
1909  DataType::Float16,
+
1910  DataType::QAsymmS8,
+
1911  DataType::QAsymmU8,
+
1912  DataType::QSymmS16,
+
1913  DataType::Signed32
+
1914  };
1915 
-
1916  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
-
1917  "Reference maximum: input and output types are mismatched");
+
1916  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
+
1917  "Reference maximum: input 0 is not a supported type.");
1918 
-
1919  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
-
1920  "Reference maximum: shapes are not suitable for implicit broadcast.");
+
1919  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
+
1920  "Reference maximum: input 1 is not a supported type.");
1921 
-
1922  return supported;
-
1923 }
+
1922  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
1923  "Reference maximum: output is not a supported type.");
+
1924 
+
1925  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
+
1926  "Reference maximum: input 0 and Input 1 types are mismatched");
+
1927 
+
1928  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
+
1929  "Reference maximum: input and output types are mismatched");
+
1930 
+
1931  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
+
1932  "Reference maximum: shapes are not suitable for implicit broadcast.");
+
1933 
+
1934  return supported;
+
1935 }
-

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

+

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -3849,66 +3863,66 @@ Additional Inherited Members
-

Definition at line 1925 of file RefLayerSupport.cpp.

-
1929 {
-
1930  bool supported = true;
-
1931  std::string meanLayerStr = "Mean";
-
1932  std::string outputTensorStr = "output";
-
1933 
-
1934  std::array<DataType,6> supportedTypes =
-
1935  {
-
1936  DataType::Float32,
-
1937  DataType::Float16,
-
1938  DataType::QAsymmS8,
-
1939  DataType::QAsymmU8,
-
1940  DataType::QSymmS16
-
1941  };
-
1942 
-
1943  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
-
1944  "Reference Mean: input type not supported.");
+

Definition at line 1937 of file RefLayerSupport.cpp.

+
1941 {
+
1942  bool supported = true;
+
1943  std::string meanLayerStr = "Mean";
+
1944  std::string outputTensorStr = "output";
1945 
-
1946  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
-
1947  "Reference Mean: input and output types are mismatched");
-
1948 
-
1949  if (descriptor.m_KeepDims)
-
1950  {
-
1951  supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, input.GetNumDimensions()),
-
1952  reasonIfUnsupported,
-
1953  CreateIncorrectDimensionsErrorMsg(input.GetNumDimensions(),
-
1954  output.GetNumDimensions(),
-
1955  meanLayerStr, outputTensorStr).data());
-
1956  }
-
1957  else if (descriptor.m_Axis.empty())
-
1958  {
-
1959  supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, 1),
-
1960  reasonIfUnsupported,
-
1961  CreateIncorrectDimensionsErrorMsg(1, output.GetNumDimensions(),
-
1962  meanLayerStr, outputTensorStr).data());
-
1963  }
-
1964  else
-
1965  {
-
1966  auto outputDim = input.GetNumDimensions() - armnn::numeric_cast<unsigned int>(descriptor.m_Axis.size());
-
1967 
-
1968  if (outputDim > 0)
-
1969  {
-
1970  supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, outputDim),
-
1971  reasonIfUnsupported,
-
1972  CreateIncorrectDimensionsErrorMsg(outputDim, output.GetNumDimensions(),
-
1973  meanLayerStr, outputTensorStr).data());
-
1974  }
-
1975  else
-
1976  {
-
1977  supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, 1),
-
1978  reasonIfUnsupported,
-
1979  CreateIncorrectDimensionsErrorMsg(1, output.GetNumDimensions(),
-
1980  meanLayerStr, outputTensorStr).data());
-
1981  }
-
1982  }
-
1983 
-
1984  return supported;
-
1985 }
+
1946  std::array<DataType,6> supportedTypes =
+
1947  {
+
1948  DataType::Float32,
+
1949  DataType::Float16,
+
1950  DataType::QAsymmS8,
+
1951  DataType::QAsymmU8,
+
1952  DataType::QSymmS16
+
1953  };
+
1954 
+
1955  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
+
1956  "Reference Mean: input type not supported.");
+
1957 
+
1958  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
+
1959  "Reference Mean: input and output types are mismatched");
+
1960 
+
1961  if (descriptor.m_KeepDims)
+
1962  {
+
1963  supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, input.GetNumDimensions()),
+
1964  reasonIfUnsupported,
+
1965  CreateIncorrectDimensionsErrorMsg(input.GetNumDimensions(),
+
1966  output.GetNumDimensions(),
+
1967  meanLayerStr, outputTensorStr).data());
+
1968  }
+
1969  else if (descriptor.m_Axis.empty())
+
1970  {
+
1971  supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, 1),
+
1972  reasonIfUnsupported,
+
1973  CreateIncorrectDimensionsErrorMsg(1, output.GetNumDimensions(),
+
1974  meanLayerStr, outputTensorStr).data());
+
1975  }
+
1976  else
+
1977  {
+
1978  auto outputDim = input.GetNumDimensions() - armnn::numeric_cast<unsigned int>(descriptor.m_Axis.size());
+
1979 
+
1980  if (outputDim > 0)
+
1981  {
+
1982  supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, outputDim),
+
1983  reasonIfUnsupported,
+
1984  CreateIncorrectDimensionsErrorMsg(outputDim, output.GetNumDimensions(),
+
1985  meanLayerStr, outputTensorStr).data());
+
1986  }
+
1987  else
+
1988  {
+
1989  supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, 1),
+
1990  reasonIfUnsupported,
+
1991  CreateIncorrectDimensionsErrorMsg(1, output.GetNumDimensions(),
+
1992  meanLayerStr, outputTensorStr).data());
+
1993  }
+
1994  }
+
1995 
+
1996  return supported;
+
1997 }
-

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, TensorInfo::GetNumDimensions(), MeanDescriptor::m_Axis, MeanDescriptor::m_KeepDims, armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

+

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, TensorInfo::GetNumDimensions(), MeanDescriptor::m_Axis, MeanDescriptor::m_KeepDims, armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -3946,34 +3960,34 @@ Additional Inherited Members
-

Definition at line 1987 of file RefLayerSupport.cpp.

-
1990 {
-
1991  bool supported = true;
-
1992 
-
1993  std::array<DataType,7> supportedTypes =
-
1994  {
-
1995  DataType::BFloat16,
-
1996  DataType::Float32,
-
1997  DataType::Float16,
-
1998  DataType::QAsymmS8,
-
1999  DataType::QAsymmU8,
-
2000  DataType::QSymmS16,
-
2001  DataType::Boolean
-
2002  };
-
2003 
-
2004  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
-
2005  "Reference MemCopy: input type not supported");
-
2006 
-
2007  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
2008  "Reference MemCopy: output type not supported");
-
2009 
-
2010  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
-
2011  "Reference MemCopy: input and output types are mismatched");
-
2012 
-
2013  return supported;
-
2014 }
+

Definition at line 1999 of file RefLayerSupport.cpp.

+
2002 {
+
2003  bool supported = true;
+
2004 
+
2005  std::array<DataType,7> supportedTypes =
+
2006  {
+
2007  DataType::BFloat16,
+
2008  DataType::Float32,
+
2009  DataType::Float16,
+
2010  DataType::QAsymmS8,
+
2011  DataType::QAsymmU8,
+
2012  DataType::QSymmS16,
+
2013  DataType::Boolean
+
2014  };
+
2015 
+
2016  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
+
2017  "Reference MemCopy: input type not supported");
+
2018 
+
2019  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
2020  "Reference MemCopy: output type not supported");
+
2021 
+
2022  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
+
2023  "Reference MemCopy: input and output types are mismatched");
+
2024 
+
2025  return supported;
+
2026 }
-

References armnn::BFloat16, armnn::Boolean, armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

+

References armnn::BFloat16, armnn::Boolean, armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -4017,41 +4031,41 @@ Additional Inherited Members
-

Definition at line 2016 of file RefLayerSupport.cpp.

-
2020 {
-
2021  bool supported = true;
-
2022 
-
2023  std::array<DataType,7> supportedTypes = {
-
2024  DataType::Float32,
-
2025  DataType::Float16,
-
2026  DataType::QAsymmS8,
-
2027  DataType::QAsymmU8,
-
2028  DataType::QSymmS16,
-
2029  DataType::Signed32
-
2030  };
-
2031 
-
2032  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
-
2033  "Reference minimum: input 0 is not a supported type.");
+

Definition at line 2028 of file RefLayerSupport.cpp.

+
2032 {
+
2033  bool supported = true;
2034 
-
2035  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
-
2036  "Reference minimum: input 1 is not a supported type.");
-
2037 
-
2038  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
2039  "Reference minimum: output is not a supported type.");
-
2040 
-
2041  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
-
2042  "Reference minimum: input 0 and Input 1 types are mismatched");
+
2035  std::array<DataType,7> supportedTypes = {
+
2036  DataType::Float32,
+
2037  DataType::Float16,
+
2038  DataType::QAsymmS8,
+
2039  DataType::QAsymmU8,
+
2040  DataType::QSymmS16,
+
2041  DataType::Signed32
+
2042  };
2043 
-
2044  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
-
2045  "Reference minimum: input and output types are mismatched");
+
2044  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
+
2045  "Reference minimum: input 0 is not a supported type.");
2046 
-
2047  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
-
2048  "Reference minimum: shapes are not suitable for implicit broadcast.");
+
2047  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
+
2048  "Reference minimum: input 1 is not a supported type.");
2049 
-
2050  return supported;
-
2051 }
+
2050  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
2051  "Reference minimum: output is not a supported type.");
+
2052 
+
2053  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
+
2054  "Reference minimum: input 0 and Input 1 types are mismatched");
+
2055 
+
2056  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
+
2057  "Reference minimum: input and output types are mismatched");
+
2058 
+
2059  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
+
2060  "Reference minimum: shapes are not suitable for implicit broadcast.");
+
2061 
+
2062  return supported;
+
2063 }
-

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

+

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -4095,41 +4109,41 @@ Additional Inherited Members
-

Definition at line 2053 of file RefLayerSupport.cpp.

-
2057 {
-
2058  bool supported = true;
-
2059 
-
2060  std::array<DataType,7> supportedTypes = {
-
2061  DataType::Float32,
-
2062  DataType::Float16,
-
2063  DataType::QAsymmS8,
-
2064  DataType::QAsymmU8,
-
2065  DataType::QSymmS16,
-
2066  DataType::Signed32
-
2067  };
-
2068 
-
2069  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
-
2070  "Reference multiplication: input 0 is not a supported type.");
+

Definition at line 2065 of file RefLayerSupport.cpp.

+
2069 {
+
2070  bool supported = true;
2071 
-
2072  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
-
2073  "Reference multiplication: input 1 is not a supported type.");
-
2074 
-
2075  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
2076  "Reference multiplication: output is not a supported type.");
-
2077 
-
2078  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
-
2079  "Reference multiplication: input 0 and Input 1 types are mismatched");
+
2072  std::array<DataType,7> supportedTypes = {
+
2073  DataType::Float32,
+
2074  DataType::Float16,
+
2075  DataType::QAsymmS8,
+
2076  DataType::QAsymmU8,
+
2077  DataType::QSymmS16,
+
2078  DataType::Signed32
+
2079  };
2080 
-
2081  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
-
2082  "Reference multiplication: input and output types are mismatched");
+
2081  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
+
2082  "Reference multiplication: input 0 is not a supported type.");
2083 
-
2084  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
-
2085  "Reference multiplication: shapes are not suitable for implicit broadcast.");
+
2084  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
+
2085  "Reference multiplication: input 1 is not a supported type.");
2086 
-
2087  return supported;
-
2088 }
+
2087  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
2088  "Reference multiplication: output is not a supported type.");
+
2089 
+
2090  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
+
2091  "Reference multiplication: input 0 and Input 1 types are mismatched");
+
2092 
+
2093  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
+
2094  "Reference multiplication: input and output types are mismatched");
+
2095 
+
2096  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
+
2097  "Reference multiplication: shapes are not suitable for implicit broadcast.");
+
2098 
+
2099  return supported;
+
2100 }
-

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

+

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -4173,36 +4187,36 @@ Additional Inherited Members
-

Definition at line 2090 of file RefLayerSupport.cpp.

-
2094 {
-
2095  IgnoreUnused(descriptor);
-
2096 
-
2097  // Define supported types
-
2098  std::array<DataType, 6> supportedTypes =
-
2099  {
-
2100  DataType::Float16,
-
2101  DataType::Float32,
-
2102  DataType::QAsymmS8,
-
2103  DataType::QAsymmU8,
-
2104  DataType::QSymmS16
-
2105  };
-
2106 
-
2107  bool supported = true;
+

Definition at line 2102 of file RefLayerSupport.cpp.

+
2106 {
+
2107  IgnoreUnused(descriptor);
2108 
-
2109  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
-
2110  "Reference normalization: input type not supported.");
-
2111 
-
2112  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
2113  "Reference normalization: output type not supported.");
-
2114 
-
2115  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
-
2116  "Reference normalization: input and output shapes have different "
-
2117  "num total elements.");
+
2109  // Define supported types
+
2110  std::array<DataType, 6> supportedTypes =
+
2111  {
+
2112  DataType::Float16,
+
2113  DataType::Float32,
+
2114  DataType::QAsymmS8,
+
2115  DataType::QAsymmU8,
+
2116  DataType::QSymmS16
+
2117  };
2118 
-
2119  return supported;
-
2120 }
+
2119  bool supported = true;
+
2120 
+
2121  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
+
2122  "Reference normalization: input type not supported.");
+
2123 
+
2124  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
2125  "Reference normalization: output type not supported.");
+
2126 
+
2127  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
+
2128  "Reference normalization: input and output shapes have different "
+
2129  "num total elements.");
+
2130 
+
2131  return supported;
+
2132 }
-

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

+

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -4234,10 +4248,10 @@ Additional Inherited Members
-

Definition at line 2122 of file RefLayerSupport.cpp.

-
2124 {
-
2125  return true;
-
2126 }
+

Definition at line 2134 of file RefLayerSupport.cpp.

+
2136 {
+
2137  return true;
+
2138 }

Referenced by RefLayerSupport::IsLayerSupported().

@@ -4281,34 +4295,34 @@ Additional Inherited Members
-

Definition at line 2128 of file RefLayerSupport.cpp.

-
2132 {
-
2133  IgnoreUnused(descriptor);
-
2134  bool supported = true;
-
2135 
-
2136  // Define supported output and inputs types.
-
2137  std::array<DataType,6> supportedTypes =
-
2138  {
-
2139  DataType::Float32,
-
2140  DataType::Float16,
-
2141  DataType::QAsymmS8,
-
2142  DataType::QAsymmU8,
-
2143  DataType::QSymmS16
-
2144  };
-
2145 
-
2146  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
-
2147  "Reference pad: input is not a supported type.");
-
2148 
-
2149  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
2150  "Reference pad: output is not a supported type.");
-
2151 
-
2152  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
-
2153  "Reference pad: input and output types are mismatched.");
-
2154 
-
2155  return supported;
-
2156 }
+

Definition at line 2140 of file RefLayerSupport.cpp.

+
2144 {
+
2145  IgnoreUnused(descriptor);
+
2146  bool supported = true;
+
2147 
+
2148  // Define supported output and inputs types.
+
2149  std::array<DataType,6> supportedTypes =
+
2150  {
+
2151  DataType::Float32,
+
2152  DataType::Float16,
+
2153  DataType::QAsymmS8,
+
2154  DataType::QAsymmU8,
+
2155  DataType::QSymmS16
+
2156  };
+
2157 
+
2158  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
+
2159  "Reference pad: input is not a supported type.");
+
2160 
+
2161  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
2162  "Reference pad: output is not a supported type.");
+
2163 
+
2164  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
+
2165  "Reference pad: input and output types are mismatched.");
+
2166 
+
2167  return supported;
+
2168 }
-

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

+

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -4352,35 +4366,35 @@ Additional Inherited Members
-

Definition at line 2158 of file RefLayerSupport.cpp.

-
2162 {
-
2163  IgnoreUnused(descriptor);
-
2164  bool supported = true;
-
2165 
-
2166  // Define supported output and inputs types.
-
2167  std::array<DataType, 6> supportedTypes =
-
2168  {
-
2169  DataType::BFloat16,
-
2170  DataType::Float32,
-
2171  DataType::Float16,
-
2172  DataType::QAsymmS8,
-
2173  DataType::QAsymmU8,
-
2174  DataType::QSymmS16
-
2175  };
-
2176 
-
2177  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
-
2178  "Reference permute: input is not a supported type.");
-
2179 
-
2180  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
2181  "Reference permute: output is not a supported type.");
-
2182 
-
2183  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
-
2184  "Reference permute: input and output types are mismatched.");
-
2185 
-
2186  return supported;
-
2187 }
+

Definition at line 2170 of file RefLayerSupport.cpp.

+
2174 {
+
2175  IgnoreUnused(descriptor);
+
2176  bool supported = true;
+
2177 
+
2178  // Define supported output and inputs types.
+
2179  std::array<DataType, 6> supportedTypes =
+
2180  {
+
2181  DataType::BFloat16,
+
2182  DataType::Float32,
+
2183  DataType::Float16,
+
2184  DataType::QAsymmS8,
+
2185  DataType::QAsymmU8,
+
2186  DataType::QSymmS16
+
2187  };
+
2188 
+
2189  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
+
2190  "Reference permute: input is not a supported type.");
+
2191 
+
2192  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
2193  "Reference permute: output is not a supported type.");
+
2194 
+
2195  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
+
2196  "Reference permute: input and output types are mismatched.");
+
2197 
+
2198  return supported;
+
2199 }
-

References armnn::BFloat16, armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

+

References armnn::BFloat16, armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -4424,34 +4438,34 @@ Additional Inherited Members
-

Definition at line 2189 of file RefLayerSupport.cpp.

-
2193 {
-
2194  IgnoreUnused(descriptor);
-
2195  bool supported = true;
-
2196 
-
2197  // Define supported output and inputs types.
-
2198  std::array<DataType,6> supportedTypes =
-
2199  {
-
2200  DataType::Float32,
-
2201  DataType::Float16,
-
2202  DataType::QAsymmS8,
-
2203  DataType::QAsymmU8,
-
2204  DataType::QSymmS16
-
2205  };
-
2206 
-
2207  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
-
2208  "Reference poolind2d: input is not a supported type.");
-
2209 
-
2210  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
2211  "Reference poolind2d: output is not a supported type.");
-
2212 
-
2213  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
-
2214  "Reference poolind2d: input and output types are mismatched.");
-
2215 
-
2216  return supported;
-
2217 }
+

Definition at line 2201 of file RefLayerSupport.cpp.

+
2205 {
+
2206  IgnoreUnused(descriptor);
+
2207  bool supported = true;
+
2208 
+
2209  // Define supported output and inputs types.
+
2210  std::array<DataType,6> supportedTypes =
+
2211  {
+
2212  DataType::Float32,
+
2213  DataType::Float16,
+
2214  DataType::QAsymmS8,
+
2215  DataType::QAsymmU8,
+
2216  DataType::QSymmS16
+
2217  };
+
2218 
+
2219  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
+
2220  "Reference poolind2d: input is not a supported type.");
+
2221 
+
2222  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
2223  "Reference poolind2d: output is not a supported type.");
+
2224 
+
2225  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
+
2226  "Reference poolind2d: input and output types are mismatched.");
+
2227 
+
2228  return supported;
+
2229 }
-

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

+

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -4495,34 +4509,34 @@ Additional Inherited Members
-

Definition at line 2219 of file RefLayerSupport.cpp.

-
2223 {
-
2224  IgnoreUnused(descriptor);
-
2225  bool supported = true;
-
2226 
-
2227  // Define supported output and inputs types.
-
2228  std::array<DataType,6> supportedTypes =
-
2229  {
-
2230  DataType::Float32,
-
2231  DataType::Float16,
-
2232  DataType::QAsymmS8,
-
2233  DataType::QAsymmU8,
-
2234  DataType::QSymmS16
-
2235  };
-
2236 
-
2237  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
-
2238  "Reference poolind3d: input is not a supported type.");
-
2239 
-
2240  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
2241  "Reference poolind3d: output is not a supported type.");
-
2242 
-
2243  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
-
2244  "Reference poolind3d: input and output types are mismatched.");
-
2245 
-
2246  return supported;
-
2247 }
+

Definition at line 2231 of file RefLayerSupport.cpp.

+
2235 {
+
2236  IgnoreUnused(descriptor);
+
2237  bool supported = true;
+
2238 
+
2239  // Define supported output and inputs types.
+
2240  std::array<DataType,6> supportedTypes =
+
2241  {
+
2242  DataType::Float32,
+
2243  DataType::Float16,
+
2244  DataType::QAsymmS8,
+
2245  DataType::QAsymmU8,
+
2246  DataType::QSymmS16
+
2247  };
+
2248 
+
2249  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
+
2250  "Reference poolind3d: input is not a supported type.");
+
2251 
+
2252  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
2253  "Reference poolind3d: output is not a supported type.");
+
2254 
+
2255  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
+
2256  "Reference poolind3d: input and output types are mismatched.");
+
2257 
+
2258  return supported;
+
2259 }
-

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

+

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -4566,38 +4580,38 @@ Additional Inherited Members
-

Definition at line 2708 of file RefLayerSupport.cpp.

-
2712 {
-
2713  bool supported = true;
-
2714 
-
2715  std::array<DataType, 6> supportedTypes
-
2716  {
-
2717  DataType::Float32,
-
2718  DataType::Float16,
-
2719  DataType::QAsymmS8,
-
2720  DataType::QAsymmU8,
-
2721  DataType::QSymmS16
-
2722  };
-
2723 
-
2724  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
-
2725  "PReLU: input is not a supported type.");
-
2726 
-
2727  supported &= CheckSupportRule(TypeAnyOf(alpha, supportedTypes), reasonIfUnsupported,
-
2728  "PReLU: alpha is not a supported type.");
-
2729 
-
2730  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
2731  "PReLU: output is not a supported type.");
-
2732 
-
2733  supported &= CheckSupportRule(TypesAreEqual(input, alpha, output), reasonIfUnsupported,
-
2734  "PReLU: input, alpha and output types are mismatched");
-
2735 
-
2736  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input, alpha, output), reasonIfUnsupported,
-
2737  "PReLU: shapes are not suitable for implicit broadcast");
-
2738 
-
2739  return supported;
-
2740 }
+

Definition at line 2777 of file RefLayerSupport.cpp.

+
2781 {
+
2782  bool supported = true;
+
2783 
+
2784  std::array<DataType, 6> supportedTypes
+
2785  {
+
2786  DataType::Float32,
+
2787  DataType::Float16,
+
2788  DataType::QAsymmS8,
+
2789  DataType::QAsymmU8,
+
2790  DataType::QSymmS16
+
2791  };
+
2792 
+
2793  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
+
2794  "PReLU: input is not a supported type.");
+
2795 
+
2796  supported &= CheckSupportRule(TypeAnyOf(alpha, supportedTypes), reasonIfUnsupported,
+
2797  "PReLU: alpha is not a supported type.");
+
2798 
+
2799  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
2800  "PReLU: output is not a supported type.");
+
2801 
+
2802  supported &= CheckSupportRule(TypesAreEqual(input, alpha, output), reasonIfUnsupported,
+
2803  "PReLU: input, alpha and output types are mismatched");
+
2804 
+
2805  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input, alpha, output), reasonIfUnsupported,
+
2806  "PReLU: shapes are not suitable for implicit broadcast");
+
2807 
+
2808  return supported;
+
2809 }
-

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

+

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -4671,21 +4685,21 @@ Additional Inherited Members
-

Definition at line 2250 of file RefLayerSupport.cpp.

-
2259 {
-
2260  IgnoreUnused(input);
-
2261  IgnoreUnused(previousOutputIn);
-
2262  IgnoreUnused(previousCellStateIn);
-
2263  IgnoreUnused(outputStateOut);
-
2264  IgnoreUnused(cellStateOut);
-
2265  IgnoreUnused(output);
-
2266  IgnoreUnused(descriptor);
-
2267  IgnoreUnused(paramsInfo);
-
2268 
-
2269  IgnoreUnused(reasonIfUnsupported);
-
2270 
-
2271  return true;
-
2272 }
+

Definition at line 2262 of file RefLayerSupport.cpp.

+
2271 {
+
2272  IgnoreUnused(input);
+
2273  IgnoreUnused(previousOutputIn);
+
2274  IgnoreUnused(previousCellStateIn);
+
2275  IgnoreUnused(outputStateOut);
+
2276  IgnoreUnused(cellStateOut);
+
2277  IgnoreUnused(output);
+
2278  IgnoreUnused(descriptor);
+
2279  IgnoreUnused(paramsInfo);
+
2280 
+
2281  IgnoreUnused(reasonIfUnsupported);
+
2282 
+
2283  return true;
+
2284 }

References armnn::IgnoreUnused().

@@ -4725,40 +4739,40 @@ Additional Inherited Members
-

Definition at line 2274 of file RefLayerSupport.cpp.

-
2277 {
-
2278  bool supported = true;
-
2279 
-
2280  // Define supported input types.
-
2281  std::array<DataType,7> supportedInputTypes = {
-
2282  DataType::Float32,
-
2283  DataType::Float16,
-
2284  DataType::QAsymmS8,
-
2285  DataType::QAsymmU8,
-
2286  DataType::QSymmS8,
-
2287  DataType::QSymmS16
-
2288  };
-
2289 
-
2290  supported &= CheckSupportRule(TypeAnyOf(input, supportedInputTypes), reasonIfUnsupported,
-
2291  "Reference quantize: input type not supported.");
-
2292 
-
2293  // Define supported output types.
-
2294  std::array<DataType,4> supportedOutputTypes = {
-
2295  DataType::QAsymmS8,
-
2296  DataType::QAsymmU8,
-
2297  DataType::QSymmS8,
-
2298  DataType::QSymmS16
-
2299  };
-
2300  supported &= CheckSupportRule(TypeAnyOf(output, supportedOutputTypes), reasonIfUnsupported,
-
2301  "Reference quantize: output type not supported.");
-
2302 
-
2303  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
-
2304  "Reference quantize: input and output shapes have different num total elements.");
-
2305 
-
2306  return supported;
-
2307 }
+

Definition at line 2286 of file RefLayerSupport.cpp.

+
2289 {
+
2290  bool supported = true;
+
2291 
+
2292  // Define supported input types.
+
2293  std::array<DataType,7> supportedInputTypes = {
+
2294  DataType::Float32,
+
2295  DataType::Float16,
+
2296  DataType::QAsymmS8,
+
2297  DataType::QAsymmU8,
+
2298  DataType::QSymmS8,
+
2299  DataType::QSymmS16
+
2300  };
+
2301 
+
2302  supported &= CheckSupportRule(TypeAnyOf(input, supportedInputTypes), reasonIfUnsupported,
+
2303  "Reference quantize: input type not supported.");
+
2304 
+
2305  // Define supported output types.
+
2306  std::array<DataType,4> supportedOutputTypes = {
+
2307  DataType::QAsymmS8,
+
2308  DataType::QAsymmU8,
+
2309  DataType::QSymmS8,
+
2310  DataType::QSymmS16
+
2311  };
+
2312  supported &= CheckSupportRule(TypeAnyOf(output, supportedOutputTypes), reasonIfUnsupported,
+
2313  "Reference quantize: output type not supported.");
+
2314 
+
2315  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
+
2316  "Reference quantize: input and output shapes have different num total elements.");
+
2317 
+
2318  return supported;
+
2319 }
-

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::QSymmS8.

+

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::QSymmS8.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -4796,20 +4810,20 @@ Additional Inherited Members
-

Definition at line 2309 of file RefLayerSupport.cpp.

-
2312 {
-
2313  IgnoreUnused(input);
-
2314  // Define supported output types.
-
2315  std::array<DataType,1> supportedOutputTypes =
-
2316  {
-
2317  DataType::Signed32,
-
2318  };
-
2319 
-
2320  return CheckSupportRule(TypeAnyOf(output, supportedOutputTypes), reasonIfUnsupported,
-
2321  "Reference rank: input type not supported.");
-
2322 }
+

Definition at line 2321 of file RefLayerSupport.cpp.

+
2324 {
+
2325  IgnoreUnused(input);
+
2326  // Define supported output types.
+
2327  std::array<DataType,1> supportedOutputTypes =
+
2328  {
+
2329  DataType::Signed32,
+
2330  };
+
2331 
+
2332  return CheckSupportRule(TypeAnyOf(output, supportedOutputTypes), reasonIfUnsupported,
+
2333  "Reference rank: input type not supported.");
+
2334 }
-

References armnn::CheckSupportRule(), armnn::IgnoreUnused(), and armnn::Signed32.

+

References armnn::CheckSupportRule(), armnn::IgnoreUnused(), and armnn::Signed32.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -4853,33 +4867,33 @@ Additional Inherited Members
-

Definition at line 2324 of file RefLayerSupport.cpp.

-
2328 {
-
2329  IgnoreUnused(descriptor);
-
2330  bool supported = true;
-
2331  std::array<DataType,7> supportedTypes =
-
2332  {
-
2333  DataType::Float32,
-
2334  DataType::Float16,
-
2335  DataType::QAsymmS8,
-
2336  DataType::QAsymmU8,
-
2337  DataType::QSymmS16,
-
2338  DataType::Signed32
-
2339  };
-
2340 
-
2341  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
-
2342  "Reference Reduce: input type not supported");
-
2343 
-
2344  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
2345  "Reference Reduce: output type not supported");
-
2346 
-
2347  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
-
2348  "Reference Reduce: input and output types not matching");
-
2349 
-
2350  return supported;
-
2351 }
+

Definition at line 2336 of file RefLayerSupport.cpp.

+
2340 {
+
2341  IgnoreUnused(descriptor);
+
2342  bool supported = true;
+
2343  std::array<DataType,7> supportedTypes =
+
2344  {
+
2345  DataType::Float32,
+
2346  DataType::Float16,
+
2347  DataType::QAsymmS8,
+
2348  DataType::QAsymmU8,
+
2349  DataType::QSymmS16,
+
2350  DataType::Signed32
+
2351  };
+
2352 
+
2353  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
+
2354  "Reference Reduce: input type not supported");
+
2355 
+
2356  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
2357  "Reference Reduce: output type not supported");
+
2358 
+
2359  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
+
2360  "Reference Reduce: input and output types not matching");
+
2361 
+
2362  return supported;
+
2363 }
-

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

+

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -4923,28 +4937,28 @@ Additional Inherited Members
-

Definition at line 2353 of file RefLayerSupport.cpp.

-
2357 {
-
2358  IgnoreUnused(output);
-
2359  IgnoreUnused(descriptor);
-
2360  // Define supported output types.
-
2361  std::array<DataType,8> supportedOutputTypes =
-
2362  {
-
2363  DataType::BFloat16,
-
2364  DataType::Float32,
-
2365  DataType::Float16,
-
2366  DataType::Signed32,
-
2367  DataType::QAsymmS8,
-
2368  DataType::QAsymmU8,
-
2369  DataType::QSymmS16,
-
2370  DataType::Boolean
-
2371  };
-
2372 
-
2373  return CheckSupportRule(TypeAnyOf(input, supportedOutputTypes), reasonIfUnsupported,
-
2374  "Reference reshape: input type not supported.");
-
2375 }
+

Definition at line 2365 of file RefLayerSupport.cpp.

+
2369 {
+
2370  IgnoreUnused(output);
+
2371  IgnoreUnused(descriptor);
+
2372  // Define supported output types.
+
2373  std::array<DataType,8> supportedOutputTypes =
+
2374  {
+
2375  DataType::BFloat16,
+
2376  DataType::Float32,
+
2377  DataType::Float16,
+
2378  DataType::Signed32,
+
2379  DataType::QAsymmS8,
+
2380  DataType::QAsymmU8,
+
2381  DataType::QSymmS16,
+
2382  DataType::Boolean
+
2383  };
+
2384 
+
2385  return CheckSupportRule(TypeAnyOf(input, supportedOutputTypes), reasonIfUnsupported,
+
2386  "Reference reshape: input type not supported.");
+
2387 }
-

References armnn::BFloat16, armnn::Boolean, armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

+

References armnn::BFloat16, armnn::Boolean, armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -4988,34 +5002,34 @@ Additional Inherited Members
-

Definition at line 2377 of file RefLayerSupport.cpp.

-
2381 {
-
2382  IgnoreUnused(descriptor);
-
2383  bool supported = true;
-
2384  std::array<DataType,7> supportedTypes =
-
2385  {
-
2386  DataType::BFloat16,
-
2387  DataType::Float32,
-
2388  DataType::Float16,
-
2389  DataType::QAsymmS8,
-
2390  DataType::QAsymmU8,
-
2391  DataType::QSymmS8,
-
2392  DataType::QSymmS16
-
2393  };
-
2394 
-
2395  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
-
2396  "Reference Resize: input type not supported");
-
2397 
-
2398  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
2399  "Reference Resize: output type not supported");
-
2400 
-
2401  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
-
2402  "Reference Resize: input and output types not matching");
-
2403 
-
2404  return supported;
-
2405 }
+

Definition at line 2389 of file RefLayerSupport.cpp.

+
2393 {
+
2394  IgnoreUnused(descriptor);
+
2395  bool supported = true;
+
2396  std::array<DataType,7> supportedTypes =
+
2397  {
+
2398  DataType::BFloat16,
+
2399  DataType::Float32,
+
2400  DataType::Float16,
+
2401  DataType::QAsymmS8,
+
2402  DataType::QAsymmU8,
+
2403  DataType::QSymmS8,
+
2404  DataType::QSymmS16
+
2405  };
+
2406 
+
2407  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
+
2408  "Reference Resize: input type not supported");
+
2409 
+
2410  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
2411  "Reference Resize: output type not supported");
+
2412 
+
2413  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
+
2414  "Reference Resize: input and output types not matching");
+
2415 
+
2416  return supported;
+
2417 }
-

References armnn::BFloat16, armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::QSymmS8.

+

References armnn::BFloat16, armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::QSymmS8.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -5059,43 +5073,152 @@ Additional Inherited Members
-

Definition at line 2407 of file RefLayerSupport.cpp.

-
2411 {
-
2412  bool supported = true;
-
2413  // ReverseV2 is data type agnostic so it can support all the types in the Reference backend
-
2414  std::array<DataType,8> supportedTypes =
-
2415  {
-
2416  DataType::BFloat16,
-
2417  DataType::Float32,
-
2418  DataType::Float16,
-
2419  DataType::QAsymmS8,
-
2420  DataType::QAsymmU8,
-
2421  DataType::QSymmS8,
-
2422  DataType::QSymmS16,
-
2423  DataType::Signed32
-
2424  };
-
2425 
-
2426  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
-
2427  "Reference ReverseV2: input0 type not supported");
-
2428 
-
2429  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
2430  "Reference ReverseV2: output type not supported");
-
2431 
-
2432  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
-
2433  "Reference ReverseV2: input0 and output types not matching");
-
2434 
-
2435  std::array<DataType,6> input2SupportedTypes =
-
2436  {
-
2437  DataType::Signed32
-
2438  };
-
2439 
-
2440  supported &= CheckSupportRule(TypeAnyOf(input1, input2SupportedTypes), reasonIfUnsupported,
-
2441  "Reference ReverseV2: input1 type not supported");
-
2442 
-
2443  return supported;
-
2444 }
+

Definition at line 2419 of file RefLayerSupport.cpp.

+
2423 {
+
2424  bool supported = true;
+
2425  // ReverseV2 is data type agnostic so it can support all the types in the Reference backend
+
2426  std::array<DataType,8> supportedTypes =
+
2427  {
+
2428  DataType::BFloat16,
+
2429  DataType::Float32,
+
2430  DataType::Float16,
+
2431  DataType::QAsymmS8,
+
2432  DataType::QAsymmU8,
+
2433  DataType::QSymmS8,
+
2434  DataType::QSymmS16,
+
2435  DataType::Signed32
+
2436  };
+
2437 
+
2438  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
+
2439  "Reference ReverseV2: input0 type not supported");
+
2440 
+
2441  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
2442  "Reference ReverseV2: output type not supported");
+
2443 
+
2444  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
+
2445  "Reference ReverseV2: input0 and output types not matching");
+
2446 
+
2447  std::array<DataType,6> input2SupportedTypes =
+
2448  {
+
2449  DataType::Signed32
+
2450  };
+
2451 
+
2452  supported &= CheckSupportRule(TypeAnyOf(input1, input2SupportedTypes), reasonIfUnsupported,
+
2453  "Reference ReverseV2: input1 type not supported");
+
2454 
+
2455  return supported;
+
2456 }
+
+

References armnn::BFloat16, armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, armnn::QSymmS8, and armnn::Signed32.

+ +

Referenced by RefLayerSupport::IsLayerSupported().

+ +
+
+ +

◆ IsScatterNdSupported()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool IsScatterNdSupported (const TensorInfo & input,
const TensorInfo & indices,
const TensorInfo & updates,
const TensorInfo & output,
const ScatterNdDescriptor & descriptor,
Optional< std::string & > reasonIfUnsupported = EmptyOptional() 
) const
+
+ +

Definition at line 2458 of file RefLayerSupport.cpp.

+
2464 {
+
2465  IgnoreUnused(descriptor);
+
2466 
+
2467  bool supported = true;
+
2468 
+
2469  std::array<DataType, 7> supportedTypes
+
2470  {
+
2471  DataType::Float32,
+
2472  DataType::Float16,
+
2473  DataType::QAsymmS8,
+
2474  DataType::QAsymmU8,
+
2475  DataType::QSymmS8,
+
2476  DataType::QSymmS16,
+
2477  DataType::Signed32
+
2478  };
+
2479 
+
2480  std::array<DataType, 1> indicesSupportedTypes =
+
2481  {
+
2482  DataType::Signed32
+
2483  };
+
2484 
+
2485  supported &= CheckSupportRule(TypeAnyOf(indices, indicesSupportedTypes), reasonIfUnsupported,
+
2486  "ScatterNd: indices type not supported.");
+
2487 
+
2488  supported &= CheckSupportRule(TypeAnyOf(updates, supportedTypes), reasonIfUnsupported,
+
2489  "ScatterNd: updates type not supported.");
+
2490 
+
2491  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
2492  "ScatterNd: output type not supported");
+
2493 
+
2494  supported &= CheckSupportRule(TypesAreEqual(updates, output), reasonIfUnsupported,
+
2495  "ScatterNd: input and updates types are mismatched");
+
2496 
+
2497  if (descriptor.m_InputEnabled)
+
2498  {
+
2499  // If the input slot is enabled, we have the input tensor in this slot
+
2500  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
+
2501  "ScatterNd: input type not supported.");
+
2502 
+
2503  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
+
2504  "ScatterNd: input and output types are mismatched");
+
2505  }
+
2506  else
+
2507  {
+
2508  // If the input slot is not enabled, we have the shape tensor in this slot
+
2509  supported &= CheckSupportRule(TypeAnyOf(input, indicesSupportedTypes), reasonIfUnsupported,
+
2510  "ScatterNd: shape type not supported.");
+
2511  }
+
2512 
+
2513  return supported;
+
2514 }
-

References armnn::BFloat16, armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, armnn::QSymmS8, and armnn::Signed32.

+

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), ScatterNdDescriptor::m_InputEnabled, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, armnn::QSymmS8, and armnn::Signed32.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -5133,23 +5256,23 @@ Additional Inherited Members
-

Definition at line 2446 of file RefLayerSupport.cpp.

-
2449 {
-
2450  IgnoreUnused(input);
-
2451  bool supported = true;
-
2452 
-
2453  std::array<DataType, 1> supportedTypes =
-
2454  {
-
2455  DataType::Signed32
-
2456  };
-
2457 
-
2458  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
2459  "Reference Shape: output type not supported");
-
2460 
-
2461  return supported;
-
2462 }
+

Definition at line 2516 of file RefLayerSupport.cpp.

+
2519 {
+
2520  IgnoreUnused(input);
+
2521  bool supported = true;
+
2522 
+
2523  std::array<DataType, 1> supportedTypes =
+
2524  {
+
2525  DataType::Signed32
+
2526  };
+
2527 
+
2528  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
2529  "Reference Shape: output type not supported");
+
2530 
+
2531  return supported;
+
2532 }
-

References armnn::CheckSupportRule(), armnn::IgnoreUnused(), and armnn::Signed32.

+

References armnn::CheckSupportRule(), armnn::IgnoreUnused(), and armnn::Signed32.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -5193,33 +5316,33 @@ Additional Inherited Members
-

Definition at line 2464 of file RefLayerSupport.cpp.

-
2468 {
-
2469  IgnoreUnused(descriptor);
-
2470  bool supported = true;
-
2471 
-
2472  std::array<DataType, 5> supportedTypes =
-
2473  {
-
2474  DataType::Float32,
-
2475  DataType::QAsymmS8,
-
2476  DataType::QAsymmU8,
-
2477  DataType::QSymmS16,
-
2478  DataType::Signed32
-
2479  };
-
2480 
-
2481  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
-
2482  "Reference Slice: input type not supported");
-
2483 
-
2484  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
2485  "Reference Slice: output type not supported");
-
2486 
-
2487  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
-
2488  "Reference Slice: input and output types are mismatched");
-
2489 
-
2490  return supported;
-
2491 }
+

Definition at line 2534 of file RefLayerSupport.cpp.

+
2538 {
+
2539  IgnoreUnused(descriptor);
+
2540  bool supported = true;
+
2541 
+
2542  std::array<DataType, 5> supportedTypes =
+
2543  {
+
2544  DataType::Float32,
+
2545  DataType::QAsymmS8,
+
2546  DataType::QAsymmU8,
+
2547  DataType::QSymmS16,
+
2548  DataType::Signed32
+
2549  };
+
2550 
+
2551  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
+
2552  "Reference Slice: input type not supported");
+
2553 
+
2554  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
2555  "Reference Slice: output type not supported");
+
2556 
+
2557  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
+
2558  "Reference Slice: input and output types are mismatched");
+
2559 
+
2560  return supported;
+
2561 }
-

References armnn::CheckSupportRule(), armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

+

References armnn::CheckSupportRule(), armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -5263,33 +5386,33 @@ Additional Inherited Members
-

Definition at line 2493 of file RefLayerSupport.cpp.

-
2497 {
-
2498  IgnoreUnused(descriptor);
-
2499  bool supported = true;
-
2500  std::array<DataType,7> supportedTypes =
-
2501  {
-
2502  DataType::Float32,
-
2503  DataType::Float16,
-
2504  DataType::QSymmS8,
-
2505  DataType::QAsymmS8,
-
2506  DataType::QAsymmU8,
-
2507  DataType::QSymmS16
-
2508  };
-
2509 
-
2510  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
-
2511  "Reference Softmax: output type not supported");
-
2512 
-
2513  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
2514  "Reference Softmax: input type not supported");
-
2515 
-
2516  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
-
2517  "Reference Softmax: input type not supported");
-
2518 
-
2519  return supported;
-
2520 }
+

Definition at line 2563 of file RefLayerSupport.cpp.

+
2567 {
+
2568  IgnoreUnused(descriptor);
+
2569  bool supported = true;
+
2570  std::array<DataType,7> supportedTypes =
+
2571  {
+
2572  DataType::Float32,
+
2573  DataType::Float16,
+
2574  DataType::QSymmS8,
+
2575  DataType::QAsymmS8,
+
2576  DataType::QAsymmU8,
+
2577  DataType::QSymmS16
+
2578  };
+
2579 
+
2580  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
+
2581  "Reference Softmax: output type not supported");
+
2582 
+
2583  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
2584  "Reference Softmax: input type not supported");
+
2585 
+
2586  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
+
2587  "Reference Softmax: input type not supported");
+
2588 
+
2589  return supported;
+
2590 }
-

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::QSymmS8.

+

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::QSymmS8.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -5333,32 +5456,32 @@ Additional Inherited Members
-

Definition at line 2522 of file RefLayerSupport.cpp.

-
2526 {
-
2527  IgnoreUnused(descriptor);
-
2528  bool supported = true;
-
2529  std::array<DataType,6> supportedTypes =
-
2530  {
-
2531  DataType::Float32,
-
2532  DataType::Float16,
-
2533  DataType::QAsymmS8,
-
2534  DataType::QAsymmU8,
-
2535  DataType::QSymmS16
-
2536  };
-
2537 
-
2538  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
-
2539  "Reference SpaceToBatchNd: input type not supported");
-
2540 
-
2541  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
2542  "Reference SpaceToBatchNd: output type not supported");
-
2543 
-
2544  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
-
2545  "Reference SpaceToBatchNd: input and output types are mismatched");
-
2546 
-
2547  return supported;
-
2548 }
+

Definition at line 2592 of file RefLayerSupport.cpp.

+
2596 {
+
2597  IgnoreUnused(descriptor);
+
2598  bool supported = true;
+
2599  std::array<DataType,6> supportedTypes =
+
2600  {
+
2601  DataType::Float32,
+
2602  DataType::Float16,
+
2603  DataType::QAsymmS8,
+
2604  DataType::QAsymmU8,
+
2605  DataType::QSymmS16
+
2606  };
+
2607 
+
2608  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
+
2609  "Reference SpaceToBatchNd: input type not supported");
+
2610 
+
2611  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
2612  "Reference SpaceToBatchNd: output type not supported");
+
2613 
+
2614  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
+
2615  "Reference SpaceToBatchNd: input and output types are mismatched");
+
2616 
+
2617  return supported;
+
2618 }
-

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

+

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -5402,34 +5525,34 @@ Additional Inherited Members
-

Definition at line 2550 of file RefLayerSupport.cpp.

-
2554 {
-
2555 
-
2556  IgnoreUnused(descriptor);
-
2557  bool supported = true;
-
2558 
-
2559  std::array<DataType,6> supportedTypes =
-
2560  {
-
2561  DataType::Float32,
-
2562  DataType::Float16,
-
2563  DataType::QAsymmS8,
-
2564  DataType::QAsymmU8,
-
2565  DataType::QSymmS16
-
2566  };
-
2567 
-
2568  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
-
2569  "Reference SpaceToDepth: input type not supported");
-
2570 
-
2571  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
2572  "Reference SpaceToDepth: output type not supported");
-
2573 
-
2574  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
-
2575  "Reference SpaceToDepth: input and output types are mismatched");
-
2576 
-
2577  return supported;
-
2578 }
+

Definition at line 2620 of file RefLayerSupport.cpp.

+
2624 {
+
2625 
+
2626  IgnoreUnused(descriptor);
+
2627  bool supported = true;
+
2628 
+
2629  std::array<DataType,6> supportedTypes =
+
2630  {
+
2631  DataType::Float32,
+
2632  DataType::Float16,
+
2633  DataType::QAsymmS8,
+
2634  DataType::QAsymmU8,
+
2635  DataType::QSymmS16
+
2636  };
+
2637 
+
2638  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
+
2639  "Reference SpaceToDepth: input type not supported");
+
2640 
+
2641  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
2642  "Reference SpaceToDepth: output type not supported");
+
2643 
+
2644  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
+
2645  "Reference SpaceToDepth: input and output types are mismatched");
+
2646 
+
2647  return supported;
+
2648 }
-

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

+

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -5473,34 +5596,34 @@ Additional Inherited Members
-

Definition at line 2580 of file RefLayerSupport.cpp.

-
2584 {
-
2585  IgnoreUnused(descriptor);
-
2586  bool supported = true;
-
2587  std::array<DataType,6> supportedTypes =
-
2588  {
-
2589  DataType::Float32,
-
2590  DataType::Float16,
-
2591  DataType::QAsymmS8,
-
2592  DataType::QAsymmU8,
-
2593  DataType::QSymmS16
-
2594  };
-
2595 
-
2596  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
-
2597  "Reference splitter: output type not supported");
-
2598  for (const TensorInfo& output : outputs)
-
2599  {
-
2600  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
-
2601  "Reference splitter: input type not supported");
-
2602 
-
2603  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
-
2604  "Reference splitter: input and output types mismatched.");
-
2605  }
-
2606 
-
2607  return supported;
-
2608 }
+

Definition at line 2650 of file RefLayerSupport.cpp.

+
2654 {
+
2655  IgnoreUnused(descriptor);
+
2656  bool supported = true;
+
2657  std::array<DataType,6> supportedTypes =
+
2658  {
+
2659  DataType::Float32,
+
2660  DataType::Float16,
+
2661  DataType::QAsymmS8,
+
2662  DataType::QAsymmU8,
+
2663  DataType::QSymmS16
+
2664  };
+
2665 
+
2666  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
+
2667  "Reference splitter: output type not supported");
+
2668  for (const TensorInfo& output : outputs)
+
2669  {
+
2670  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
+
2671  "Reference splitter: input type not supported");
+
2672 
+
2673  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
+
2674  "Reference splitter: input and output types mismatched.");
+
2675  }
+
2676 
+
2677  return supported;
+
2678 }
-

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

+

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -5544,37 +5667,36 @@ Additional Inherited Members
-

Definition at line 2610 of file RefLayerSupport.cpp.

-
2614 {
-
2615  IgnoreUnused(descriptor);
-
2616 
-
2617  bool supported = true;
-
2618  std::array<DataType,7> supportedTypes =
-
2619  {
-
2620  DataType::Float32,
-
2621  DataType::Float16,
-
2622  DataType::QAsymmS8,
-
2623  DataType::QAsymmU8,
-
2624  DataType::QSymmS16,
-
2625  DataType::Signed32
-
2626  };
-
2627 
-
2628  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
2629  "Reference stack: output type not supported");
-
2630  for (const TensorInfo* input : inputs)
-
2631  {
-
2632  ARMNN_ASSERT(input != nullptr);
-
2633  supported &= CheckSupportRule(TypeAnyOf(*input, supportedTypes), reasonIfUnsupported,
-
2634  "Reference stack: input type not supported");
-
2635 
-
2636  supported &= CheckSupportRule(TypesAreEqual(*input, output), reasonIfUnsupported,
-
2637  "Reference stack: input and output types mismatched.");
-
2638  }
-
2639 
-
2640  return supported;
-
2641 }
+

Definition at line 2680 of file RefLayerSupport.cpp.

+
2684 {
+
2685  IgnoreUnused(descriptor);
+
2686 
+
2687  bool supported = true;
+
2688  std::array<DataType,7> supportedTypes =
+
2689  {
+
2690  DataType::Float32,
+
2691  DataType::Float16,
+
2692  DataType::QAsymmS8,
+
2693  DataType::QAsymmU8,
+
2694  DataType::QSymmS16,
+
2695  DataType::Signed32
+
2696  };
+
2697 
+
2698  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
2699  "Reference stack: output type not supported");
+
2700  for (const TensorInfo* input : inputs)
+
2701  {
+
2702  supported &= CheckSupportRule(TypeAnyOf(*input, supportedTypes), reasonIfUnsupported,
+
2703  "Reference stack: input type not supported");
+
2704 
+
2705  supported &= CheckSupportRule(TypesAreEqual(*input, output), reasonIfUnsupported,
+
2706  "Reference stack: input and output types mismatched.");
+
2707  }
+
2708 
+
2709  return supported;
+
2710 }
-

References ARMNN_ASSERT, armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

+

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -5618,32 +5740,32 @@ Additional Inherited Members
-

Definition at line 2643 of file RefLayerSupport.cpp.

-
2647 {
-
2648  IgnoreUnused(descriptor);
-
2649  bool supported = true;
-
2650 
-
2651  std::array<DataType,5> supportedTypes =
-
2652  {
-
2653  DataType::Float32,
-
2654  DataType::QAsymmS8,
-
2655  DataType::QAsymmU8,
-
2656  DataType::QSymmS16
-
2657  };
-
2658 
-
2659  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
-
2660  "Reference StridedSlice: input type not supported");
-
2661 
-
2662  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
2663  "Reference StridedSlice: output type not supported");
-
2664 
-
2665  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
-
2666  "Reference StridedSlice: input and output types are mismatched");
-
2667 
-
2668  return supported;
-
2669 }
+

Definition at line 2712 of file RefLayerSupport.cpp.

+
2716 {
+
2717  IgnoreUnused(descriptor);
+
2718  bool supported = true;
+
2719 
+
2720  std::array<DataType,5> supportedTypes =
+
2721  {
+
2722  DataType::Float32,
+
2723  DataType::QAsymmS8,
+
2724  DataType::QAsymmU8,
+
2725  DataType::QSymmS16
+
2726  };
+
2727 
+
2728  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
+
2729  "Reference StridedSlice: input type not supported");
+
2730 
+
2731  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
2732  "Reference StridedSlice: output type not supported");
+
2733 
+
2734  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
+
2735  "Reference StridedSlice: input and output types are mismatched");
+
2736 
+
2737  return supported;
+
2738 }
-

References armnn::CheckSupportRule(), armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

+

References armnn::CheckSupportRule(), armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -5687,41 +5809,41 @@ Additional Inherited Members
-

Definition at line 2671 of file RefLayerSupport.cpp.

-
2675 {
-
2676  bool supported = true;
-
2677 
-
2678  std::array<DataType,7> supportedTypes = {
-
2679  DataType::Float32,
-
2680  DataType::Float16,
-
2681  DataType::QAsymmS8,
-
2682  DataType::QAsymmU8,
-
2683  DataType::QSymmS16,
-
2684  DataType::Signed32
-
2685  };
-
2686 
-
2687  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
-
2688  "Reference subtraction: input 0 is not a supported type.");
-
2689 
-
2690  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
-
2691  "Reference subtraction: input 1 is not a supported type.");
-
2692 
-
2693  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
2694  "Reference subtraction: output is not a supported type.");
-
2695 
-
2696  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
-
2697  "Reference subtraction: input 0 and Input 1 types are mismatched");
-
2698 
-
2699  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
-
2700  "Reference subtraction: input and output types are mismatched");
-
2701 
-
2702  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
-
2703  "Reference subtraction: shapes are not suitable for implicit broadcast.");
-
2704 
-
2705  return supported;
-
2706 }
+

Definition at line 2740 of file RefLayerSupport.cpp.

+
2744 {
+
2745  bool supported = true;
+
2746 
+
2747  std::array<DataType,7> supportedTypes = {
+
2748  DataType::Float32,
+
2749  DataType::Float16,
+
2750  DataType::QAsymmS8,
+
2751  DataType::QAsymmU8,
+
2752  DataType::QSymmS16,
+
2753  DataType::Signed32
+
2754  };
+
2755 
+
2756  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
+
2757  "Reference subtraction: input 0 is not a supported type.");
+
2758 
+
2759  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
+
2760  "Reference subtraction: input 1 is not a supported type.");
+
2761 
+
2762  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
2763  "Reference subtraction: output is not a supported type.");
+
2764 
+
2765  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
+
2766  "Reference subtraction: input 0 and Input 1 types are mismatched");
+
2767 
+
2768  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
+
2769  "Reference subtraction: input and output types are mismatched");
+
2770 
+
2771  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
+
2772  "Reference subtraction: shapes are not suitable for implicit broadcast.");
+
2773 
+
2774  return supported;
+
2775 }
-

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

+

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -5765,33 +5887,33 @@ Additional Inherited Members
-

Definition at line 2742 of file RefLayerSupport.cpp.

-
2746 {
-
2747  IgnoreUnused(descriptor);
-
2748 
-
2749  bool supported = true;
-
2750 
-
2751  std::array<DataType, 7> supportedTypes
-
2752  {
-
2753  DataType::Float32,
-
2754  DataType::Float16,
-
2755  DataType::QAsymmS8,
-
2756  DataType::QAsymmU8,
-
2757  DataType::QSymmS8,
-
2758  DataType::QSymmS16,
-
2759  DataType::Signed32
-
2760  };
-
2761 
-
2762  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
-
2763  "Tile: input type not supported.");
-
2764 
-
2765  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
2766  "Tile: output type not supported");
-
2767 
-
2768  return supported;
-
2769 }
+

Definition at line 2811 of file RefLayerSupport.cpp.

+
2815 {
+
2816  IgnoreUnused(descriptor);
+
2817 
+
2818  bool supported = true;
+
2819 
+
2820  std::array<DataType, 7> supportedTypes
+
2821  {
+
2822  DataType::Float32,
+
2823  DataType::Float16,
+
2824  DataType::QAsymmS8,
+
2825  DataType::QAsymmU8,
+
2826  DataType::QSymmS8,
+
2827  DataType::QSymmS16,
+
2828  DataType::Signed32
+
2829  };
+
2830 
+
2831  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
+
2832  "Tile: input type not supported.");
+
2833 
+
2834  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
2835  "Tile: output type not supported");
+
2836 
+
2837  return supported;
+
2838 }
-

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, armnn::QSymmS8, and armnn::Signed32.

+

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, armnn::QSymmS8, and armnn::Signed32.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -5847,70 +5969,70 @@ Additional Inherited Members
-

Definition at line 2771 of file RefLayerSupport.cpp.

-
2777 {
-
2778  IgnoreUnused(descriptor);
-
2779  bool supported = true;
-
2780 
-
2781  std::array<DataType,7> supportedTypes =
-
2782  {
-
2783  DataType::Float32,
-
2784  DataType::Float16,
-
2785  DataType::QAsymmS8,
-
2786  DataType::QAsymmU8,
-
2787  DataType::QSymmS8,
-
2788  DataType::QSymmS16
-
2789  };
-
2790 
-
2791  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
-
2792  "Reference TransposeConvolution2d: input is not a supported type.");
-
2793 
-
2794  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
2795  "Reference TransposeConvolution2d: output is not a supported type.");
-
2796 
-
2797  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
-
2798  "Reference TransposeConvolution2d: input and output types mismatched.");
-
2799 
-
2800 
-
2801  const DataType inputType = input.GetDataType();
-
2802  if (IsQuantized8BitType(inputType))
-
2803  {
-
2804  std::array<DataType, 3> supportedWeightTypes =
-
2805  {
-
2806  DataType::QAsymmS8,
-
2807  DataType::QAsymmU8,
-
2808  DataType::QSymmS8
-
2809  };
-
2810 
-
2811  supported &= CheckSupportRule(TypeAnyOf(weights, supportedWeightTypes), reasonIfUnsupported,
-
2812  "Reference TransposeConvolution2d: weights type not supported for "
-
2813  "quantized input.");
-
2814  }
-
2815  else
-
2816  {
-
2817  supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
-
2818  "Reference TransposeConvolution2d: weights is not a supported type.");
-
2819 
-
2820  supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
-
2821  "Reference TransposeConvolution2d: input and weights types mismatched.");
-
2822  }
-
2823 
-
2824  if (biases.has_value())
-
2825  {
-
2826  std::array<DataType,4> biasesSupportedTypes =
-
2827  {
-
2828  DataType::Float32,
-
2829  DataType::Float16,
-
2830  DataType::Signed32
-
2831  };
-
2832  supported &= CheckSupportRule(TypeAnyOf(biases.value(), biasesSupportedTypes), reasonIfUnsupported,
-
2833  "Reference TransposeConvolution2d: biases is not a supported type.");
-
2834  }
-
2835 
-
2836  return supported;
-
2837 }
+

Definition at line 2840 of file RefLayerSupport.cpp.

+
2846 {
+
2847  IgnoreUnused(descriptor);
+
2848  bool supported = true;
+
2849 
+
2850  std::array<DataType,7> supportedTypes =
+
2851  {
+
2852  DataType::Float32,
+
2853  DataType::Float16,
+
2854  DataType::QAsymmS8,
+
2855  DataType::QAsymmU8,
+
2856  DataType::QSymmS8,
+
2857  DataType::QSymmS16
+
2858  };
+
2859 
+
2860  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
+
2861  "Reference TransposeConvolution2d: input is not a supported type.");
+
2862 
+
2863  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
2864  "Reference TransposeConvolution2d: output is not a supported type.");
+
2865 
+
2866  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
+
2867  "Reference TransposeConvolution2d: input and output types mismatched.");
+
2868 
+
2869 
+
2870  const DataType inputType = input.GetDataType();
+
2871  if (IsQuantized8BitType(inputType))
+
2872  {
+
2873  std::array<DataType, 3> supportedWeightTypes =
+
2874  {
+
2875  DataType::QAsymmS8,
+
2876  DataType::QAsymmU8,
+
2877  DataType::QSymmS8
+
2878  };
+
2879 
+
2880  supported &= CheckSupportRule(TypeAnyOf(weights, supportedWeightTypes), reasonIfUnsupported,
+
2881  "Reference TransposeConvolution2d: weights type not supported for "
+
2882  "quantized input.");
+
2883  }
+
2884  else
+
2885  {
+
2886  supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
+
2887  "Reference TransposeConvolution2d: weights is not a supported type.");
+
2888 
+
2889  supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
+
2890  "Reference TransposeConvolution2d: input and weights types mismatched.");
+
2891  }
+
2892 
+
2893  if (biases.has_value())
+
2894  {
+
2895  std::array<DataType,4> biasesSupportedTypes =
+
2896  {
+
2897  DataType::Float32,
+
2898  DataType::Float16,
+
2899  DataType::Signed32
+
2900  };
+
2901  supported &= CheckSupportRule(TypeAnyOf(biases.value(), biasesSupportedTypes), reasonIfUnsupported,
+
2902  "Reference TransposeConvolution2d: biases is not a supported type.");
+
2903  }
+
2904 
+
2905  return supported;
+
2906 }
-

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, TensorInfo::GetDataType(), OptionalBase::has_value(), armnn::IgnoreUnused(), armnn::IsQuantized8BitType(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, armnn::QSymmS8, armnn::Signed32, and OptionalReferenceSwitch< std::is_reference< T >::value, T >::value().

+

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, TensorInfo::GetDataType(), OptionalBase::has_value(), armnn::IgnoreUnused(), armnn::IsQuantized8BitType(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, armnn::QSymmS8, armnn::Signed32, and OptionalReferenceSwitch< std::is_reference< T >::value, T >::value().

Referenced by RefLayerSupport::IsLayerSupported().

@@ -5954,35 +6076,35 @@ Additional Inherited Members
-

Definition at line 2839 of file RefLayerSupport.cpp.

-
2843 {
-
2844  IgnoreUnused(descriptor);
-
2845  bool supported = true;
-
2846 
-
2847  // Define supported output and inputs types.
-
2848  std::array<DataType, 6> supportedTypes =
-
2849  {
-
2850  DataType::BFloat16,
-
2851  DataType::Float32,
-
2852  DataType::Float16,
-
2853  DataType::QAsymmS8,
-
2854  DataType::QAsymmU8,
-
2855  DataType::QSymmS16
-
2856  };
-
2857 
-
2858  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
-
2859  "Reference transpose: input is not a supported type.");
-
2860 
-
2861  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
2862  "Reference transpose: output is not a supported type.");
-
2863 
-
2864  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
-
2865  "Reference transpose: input and output types are mismatched.");
-
2866 
-
2867  return supported;
-
2868 }
+

Definition at line 2908 of file RefLayerSupport.cpp.

+
2912 {
+
2913  IgnoreUnused(descriptor);
+
2914  bool supported = true;
+
2915 
+
2916  // Define supported output and inputs types.
+
2917  std::array<DataType, 6> supportedTypes =
+
2918  {
+
2919  DataType::BFloat16,
+
2920  DataType::Float32,
+
2921  DataType::Float16,
+
2922  DataType::QAsymmS8,
+
2923  DataType::QAsymmU8,
+
2924  DataType::QSymmS16
+
2925  };
+
2926 
+
2927  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
+
2928  "Reference transpose: input is not a supported type.");
+
2929 
+
2930  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
2931  "Reference transpose: output is not a supported type.");
+
2932 
+
2933  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
+
2934  "Reference transpose: input and output types are mismatched.");
+
2935 
+
2936  return supported;
+
2937 }
-

References armnn::BFloat16, armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

+

References armnn::BFloat16, armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -6056,143 +6178,143 @@ Additional Inherited Members
-

Definition at line 2870 of file RefLayerSupport.cpp.

-
2880 {
-
2881  IgnoreUnused(descriptor);
-
2882  IgnoreUnused(paramsInfo);
-
2883  IgnoreUnused(outputStateIn);
-
2884  IgnoreUnused(cellStateIn);
-
2885  IgnoreUnused(outputStateOut);
-
2886  IgnoreUnused(cellStateOut);
-
2887  bool supported = true;
-
2888 
-
2889  std::array<DataType, 2> supportedTypes =
-
2890  {
-
2891  DataType::Float32,
-
2892  DataType::QAsymmS8
-
2893  };
-
2894 
-
2895  std::array<DataType, 2> supportedWeightTypes =
-
2896  {
-
2897  DataType::Float32,
-
2898  DataType::QAsymmS8
-
2899  };
-
2900 
-
2901  std::array<DataType, 3> supportedBiasTypes =
-
2902  {
-
2903  DataType::Float32,
-
2904  DataType::QAsymmS8,
-
2905  DataType::Signed32
-
2906  };
-
2907 
-
2908  // check inputs and outputs
-
2909  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
-
2910  "Reference UnidirectionalSequenceLstm: input is not a supported type.");
-
2911  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
-
2912  "Reference UnidirectionalSequenceLstm: output is not a supported type.");
-
2913 
-
2914  // check layer parameters
-
2915  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetInputToForgetWeights(), supportedWeightTypes),
-
2916  reasonIfUnsupported,
-
2917  "Reference UnidirectionalSequenceLstm: InputToForgetWeights "
-
2918  "is not a supported type.");
-
2919  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetInputToCellWeights(), supportedWeightTypes),
-
2920  reasonIfUnsupported,
-
2921  "Reference UnidirectionalSequenceLstm: InputToCellWeights is not a supported type.");
-
2922  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetInputToOutputWeights(), supportedWeightTypes),
-
2923  reasonIfUnsupported,
-
2924  "Reference UnidirectionalSequenceLstm: InputToOutputWeights "
-
2925  "is not a supported type.");
-
2926  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetRecurrentToForgetWeights(), supportedWeightTypes),
-
2927  reasonIfUnsupported,
-
2928  "Reference UnidirectionalSequenceLstm: RecurrentToForgetWeights "
-
2929  "is not a supported type.");
-
2930  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetRecurrentToCellWeights(), supportedWeightTypes),
-
2931  reasonIfUnsupported,
-
2932  "Reference UnidirectionalSequenceLstm: RecurrentToCellWeights "
-
2933  "is not a supported type.");
-
2934  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetRecurrentToOutputWeights(), supportedWeightTypes),
-
2935  reasonIfUnsupported,
-
2936  "Reference UnidirectionalSequenceLstm: RecurrentToOutputWeights "
-
2937  "is not a supported type.");
-
2938 
-
2939  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetForgetGateBias(), supportedBiasTypes), reasonIfUnsupported,
-
2940  "Reference UnidirectionalSequenceLstm: ForgetGateBias is not a supported type.");
-
2941  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetCellBias(), supportedBiasTypes), reasonIfUnsupported,
-
2942  "Reference UnidirectionalSequenceLstm: CellBias is not a supported type.");
-
2943  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetOutputGateBias(), supportedBiasTypes), reasonIfUnsupported,
-
2944  "Reference UnidirectionalSequenceLstm: OutputGateBias is not a supported type.");
-
2945  if (!descriptor.m_CifgEnabled)
-
2946  {
-
2947  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetInputToInputWeights(), supportedWeightTypes),
-
2948  reasonIfUnsupported,
-
2949  "Reference UnidirectionalSequenceLstm: InputToInputWeights "
-
2950  "is not a supported type.");
-
2951  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetRecurrentToInputWeights(), supportedWeightTypes),
-
2952  reasonIfUnsupported,
-
2953  "Reference UnidirectionalSequenceLstm: RecurrentToInputWeights "
-
2954  "is not a supported type.");
-
2955  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetInputGateBias(), supportedBiasTypes), reasonIfUnsupported,
-
2956  "Reference UnidirectionalSequenceLstm: InputGateBias is not a supported type.");
-
2957  if (descriptor.m_PeepholeEnabled)
-
2958  {
-
2959  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetCellToInputWeights(), supportedWeightTypes),
-
2960  reasonIfUnsupported,
-
2961  "Reference UnidirectionalSequenceLstm: CellToInputWeights "
-
2962  "is not a supported type.");
-
2963  }
-
2964  }
-
2965  if (descriptor.m_PeepholeEnabled)
-
2966  {
-
2967  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetCellToForgetWeights(), supportedWeightTypes),
-
2968  reasonIfUnsupported,
-
2969  "Reference UnidirectionalSequenceLstm: CellToForgetWeights "
-
2970  "is not a supported type.");
-
2971  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetCellToOutputWeights(), supportedWeightTypes),
-
2972  reasonIfUnsupported,
-
2973  "Reference UnidirectionalSequenceLstm: CellToOutputWeights "
-
2974  "is not a supported type.");
-
2975  }
-
2976  if (descriptor.m_ProjectionEnabled)
-
2977  {
-
2978  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetProjectionWeights(), supportedWeightTypes),
-
2979  reasonIfUnsupported,
-
2980  "Reference UnidirectionalSequenceLstm: ProjectionWeights "
-
2981  "is not a supported type.");
-
2982  if (paramsInfo.m_ProjectionBias != nullptr)
-
2983  {
-
2984  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetProjectionBias()), reasonIfUnsupported,
-
2985  "Reference UnidirectionalSequenceLstm: input and ProjectionBias types "
-
2986  "are mismatched");
-
2987  }
-
2988  }
-
2989  if (descriptor.m_LayerNormEnabled)
-
2990  {
-
2991  if (!descriptor.m_CifgEnabled)
-
2992  {
-
2993  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetInputLayerNormWeights(), supportedWeightTypes),
-
2994  reasonIfUnsupported,
-
2995  "Reference UnidirectionalSequenceLstm: InputLayerNormWeights "
-
2996  "is not a supported type.");
-
2997  }
-
2998  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetForgetLayerNormWeights(), supportedWeightTypes),
-
2999  reasonIfUnsupported,
-
3000  "Reference UnidirectionalSequenceLstm: ForgetLayerNormWeights "
-
3001  "is not a supported type.");
-
3002  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetCellLayerNormWeights(), supportedWeightTypes),
-
3003  reasonIfUnsupported,
-
3004  "Reference UnidirectionalSequenceLstm: CellLayerNormWeights "
-
3005  "is not a supported type.");
-
3006  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetOutputLayerNormWeights(), supportedWeightTypes),
-
3007  reasonIfUnsupported,
-
3008  "Reference UnidirectionalSequenceLstm: OutputLayerNormWeights "
-
3009  "is not a supported type.");
-
3010  }
-
3011 
-
3012  return supported;
-
3013 }
+

Definition at line 2939 of file RefLayerSupport.cpp.

+
2949 {
+
2950  IgnoreUnused(descriptor);
+
2951  IgnoreUnused(paramsInfo);
+
2952  IgnoreUnused(outputStateIn);
+
2953  IgnoreUnused(cellStateIn);
+
2954  IgnoreUnused(outputStateOut);
+
2955  IgnoreUnused(cellStateOut);
+
2956  bool supported = true;
+
2957 
+
2958  std::array<DataType, 2> supportedTypes =
+
2959  {
+
2960  DataType::Float32,
+
2961  DataType::QAsymmS8
+
2962  };
+
2963 
+
2964  std::array<DataType, 2> supportedWeightTypes =
+
2965  {
+
2966  DataType::Float32,
+
2967  DataType::QAsymmS8
+
2968  };
+
2969 
+
2970  std::array<DataType, 3> supportedBiasTypes =
+
2971  {
+
2972  DataType::Float32,
+
2973  DataType::QAsymmS8,
+
2974  DataType::Signed32
+
2975  };
+
2976 
+
2977  // check inputs and outputs
+
2978  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
+
2979  "Reference UnidirectionalSequenceLstm: input is not a supported type.");
+
2980  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+
2981  "Reference UnidirectionalSequenceLstm: output is not a supported type.");
+
2982 
+
2983  // check layer parameters
+
2984  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetInputToForgetWeights(), supportedWeightTypes),
+
2985  reasonIfUnsupported,
+
2986  "Reference UnidirectionalSequenceLstm: InputToForgetWeights "
+
2987  "is not a supported type.");
+
2988  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetInputToCellWeights(), supportedWeightTypes),
+
2989  reasonIfUnsupported,
+
2990  "Reference UnidirectionalSequenceLstm: InputToCellWeights is not a supported type.");
+
2991  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetInputToOutputWeights(), supportedWeightTypes),
+
2992  reasonIfUnsupported,
+
2993  "Reference UnidirectionalSequenceLstm: InputToOutputWeights "
+
2994  "is not a supported type.");
+
2995  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetRecurrentToForgetWeights(), supportedWeightTypes),
+
2996  reasonIfUnsupported,
+
2997  "Reference UnidirectionalSequenceLstm: RecurrentToForgetWeights "
+
2998  "is not a supported type.");
+
2999  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetRecurrentToCellWeights(), supportedWeightTypes),
+
3000  reasonIfUnsupported,
+
3001  "Reference UnidirectionalSequenceLstm: RecurrentToCellWeights "
+
3002  "is not a supported type.");
+
3003  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetRecurrentToOutputWeights(), supportedWeightTypes),
+
3004  reasonIfUnsupported,
+
3005  "Reference UnidirectionalSequenceLstm: RecurrentToOutputWeights "
+
3006  "is not a supported type.");
+
3007 
+
3008  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetForgetGateBias(), supportedBiasTypes), reasonIfUnsupported,
+
3009  "Reference UnidirectionalSequenceLstm: ForgetGateBias is not a supported type.");
+
3010  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetCellBias(), supportedBiasTypes), reasonIfUnsupported,
+
3011  "Reference UnidirectionalSequenceLstm: CellBias is not a supported type.");
+
3012  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetOutputGateBias(), supportedBiasTypes), reasonIfUnsupported,
+
3013  "Reference UnidirectionalSequenceLstm: OutputGateBias is not a supported type.");
+
3014  if (!descriptor.m_CifgEnabled)
+
3015  {
+
3016  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetInputToInputWeights(), supportedWeightTypes),
+
3017  reasonIfUnsupported,
+
3018  "Reference UnidirectionalSequenceLstm: InputToInputWeights "
+
3019  "is not a supported type.");
+
3020  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetRecurrentToInputWeights(), supportedWeightTypes),
+
3021  reasonIfUnsupported,
+
3022  "Reference UnidirectionalSequenceLstm: RecurrentToInputWeights "
+
3023  "is not a supported type.");
+
3024  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetInputGateBias(), supportedBiasTypes), reasonIfUnsupported,
+
3025  "Reference UnidirectionalSequenceLstm: InputGateBias is not a supported type.");
+
3026  if (descriptor.m_PeepholeEnabled)
+
3027  {
+
3028  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetCellToInputWeights(), supportedWeightTypes),
+
3029  reasonIfUnsupported,
+
3030  "Reference UnidirectionalSequenceLstm: CellToInputWeights "
+
3031  "is not a supported type.");
+
3032  }
+
3033  }
+
3034  if (descriptor.m_PeepholeEnabled)
+
3035  {
+
3036  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetCellToForgetWeights(), supportedWeightTypes),
+
3037  reasonIfUnsupported,
+
3038  "Reference UnidirectionalSequenceLstm: CellToForgetWeights "
+
3039  "is not a supported type.");
+
3040  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetCellToOutputWeights(), supportedWeightTypes),
+
3041  reasonIfUnsupported,
+
3042  "Reference UnidirectionalSequenceLstm: CellToOutputWeights "
+
3043  "is not a supported type.");
+
3044  }
+
3045  if (descriptor.m_ProjectionEnabled)
+
3046  {
+
3047  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetProjectionWeights(), supportedWeightTypes),
+
3048  reasonIfUnsupported,
+
3049  "Reference UnidirectionalSequenceLstm: ProjectionWeights "
+
3050  "is not a supported type.");
+
3051  if (paramsInfo.m_ProjectionBias != nullptr)
+
3052  {
+
3053  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetProjectionBias()), reasonIfUnsupported,
+
3054  "Reference UnidirectionalSequenceLstm: input and ProjectionBias types "
+
3055  "are mismatched");
+
3056  }
+
3057  }
+
3058  if (descriptor.m_LayerNormEnabled)
+
3059  {
+
3060  if (!descriptor.m_CifgEnabled)
+
3061  {
+
3062  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetInputLayerNormWeights(), supportedWeightTypes),
+
3063  reasonIfUnsupported,
+
3064  "Reference UnidirectionalSequenceLstm: InputLayerNormWeights "
+
3065  "is not a supported type.");
+
3066  }
+
3067  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetForgetLayerNormWeights(), supportedWeightTypes),
+
3068  reasonIfUnsupported,
+
3069  "Reference UnidirectionalSequenceLstm: ForgetLayerNormWeights "
+
3070  "is not a supported type.");
+
3071  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetCellLayerNormWeights(), supportedWeightTypes),
+
3072  reasonIfUnsupported,
+
3073  "Reference UnidirectionalSequenceLstm: CellLayerNormWeights "
+
3074  "is not a supported type.");
+
3075  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetOutputLayerNormWeights(), supportedWeightTypes),
+
3076  reasonIfUnsupported,
+
3077  "Reference UnidirectionalSequenceLstm: OutputLayerNormWeights "
+
3078  "is not a supported type.");
+
3079  }
+
3080 
+
3081  return supported;
+
3082 }
-

References armnn::CheckSupportRule(), armnn::Float32, LstmInputParamsInfo::GetCellBias(), LstmInputParamsInfo::GetCellLayerNormWeights(), LstmInputParamsInfo::GetCellToForgetWeights(), LstmInputParamsInfo::GetCellToInputWeights(), LstmInputParamsInfo::GetCellToOutputWeights(), LstmInputParamsInfo::GetForgetGateBias(), LstmInputParamsInfo::GetForgetLayerNormWeights(), LstmInputParamsInfo::GetInputGateBias(), LstmInputParamsInfo::GetInputLayerNormWeights(), LstmInputParamsInfo::GetInputToCellWeights(), LstmInputParamsInfo::GetInputToForgetWeights(), LstmInputParamsInfo::GetInputToInputWeights(), LstmInputParamsInfo::GetInputToOutputWeights(), LstmInputParamsInfo::GetOutputGateBias(), LstmInputParamsInfo::GetOutputLayerNormWeights(), LstmInputParamsInfo::GetProjectionBias(), LstmInputParamsInfo::GetProjectionWeights(), LstmInputParamsInfo::GetRecurrentToCellWeights(), LstmInputParamsInfo::GetRecurrentToForgetWeights(), LstmInputParamsInfo::GetRecurrentToInputWeights(), LstmInputParamsInfo::GetRecurrentToOutputWeights(), armnn::IgnoreUnused(), LstmDescriptor::m_CifgEnabled, LstmDescriptor::m_LayerNormEnabled, LstmDescriptor::m_PeepholeEnabled, LstmInputParamsInfo::m_ProjectionBias, LstmDescriptor::m_ProjectionEnabled, armnn::QAsymmS8, and armnn::Signed32.

+

References armnn::CheckSupportRule(), armnn::Float32, LstmInputParamsInfo::GetCellBias(), LstmInputParamsInfo::GetCellLayerNormWeights(), LstmInputParamsInfo::GetCellToForgetWeights(), LstmInputParamsInfo::GetCellToInputWeights(), LstmInputParamsInfo::GetCellToOutputWeights(), LstmInputParamsInfo::GetForgetGateBias(), LstmInputParamsInfo::GetForgetLayerNormWeights(), LstmInputParamsInfo::GetInputGateBias(), LstmInputParamsInfo::GetInputLayerNormWeights(), LstmInputParamsInfo::GetInputToCellWeights(), LstmInputParamsInfo::GetInputToForgetWeights(), LstmInputParamsInfo::GetInputToInputWeights(), LstmInputParamsInfo::GetInputToOutputWeights(), LstmInputParamsInfo::GetOutputGateBias(), LstmInputParamsInfo::GetOutputLayerNormWeights(), LstmInputParamsInfo::GetProjectionBias(), LstmInputParamsInfo::GetProjectionWeights(), LstmInputParamsInfo::GetRecurrentToCellWeights(), LstmInputParamsInfo::GetRecurrentToForgetWeights(), LstmInputParamsInfo::GetRecurrentToInputWeights(), LstmInputParamsInfo::GetRecurrentToOutputWeights(), armnn::IgnoreUnused(), LstmDescriptor::m_CifgEnabled, LstmDescriptor::m_LayerNormEnabled, LstmDescriptor::m_PeepholeEnabled, LstmInputParamsInfo::m_ProjectionBias, LstmDescriptor::m_ProjectionEnabled, armnn::QAsymmS8, and armnn::Signed32.

Referenced by RefLayerSupport::IsLayerSupported().

@@ -6204,41 +6326,40 @@ Additional Inherited Members
-
armnn::RefLayerSupport::IsLstmSupported
bool IsLstmSupported(const TensorInfo &input, const TensorInfo &outputStateIn, const TensorInfo &cellStateIn, const TensorInfo &scratchBuffer, const TensorInfo &outputStateOut, const TensorInfo &cellStateOut, const TensorInfo &output, const LstmDescriptor &descriptor, const LstmInputParamsInfo &paramsInfo, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1777
-
ARMNN_ASSERT
#define ARMNN_ASSERT(COND)
Definition: Assert.hpp:14
+
armnn::RefLayerSupport::IsLstmSupported
bool IsLstmSupported(const TensorInfo &input, const TensorInfo &outputStateIn, const TensorInfo &cellStateIn, const TensorInfo &scratchBuffer, const TensorInfo &outputStateOut, const TensorInfo &cellStateOut, const TensorInfo &output, const LstmDescriptor &descriptor, const LstmInputParamsInfo &paramsInfo, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1789
-
armnn::RefLayerSupport::IsDepthwiseConvolutionSupported
bool IsDepthwiseConvolutionSupported(const TensorInfo &input, const TensorInfo &output, const DepthwiseConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1226
+
armnn::RefLayerSupport::IsDepthwiseConvolutionSupported
bool IsDepthwiseConvolutionSupported(const TensorInfo &input, const TensorInfo &output, const DepthwiseConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1235
-
armnn::RefLayerSupport::IsPooling3dSupported
bool IsPooling3dSupported(const TensorInfo &input, const TensorInfo &output, const Pooling3dDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2219
+
armnn::RefLayerSupport::IsPooling3dSupported
bool IsPooling3dSupported(const TensorInfo &input, const TensorInfo &output, const Pooling3dDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2231
-
armnn::RefLayerSupport::IsReverseV2Supported
bool IsReverseV2Supported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2407
+
armnn::RefLayerSupport::IsReverseV2Supported
bool IsReverseV2Supported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2419
-
armnn::RefLayerSupport::IsQLstmSupported
bool IsQLstmSupported(const TensorInfo &input, const TensorInfo &previousOutputIn, const TensorInfo &previousCellStateIn, const TensorInfo &outputStateOut, const TensorInfo &cellStateOut, const TensorInfo &output, const QLstmDescriptor &descriptor, const LstmInputParamsInfo &paramsInfo, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2250
+
armnn::RefLayerSupport::IsQLstmSupported
bool IsQLstmSupported(const TensorInfo &input, const TensorInfo &previousOutputIn, const TensorInfo &previousCellStateIn, const TensorInfo &outputStateOut, const TensorInfo &cellStateOut, const TensorInfo &output, const QLstmDescriptor &descriptor, const LstmInputParamsInfo &paramsInfo, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2262
armnn::IsQuantized8BitType
constexpr bool IsQuantized8BitType(DataType dataType)
Definition: TypesUtils.hpp:316
-
armnn::RefLayerSupport::IsTileSupported
bool IsTileSupported(const TensorInfo &input, const TensorInfo &output, const TileDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2742
-
armnn::RefLayerSupport::IsConvolution2dSupported
bool IsConvolution2dSupported(const TensorInfo &input, const TensorInfo &output, const Convolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1030
-
armnn::RefLayerSupport::IsFloorSupported
bool IsFloorSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1503
-
armnn::RefLayerSupport::IsDequantizeSupported
bool IsDequantizeSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1295
+
armnn::RefLayerSupport::IsTileSupported
bool IsTileSupported(const TensorInfo &input, const TensorInfo &output, const TileDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2811
+
armnn::RefLayerSupport::IsConvolution2dSupported
bool IsConvolution2dSupported(const TensorInfo &input, const TensorInfo &output, const Convolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1039
+
armnn::RefLayerSupport::IsFloorSupported
bool IsFloorSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1512
+
armnn::RefLayerSupport::IsDequantizeSupported
bool IsDequantizeSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1304
-
armnn::RefLayerSupport::IsPooling2dSupported
bool IsPooling2dSupported(const TensorInfo &input, const TensorInfo &output, const Pooling2dDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2189
-
armnn::RefLayerSupport::IsDetectionPostProcessSupported
bool IsDetectionPostProcessSupported(const TensorInfo &boxEncodings, const TensorInfo &scores, const TensorInfo &anchors, const TensorInfo &detectionBoxes, const TensorInfo &detectionClasses, const TensorInfo &detectionScores, const TensorInfo &numDetections, const DetectionPostProcessDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1330
+
armnn::RefLayerSupport::IsPooling2dSupported
bool IsPooling2dSupported(const TensorInfo &input, const TensorInfo &output, const Pooling2dDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2201
+
armnn::RefLayerSupport::IsDetectionPostProcessSupported
bool IsDetectionPostProcessSupported(const TensorInfo &boxEncodings, const TensorInfo &scores, const TensorInfo &anchors, const TensorInfo &detectionBoxes, const TensorInfo &detectionClasses, const TensorInfo &detectionScores, const TensorInfo &numDetections, const DetectionPostProcessDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1339
-
armnn::RefLayerSupport::IsAdditionSupported
bool IsAdditionSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:621
-
armnn::RefLayerSupport::IsInputSupported
bool IsInputSupported(const TensorInfo &input, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1655
+
armnn::RefLayerSupport::IsAdditionSupported
bool IsAdditionSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:628
+
armnn::RefLayerSupport::IsInputSupported
bool IsInputSupported(const TensorInfo &input, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1664
-
armnn::RefLayerSupport::IsMeanSupported
bool IsMeanSupported(const TensorInfo &input, const TensorInfo &output, const MeanDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1925
-
armnn::RefLayerSupport::IsTransposeConvolution2dSupported
bool IsTransposeConvolution2dSupported(const TensorInfo &input, const TensorInfo &output, const TransposeConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2771
+
armnn::RefLayerSupport::IsMeanSupported
bool IsMeanSupported(const TensorInfo &input, const TensorInfo &output, const MeanDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1937
+
armnn::RefLayerSupport::IsTransposeConvolution2dSupported
bool IsTransposeConvolution2dSupported(const TensorInfo &input, const TensorInfo &output, const TransposeConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2840
-
armnn::RefLayerSupport::IsRankSupported
bool IsRankSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2309
+
armnn::RefLayerSupport::IsRankSupported
bool IsRankSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2321
armnn::ActivationFunction::BoundedReLu
@ BoundedReLu
min(a, max(b, input)) ReLu1 & ReLu6.
@@ -6246,117 +6367,119 @@ Additional Inherited Members -
armnn::RefLayerSupport::IsSplitterSupported
bool IsSplitterSupported(const TensorInfo &input, const std::vector< std::reference_wrapper< TensorInfo >> &outputs, const ViewsDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2580
-
armnn::RefLayerSupport::IsConvolution3dSupported
bool IsConvolution3dSupported(const TensorInfo &input, const TensorInfo &output, const Convolution3dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1099
+
armnn::RefLayerSupport::IsSplitterSupported
bool IsSplitterSupported(const TensorInfo &input, const std::vector< std::reference_wrapper< TensorInfo >> &outputs, const ViewsDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2650
+
armnn::RefLayerSupport::IsConvolution3dSupported
bool IsConvolution3dSupported(const TensorInfo &input, const TensorInfo &output, const Convolution3dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1108
-
armnn::RefLayerSupport::IsBatchMatMulSupported
bool IsBatchMatMulSupported(const TensorInfo &inputX, const TensorInfo &inputY, const TensorInfo &output, const BatchMatMulDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:690
+
armnn::RefLayerSupport::IsBatchMatMulSupported
bool IsBatchMatMulSupported(const TensorInfo &inputX, const TensorInfo &inputY, const TensorInfo &output, const BatchMatMulDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:697
-
armnn::RefLayerSupport::IsSubtractionSupported
bool IsSubtractionSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2671
+
armnn::RefLayerSupport::IsSubtractionSupported
bool IsSubtractionSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2740
-
armnn::RefLayerSupport::IsQuantizeSupported
bool IsQuantizeSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2274
+
armnn::RefLayerSupport::IsQuantizeSupported
bool IsQuantizeSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2286
-
armnn::RefLayerSupport::IsArgMinMaxSupported
bool IsArgMinMaxSupported(const TensorInfo &input, const TensorInfo &output, const ArgMinMaxDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:658
+
armnn::RefLayerSupport::IsArgMinMaxSupported
bool IsArgMinMaxSupported(const TensorInfo &input, const TensorInfo &output, const ArgMinMaxDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:665
-
armnn::RefLayerSupport::IsPermuteSupported
bool IsPermuteSupported(const TensorInfo &input, const TensorInfo &output, const PermuteDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2158
-
armnn::RefLayerSupport::IsComparisonSupported
bool IsComparisonSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const ComparisonDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:908
-
armnn::RefLayerSupport::IsBatchNormalizationSupported
bool IsBatchNormalizationSupported(const TensorInfo &input, const TensorInfo &output, const TensorInfo &mean, const TensorInfo &var, const TensorInfo &beta, const TensorInfo &gamma, const BatchNormalizationDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:735
+
armnn::RefLayerSupport::IsPermuteSupported
bool IsPermuteSupported(const TensorInfo &input, const TensorInfo &output, const PermuteDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2170
+
armnn::RefLayerSupport::IsComparisonSupported
bool IsComparisonSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const ComparisonDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:915
+
armnn::RefLayerSupport::IsBatchNormalizationSupported
bool IsBatchNormalizationSupported(const TensorInfo &input, const TensorInfo &output, const TensorInfo &mean, const TensorInfo &var, const TensorInfo &beta, const TensorInfo &gamma, const BatchNormalizationDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:742
-
armnn::RefLayerSupport::IsSpaceToDepthSupported
bool IsSpaceToDepthSupported(const TensorInfo &input, const TensorInfo &output, const SpaceToDepthDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2550
-
armnn::RefLayerSupport::IsActivationSupported
bool IsActivationSupported(const TensorInfo &input, const TensorInfo &output, const ActivationDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:553
+
armnn::RefLayerSupport::IsSpaceToDepthSupported
bool IsSpaceToDepthSupported(const TensorInfo &input, const TensorInfo &output, const SpaceToDepthDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2620
+
armnn::RefLayerSupport::IsActivationSupported
bool IsActivationSupported(const TensorInfo &input, const TensorInfo &output, const ActivationDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:560
-
armnn::RefLayerSupport::IsFakeQuantizationSupported
bool IsFakeQuantizationSupported(const TensorInfo &input, const FakeQuantizationDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1460
+
armnn::RefLayerSupport::IsFakeQuantizationSupported
bool IsFakeQuantizationSupported(const TensorInfo &input, const FakeQuantizationDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1469
armnn::LayerSupportBase::IsQuantizedLstmSupported
bool IsQuantizedLstmSupported(const TensorInfo &input, const TensorInfo &previousCellStateIn, const TensorInfo &previousOutputIn, const TensorInfo &cellStateOut, const TensorInfo &output, const QuantizedLstmInputParamsInfo &paramsInfo, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: LayerSupportBase.cpp:120
-
armnn::RefLayerSupport::IsElementwiseUnarySupported
bool IsElementwiseUnarySupported(const TensorInfo &input, const TensorInfo &output, const ElementwiseUnaryDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1409
-
armnn::RefLayerSupport::IsConcatSupported
bool IsConcatSupported(const std::vector< const TensorInfo * > inputs, const TensorInfo &output, const OriginsDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:939
+
armnn::RefLayerSupport::IsElementwiseUnarySupported
bool IsElementwiseUnarySupported(const TensorInfo &input, const TensorInfo &output, const ElementwiseUnaryDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1418
+
armnn::RefLayerSupport::IsConcatSupported
bool IsConcatSupported(const std::vector< const TensorInfo * > inputs, const TensorInfo &output, const OriginsDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:949
-
armnn::RefLayerSupport::IsReduceSupported
bool IsReduceSupported(const TensorInfo &input, const TensorInfo &output, const ReduceDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2324
+
armnn::RefLayerSupport::IsReduceSupported
bool IsReduceSupported(const TensorInfo &input, const TensorInfo &output, const ReduceDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2336
+ -
armnn::RefLayerSupport::IsResizeSupported
bool IsResizeSupported(const TensorInfo &input, const TensorInfo &output, const ResizeDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2377
-
armnn::RefLayerSupport::IsDepthToSpaceSupported
bool IsDepthToSpaceSupported(const TensorInfo &input, const TensorInfo &output, const DepthToSpaceDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1197
+
armnn::RefLayerSupport::IsResizeSupported
bool IsResizeSupported(const TensorInfo &input, const TensorInfo &output, const ResizeDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2389
+
armnn::RefLayerSupport::IsDepthToSpaceSupported
bool IsDepthToSpaceSupported(const TensorInfo &input, const TensorInfo &output, const DepthToSpaceDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1206
armnn::DataType
DataType
Definition: Types.hpp:48
-
armnn::RefLayerSupport::IsBatchToSpaceNdSupported
bool IsBatchToSpaceNdSupported(const TensorInfo &input, const TensorInfo &output, const BatchToSpaceNdDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:781
-
armnn::RefLayerSupport::IsBroadcastToSupported
bool IsBroadcastToSupported(const TensorInfo &input, const TensorInfo &output, const BroadcastToDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:816
+
armnn::RefLayerSupport::IsBatchToSpaceNdSupported
bool IsBatchToSpaceNdSupported(const TensorInfo &input, const TensorInfo &output, const BatchToSpaceNdDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:788
+
armnn::RefLayerSupport::IsBroadcastToSupported
bool IsBroadcastToSupported(const TensorInfo &input, const TensorInfo &output, const BroadcastToDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:823
-
armnn::RefLayerSupport::IsSpaceToBatchNdSupported
bool IsSpaceToBatchNdSupported(const TensorInfo &input, const TensorInfo &output, const SpaceToBatchNdDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2522
+
armnn::RefLayerSupport::IsSpaceToBatchNdSupported
bool IsSpaceToBatchNdSupported(const TensorInfo &input, const TensorInfo &output, const SpaceToBatchNdDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2592
armnn::LayerSupportBase::IsMergeSupported
bool IsMergeSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: LayerSupportBase.cpp:112
-
armnn::RefLayerSupport::IsL2NormalizationSupported
bool IsL2NormalizationSupported(const TensorInfo &input, const TensorInfo &output, const L2NormalizationDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1692
+
armnn::RefLayerSupport::IsL2NormalizationSupported
bool IsL2NormalizationSupported(const TensorInfo &input, const TensorInfo &output, const L2NormalizationDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1701
-
armnn::RefLayerSupport::IsMaximumSupported
bool IsMaximumSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1888
+
armnn::RefLayerSupport::IsMaximumSupported
bool IsMaximumSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1900
armnn::LayerSupportBase::IsMemImportSupported
bool IsMemImportSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: LayerSupportBase.cpp:105
-
armnn::RefLayerSupport::IsReshapeSupported
bool IsReshapeSupported(const TensorInfo &input, const TensorInfo &output, const ReshapeDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2353
+
armnn::RefLayerSupport::IsReshapeSupported
bool IsReshapeSupported(const TensorInfo &input, const TensorInfo &output, const ReshapeDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2365
-
armnn::RefLayerSupport::IsCastSupported
bool IsCastSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:846
-
armnn::RefLayerSupport::IsFullyConnectedSupported
bool IsFullyConnectedSupported(const TensorInfo &input, const TensorInfo &output, const TensorInfo &weights, const TensorInfo &biases, const FullyConnectedDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1525
+
armnn::RefLayerSupport::IsCastSupported
bool IsCastSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:853
+
armnn::RefLayerSupport::IsFullyConnectedSupported
bool IsFullyConnectedSupported(const TensorInfo &input, const TensorInfo &output, const TensorInfo &weights, const TensorInfo &biases, const FullyConnectedDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1534
-
armnn::RefLayerSupport::IsOutputSupported
bool IsOutputSupported(const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2122
-
armnn::RefLayerSupport::IsDebugSupported
bool IsDebugSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1167
+
armnn::RefLayerSupport::IsOutputSupported
bool IsOutputSupported(const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2134
+
armnn::RefLayerSupport::IsDebugSupported
bool IsDebugSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1176
-
armnn::RefLayerSupport::IsConvertFp16ToFp32Supported
bool IsConvertFp16ToFp32Supported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:990
+
armnn::RefLayerSupport::IsConvertFp16ToFp32Supported
bool IsConvertFp16ToFp32Supported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:999
-
armnn::RefLayerSupport::IsLogicalBinarySupported
bool IsLogicalBinarySupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const LogicalBinaryDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported) const
Definition: RefLayerSupport.cpp:1726
+
armnn::RefLayerSupport::IsLogicalBinarySupported
bool IsLogicalBinarySupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const LogicalBinaryDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported) const
Definition: RefLayerSupport.cpp:1735
-
armnn::RefLayerSupport::IsDivisionSupported
bool IsDivisionSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1372
+
armnn::RefLayerSupport::IsDivisionSupported
bool IsDivisionSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1381
-
armnn::RefLayerSupport::IsNormalizationSupported
bool IsNormalizationSupported(const TensorInfo &input, const TensorInfo &output, const NormalizationDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2090
+
armnn::RefLayerSupport::IsNormalizationSupported
bool IsNormalizationSupported(const TensorInfo &input, const TensorInfo &output, const NormalizationDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2102
-
armnn::RefLayerSupport::IsPreluSupported
bool IsPreluSupported(const TensorInfo &input, const TensorInfo &alpha, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2708
-
armnn::RefLayerSupport::IsFillSupported
bool IsFillSupported(const TensorInfo &input, const TensorInfo &output, const FillDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1478
+
armnn::RefLayerSupport::IsPreluSupported
bool IsPreluSupported(const TensorInfo &input, const TensorInfo &alpha, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2777
+
armnn::RefLayerSupport::IsFillSupported
bool IsFillSupported(const TensorInfo &input, const TensorInfo &output, const FillDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1487
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
-
armnn::RefLayerSupport::IsMultiplicationSupported
bool IsMultiplicationSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2053
+
armnn::RefLayerSupport::IsMultiplicationSupported
bool IsMultiplicationSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2065
armnn::IsSupportedForDataTypeGeneric
bool IsSupportedForDataTypeGeneric(Optional< std::string & > reasonIfUnsupported, DataType dataType, Float16Func float16FuncPtr, Float32Func float32FuncPtr, Uint8Func uint8FuncPtr, Int32Func int32FuncPtr, BooleanFunc booleanFuncPtr, Params &&... params)
Definition: LayerSupportCommon.hpp:27
-
armnn::RefLayerSupport::IsStridedSliceSupported
bool IsStridedSliceSupported(const TensorInfo &input, const TensorInfo &output, const StridedSliceDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2643
+
armnn::RefLayerSupport::IsStridedSliceSupported
bool IsStridedSliceSupported(const TensorInfo &input, const TensorInfo &output, const StridedSliceDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2712
-
armnn::RefLayerSupport::IsMemCopySupported
bool IsMemCopySupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1987
+
armnn::RefLayerSupport::IsMemCopySupported
bool IsMemCopySupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1999
+
armnn::RefLayerSupport::IsScatterNdSupported
bool IsScatterNdSupported(const TensorInfo &input, const TensorInfo &indices, const TensorInfo &updates, const TensorInfo &output, const ScatterNdDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2458
-
armnn::RefLayerSupport::IsConstantSupported
bool IsConstantSupported(const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:972
+
armnn::RefLayerSupport::IsConstantSupported
bool IsConstantSupported(const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:981
-
armnn::RefLayerSupport::IsChannelShuffleSupported
bool IsChannelShuffleSupported(const TensorInfo &input, const TensorInfo &output, const ChannelShuffleDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:876
+
armnn::RefLayerSupport::IsChannelShuffleSupported
bool IsChannelShuffleSupported(const TensorInfo &input, const TensorInfo &output, const ChannelShuffleDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:883
-
armnn::RefLayerSupport::IsShapeSupported
bool IsShapeSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2446
+
armnn::RefLayerSupport::IsShapeSupported
bool IsShapeSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2516
-
armnn::RefLayerSupport::IsTransposeSupported
bool IsTransposeSupported(const TensorInfo &input, const TensorInfo &output, const TransposeDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2839
+
armnn::RefLayerSupport::IsTransposeSupported
bool IsTransposeSupported(const TensorInfo &input, const TensorInfo &output, const TransposeDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2908
-
armnn::RefLayerSupport::IsConvertFp32ToFp16Supported
bool IsConvertFp32ToFp16Supported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1010
-
armnn::RefLayerSupport::IsGatherSupported
bool IsGatherSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const GatherDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1622
-
armnn::RefLayerSupport::IsStackSupported
bool IsStackSupported(const std::vector< const TensorInfo * > &inputs, const TensorInfo &output, const StackDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2610
-
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string & > reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38
-
armnn::RefLayerSupport::IsLogSoftmaxSupported
bool IsLogSoftmaxSupported(const TensorInfo &input, const TensorInfo &output, const LogSoftmaxDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported) const
Definition: RefLayerSupport.cpp:1751
+
armnn::RefLayerSupport::IsConvertFp32ToFp16Supported
bool IsConvertFp32ToFp16Supported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1019
+
armnn::RefLayerSupport::IsGatherSupported
bool IsGatherSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const GatherDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1631
+
armnn::RefLayerSupport::IsStackSupported
bool IsStackSupported(const std::vector< const TensorInfo * > &inputs, const TensorInfo &output, const StackDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2680
+
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string & > reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37
+
armnn::RefLayerSupport::IsLogSoftmaxSupported
bool IsLogSoftmaxSupported(const TensorInfo &input, const TensorInfo &output, const LogSoftmaxDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported) const
Definition: RefLayerSupport.cpp:1763
@@ -6365,15 +6488,15 @@ Additional Inherited Members -
armnn::RefLayerSupport::IsSoftmaxSupported
bool IsSoftmaxSupported(const TensorInfo &input, const TensorInfo &output, const SoftmaxDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2493
-
armnn::RefLayerSupport::IsSliceSupported
bool IsSliceSupported(const TensorInfo &input, const TensorInfo &output, const SliceDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2464
+
armnn::RefLayerSupport::IsSoftmaxSupported
bool IsSoftmaxSupported(const TensorInfo &input, const TensorInfo &output, const SoftmaxDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2563
+
armnn::RefLayerSupport::IsSliceSupported
bool IsSliceSupported(const TensorInfo &input, const TensorInfo &output, const SliceDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2534
-
armnn::RefLayerSupport::IsPadSupported
bool IsPadSupported(const TensorInfo &input, const TensorInfo &output, const PadDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2128
+
armnn::RefLayerSupport::IsPadSupported
bool IsPadSupported(const TensorInfo &input, const TensorInfo &output, const PadDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2140
-
armnn::RefLayerSupport::IsGatherNdSupported
bool IsGatherNdSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1591
-
armnn::RefLayerSupport::IsUnidirectionalSequenceLstmSupported
bool IsUnidirectionalSequenceLstmSupported(const TensorInfo &input, const TensorInfo &outputStateIn, const TensorInfo &cellStateIn, const TensorInfo &outputStateOut, const TensorInfo &cellStateOut, const TensorInfo &output, const UnidirectionalSequenceLstmDescriptor &descriptor, const LstmInputParamsInfo &paramsInfo, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2870
-
armnn::RefLayerSupport::IsInstanceNormalizationSupported
bool IsInstanceNormalizationSupported(const TensorInfo &input, const TensorInfo &output, const InstanceNormalizationDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1661
-
armnn::RefLayerSupport::IsMinimumSupported
bool IsMinimumSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2016
+
armnn::RefLayerSupport::IsGatherNdSupported
bool IsGatherNdSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1600
+
armnn::RefLayerSupport::IsUnidirectionalSequenceLstmSupported
bool IsUnidirectionalSequenceLstmSupported(const TensorInfo &input, const TensorInfo &outputStateIn, const TensorInfo &cellStateIn, const TensorInfo &outputStateOut, const TensorInfo &cellStateOut, const TensorInfo &output, const UnidirectionalSequenceLstmDescriptor &descriptor, const LstmInputParamsInfo &paramsInfo, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2939
+
armnn::RefLayerSupport::IsInstanceNormalizationSupported
bool IsInstanceNormalizationSupported(const TensorInfo &input, const TensorInfo &output, const InstanceNormalizationDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1670
+
armnn::RefLayerSupport::IsMinimumSupported
bool IsMinimumSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2028
@@ -6381,7 +6504,7 @@ Additional Inherited Members