IVGCVSW-4454 Remove the CounterSet and Device fields from Category
Signed-off-by: Sadik Armagan <sadik.armagan@arm.com>
Change-Id: I721f59cd1f6d068e02dabd62c42871a43be9d934
diff --git a/include/armnn/backends/profiling/IBackendProfiling.hpp b/include/armnn/backends/profiling/IBackendProfiling.hpp
index 989c5e8..3352d37 100644
--- a/include/armnn/backends/profiling/IBackendProfiling.hpp
+++ b/include/armnn/backends/profiling/IBackendProfiling.hpp
@@ -49,9 +49,7 @@
class IRegisterBackendCounters
{
public:
- virtual void RegisterCategory(const std::string& categoryName,
- const Optional<uint16_t>& deviceUid = EmptyOptional(),
- const Optional<uint16_t>& counterSetUid = EmptyOptional()) = 0;
+ virtual void RegisterCategory(const std::string& categoryName) = 0;
virtual uint16_t RegisterDevice(const std::string& deviceName,
uint16_t cores = 0,
diff --git a/src/profiling/CounterDirectory.cpp b/src/profiling/CounterDirectory.cpp
index 6b2a945..052e452 100644
--- a/src/profiling/CounterDirectory.cpp
+++ b/src/profiling/CounterDirectory.cpp
@@ -18,9 +18,7 @@
namespace profiling
{
-const Category* CounterDirectory::RegisterCategory(const std::string& categoryName,
- const Optional<uint16_t>& deviceUid,
- const Optional<uint16_t>& counterSetUid)
+const Category* CounterDirectory::RegisterCategory(const std::string& categoryName)
{
// Check that the given category name is valid
if (categoryName.empty() ||
@@ -37,38 +35,8 @@
% categoryName));
}
- // Check that a device with the given (optional) UID is already registered
- uint16_t deviceUidValue = deviceUid.has_value() ? deviceUid.value() : 0;
- if (deviceUidValue > 0)
- {
- // Check that the (optional) device is already registered
- if (!IsDeviceRegistered(deviceUidValue))
- {
- throw InvalidArgumentException(
- boost::str(boost::format("Trying to connect a category (\"%1%\") to a device that is "
- "not registered (UID %2%)")
- % categoryName
- % deviceUidValue));
- }
- }
-
- // Check that a counter set with the given (optional) UID is already registered
- uint16_t counterSetUidValue = counterSetUid.has_value() ? counterSetUid.value() : 0;
- if (counterSetUidValue > 0)
- {
- // Check that the (optional) counter set is already registered
- if (!IsCounterSetRegistered(counterSetUidValue))
- {
- throw InvalidArgumentException(
- boost::str(boost::format("Trying to connect a category (name: \"%1%\") to a counter set "
- "that is not registered (UID: %2%)")
- % categoryName
- % counterSetUidValue));
- }
- }
-
// Create the category
- CategoryPtr category = std::make_unique<Category>(categoryName, deviceUidValue, counterSetUidValue);
+ CategoryPtr category = std::make_unique<Category>(categoryName);
BOOST_ASSERT(category);
// Get the raw category pointer
@@ -100,12 +68,7 @@
% deviceName));
}
- // Peek the next UID, do not get an actual valid UID just now as we don't want to waste a good UID in case
- // the registration fails. We'll get a proper one once we're sure that the device can be registered
- uint16_t deviceUidPeek = GetNextUid(true);
-
// Check that a category with the given (optional) parent category name is already registered
- Category* parentCategoryPtr = nullptr;
if (parentCategoryName.has_value())
{
// Get the (optional) parent category name
@@ -129,32 +92,10 @@
% deviceName
% parentCategoryNameValue));
}
-
- // Get the parent category
- const CategoryPtr& parentCategory = *categoryIt;
- BOOST_ASSERT(parentCategory);
-
- // Check that the given parent category is not already connected to another device
- if (parentCategory->m_DeviceUid != 0 && parentCategory->m_DeviceUid != deviceUidPeek)
- {
- throw InvalidArgumentException(
- boost::str(boost::format("Trying to connect a device (UID: %1%) to a parent category that is "
- "already connected to a different device "
- "(category \"%2%\" connected to device %3%)")
- % deviceUidPeek
- % parentCategoryNameValue
- % parentCategory->m_DeviceUid));
- }
-
- // The parent category can be associated to the device that is about to be registered.
- // Get the raw pointer to the parent category (to be used later when the device is actually been
- // registered, to make sure that the category is associated to an existing device)
- parentCategoryPtr = parentCategory.get();
}
// Get the device UID
uint16_t deviceUid = GetNextUid();
- BOOST_ASSERT(deviceUid == deviceUidPeek);
// Create the device
DevicePtr device = std::make_unique<Device>(deviceUid, deviceName, cores);
@@ -167,13 +108,6 @@
// Register the device
m_Devices.insert(std::make_pair(deviceUid, std::move(device)));
- // Connect the device to the parent category, if required
- if (parentCategoryPtr)
- {
- // Set the device UID in the parent category
- parentCategoryPtr->m_DeviceUid = deviceUid;
- }
-
return devicePtr;
}
@@ -201,7 +135,6 @@
uint16_t counterSetUidPeek = GetNextUid(true);
// Check that a category with the given (optional) parent category name is already registered
- Category* parentCategoryPtr = nullptr;
if (parentCategoryName.has_value())
{
// Get the (optional) parent category name
@@ -225,27 +158,6 @@
% counterSetUidPeek
% parentCategoryNameValue));
}
-
- // Get the parent category
- const CategoryPtr& parentCategory = *it;
- BOOST_ASSERT(parentCategory);
-
- // Check that the given parent category is not already connected to another counter set
- if (parentCategory->m_CounterSetUid != 0 && parentCategory->m_CounterSetUid != counterSetUidPeek)
- {
- throw InvalidArgumentException(
- boost::str(boost::format("Trying to connect a counter set (UID: %1%) to a parent category "
- "that is already connected to a different counter set "
- "(category \"%2%\" connected to counter set %3%)")
- % counterSetUidPeek
- % parentCategoryNameValue
- % parentCategory->m_CounterSetUid));
- }
-
- // The parent category can be associated to the counter set that is about to be registered.
- // Get the raw pointer to the parent category (to be used later when the counter set is actually been
- // registered, to make sure that the category is associated to an existing counter set)
- parentCategoryPtr = parentCategory.get();
}
// Get the counter set UID
@@ -263,13 +175,6 @@
// 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 (parentCategoryPtr)
- {
- // Set the counter set UID in the parent category
- parentCategoryPtr->m_CounterSetUid = counterSetUid;
- }
-
return counterSetPtr;
}
@@ -381,7 +286,7 @@
// Get the number of cores (this call may throw)
uint16_t deviceUidValue = deviceUid.has_value() ? deviceUid.value() : 0;
- uint16_t deviceCores = GetNumberOfCores(numberOfCores, deviceUidValue, parentCategory);
+ uint16_t deviceCores = GetNumberOfCores(numberOfCores, deviceUidValue);
// Get the counter UIDs and calculate the max counter UID
std::vector<uint16_t> counterUids = GetNextCounterUids(uid, deviceCores);
@@ -599,19 +504,14 @@
}
uint16_t CounterDirectory::GetNumberOfCores(const Optional<uint16_t>& numberOfCores,
- uint16_t deviceUid,
- const CategoryPtr& parentCategory)
+ uint16_t deviceUid)
{
- BOOST_ASSERT(parentCategory);
-
// To get the number of cores, apply the following rules:
//
// 1. If numberOfCores is set then take it as the deviceCores value
// 2. If numberOfCores is not set then check to see if this counter is directly associated with a device,
// if so then that devices number of cores is taken as the deviceCores value
- // 3. If neither of the above is set then look at the category to see if it has a device associated with it,
- // if it does then take that device's numberOfCores as the deviceCores value
- // 4. If none of the above holds then set deviceCores to zero
+ // 3. If none of the above holds then set deviceCores to zero
// 1. If numberOfCores is set then take it as the deviceCores value
if (numberOfCores.has_value())
@@ -642,30 +542,7 @@
return device->m_Cores;
}
- // 3. If neither of the above is set then look at the category to see if it has a device associated with it,
- // if it does then take that device's numberOfCores as the deviceCores value
- uint16_t parentCategoryDeviceUid = parentCategory->m_DeviceUid;
- if (parentCategoryDeviceUid > 0)
- {
- // Check that the device associated to the parent category is already registered
- auto deviceIt = FindDevice(parentCategoryDeviceUid);
- if (deviceIt == m_Devices.end())
- {
- throw InvalidArgumentException(
- boost::str(boost::format("Trying to get the number of cores from a device that is "
- "not registered (device UID %1%)")
- % parentCategoryDeviceUid));
- }
-
- // Get the associated device
- const DevicePtr& device = deviceIt->second;
- BOOST_ASSERT(device);
-
- // Get the number of cores of the device associated to the parent category
- return device->m_Cores;
- }
-
- // 4. If none of the above holds then set deviceCores to zero
+ // 3. If none of the above holds then set deviceCores to zero
return 0;
}
diff --git a/src/profiling/CounterDirectory.hpp b/src/profiling/CounterDirectory.hpp
index 22bae89..6a73a76 100644
--- a/src/profiling/CounterDirectory.hpp
+++ b/src/profiling/CounterDirectory.hpp
@@ -27,9 +27,7 @@
~CounterDirectory() = default;
// Register profiling objects
- const Category* RegisterCategory (const std::string& categoryName,
- const Optional<uint16_t>& deviceUid = EmptyOptional(),
- const Optional<uint16_t>& counterSetUid = EmptyOptional()) override;
+ const Category* RegisterCategory (const std::string& categoryName) override;
const Device* RegisterDevice (const std::string& deviceName,
uint16_t cores = 0,
const Optional<std::string>& parentCategoryName = EmptyOptional()) override;
@@ -51,7 +49,7 @@
// 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 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()); }
@@ -95,8 +93,7 @@
CountersIt FindCounter(uint16_t counterUid) const;
CountersIt FindCounter(const std::string& counterName) const;
uint16_t GetNumberOfCores(const Optional<uint16_t>& numberOfCores,
- uint16_t deviceUid,
- const CategoryPtr& parentCategory);
+ uint16_t deviceUid);
};
} // namespace profiling
diff --git a/src/profiling/DirectoryCaptureCommandHandler.cpp b/src/profiling/DirectoryCaptureCommandHandler.cpp
index f221513..65cac84 100644
--- a/src/profiling/DirectoryCaptureCommandHandler.cpp
+++ b/src/profiling/DirectoryCaptureCommandHandler.cpp
@@ -153,18 +153,6 @@
{
uint32_t categoryRecordOffset = offset + categoryOffsets[categoryIndex];
- // Category record word 0:
- // 0:15 The deviceUid of a counter_set the category is associated with.
- // Set to zero if the category is NOT associated with a counter set.
- uint16_t counterSetUid = profiling::ReadUint16(data, categoryRecordOffset);
- categoryRecordOffset += uint16_t_size;
-
- // 16:31 The deviceUid of a device element which identifies some hardware device that the category belongs to.
- // Set to zero if the category is NOT associated with a device
- uint16_t deviceUid = profiling::ReadUint16(data, categoryRecordOffset);
-
- categoryRecordOffset += uint16_t_size;
-
// Category record word 1:
// 0:15 Reserved, value 0x0000.
categoryRecordOffset += uint16_t_size;
@@ -197,7 +185,7 @@
categoryRecordOffset += uint32_t_size;
const Category* category = m_CounterDirectory.RegisterCategory(
- GetStringNameFromBuffer(data, categoryRecordOffset + nameOffset), deviceUid, counterSetUid);
+ GetStringNameFromBuffer(data, categoryRecordOffset + nameOffset));
for (auto& counter : eventRecords)
{
const Counter* registeredCounter = m_CounterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
diff --git a/src/profiling/ICounterDirectory.hpp b/src/profiling/ICounterDirectory.hpp
index 4f82b2e..b19f7d3 100644
--- a/src/profiling/ICounterDirectory.hpp
+++ b/src/profiling/ICounterDirectory.hpp
@@ -49,10 +49,8 @@
{
public:
// Constructors
- Category(const std::string& name, uint16_t deviceUid, uint16_t counterSetUid)
+ Category(const std::string& name)
: m_Name(name)
- , m_DeviceUid(deviceUid)
- , m_CounterSetUid(counterSetUid)
{}
// Fields
@@ -60,8 +58,6 @@
// Connections
std::vector<uint16_t> m_Counters; // The UIDs of the counters associated with this category
- uint16_t m_DeviceUid; // Optional, set to zero if the counter is not associated with a device
- uint16_t m_CounterSetUid; // Optional, set to zero if the counter is not associated with a counter set
};
class Device final
diff --git a/src/profiling/ICounterRegistry.hpp b/src/profiling/ICounterRegistry.hpp
index 75bc8ef..83bc335 100644
--- a/src/profiling/ICounterRegistry.hpp
+++ b/src/profiling/ICounterRegistry.hpp
@@ -20,9 +20,7 @@
virtual ~ICounterRegistry() {}
// Register profiling objects
- virtual const Category* RegisterCategory (const std::string& categoryName,
- const Optional<uint16_t>& deviceUid,
- const Optional<uint16_t>& counterSetUid) = 0;
+ virtual const Category* RegisterCategory (const std::string& categoryName) = 0;
virtual const Device* RegisterDevice (const std::string& deviceName,
uint16_t cores,
diff --git a/src/profiling/ProfilingUtils.cpp b/src/profiling/ProfilingUtils.cpp
index 0125f0d..3b06a26 100644
--- a/src/profiling/ProfilingUtils.cpp
+++ b/src/profiling/ProfilingUtils.cpp
@@ -1014,19 +1014,11 @@
categoryHeader.append(CentreAlignFormatting("Name", 20));
categoryHeader.append(" | ");
- categoryHeader.append(CentreAlignFormatting("Device", 12));
- categoryHeader.append(" | ");
- categoryHeader.append(CentreAlignFormatting("Counter set UID:", 16));
- categoryHeader.append(" | ");
categoryHeader.append(CentreAlignFormatting("Event Count", 14));
categoryHeader.append("\n");
categoryBody.append(CentreAlignFormatting(category->m_Name, 20));
categoryBody.append(" | ");
- categoryBody.append(CentreAlignFormatting(std::to_string(category->m_DeviceUid), 12));
- categoryBody.append(" | ");
- categoryBody.append(CentreAlignFormatting(std::to_string(category->m_CounterSetUid), 16));
- categoryBody.append(" | ");
categoryBody.append(CentreAlignFormatting(std::to_string(category->m_Counters.size()), 14));
std::cout << "\n" << "\n";
diff --git a/src/profiling/RegisterBackendCounters.cpp b/src/profiling/RegisterBackendCounters.cpp
index 0c68838..36f6106 100644
--- a/src/profiling/RegisterBackendCounters.cpp
+++ b/src/profiling/RegisterBackendCounters.cpp
@@ -11,11 +11,9 @@
namespace profiling
{
-void RegisterBackendCounters::RegisterCategory(const std::string& categoryName,
- const Optional<uint16_t>& deviceUid,
- const Optional<uint16_t>& counterSetUid)
+void RegisterBackendCounters::RegisterCategory(const std::string& categoryName)
{
- m_CounterDirectory.RegisterCategory(categoryName, deviceUid, counterSetUid);
+ m_CounterDirectory.RegisterCategory(categoryName);
}
uint16_t RegisterBackendCounters::RegisterDevice(const std::string& deviceName,
diff --git a/src/profiling/RegisterBackendCounters.hpp b/src/profiling/RegisterBackendCounters.hpp
index 41886c0..8f1fa04 100644
--- a/src/profiling/RegisterBackendCounters.hpp
+++ b/src/profiling/RegisterBackendCounters.hpp
@@ -27,9 +27,7 @@
~RegisterBackendCounters() = default;
- void RegisterCategory(const std::string& categoryName,
- const Optional<uint16_t>& deviceUid = EmptyOptional(),
- const Optional<uint16_t>& counterSetUid = EmptyOptional()) override;
+ void RegisterCategory(const std::string& categoryName) override;
uint16_t RegisterDevice(const std::string& deviceName,
uint16_t cores = 0,
diff --git a/src/profiling/SendCounterPacket.cpp b/src/profiling/SendCounterPacket.cpp
index f60586e..b8ef189 100644
--- a/src/profiling/SendCounterPacket.cpp
+++ b/src/profiling/SendCounterPacket.cpp
@@ -182,21 +182,12 @@
const std::string& categoryName = category->m_Name;
const std::vector<uint16_t> categoryCounters = category->m_Counters;
- uint16_t deviceUid = category->m_DeviceUid;
- uint16_t counterSetUid = category->m_CounterSetUid;
BOOST_ASSERT(!categoryName.empty());
// Utils
size_t uint32_t_size = sizeof(uint32_t);
- // Category record word 0:
- // 16:31 [16] device: the uid of a device element which identifies some hardware device that
- // the category belongs to
- // 0:15 [16] counter_set: the uid of a counter_set the category is associated with
- uint32_t categoryRecordWord0 = (static_cast<uint32_t>(deviceUid) << 16) |
- (static_cast<uint32_t>(counterSetUid));
-
// Category record word 1:
// 16:31 [16] event_count: number of events belonging to this category
// 0:15 [16] reserved: all zeros
@@ -252,7 +243,7 @@
uint32_t categoryRecordWord3 = numeric_cast<uint32_t>(eventRecordOffsets.size() * uint32_t_size);
// Calculate the size in words of the category record
- size_t categoryRecordSize = 4u + // The size of the fixed part (device + counter_set + event_count + reserved +
+ size_t categoryRecordSize = 3u + // The size of the fixed part (device + counter_set + event_count + reserved +
// event_pointer_table_offset + name_offset)
eventRecordOffsets.size() + // The size of the variable part (the event pointer table +
categoryNameBuffer.size() + // and the category name including the null-terminator +
@@ -263,11 +254,10 @@
ARMNN_NO_CONVERSION_WARN_BEGIN
// Create the category record
- categoryRecord[0] = categoryRecordWord0; // device + counter_set
- categoryRecord[1] = categoryRecordWord1; // event_count + reserved
- categoryRecord[2] = categoryRecordWord2; // event_pointer_table_offset
- categoryRecord[3] = categoryRecordWord3; // name_offset
- auto offset = categoryRecord.begin() + 4u;
+ categoryRecord[0] = categoryRecordWord1; // event_count + reserved
+ categoryRecord[1] = categoryRecordWord2; // event_pointer_table_offset
+ categoryRecord[2] = categoryRecordWord3; // name_offset
+ auto offset = categoryRecord.begin() + 3u;
std::copy(eventRecordOffsets.begin(), eventRecordOffsets.end(), offset); // event_pointer_table
offset += eventRecordOffsets.size();
std::copy(categoryNameBuffer.begin(), categoryNameBuffer.end(), offset); // name
diff --git a/src/profiling/test/ProfilingMocks.hpp b/src/profiling/test/ProfilingMocks.hpp
index 3782a0f..19aad49 100644
--- a/src/profiling/test/ProfilingMocks.hpp
+++ b/src/profiling/test/ProfilingMocks.hpp
@@ -443,18 +443,10 @@
~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())
+ const Category* RegisterCategory(const std::string& categoryName)
{
- // 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);
+ CategoryPtr category = std::make_unique<Category>(categoryName);
BOOST_ASSERT(category);
// Get the raw category pointer
@@ -468,8 +460,7 @@
}
const Device* RegisterDevice(const std::string& deviceName,
- uint16_t cores = 0,
- const armnn::Optional<std::string>& parentCategoryName = armnn::EmptyOptional())
+ uint16_t cores = 0)
{
// Get the device UID
uint16_t deviceUid = GetNextUid();
@@ -485,22 +476,12 @@
// 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())
+ uint16_t count = 0)
{
// Get the counter set UID
uint16_t counterSetUid = GetNextUid();
@@ -516,15 +497,6 @@
// 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;
}
diff --git a/src/profiling/test/ProfilingTests.cpp b/src/profiling/test/ProfilingTests.cpp
index c025aa2..6c1e84b 100644
--- a/src/profiling/test/ProfilingTests.cpp
+++ b/src/profiling/test/ProfilingTests.cpp
@@ -787,8 +787,6 @@
BOOST_CHECK(category);
BOOST_CHECK(category->m_Name == categoryName);
BOOST_CHECK(category->m_Counters.empty());
- BOOST_CHECK(category->m_DeviceUid == 0);
- BOOST_CHECK(category->m_CounterSetUid == 0);
// Get the registered category
const Category* registeredCategory = counterDirectory.GetCategory(categoryName);
@@ -821,39 +819,29 @@
// Register a new category not associated to any device
const std::string categoryWoDeviceName = "some_category_without_device";
const Category* categoryWoDevice = nullptr;
- BOOST_CHECK_NO_THROW(categoryWoDevice = counterDirectory.RegisterCategory(categoryWoDeviceName, 0));
+ BOOST_CHECK_NO_THROW(categoryWoDevice = counterDirectory.RegisterCategory(categoryWoDeviceName));
BOOST_CHECK(counterDirectory.GetCategoryCount() == 2);
BOOST_CHECK(categoryWoDevice);
BOOST_CHECK(categoryWoDevice->m_Name == categoryWoDeviceName);
BOOST_CHECK(categoryWoDevice->m_Counters.empty());
- BOOST_CHECK(categoryWoDevice->m_DeviceUid == 0);
- BOOST_CHECK(categoryWoDevice->m_CounterSetUid == 0);
- // Register a new category associated to an invalid device
- const std::string categoryWInvalidDeviceName = "some_category_with_invalid_device";
-
- ARMNN_NO_CONVERSION_WARN_BEGIN
- uint16_t invalidDeviceUid = device->m_Uid + 10;
- ARMNN_NO_CONVERSION_WARN_END
-
- const Category* categoryWInvalidDevice = nullptr;
- BOOST_CHECK_THROW(categoryWInvalidDevice =
- counterDirectory.RegisterCategory(categoryWInvalidDeviceName, invalidDeviceUid),
+ // Register a new category associated to an invalid device name (already exist)
+ const Category* categoryInvalidDeviceName = nullptr;
+ BOOST_CHECK_THROW(categoryInvalidDeviceName =
+ counterDirectory.RegisterCategory(categoryWoDeviceName),
armnn::InvalidArgumentException);
BOOST_CHECK(counterDirectory.GetCategoryCount() == 2);
- BOOST_CHECK(!categoryWInvalidDevice);
+ BOOST_CHECK(!categoryInvalidDeviceName);
// Register a new category associated to a valid device
const std::string categoryWValidDeviceName = "some_category_with_valid_device";
const Category* categoryWValidDevice = nullptr;
BOOST_CHECK_NO_THROW(categoryWValidDevice =
- counterDirectory.RegisterCategory(categoryWValidDeviceName, device->m_Uid));
+ counterDirectory.RegisterCategory(categoryWValidDeviceName));
BOOST_CHECK(counterDirectory.GetCategoryCount() == 3);
BOOST_CHECK(categoryWValidDevice);
BOOST_CHECK(categoryWValidDevice != category);
BOOST_CHECK(categoryWValidDevice->m_Name == categoryWValidDeviceName);
- BOOST_CHECK(categoryWValidDevice->m_DeviceUid == device->m_Uid);
- BOOST_CHECK(categoryWValidDevice->m_CounterSetUid == 0);
// Register a counter set for testing
const std::string counterSetName = "some_counter_set";
@@ -869,50 +857,29 @@
const std::string categoryWoCounterSetName = "some_category_without_counter_set";
const Category* categoryWoCounterSet = nullptr;
BOOST_CHECK_NO_THROW(categoryWoCounterSet =
- counterDirectory.RegisterCategory(categoryWoCounterSetName, armnn::EmptyOptional(), 0));
+ counterDirectory.RegisterCategory(categoryWoCounterSetName));
BOOST_CHECK(counterDirectory.GetCategoryCount() == 4);
BOOST_CHECK(categoryWoCounterSet);
BOOST_CHECK(categoryWoCounterSet->m_Name == categoryWoCounterSetName);
- BOOST_CHECK(categoryWoCounterSet->m_DeviceUid == 0);
- BOOST_CHECK(categoryWoCounterSet->m_CounterSetUid == 0);
-
- // Register a new category associated to an invalid counter set
- const std::string categoryWInvalidCounterSetName = "some_category_with_invalid_counter_set";
-
- ARMNN_NO_CONVERSION_WARN_BEGIN
- uint16_t invalidCunterSetUid = counterSet->m_Uid + 10;
- ARMNN_NO_CONVERSION_WARN_END
-
- const Category* categoryWInvalidCounterSet = nullptr;
- BOOST_CHECK_THROW(categoryWInvalidCounterSet = counterDirectory.RegisterCategory(
- categoryWInvalidCounterSetName, armnn::EmptyOptional(), invalidCunterSetUid),
- armnn::InvalidArgumentException);
- BOOST_CHECK(counterDirectory.GetCategoryCount() == 4);
- BOOST_CHECK(!categoryWInvalidCounterSet);
// Register a new category associated to a valid counter set
const std::string categoryWValidCounterSetName = "some_category_with_valid_counter_set";
const Category* categoryWValidCounterSet = nullptr;
- BOOST_CHECK_NO_THROW(categoryWValidCounterSet = counterDirectory.RegisterCategory(
- categoryWValidCounterSetName, armnn::EmptyOptional(), counterSet->m_Uid));
+ BOOST_CHECK_NO_THROW(categoryWValidCounterSet = counterDirectory.RegisterCategory(categoryWValidCounterSetName));
BOOST_CHECK(counterDirectory.GetCategoryCount() == 5);
BOOST_CHECK(categoryWValidCounterSet);
BOOST_CHECK(categoryWValidCounterSet != category);
BOOST_CHECK(categoryWValidCounterSet->m_Name == categoryWValidCounterSetName);
- BOOST_CHECK(categoryWValidCounterSet->m_DeviceUid == 0);
- BOOST_CHECK(categoryWValidCounterSet->m_CounterSetUid == counterSet->m_Uid);
// Register a new category associated to a valid device and counter set
const std::string categoryWValidDeviceAndValidCounterSetName = "some_category_with_valid_device_and_counter_set";
const Category* categoryWValidDeviceAndValidCounterSet = nullptr;
BOOST_CHECK_NO_THROW(categoryWValidDeviceAndValidCounterSet = counterDirectory.RegisterCategory(
- categoryWValidDeviceAndValidCounterSetName, device->m_Uid, counterSet->m_Uid));
+ categoryWValidDeviceAndValidCounterSetName));
BOOST_CHECK(counterDirectory.GetCategoryCount() == 6);
BOOST_CHECK(categoryWValidDeviceAndValidCounterSet);
BOOST_CHECK(categoryWValidDeviceAndValidCounterSet != category);
BOOST_CHECK(categoryWValidDeviceAndValidCounterSet->m_Name == categoryWValidDeviceAndValidCounterSetName);
- BOOST_CHECK(categoryWValidDeviceAndValidCounterSet->m_DeviceUid == device->m_Uid);
- BOOST_CHECK(categoryWValidDeviceAndValidCounterSet->m_CounterSetUid == counterSet->m_Uid);
}
BOOST_AUTO_TEST_CASE(CheckCounterDirectoryRegisterDevice)
@@ -1004,8 +971,6 @@
BOOST_CHECK(category);
BOOST_CHECK(category->m_Name == categoryName);
BOOST_CHECK(category->m_Counters.empty());
- BOOST_CHECK(category->m_DeviceUid == 0);
- BOOST_CHECK(category->m_CounterSetUid == 0);
// Register a new device with cores and valid parent category
const std::string deviceWCoresWValidParentCategoryName = "some_device_with_cores_with_valid_parent_category";
@@ -1019,15 +984,6 @@
BOOST_CHECK(deviceWCoresWValidParentCategory->m_Uid > device->m_Uid);
BOOST_CHECK(deviceWCoresWValidParentCategory->m_Uid > deviceWCores->m_Uid);
BOOST_CHECK(deviceWCoresWValidParentCategory->m_Cores == 4);
- BOOST_CHECK(category->m_DeviceUid == deviceWCoresWValidParentCategory->m_Uid);
-
- // Register a device associated to a category already associated to a different device
- const std::string deviceSameCategoryName = "some_device_with_invalid_parent_category";
- const Device* deviceSameCategory = nullptr;
- BOOST_CHECK_THROW(deviceSameCategory = counterDirectory.RegisterDevice(deviceSameCategoryName, 0, categoryName),
- armnn::InvalidArgumentException);
- BOOST_CHECK(counterDirectory.GetDeviceCount() == 3);
- BOOST_CHECK(!deviceSameCategory);
}
BOOST_AUTO_TEST_CASE(CheckCounterDirectoryRegisterCounterSet)
@@ -1123,8 +1079,6 @@
BOOST_CHECK(category);
BOOST_CHECK(category->m_Name == categoryName);
BOOST_CHECK(category->m_Counters.empty());
- BOOST_CHECK(category->m_DeviceUid == 0);
- BOOST_CHECK(category->m_CounterSetUid == 0);
// Register a new counter set with count and valid parent category
const std::string counterSetWCountWValidParentCategoryName = "some_counter_set_with_count_"
@@ -1139,13 +1093,13 @@
BOOST_CHECK(counterSetWCountWValidParentCategory->m_Uid > counterSet->m_Uid);
BOOST_CHECK(counterSetWCountWValidParentCategory->m_Uid > counterSetWCount->m_Uid);
BOOST_CHECK(counterSetWCountWValidParentCategory->m_Count == 42);
- BOOST_CHECK(category->m_CounterSetUid == counterSetWCountWValidParentCategory->m_Uid);
- // Register a counter set associated to a category already associated to a different counter set
+ // Register a counter set associated to a category with invalid name
const std::string counterSetSameCategoryName = "some_counter_set_with_invalid_parent_category";
+ const std::string invalidCategoryName = "";
const CounterSet* counterSetSameCategory = nullptr;
BOOST_CHECK_THROW(counterSetSameCategory =
- counterDirectory.RegisterCounterSet(counterSetSameCategoryName, 0, categoryName),
+ counterDirectory.RegisterCounterSet(counterSetSameCategoryName, 0, invalidCategoryName),
armnn::InvalidArgumentException);
BOOST_CHECK(counterDirectory.GetCounterSetCount() == 3);
BOOST_CHECK(!counterSetSameCategory);
@@ -1323,8 +1277,6 @@
BOOST_CHECK(category);
BOOST_CHECK(category->m_Name == categoryName);
BOOST_CHECK(category->m_Counters.empty());
- BOOST_CHECK(category->m_DeviceUid == 0);
- BOOST_CHECK(category->m_CounterSetUid == 0);
// Register a counter with a valid parent category name
const Counter* counter = nullptr;
@@ -1602,6 +1554,7 @@
// Register a counter with a valid parent category name and getting the number of cores of the multi-core device
// associated to that category
const Counter* counterWMultiCoreDeviceWParentCategory = nullptr;
+ uint16_t numberOfCourse = multiCoreDeviceWParentCategory->m_Cores;
BOOST_CHECK_NO_THROW(counterWMultiCoreDeviceWParentCategory =
counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
100,
@@ -1611,9 +1564,9 @@
123.45f,
"valid name 10",
"valid description",
- armnn::EmptyOptional(),// Units
- armnn::EmptyOptional(),// Number of cores
- armnn::EmptyOptional(),// Device UID
+ armnn::EmptyOptional(), // Units
+ numberOfCourse, // Number of cores
+ armnn::EmptyOptional(), // Device UID
armnn::EmptyOptional()));// Counter set UID
BOOST_CHECK(counterDirectory.GetCounterCount() == 26);
BOOST_CHECK(counterWMultiCoreDeviceWParentCategory);
@@ -1626,8 +1579,6 @@
BOOST_CHECK(counterWMultiCoreDeviceWParentCategory->m_Name == "valid name 10");
BOOST_CHECK(counterWMultiCoreDeviceWParentCategory->m_Description == "valid description");
BOOST_CHECK(counterWMultiCoreDeviceWParentCategory->m_Units == "");
- BOOST_CHECK(counterWMultiCoreDeviceWParentCategory->m_DeviceUid == 0);
- BOOST_CHECK(counterWMultiCoreDeviceWParentCategory->m_CounterSetUid == 0);
BOOST_CHECK(category->m_Counters.size() == 26);
for (size_t i = 0; i < 2; i++)
{
@@ -1702,8 +1653,6 @@
BOOST_CHECK(anotherCategory != category);
BOOST_CHECK(anotherCategory->m_Name == anotherCategoryName);
BOOST_CHECK(anotherCategory->m_Counters.empty());
- BOOST_CHECK(anotherCategory->m_DeviceUid == 0);
- BOOST_CHECK(anotherCategory->m_CounterSetUid == 0);
// Register a counter to the other category
const Counter* anotherCounter = nullptr;
@@ -2304,7 +2253,7 @@
BOOST_CHECK(device != nullptr);
const CounterSet* counterSet = counterDirectory.RegisterCounterSet("countersetA");
BOOST_CHECK(counterSet != nullptr);
- counterDirectory.RegisterCategory("categoryA", device->m_Uid, counterSet->m_Uid);
+ counterDirectory.RegisterCategory("categoryA");
counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID, 24,
"categoryA", 0, 1, 2.0f, "counterA", "descA");
counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID, 25,
@@ -2326,7 +2275,7 @@
BOOST_TEST(((header1Word0 >> 26) & 0x0000003F) == 0); // packet family
BOOST_TEST(((header1Word0 >> 16) & 0x000003FF) == 2); // packet id
- BOOST_TEST(header1Word1 == 240); // data length
+ BOOST_TEST(header1Word1 == 236); // data length
uint32_t bodyHeader1Word0 = ReadUint32(readBuffer1, 8);
uint32_t bodyHeader1Word1 = ReadUint32(readBuffer1, 12);
@@ -2474,9 +2423,9 @@
// Write the packet to the mock profiling connection
mockProfilingConnection->WritePacket(std::move(requestCounterDirectoryPacket));
- // Expecting one CounterDirectory Packet of length 656
+ // Expecting one CounterDirectory Packet of length 652
// and one TimelineMessageDirectory packet of length 427
- BOOST_CHECK(helper.WaitForPacketsSent(mockProfilingConnection, PacketType::CounterDirectory, 656) == 1);
+ BOOST_CHECK(helper.WaitForPacketsSent(mockProfilingConnection, PacketType::CounterDirectory, 652) == 1);
BOOST_CHECK(helper.WaitForPacketsSent(mockProfilingConnection, PacketType::TimelineMessageDirectory, 427) == 1);
// The Request Counter Directory Command Handler should not have updated the profiling state
diff --git a/src/profiling/test/SendCounterPacketTests.cpp b/src/profiling/test/SendCounterPacketTests.cpp
index 48a0bb6..d7dc7e2 100644
--- a/src/profiling/test/SendCounterPacketTests.cpp
+++ b/src/profiling/test/SendCounterPacketTests.cpp
@@ -858,9 +858,7 @@
// Create a category for testing
const std::string categoryName = "some_category";
- uint16_t deviceUid = 1302;
- uint16_t counterSetUid = 20734;
- const CategoryPtr category = std::make_unique<Category>(categoryName, deviceUid, counterSetUid);
+ const CategoryPtr category = std::make_unique<Category>(categoryName);
BOOST_ASSERT(category);
category->m_Counters = { 11u, 23u, 5670u };
@@ -917,21 +915,14 @@
BOOST_CHECK(result);
BOOST_CHECK(errorMessage.empty());
- BOOST_CHECK(categoryRecord.size() == 80); // Size in words: header [4] + event pointer table [3] +
+ BOOST_CHECK(categoryRecord.size() == 79); // Size in words: header [3] + event pointer table [3] +
// category name [5] + event records [68 = 22 + 20 + 26]
- uint16_t categoryRecordWord0[]
+ uint16_t categoryRecordWord1[]
{
static_cast<uint16_t>(categoryRecord[0] >> 16),
static_cast<uint16_t>(categoryRecord[0])
};
- uint16_t categoryRecordWord1[]
- {
- static_cast<uint16_t>(categoryRecord[1] >> 16),
- static_cast<uint16_t>(categoryRecord[1])
- };
- BOOST_CHECK(categoryRecordWord0[0] == deviceUid); // device
- BOOST_CHECK(categoryRecordWord0[1] == counterSetUid); // counter_set
BOOST_CHECK(categoryRecordWord1[0] == categoryEventCount); // event_count
BOOST_CHECK(categoryRecordWord1[1] == 0); // reserved
@@ -943,10 +934,10 @@
categoryEventCount * uint32_t_size; // The size of the event pointer table
ARMNN_NO_CONVERSION_WARN_END
- BOOST_CHECK(categoryRecord[2] == eventPointerTableOffset); // event_pointer_table_offset
- BOOST_CHECK(categoryRecord[3] == categoryNameOffset); // name_offset
+ BOOST_CHECK(categoryRecord[1] == eventPointerTableOffset); // event_pointer_table_offset
+ BOOST_CHECK(categoryRecord[2] == categoryNameOffset); // name_offset
- auto categoryRecordPool = reinterpret_cast<unsigned char*>(categoryRecord.data() + 4u); // The start of the pool
+ auto categoryRecordPool = reinterpret_cast<unsigned char*>(categoryRecord.data() + 3u); // The start of the pool
// The event pointer table
uint32_t eventRecord0Offset = categoryRecordPool[eventPointerTableOffset + 0 * uint32_t_size];
@@ -1062,9 +1053,7 @@
// Create a category for testing
const std::string categoryName = "some invalid category";
- uint16_t deviceUid = 1302;
- uint16_t counterSetUid = 20734;
- const CategoryPtr category = std::make_unique<Category>(categoryName, deviceUid, counterSetUid);
+ const CategoryPtr category = std::make_unique<Category>(categoryName);
BOOST_CHECK(category);
// Create a category record
@@ -1085,9 +1074,7 @@
// Create a category for testing
const std::string categoryName = "some_category";
- uint16_t deviceUid = 1302;
- uint16_t counterSetUid = 20734;
- const CategoryPtr category = std::make_unique<Category>(categoryName, deviceUid, counterSetUid);
+ const CategoryPtr category = std::make_unique<Category>(categoryName);
BOOST_CHECK(category);
category->m_Counters = { 11u, 23u, 5670u };
@@ -1174,20 +1161,19 @@
// Register a category associated to "device1" and "counterset1"
const std::string category1Name = "category1";
const Category* category1 = nullptr;
- BOOST_CHECK_NO_THROW(category1 = counterDirectory.RegisterCategory(category1Name,
- device1->m_Uid,
- counterSet1->m_Uid));
+ BOOST_CHECK_NO_THROW(category1 = counterDirectory.RegisterCategory(category1Name));
BOOST_CHECK(counterDirectory.GetCategoryCount() == 1);
BOOST_CHECK(category1);
// Register a category not associated to "device2" but no counter set
const std::string category2Name = "category2";
const Category* category2 = nullptr;
- BOOST_CHECK_NO_THROW(category2 = counterDirectory.RegisterCategory(category2Name,
- device2->m_Uid));
+ BOOST_CHECK_NO_THROW(category2 = counterDirectory.RegisterCategory(category2Name));
BOOST_CHECK(counterDirectory.GetCategoryCount() == 2);
BOOST_CHECK(category2);
+ uint16_t numberOfCores = 3;
+
// Register a counter associated to "category1"
const Counter* counter1 = nullptr;
BOOST_CHECK_NO_THROW(counter1 = counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
@@ -1198,7 +1184,8 @@
123.45f,
"counter1",
"counter1description",
- std::string("counter1units")));
+ std::string("counter1units"),
+ numberOfCores));
BOOST_CHECK(counterDirectory.GetCounterCount() == 3);
BOOST_CHECK(counter1);
@@ -1249,7 +1236,7 @@
uint32_t packetHeaderWord1 = ReadUint32(readBuffer, 4);
BOOST_TEST(((packetHeaderWord0 >> 26) & 0x3F) == 0); // packet_family
BOOST_TEST(((packetHeaderWord0 >> 16) & 0x3FF) == 2); // packet_id
- BOOST_TEST(packetHeaderWord1 == 936); // data_length
+ BOOST_TEST(packetHeaderWord1 == 928); // data_length
// Check the body header
uint32_t bodyHeaderWord0 = ReadUint32(readBuffer, 8);
@@ -1282,7 +1269,7 @@
uint32_t categoryRecordOffset0 = ReadUint32(readBuffer, 44);
uint32_t categoryRecordOffset1 = ReadUint32(readBuffer, 48);
BOOST_TEST(categoryRecordOffset0 == 64); // Category record offset for "category1"
- BOOST_TEST(categoryRecordOffset1 == 476); // Category record offset for "category2"
+ BOOST_TEST(categoryRecordOffset1 == 472); // Category record offset for "category2"
// Get the device record pool offset
uint32_t uint32_t_size = sizeof(uint32_t);
@@ -1431,8 +1418,6 @@
// Category record structure/collection used for testing
struct CategoryRecord
{
- uint16_t device;
- uint16_t counter_set;
uint16_t event_count;
uint32_t event_pointer_table_offset;
uint32_t name_offset;
@@ -1451,24 +1436,20 @@
uint32_t categoryRecordOffset = ReadUint32(readBuffer, categoryRecordsPointerTableOffset + i * uint32_t_size);
// Collect the data for the category record
- uint32_t categoryRecordWord0 = ReadUint32(readBuffer,
- packetBodyPoolOffset + categoryRecordOffset + 0 * uint32_t_size);
uint32_t categoryRecordWord1 = ReadUint32(readBuffer,
- packetBodyPoolOffset + categoryRecordOffset + 1 * uint32_t_size);
+ packetBodyPoolOffset + categoryRecordOffset + 0 * uint32_t_size);
uint32_t categoryRecordWord2 = ReadUint32(readBuffer,
- packetBodyPoolOffset + categoryRecordOffset + 2 * uint32_t_size);
+ packetBodyPoolOffset + categoryRecordOffset + 1 * uint32_t_size);
uint32_t categoryRecordWord3 = ReadUint32(readBuffer,
- packetBodyPoolOffset + categoryRecordOffset + 3 * uint32_t_size);
+ packetBodyPoolOffset + categoryRecordOffset + 2 * uint32_t_size);
CategoryRecord categoryRecord;
- categoryRecord.device = static_cast<uint16_t>(categoryRecordWord0 >> 16); // device
- categoryRecord.counter_set = static_cast<uint16_t>(categoryRecordWord0); // counter_set
categoryRecord.event_count = static_cast<uint16_t>(categoryRecordWord1 >> 16); // event_count
categoryRecord.event_pointer_table_offset = categoryRecordWord2; // event_pointer_table_offset
categoryRecord.name_offset = categoryRecordWord3; // name_offset
uint32_t categoryRecordPoolOffset = packetBodyPoolOffset + // Packet body offset
categoryRecordOffset + // Category record offset
- 4 * uint32_t_size; // Category record header
+ 3 * uint32_t_size; // Category record header
uint32_t categoryRecordNameLength = ReadUint32(readBuffer,
categoryRecordPoolOffset + categoryRecord.name_offset);
@@ -1603,8 +1584,6 @@
const Category* category = counterDirectory.GetCategory(categoryRecord.name);
BOOST_CHECK(category);
BOOST_CHECK(category->m_Name == categoryRecord.name);
- BOOST_CHECK(category->m_DeviceUid == categoryRecord.device);
- BOOST_CHECK(category->m_CounterSetUid == categoryRecord.counter_set);
BOOST_CHECK(category->m_Counters.size() == categoryRecord.event_count);
// Check that the event records are correct
@@ -1701,9 +1680,7 @@
// Register an invalid category associated to an invalid device and an invalid counter set
const std::string categoryName = "c@t€gory";
const Category* category = nullptr;
- BOOST_CHECK_NO_THROW(category = counterDirectory.RegisterCategory(categoryName,
- device->m_Uid,
- counterSet->m_Uid));
+ BOOST_CHECK_NO_THROW(category = counterDirectory.RegisterCategory(categoryName));
BOOST_CHECK(counterDirectory.GetCategoryCount() == 1);
BOOST_CHECK(category);
@@ -1735,9 +1712,7 @@
// Register an valid category associated to a valid device and a valid counter set
const std::string categoryName = "category";
const Category* category = nullptr;
- BOOST_CHECK_NO_THROW(category = counterDirectory.RegisterCategory(categoryName,
- device->m_Uid,
- counterSet->m_Uid));
+ BOOST_CHECK_NO_THROW(category = counterDirectory.RegisterCategory(categoryName));
BOOST_CHECK(counterDirectory.GetCategoryCount() == 1);
BOOST_CHECK(category);
diff --git a/tests/profiling/gatordmock/CounterDirectory.hpp b/tests/profiling/gatordmock/CounterDirectory.hpp
index 7b45e66..528c037 100644
--- a/tests/profiling/gatordmock/CounterDirectory.hpp
+++ b/tests/profiling/gatordmock/CounterDirectory.hpp
@@ -106,8 +106,6 @@
struct CategoryRecord
{
- uint16_t m_DeviceUid;
- uint16_t m_CounterSet;
uint16_t m_EventCount;
std::string m_CategoryName;
std::vector<EventRecord> m_EventRecords;
@@ -119,19 +117,11 @@
header.append(gatordmock::CentreAlignFormatting("Name", 20));
header.append(" | ");
- header.append(gatordmock::CentreAlignFormatting("Device", 12));
- header.append(" | ");
- header.append(gatordmock::CentreAlignFormatting("Counter set UID:", 16));
- header.append(" | ");
header.append(gatordmock::CentreAlignFormatting("Event Count", 14));
header.append("\n");
body.append(gatordmock::CentreAlignFormatting(m_CategoryName, 20));
body.append(" | ");
- body.append(gatordmock::CentreAlignFormatting(std::to_string(m_DeviceUid), 12));
- body.append(" | ");
- body.append(gatordmock::CentreAlignFormatting(std::to_string(m_CounterSet), 16));
- body.append(" | ");
body.append(gatordmock::CentreAlignFormatting(std::to_string(m_EventCount), 14));
std::cout << "\n" << "\n";
diff --git a/tests/profiling/gatordmock/tests/GatordMockTests.cpp b/tests/profiling/gatordmock/tests/GatordMockTests.cpp
index 02adffb..fecfce4 100644
--- a/tests/profiling/gatordmock/tests/GatordMockTests.cpp
+++ b/tests/profiling/gatordmock/tests/GatordMockTests.cpp
@@ -243,8 +243,6 @@
if (receivedCategory->m_Name.compare(category->m_Name) == 0)
{
// We've found the matching category.
- BOOST_CHECK(category->m_DeviceUid == receivedCategory->m_DeviceUid);
- BOOST_CHECK(category->m_CounterSetUid == receivedCategory->m_CounterSetUid);
// Now look at the interiors of the counters. Start by sorting them.
std::sort(category->m_Counters.begin(), category->m_Counters.end());
std::sort(receivedCategory->m_Counters.begin(), receivedCategory->m_Counters.end());