src/armnn/test/UtilsTests.cpp

   1 //
   2 // Copyright © 2017 Arm Ltd. All rights reserved.
   3 // See LICENSE file in the project root for full license information.
   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 }
  24
  25 BOOST_AUTO_TEST_CASE(GetDataTypeTest)
  26 {
  27     BOOST_TEST((armnn::GetDataType<float>() == armnn::DataType::Float32));
  28     BOOST_TEST((armnn::GetDataType<uint8_t>() == armnn::DataType::QuantisedAsymm8));
  29     BOOST_TEST((armnn::GetDataType<int32_t>() == armnn::DataType::Signed32));
  30 }
  31
  32 BOOST_AUTO_TEST_CASE(PermuteDescriptorWithTooManyMappings)
  33 {
  34     BOOST_CHECK_THROW(armnn::PermuteDescriptor({ 0u, 1u, 2u, 3u, 4u }), armnn::InvalidArgumentException);
  35 }
  36
  37 BOOST_AUTO_TEST_CASE(PermuteDescriptorWithInvalidMappings1d)
  38 {
  39     BOOST_CHECK_THROW(armnn::PermuteDescriptor({ 1u }), armnn::InvalidArgumentException);
  40 }
  41
  42 BOOST_AUTO_TEST_CASE(PermuteDescriptorWithInvalidMappings2d)
  43 {
  44     BOOST_CHECK_THROW(armnn::PermuteDescriptor({ 2u, 0u }), armnn::InvalidArgumentException);
  45 }
  46
  47 BOOST_AUTO_TEST_CASE(PermuteDescriptorWithInvalidMappings3d)
  48 {
  49     BOOST_CHECK_THROW(armnn::PermuteDescriptor({ 0u, 3u, 1u }), armnn::InvalidArgumentException);
  50 }
  51
  52 BOOST_AUTO_TEST_CASE(PermuteDescriptorWithInvalidMappings4d)
  53 {
  54     BOOST_CHECK_THROW(armnn::PermuteDescriptor({ 0u, 1u, 2u, 4u }), armnn::InvalidArgumentException);
  55 }
  56
  57 BOOST_AUTO_TEST_CASE(PermuteDescriptorWithDuplicatedMappings)
  58 {
  59     BOOST_CHECK_THROW(armnn::PermuteDescriptor({ 1u, 1u, 0u }), armnn::InvalidArgumentException);
  60 }
  61
  62 BOOST_AUTO_TEST_CASE(HalfType)
  63 {
  64     using namespace half_float::literal;
  65     armnn::Half a = 1.0_h;
  66
  67     float b = 1.0f;
  68     armnn::Half c(b);
  69
  70     // Test half type
  71     BOOST_CHECK_EQUAL(a, b);
  72     BOOST_CHECK_EQUAL(sizeof(c), 2);
  73
  74     // Test half type is floating point type
  75     BOOST_CHECK(std::is_floating_point<armnn::Half>::value);
  76
  77     // Test utility function returns correct type.
  78     using ResolvedType = armnn::ResolveType<armnn::DataType::Float16>;
  79     constexpr bool isHalfType = std::is_same<armnn::Half, ResolvedType>::value;
  80     BOOST_CHECK(isHalfType);
  81
  82     armnn::DataType dt = armnn::GetDataType<armnn::Half>();
  83     BOOST_CHECK(dt == armnn::DataType::Float16);
  84
  85     //Test utility functions return correct size
  86     BOOST_CHECK(GetDataTypeSize(armnn::DataType::Float16) == 2);
  87
  88     //Test utility functions return correct name
  89     BOOST_CHECK((GetDataTypeName(armnn::DataType::Float16) == std::string("Float16")));
  90 }
  91
  92 BOOST_AUTO_TEST_CASE(GraphTopologicalSortSimpleTest)
  93 {
  94     std::map<int, std::vector<int>> graph;
  95
  96     graph[0] = {2};
  97     graph[1] = {3};
  98     graph[2] = {4};
  99     graph[3] = {4};
 100     graph[4] = {5};
 101     graph[5] = {};
 102
 103     auto getNodeInputs = [graph](int node) -> std::vector<int>
 104     {
 105         return graph.find(node)->second;
 106     };
 107
 108     std::vector<int> targetNodes = {0, 1};
 109
 110     std::vector<int> output;
 111     bool sortCompleted = armnnUtils::GraphTopologicalSort<int>(targetNodes, getNodeInputs, output);
 112
 113     BOOST_TEST(sortCompleted);
 114
 115     std::vector<int> correctResult = {5, 4, 2, 0, 3, 1};
 116     BOOST_CHECK_EQUAL_COLLECTIONS(output.begin(), output.end(), correctResult.begin(), correctResult.end());
 117 }
 118
 119 BOOST_AUTO_TEST_CASE(GraphTopologicalSortVariantTest)
 120 {
 121     std::map<int, std::vector<int>> graph;
 122
 123     graph[0] = {2};
 124     graph[1] = {2};
 125     graph[2] = {3, 4};
 126     graph[3] = {5};
 127     graph[4] = {5};
 128     graph[5] = {6};
 129     graph[6] = {};
 130
 131     auto getNodeInputs = [graph](int node) -> std::vector<int>
 132     {
 133         return graph.find(node)->second;
 134     };
 135
 136     std::vector<int> targetNodes = {0, 1};
 137
 138     std::vector<int> output;
 139     bool sortCompleted = armnnUtils::GraphTopologicalSort<int>(targetNodes, getNodeInputs, output);
 140
 141     BOOST_TEST(sortCompleted);
 142
 143     std::vector<int> correctResult = {6, 5, 3, 4, 2, 0, 1};
 144     BOOST_CHECK_EQUAL_COLLECTIONS(output.begin(), output.end(), correctResult.begin(), correctResult.end());
 145 }
 146
 147 BOOST_AUTO_TEST_CASE(CyclicalGraphTopologicalSortTest)
 148 {
 149     std::map<int, std::vector<int>> graph;
 150
 151     graph[0] = {1};
 152     graph[1] = {2};
 153     graph[2] = {0};
 154
 155     auto getNodeInputs = [graph](int node) -> std::vector<int>
 156     {
 157         return graph.find(node)->second;
 158     };
 159
 160     std::vector<int> targetNodes = {0};
 161
 162     std::vector<int> output;
 163     bool sortCompleted = armnnUtils::GraphTopologicalSort<int>(targetNodes, getNodeInputs, output);
 164
 165     BOOST_TEST(!sortCompleted);
 166 }
 167
 168 BOOST_AUTO_TEST_SUITE_END()