src/armnn/test/UtilsTests.cpp

   1 //
   2 // Copyright © 2017 Arm Ltd. All rights reserved.
   3 // SPDX-License-Identifier: MIT
   4 //
   5 #include <boost/test/unit_test.hpp>
   6
   7
   8 #include <armnn/Utils.hpp>
   9 #include <armnn/Types.hpp>
  10 #include <armnn/TypesUtils.hpp>
  11 #include <armnn/Descriptors.hpp>
  12 #include <GraphTopologicalSort.hpp>
  13 #include <Graph.hpp>
  14 #include "TypeUtils.hpp"
  15
  16 BOOST_AUTO_TEST_SUITE(Utils)
  17
  18 BOOST_AUTO_TEST_CASE(DataTypeSize)
  19 {
  20     BOOST_TEST(armnn::GetDataTypeSize(armnn::DataType::Float32) == 4);
  21     BOOST_TEST(armnn::GetDataTypeSize(armnn::DataType::QuantisedAsymm8) == 1);
  22     BOOST_TEST(armnn::GetDataTypeSize(armnn::DataType::Signed32) == 4);
  23     BOOST_TEST(armnn::GetDataTypeSize(armnn::DataType::Boolean) == 1);
  24 }
  25
  26 BOOST_AUTO_TEST_CASE(PermuteDescriptorWithTooManyMappings)
  27 {
  28     BOOST_CHECK_THROW(armnn::PermuteDescriptor({ 0u, 1u, 2u, 3u, 4u }), armnn::InvalidArgumentException);
  29 }
  30
  31 BOOST_AUTO_TEST_CASE(PermuteDescriptorWithInvalidMappings1d)
  32 {
  33     BOOST_CHECK_THROW(armnn::PermuteDescriptor({ 1u }), armnn::InvalidArgumentException);
  34 }
  35
  36 BOOST_AUTO_TEST_CASE(PermuteDescriptorWithInvalidMappings2d)
  37 {
  38     BOOST_CHECK_THROW(armnn::PermuteDescriptor({ 2u, 0u }), armnn::InvalidArgumentException);
  39 }
  40
  41 BOOST_AUTO_TEST_CASE(PermuteDescriptorWithInvalidMappings3d)
  42 {
  43     BOOST_CHECK_THROW(armnn::PermuteDescriptor({ 0u, 3u, 1u }), armnn::InvalidArgumentException);
  44 }
  45
  46 BOOST_AUTO_TEST_CASE(PermuteDescriptorWithInvalidMappings4d)
  47 {
  48     BOOST_CHECK_THROW(armnn::PermuteDescriptor({ 0u, 1u, 2u, 4u }), armnn::InvalidArgumentException);
  49 }
  50
  51 BOOST_AUTO_TEST_CASE(PermuteDescriptorWithDuplicatedMappings)
  52 {
  53     BOOST_CHECK_THROW(armnn::PermuteDescriptor({ 1u, 1u, 0u }), armnn::InvalidArgumentException);
  54 }
  55
  56 BOOST_AUTO_TEST_CASE(HalfType)
  57 {
  58     using namespace half_float::literal;
  59     armnn::Half a = 1.0_h;
  60
  61     float b = 1.0f;
  62     armnn::Half c(b);
  63
  64     // Test half type
  65     BOOST_CHECK_EQUAL(a, b);
  66     BOOST_CHECK_EQUAL(sizeof(c), 2);
  67
  68     // Test half type is floating point type
  69     BOOST_CHECK(std::is_floating_point<armnn::Half>::value);
  70
  71     // Test utility function returns correct type.
  72     using ResolvedType = armnn::ResolveType<armnn::DataType::Float16>;
  73     constexpr bool isHalfType = std::is_same<armnn::Half, ResolvedType>::value;
  74     BOOST_CHECK(isHalfType);
  75
  76     //Test utility functions return correct size
  77     BOOST_CHECK(GetDataTypeSize(armnn::DataType::Float16) == 2);
  78
  79     //Test utility functions return correct name
  80     BOOST_CHECK((GetDataTypeName(armnn::DataType::Float16) == std::string("Float16")));
  81 }
  82
  83 BOOST_AUTO_TEST_CASE(GraphTopologicalSortSimpleTest)
  84 {
  85     std::map<int, std::vector<int>> graph;
  86
  87     graph[0] = {2};
  88     graph[1] = {3};
  89     graph[2] = {4};
  90     graph[3] = {4};
  91     graph[4] = {5};
  92     graph[5] = {};
  93
  94     auto getNodeInputs = [graph](int node) -> std::vector<int>
  95     {
  96         return graph.find(node)->second;
  97     };
  98
  99     std::vector<int> targetNodes = {0, 1};
 100
 101     std::vector<int> output;
 102     bool sortCompleted = armnnUtils::GraphTopologicalSort<int>(targetNodes, getNodeInputs, output);
 103
 104     BOOST_TEST(sortCompleted);
 105
 106     std::vector<int> correctResult = {5, 4, 2, 0, 3, 1};
 107     BOOST_CHECK_EQUAL_COLLECTIONS(output.begin(), output.end(), correctResult.begin(), correctResult.end());
 108 }
 109
 110 BOOST_AUTO_TEST_CASE(GraphTopologicalSortVariantTest)
 111 {
 112     std::map<int, std::vector<int>> graph;
 113
 114     graph[0] = {2};
 115     graph[1] = {2};
 116     graph[2] = {3, 4};
 117     graph[3] = {5};
 118     graph[4] = {5};
 119     graph[5] = {6};
 120     graph[6] = {};
 121
 122     auto getNodeInputs = [graph](int node) -> std::vector<int>
 123     {
 124         return graph.find(node)->second;
 125     };
 126
 127     std::vector<int> targetNodes = {0, 1};
 128
 129     std::vector<int> output;
 130     bool sortCompleted = armnnUtils::GraphTopologicalSort<int>(targetNodes, getNodeInputs, output);
 131
 132     BOOST_TEST(sortCompleted);
 133
 134     std::vector<int> correctResult = {6, 5, 3, 4, 2, 0, 1};
 135     BOOST_CHECK_EQUAL_COLLECTIONS(output.begin(), output.end(), correctResult.begin(), correctResult.end());
 136 }
 137
 138 BOOST_AUTO_TEST_CASE(CyclicalGraphTopologicalSortTest)
 139 {
 140     std::map<int, std::vector<int>> graph;
 141
 142     graph[0] = {1};
 143     graph[1] = {2};
 144     graph[2] = {0};
 145
 146     auto getNodeInputs = [graph](int node) -> std::vector<int>
 147     {
 148         return graph.find(node)->second;
 149     };
 150
 151     std::vector<int> targetNodes = {0};
 152
 153     std::vector<int> output;
 154     bool sortCompleted = armnnUtils::GraphTopologicalSort<int>(targetNodes, getNodeInputs, output);
 155
 156     BOOST_TEST(!sortCompleted);
 157 }
 158
 159 BOOST_AUTO_TEST_SUITE_END()