#include <CounterDirectory.hpp>

Inheritance diagram for CounterDirectory:

Public Member Functions
	CounterDirectory ()=default

	~CounterDirectory ()=default

const Category *	RegisterCategory (const std::string &categoryName, const Optional< uint16_t > &deviceUid=EmptyOptional(), const Optional< uint16_t > &counterSetUid=EmptyOptional()) override

const Device *	RegisterDevice (const std::string &deviceName, uint16_t cores=0, const Optional< std::string > &parentCategoryName=EmptyOptional()) override

const CounterSet *	RegisterCounterSet (const std::string &counterSetName, uint16_t count=0, const Optional< std::string > &parentCategoryName=EmptyOptional()) override

const Counter *	RegisterCounter (const BackendId &backendId, const uint16_t uid, const std::string &parentCategoryName, uint16_t counterClass, uint16_t interpolation, double multiplier, const std::string &name, const std::string &description, const Optional< std::string > &units=EmptyOptional(), const Optional< uint16_t > &numberOfCores=EmptyOptional(), const Optional< uint16_t > &deviceUid=EmptyOptional(), const Optional< uint16_t > &counterSetUid=EmptyOptional()) override

uint16_t	GetCategoryCount () const override

uint16_t	GetDeviceCount () const override

uint16_t	GetCounterSetCount () const override

uint16_t	GetCounterCount () const override

const Categories &	GetCategories () const override

const Devices &	GetDevices () const override

const CounterSets &	GetCounterSets () const override

const Counters &	GetCounters () const override

const Category *	GetCategory (const std::string &name) const override

const Device *	GetDevice (uint16_t uid) const override

const CounterSet *	GetCounterSet (uint16_t uid) const override

const Counter *	GetCounter (uint16_t uid) const override

bool	IsCategoryRegistered (const std::string &categoryName) const

bool	IsDeviceRegistered (uint16_t deviceUid) const

bool	IsDeviceRegistered (const std::string &deviceName) const

bool	IsCounterSetRegistered (uint16_t counterSetUid) const

bool	IsCounterSetRegistered (const std::string &counterSetName) const

bool	IsCounterRegistered (uint16_t counterUid) const

bool	IsCounterRegistered (const std::string &counterName) const

void	Clear ()

Public Member Functions inherited from ICounterDirectory
virtual	~ICounterDirectory ()

Public Member Functions inherited from ICounterRegistry
virtual	~ICounterRegistry ()

Detailed Description

Definition at line 23 of file CounterDirectory.hpp.

Constructor & Destructor Documentation

◆ CounterDirectory()

CounterDirectory ( )

default

◆ ~CounterDirectory()

~CounterDirectory ( )

default

Member Function Documentation

◆ Clear()

void Clear ( )

Definition at line 534 of file CounterDirectory.cpp.

References OptionalBase::has_value(), and OptionalReferenceSwitch< std::is_reference< T >::value, T >::value().

Referenced by CounterDirectory::GetCounters(), and ProfilingService::GetSendTimelinePacket().

 {
     // Clear all the counter directory contents
     m_Categories.clear();
     m_Devices.clear();
     m_CounterSets.clear();
     m_Counters.clear();
 }

◆ GetCategories()

const Categories& GetCategories ( ) const

inlineoverridevirtual

Implements ICounterDirectory.

Definition at line 59 of file CounterDirectory.hpp.

59 { return m_Categories; }

◆ GetCategory()

const Category * GetCategory ( const std::string & name ) const

overridevirtual

Implements ICounterDirectory.

Definition at line 425 of file CounterDirectory.cpp.

Referenced by BOOST_AUTO_TEST_CASE(), and CounterDirectory::GetCounters().

 {
     auto it = FindCategory(categoryName);
     if (it == m_Categories.end())
     {
         return nullptr;
     }
 
     const Category* category = it->get();
     BOOST_ASSERT(category);
 
     return category;
 }

◆ GetCategoryCount()

uint16_t GetCategoryCount ( ) const

inlineoverridevirtual

Implements ICounterDirectory.

Definition at line 53 of file CounterDirectory.hpp.

Referenced by BOOST_AUTO_TEST_CASE().

53 { return boost::numeric_cast<uint16_t>(m_Categories.size()); }

◆ GetCounter()

const Counter * GetCounter ( uint16_t uid ) const

overridevirtual

Implements ICounterDirectory.

Definition at line 469 of file CounterDirectory.cpp.

References Counter::m_MaxCounterUid, and Counter::m_Uid.

Referenced by BOOST_AUTO_TEST_CASE(), CounterDirectory::GetCounters(), and CounterDirectory::RegisterCounter().

 {
     auto it = FindCounter(counterUid);
     if (it == m_Counters.end())
     {
         return nullptr;
     }
 
     const Counter* counter = it->second.get();
     BOOST_ASSERT(counter);
     BOOST_ASSERT(counter->m_Uid <= counterUid);
     BOOST_ASSERT(counter->m_Uid <= counter->m_MaxCounterUid);
 
     return counter;
 }

◆ GetCounterCount()

uint16_t GetCounterCount ( ) const

inlineoverridevirtual

Implements ICounterDirectory.

Definition at line 56 of file CounterDirectory.hpp.

Referenced by BOOST_AUTO_TEST_CASE(), and ProfilingService::GetCounterCount().

56 { return boost::numeric_cast<uint16_t>(m_Counters.size()); }

◆ GetCounters()

const Counters& GetCounters ( ) const

inlineoverridevirtual

Implements ICounterDirectory.

Definition at line 62 of file CounterDirectory.hpp.

References CounterDirectory::Clear(), CounterDirectory::GetCategory(), CounterDirectory::GetCounter(), CounterDirectory::GetCounterSet(), CounterDirectory::GetDevice(), CounterDirectory::IsCategoryRegistered(), CounterDirectory::IsCounterRegistered(), CounterDirectory::IsCounterSetRegistered(), and CounterDirectory::IsDeviceRegistered().

62 { return m_Counters; }

◆ GetCounterSet()

const CounterSet * GetCounterSet ( uint16_t uid ) const

overridevirtual

Implements ICounterDirectory.

Definition at line 454 of file CounterDirectory.cpp.

References CounterSet::m_Uid.

Referenced by BOOST_AUTO_TEST_CASE(), and CounterDirectory::GetCounters().

 {
     auto it = FindCounterSet(counterSetUid);
     if (it == m_CounterSets.end())
     {
         return nullptr;
     }
 
     const CounterSet* counterSet = it->second.get();
     BOOST_ASSERT(counterSet);
     BOOST_ASSERT(counterSet->m_Uid == counterSetUid);
 
     return counterSet;
 }

◆ GetCounterSetCount()

uint16_t GetCounterSetCount ( ) const

inlineoverridevirtual

Implements ICounterDirectory.

Definition at line 55 of file CounterDirectory.hpp.

Referenced by BOOST_AUTO_TEST_CASE().

55 { return boost::numeric_cast<uint16_t>(m_CounterSets.size()); }

◆ GetCounterSets()

const CounterSets& GetCounterSets ( ) const

inlineoverridevirtual

Implements ICounterDirectory.

Definition at line 61 of file CounterDirectory.hpp.

61 { return m_CounterSets; }

◆ GetDevice()

const Device * GetDevice ( uint16_t uid ) const

overridevirtual

Implements ICounterDirectory.

Definition at line 439 of file CounterDirectory.cpp.

References Device::m_Uid.

Referenced by BOOST_AUTO_TEST_CASE(), and CounterDirectory::GetCounters().

 {
     auto it = FindDevice(deviceUid);
     if (it == m_Devices.end())
     {
         return nullptr;
     }
 
     const Device* device = it->second.get();
     BOOST_ASSERT(device);
     BOOST_ASSERT(device->m_Uid == deviceUid);
 
     return device;
 }

◆ GetDeviceCount()

uint16_t GetDeviceCount ( ) const

inlineoverridevirtual

Implements ICounterDirectory.

Definition at line 54 of file CounterDirectory.hpp.

Referenced by BOOST_AUTO_TEST_CASE().

54 { return boost::numeric_cast<uint16_t>(m_Devices.size()); }

◆ GetDevices()

const Devices& GetDevices ( ) const

inlineoverridevirtual

Implements ICounterDirectory.

Definition at line 60 of file CounterDirectory.hpp.

60 { return m_Devices; }

◆ IsCategoryRegistered()

bool IsCategoryRegistered ( const std::string & categoryName ) const

Definition at line 485 of file CounterDirectory.cpp.

Referenced by CounterDirectory::GetCounters(), ProfilingService::GetSendTimelinePacket(), and CounterDirectory::RegisterCategory().

 {
     auto it = FindCategory(categoryName);
 
     return it != m_Categories.end();
 }

◆ IsCounterRegistered() [1/2]

bool IsCounterRegistered ( uint16_t counterUid ) const

Definition at line 520 of file CounterDirectory.cpp.

Referenced by CounterDirectory::GetCounters(), and ProfilingService::GetSendTimelinePacket().

 {
     auto it = FindCounter(counterUid);
 
     return it != m_Counters.end();
 }

◆ IsCounterRegistered() [2/2]

bool IsCounterRegistered ( const std::string & counterName ) const

Definition at line 527 of file CounterDirectory.cpp.

 {
     auto it = FindCounter(counterName);
 
     return it != m_Counters.end();
 }

◆ IsCounterSetRegistered() [1/2]

bool IsCounterSetRegistered ( uint16_t counterSetUid ) const

Definition at line 506 of file CounterDirectory.cpp.

Referenced by CounterDirectory::GetCounters(), CounterDirectory::RegisterCategory(), CounterDirectory::RegisterCounter(), and CounterDirectory::RegisterCounterSet().

 {
     auto it = FindCounterSet(counterSetUid);
 
     return it != m_CounterSets.end();
 }

◆ IsCounterSetRegistered() [2/2]

bool IsCounterSetRegistered ( const std::string & counterSetName ) const

Definition at line 513 of file CounterDirectory.cpp.

 {
     auto it = FindCounterSet(counterSetName);
 
     return it != m_CounterSets.end();
 }

◆ IsDeviceRegistered() [1/2]

bool IsDeviceRegistered ( uint16_t deviceUid ) const

Definition at line 492 of file CounterDirectory.cpp.

Referenced by CounterDirectory::GetCounters(), CounterDirectory::RegisterCategory(), and CounterDirectory::RegisterDevice().

 {
     auto it = FindDevice(deviceUid);
 
     return it != m_Devices.end();
 }

◆ IsDeviceRegistered() [2/2]

bool IsDeviceRegistered ( const std::string & deviceName ) const

Definition at line 499 of file CounterDirectory.cpp.

 {
     auto it = FindDevice(deviceName);
 
     return it != m_Devices.end();
 }

◆ RegisterCategory()

const Category * RegisterCategory	(	const std::string &	categoryName,
		const Optional< uint16_t > &	deviceUid = `EmptyOptional()`,
		const Optional< uint16_t > &	counterSetUid = `EmptyOptional()`
	)

overridevirtual

Implements ICounterRegistry.

Definition at line 21 of file CounterDirectory.cpp.

References OptionalBase::has_value(), CounterDirectory::IsCategoryRegistered(), CounterDirectory::IsCounterSetRegistered(), CounterDirectory::IsDeviceRegistered(), and OptionalReferenceSwitch< std::is_reference< T >::value, T >::value().

Referenced by BOOST_AUTO_TEST_CASE(), and ProfilingService::GetSendTimelinePacket().

 {
     // Check that the given category name is valid
     if (categoryName.empty() ||
             !IsValidSwTraceString<SwTraceNameCharPolicy>(categoryName))
     {
         throw InvalidArgumentException("Trying to register a category with an invalid name");
     }
 
     // Check that the given category is not already registered
     if (IsCategoryRegistered(categoryName))
     {
         throw InvalidArgumentException(
                     boost::str(boost::format("Trying to register a category already registered (\"%1%\")")
                                % 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);
     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;
 }

◆ RegisterCounter()

const Counter * RegisterCounter	(	const BackendId &	backendId,
		const uint16_t	uid,
		const std::string &	parentCategoryName,
		uint16_t	counterClass,
		uint16_t	interpolation,
		double	multiplier,
		const std::string &	name,
		const std::string &	description,
		const Optional< std::string > &	units = `EmptyOptional()`,
		const Optional< uint16_t > &	numberOfCores = `EmptyOptional()`,
		const Optional< uint16_t > &	deviceUid = `EmptyOptional()`,
		const Optional< uint16_t > &	counterSetUid = `EmptyOptional()`
	)

overridevirtual

Implements ICounterRegistry.

Definition at line 276 of file CounterDirectory.cpp.

References CounterDirectory::GetCounter(), armnn::profiling::GetNextCounterUids(), OptionalBase::has_value(), CounterDirectory::IsCounterSetRegistered(), Counter::m_Name, and OptionalReferenceSwitch< std::is_reference< T >::value, T >::value().

Referenced by BOOST_AUTO_TEST_CASE(), and ProfilingService::GetSendTimelinePacket().

 {
     boost::ignore_unused(backendId);
 
     // Check that the given parent category name is valid
     if (parentCategoryName.empty() ||
             !IsValidSwTraceString<SwTraceNameCharPolicy>(parentCategoryName))
     {
         throw InvalidArgumentException("Trying to register a counter with an invalid parent category name");
     }
 
     // Check that the given class is valid
     if (counterClass != 0 && counterClass != 1)
     {
         throw InvalidArgumentException("Trying to register a counter with an invalid class");
     }
 
     // Check that the given interpolation is valid
     if (interpolation != 0 && interpolation != 1)
     {
         throw InvalidArgumentException("Trying to register a counter with an invalid interpolation");
     }
 
     // Check that the given multiplier is valid
     if (multiplier == .0f)
     {
         throw InvalidArgumentException("Trying to register a counter with an invalid multiplier");
     }
 
     // Check that the given name is valid
     if (name.empty() ||
             !IsValidSwTraceString<SwTraceCharPolicy>(name))
     {
         throw InvalidArgumentException("Trying to register a counter with an invalid name");
     }
 
     // Check that the given description is valid
     if (description.empty() ||
             !IsValidSwTraceString<SwTraceCharPolicy>(description))
     {
         throw InvalidArgumentException("Trying to register a counter with an invalid description");
     }
 
     // Check that the given units are valid
     if (units.has_value()
             && !IsValidSwTraceString<SwTraceNameCharPolicy>(units.value()))
     {
         throw InvalidArgumentException("Trying to register a counter with a invalid units");
     }
 
     // Check that the given parent category is registered
     auto categoryIt = FindCategory(parentCategoryName);
     if (categoryIt == m_Categories.end())
     {
         throw InvalidArgumentException(
                     boost::str(boost::format("Trying to connect a counter to a category "
                                              "that is not registered (name: \"%1%\")")
                                % parentCategoryName));
     }
 
     // Get the parent category
     const CategoryPtr& parentCategory = *categoryIt;
     BOOST_ASSERT(parentCategory);
 
     // Check that a counter with the given name is not already registered within the parent category
     const std::vector<uint16_t>& parentCategoryCounters = parentCategory->m_Counters;
     for (uint16_t parentCategoryCounterUid : parentCategoryCounters)
     {
         const Counter* parentCategoryCounter = GetCounter(parentCategoryCounterUid);
         BOOST_ASSERT(parentCategoryCounter);
 
         if (parentCategoryCounter->m_Name == name)
         {
             throw InvalidArgumentException(
                         boost::str(boost::format("Trying to register a counter to category \"%1%\" with a name that "
                                                  "is already used within that category (name: \"%2%\")")
                                    % parentCategoryName
                                    % name));
         }
     }
 
     // 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 counter to a counter set that is "
                                                  "not registered (counter set UID: %1%)")
                                    % counterSetUidValue));
         }
     }
 
     // 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);
 
     // Get the counter UIDs and calculate the max counter UID
     std::vector<uint16_t> counterUids = GetNextCounterUids(uid, 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>(armnn::profiling::BACKEND_ID,
                                                    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
         parentCategory->m_Counters.push_back(counterUid);
 
         // Register the counter
         m_Counters.insert(std::make_pair(counterUid, counter));
     }
 
     return counterPtr;
 }

◆ RegisterCounterSet()

const CounterSet * RegisterCounterSet	(	const std::string &	counterSetName,
		uint16_t	count = `0`,
		const Optional< std::string > &	parentCategoryName = `EmptyOptional()`
	)

overridevirtual

Implements ICounterRegistry.

Definition at line 180 of file CounterDirectory.cpp.

References armnn::profiling::GetNextUid(), OptionalBase::has_value(), CounterDirectory::IsCounterSetRegistered(), Category::m_CounterSetUid, and OptionalReferenceSwitch< std::is_reference< T >::value, T >::value().

Referenced by BOOST_AUTO_TEST_CASE().

 {
     // Check that the given counter set name is valid
     if (counterSetName.empty() ||
             !IsValidSwTraceString<SwTraceNameCharPolicy>(counterSetName))
     {
         throw InvalidArgumentException("Trying to register a counter set with an invalid name");
     }
 
     // Check that a counter set with the given name is not already registered
     if (IsCounterSetRegistered(counterSetName))
     {
         throw InvalidArgumentException(
                     boost::str(boost::format("Trying to register a counter set already registered (\"%1%\")")
                                % counterSetName));
     }
 
     // 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 counter set can be registered
     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
         const std::string& parentCategoryNameValue = parentCategoryName.value();
         if (parentCategoryNameValue.empty())
         {
             throw InvalidArgumentException(
                         boost::str(boost::format("Trying to connect a counter set (UID: %1%) to an invalid "
                                                  "parent category (name: \"%2%\")")
                                    % counterSetUidPeek
                                    % parentCategoryNameValue));
         }
 
         // Check that the given parent category is already registered
         auto it = FindCategory(parentCategoryNameValue);
         if (it == m_Categories.end())
         {
             throw InvalidArgumentException(
                         boost::str(boost::format("Trying to connect a counter set (UID: %1%) to a parent category "
                                                  "that is not registered (name: \"%2%\")")
                                    % 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
     uint16_t counterSetUid = GetNextUid();
     BOOST_ASSERT(counterSetUid == counterSetUidPeek);
 
     // 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 (parentCategoryPtr)
     {
         // Set the counter set UID in the parent category
         parentCategoryPtr->m_CounterSetUid = counterSetUid;
     }
 
     return counterSetPtr;
 }

◆ RegisterDevice()

const Device * RegisterDevice	(	const std::string &	deviceName,
		uint16_t	cores = `0`,
		const Optional< std::string > &	parentCategoryName = `EmptyOptional()`
	)

overridevirtual

Implements ICounterRegistry.

Definition at line 84 of file CounterDirectory.cpp.

References armnn::profiling::GetNextUid(), OptionalBase::has_value(), CounterDirectory::IsDeviceRegistered(), Category::m_DeviceUid, and OptionalReferenceSwitch< std::is_reference< T >::value, T >::value().

Referenced by BOOST_AUTO_TEST_CASE().

 {
     // Check that the given device name is valid
     if (deviceName.empty() ||
             !IsValidSwTraceString<SwTraceCharPolicy>(deviceName))
     {
         throw InvalidArgumentException("Trying to register a device with an invalid name");
     }
 
     // Check that a device with the given name is not already registered
     if (IsDeviceRegistered(deviceName))
     {
         throw InvalidArgumentException(
                     boost::str(boost::format("Trying to register a device already registered (\"%1%\")")
                                % 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
         const std::string& parentCategoryNameValue = parentCategoryName.value();
         if (parentCategoryNameValue.empty())
         {
             throw InvalidArgumentException(
                         boost::str(boost::format("Trying to connect a device (name: \"%1%\") to an invalid "
                                                  "parent category (name: \"%2%\")")
                                    % deviceName
                                    % parentCategoryNameValue));
         }
 
         // Check that the given parent category is already registered
         auto categoryIt = FindCategory(parentCategoryNameValue);
         if (categoryIt == m_Categories.end())
         {
             throw InvalidArgumentException(
                         boost::str(boost::format("Trying to connect a device (name: \"%1%\") to a parent category that "
                                                  "is not registered (name: \"%2%\")")
                                    % 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);
     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 device to the parent category, if required
     if (parentCategoryPtr)
     {
         // Set the device UID in the parent category
         parentCategoryPtr->m_DeviceUid = deviceUid;
     }
 
     return devicePtr;
 }

The documentation for this class was generated from the following files:

src/profiling/CounterDirectory.hpp
src/profiling/CounterDirectory.cpp

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ CounterDirectory()

◆ ~CounterDirectory()

Member Function Documentation

◆ Clear()

◆ GetCategories()

◆ GetCategory()

◆ GetCategoryCount()

◆ GetCounter()

◆ GetCounterCount()

◆ GetCounters()

◆ GetCounterSet()

◆ GetCounterSetCount()

◆ GetCounterSets()

◆ GetDevice()

◆ GetDeviceCount()

◆ GetDevices()

◆ IsCategoryRegistered()

◆ IsCounterRegistered() [1/2]

◆ IsCounterRegistered() [2/2]

◆ IsCounterSetRegistered() [1/2]

◆ IsCounterSetRegistered() [2/2]

◆ IsDeviceRegistered() [1/2]

◆ IsDeviceRegistered() [2/2]

◆ RegisterCategory()

◆ RegisterCounter()

◆ RegisterCounterSet()

◆ RegisterDevice()