From 42f9d9e8fdb15f418240a64a7b089df611a015a0 Mon Sep 17 00:00:00 2001 From: Matteo Martincigh Date: Thu, 5 Sep 2019 12:02:04 +0100 Subject: 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 --- src/profiling/test/SendCounterPacketTests.hpp | 243 +++++++++++++++++++++++++- 1 file changed, 242 insertions(+), 1 deletion(-) (limited to 'src/profiling/test/SendCounterPacketTests.hpp') 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(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& deviceUid = armnn::EmptyOptional(), + const armnn::Optional& 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(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& parentCategoryName = armnn::EmptyOptional()) + { + // Get the device UID + uint16_t deviceUid = GetNextUid(); + + // Create the device + DevicePtr device = std::make_unique(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(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& parentCategoryName = armnn::EmptyOptional()) + { + // Get the counter set UID + uint16_t counterSetUid = GetNextUid(); + + // Create the counter set + CounterSetPtr counterSet = std::make_unique(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(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& units = armnn::EmptyOptional(), + const armnn::Optional& numberOfCores = armnn::EmptyOptional(), + const armnn::Optional& deviceUid = armnn::EmptyOptional(), + const armnn::Optional& 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 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(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(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(m_Categories.size()); } + uint16_t GetDeviceCount() const override { return boost::numeric_cast(m_Devices.size()); } + uint16_t GetCounterSetCount() const override { return boost::numeric_cast(m_CounterSets.size()); } + uint16_t GetCounterCount() const override { return boost::numeric_cast(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); + } +}; -- cgit v1.2.1