IVGCVSW-3691 Implement SendCounterPacket.SendCounterDirectoryPacket() function

 * Changed the signature of SendCounterDirectoryPacket to accept any
   ICounterDirectory object
 * Added helper methods to the SendCounterPacket class for creating the records
 * Created mock classes for testing
 * Added unit tests for both SendCounterDirectoryPacket and the helper methods
 * Added unit tests for the SWTrace utility functions
 * Added ReadUint8 utility function for getting single byte out of a buffer
 * Disabled extra sign-conversion warning in the conversion macro

Change-Id: Ie2dddcd6824ed07b623f0cd78d9b7d05c5b70c39
Signed-off-by: Matteo Martincigh <matteo.martincigh@arm.com>

1 files changed, 242 insertions, 1 deletions

diff --git a/src/profiling/test/SendCounterPacketTests.hpp b/src/profiling/test/SendCounterPacketTests.hpp
index a22d02bd63..6c7bb50362 100644
--- a/src/profiling/test/SendCounterPacketTests.hpp
+++ b/src/profiling/test/SendCounterPacketTests.hpp
@@ -66,7 +66,7 @@ public:
         memcpy(buffer, message.c_str(), static_cast<unsigned int>(message.size()) + 1);
     }
 
-    void SendCounterDirectoryPacket(const CounterDirectory& counterDirectory) override
+    void SendCounterDirectoryPacket(const ICounterDirectory& counterDirectory) override
     {
         std::string message("SendCounterDirectoryPacket");
         unsigned int reserved = 0;
@@ -99,3 +99,244 @@ public:
 private:
     IBufferWrapper& m_Buffer;
 };
+
+class MockCounterDirectory : public ICounterDirectory
+{
+public:
+    MockCounterDirectory() = default;
+    ~MockCounterDirectory() = default;
+
+    // Register profiling objects
+    const Category* RegisterCategory(const std::string& categoryName,
+                                     const armnn::Optional<uint16_t>& deviceUid = armnn::EmptyOptional(),
+                                     const armnn::Optional<uint16_t>& counterSetUid = armnn::EmptyOptional())
+    {
+        // Get the device UID
+        uint16_t deviceUidValue = deviceUid.has_value() ? deviceUid.value() : 0;
+
+        // Get the counter set UID
+        uint16_t counterSetUidValue = counterSetUid.has_value() ? counterSetUid.value() : 0;
+
+        // Create the category
+        CategoryPtr category = std::make_unique<Category>(categoryName, deviceUidValue, counterSetUidValue);
+        BOOST_ASSERT(category);
+
+        // Get the raw category pointer
+        const Category* categoryPtr = category.get();
+        BOOST_ASSERT(categoryPtr);
+
+        // Register the category
+        m_Categories.insert(std::move(category));
+
+        return categoryPtr;
+    }
+
+    const Device* RegisterDevice(const std::string& deviceName,
+                                 uint16_t cores = 0,
+                                 const armnn::Optional<std::string>& parentCategoryName = armnn::EmptyOptional())
+    {
+        // Get the device UID
+        uint16_t deviceUid = GetNextUid();
+
+        // Create the device
+        DevicePtr device = std::make_unique<Device>(deviceUid, deviceName, cores);
+        BOOST_ASSERT(device);
+
+        // Get the raw device pointer
+        const Device* devicePtr = device.get();
+        BOOST_ASSERT(devicePtr);
+
+        // Register the device
+        m_Devices.insert(std::make_pair(deviceUid, std::move(device)));
+
+        // Connect the counter set to the parent category, if required
+        if (parentCategoryName.has_value())
+        {
+            // Set the counter set UID in the parent category
+            Category* parentCategory = const_cast<Category*>(GetCategory(parentCategoryName.value()));
+            BOOST_ASSERT(parentCategory);
+            parentCategory->m_DeviceUid = deviceUid;
+        }
+
+        return devicePtr;
+    }
+
+    const CounterSet* RegisterCounterSet(
+            const std::string& counterSetName,
+            uint16_t count = 0,
+            const armnn::Optional<std::string>& parentCategoryName = armnn::EmptyOptional())
+    {
+        // Get the counter set UID
+        uint16_t counterSetUid = GetNextUid();
+
+        // Create the counter set
+        CounterSetPtr counterSet = std::make_unique<CounterSet>(counterSetUid, counterSetName, count);
+        BOOST_ASSERT(counterSet);
+
+        // Get the raw counter set pointer
+        const CounterSet* counterSetPtr = counterSet.get();
+        BOOST_ASSERT(counterSetPtr);
+
+        // Register the counter set
+        m_CounterSets.insert(std::make_pair(counterSetUid, std::move(counterSet)));
+
+        // Connect the counter set to the parent category, if required
+        if (parentCategoryName.has_value())
+        {
+            // Set the counter set UID in the parent category
+            Category* parentCategory = const_cast<Category*>(GetCategory(parentCategoryName.value()));
+            BOOST_ASSERT(parentCategory);
+            parentCategory->m_CounterSetUid = counterSetUid;
+        }
+
+        return counterSetPtr;
+    }
+
+    const Counter* RegisterCounter(const std::string& parentCategoryName,
+                                   uint16_t counterClass,
+                                   uint16_t interpolation,
+                                   double multiplier,
+                                   const std::string& name,
+                                   const std::string& description,
+                                   const armnn::Optional<std::string>& units = armnn::EmptyOptional(),
+                                   const armnn::Optional<uint16_t>& numberOfCores = armnn::EmptyOptional(),
+                                   const armnn::Optional<uint16_t>& deviceUid = armnn::EmptyOptional(),
+                                   const armnn::Optional<uint16_t>& counterSetUid = armnn::EmptyOptional())
+    {
+        // Get the number of cores from the argument only
+        uint16_t deviceCores = numberOfCores.has_value() ? numberOfCores.value() : 0;
+
+        // Get the device UID
+        uint16_t deviceUidValue = deviceUid.has_value() ? deviceUid.value() : 0;
+
+        // Get the counter set UID
+        uint16_t counterSetUidValue = counterSetUid.has_value() ? counterSetUid.value() : 0;
+
+        // Get the counter UIDs and calculate the max counter UID
+        std::vector<uint16_t> counterUids = GetNextCounterUids(deviceCores);
+        BOOST_ASSERT(!counterUids.empty());
+        uint16_t maxCounterUid = deviceCores <= 1 ? counterUids.front() : counterUids.back();
+
+        // Get the counter units
+        const std::string unitsValue = units.has_value() ? units.value() : "";
+
+        // Create the counter
+        CounterPtr counter = std::make_shared<Counter>(counterUids.front(),
+                                                       maxCounterUid,
+                                                       counterClass,
+                                                       interpolation,
+                                                       multiplier,
+                                                       name,
+                                                       description,
+                                                       unitsValue,
+                                                       deviceUidValue,
+                                                       counterSetUidValue);
+        BOOST_ASSERT(counter);
+
+        // Get the raw counter pointer
+        const Counter* counterPtr = counter.get();
+        BOOST_ASSERT(counterPtr);
+
+        // Process multiple counters if necessary
+        for (uint16_t counterUid : counterUids)
+        {
+            // Connect the counter to the parent category
+            Category* parentCategory = const_cast<Category*>(GetCategory(parentCategoryName));
+            BOOST_ASSERT(parentCategory);
+            parentCategory->m_Counters.push_back(counterUid);
+
+            // Register the counter
+            m_Counters.insert(std::make_pair(counterUid, counter));
+        }
+
+        return counterPtr;
+    }
+
+    // Getters for counts
+    uint16_t GetCategoryCount()   const override { return boost::numeric_cast<uint16_t>(m_Categories.size());  }
+    uint16_t GetDeviceCount()     const override { return boost::numeric_cast<uint16_t>(m_Devices.size());     }
+    uint16_t GetCounterSetCount() const override { return boost::numeric_cast<uint16_t>(m_CounterSets.size()); }
+    uint16_t GetCounterCount()    const override { return boost::numeric_cast<uint16_t>(m_Counters.size());    }
+
+    // Getters for collections
+    const Categories&  GetCategories()  const override { return m_Categories;  }
+    const Devices&     GetDevices()     const override { return m_Devices;     }
+    const CounterSets& GetCounterSets() const override { return m_CounterSets; }
+    const Counters&    GetCounters()    const override { return m_Counters;    }
+
+    // Getters for profiling objects
+    const Category* GetCategory(const std::string& name) const override
+    {
+        auto it = std::find_if(m_Categories.begin(), m_Categories.end(), [&name](const CategoryPtr& category)
+        {
+            BOOST_ASSERT(category);
+
+            return category->m_Name == name;
+        });
+
+        if (it == m_Categories.end())
+        {
+            return nullptr;
+        }
+
+        return it->get();
+    }
+
+    const Device* GetDevice(uint16_t uid) const override
+    {
+        return nullptr; // Not used by the unit tests
+    }
+
+    const CounterSet* GetCounterSet(uint16_t uid) const override
+    {
+        return nullptr; // Not used by the unit tests
+    }
+
+    const Counter* GetCounter(uint16_t uid) const override
+    {
+        return nullptr; // Not used by the unit tests
+    }
+
+private:
+    Categories  m_Categories;
+    Devices     m_Devices;
+    CounterSets m_CounterSets;
+    Counters    m_Counters;
+};
+
+class SendCounterPacketTest : public SendCounterPacket
+{
+public:
+    SendCounterPacketTest(IBufferWrapper& buffer)
+        : SendCounterPacket(buffer)
+    {}
+
+    bool CreateDeviceRecordTest(const DevicePtr& device,
+                                DeviceRecord& deviceRecord,
+                                std::string& errorMessage)
+    {
+        return CreateDeviceRecord(device, deviceRecord, errorMessage);
+    }
+
+    bool CreateCounterSetRecordTest(const CounterSetPtr& counterSet,
+                                    CounterSetRecord& counterSetRecord,
+                                    std::string& errorMessage)
+    {
+        return CreateCounterSetRecord(counterSet, counterSetRecord, errorMessage);
+    }
+
+    bool CreateEventRecordTest(const CounterPtr& counter,
+                               EventRecord& eventRecord,
+                               std::string& errorMessage)
+    {
+        return CreateEventRecord(counter, eventRecord, errorMessage);
+    }
+
+    bool CreateCategoryRecordTest(const CategoryPtr& category,
+                                  const Counters& counters,
+                                  CategoryRecord& categoryRecord,
+                                  std::string& errorMessage)
+    {
+        return CreateCategoryRecord(category, counters, categoryRecord, errorMessage);
+    }
+};