CounterDirectory Class Reference

#include <CounterDirectory.hpp>

Inheritance diagram for CounterDirectory:

Public Member Functions
	CounterDirectory ()=default
	~CounterDirectory ()=default
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
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 438 of file CounterDirectory.cpp.

References ARMNN_ASSERT, 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 57 of file CounterDirectory.hpp.

{ return m_Categories;  }

GetCategory()

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

overridevirtual

Implements ICounterDirectory.

Definition at line 329 of file CounterDirectory.cpp.

References ARMNN_ASSERT.

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();
    ARMNN_ASSERT(category);

    return category;
}

GetCategoryCount()

uint16_t GetCategoryCount ( ) const

inlineoverridevirtual

Implements ICounterDirectory.

Definition at line 51 of file CounterDirectory.hpp.

References armnn::numeric_cast().

Referenced by BOOST_AUTO_TEST_CASE().

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

GetCounter()

const Counter * GetCounter ( uint16_t  uid ) const

overridevirtual

Implements ICounterDirectory.

Definition at line 373 of file CounterDirectory.cpp.

References ARMNN_ASSERT, 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();
    ARMNN_ASSERT(counter);
    ARMNN_ASSERT(counter->m_Uid <= counterUid);
    ARMNN_ASSERT(counter->m_Uid <= counter->m_MaxCounterUid);

    return counter;
}

GetCounterCount()

uint16_t GetCounterCount ( ) const

inlineoverridevirtual

Implements ICounterDirectory.

Definition at line 54 of file CounterDirectory.hpp.

References armnn::numeric_cast().

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

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

GetCounters()

const Counters& GetCounters ( ) const

inlineoverridevirtual

Implements ICounterDirectory.

Definition at line 60 of file CounterDirectory.hpp.

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

{ return m_Counters;    }

GetCounterSet()

const CounterSet * GetCounterSet ( uint16_t  uid ) const

overridevirtual

Implements ICounterDirectory.

Definition at line 358 of file CounterDirectory.cpp.

References ARMNN_ASSERT, and 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();
    ARMNN_ASSERT(counterSet);
    ARMNN_ASSERT(counterSet->m_Uid == counterSetUid);

    return counterSet;
}

GetCounterSetCount()

uint16_t GetCounterSetCount ( ) const

inlineoverridevirtual

Implements ICounterDirectory.

Definition at line 53 of file CounterDirectory.hpp.

References armnn::numeric_cast().

Referenced by BOOST_AUTO_TEST_CASE().

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

GetCounterSets()

const CounterSets& GetCounterSets ( ) const

inlineoverridevirtual

Implements ICounterDirectory.

Definition at line 59 of file CounterDirectory.hpp.

{ return m_CounterSets; }

GetDevice()

const Device * GetDevice ( uint16_t  uid ) const

overridevirtual

Implements ICounterDirectory.

Definition at line 343 of file CounterDirectory.cpp.

References ARMNN_ASSERT, and 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();
    ARMNN_ASSERT(device);
    ARMNN_ASSERT(device->m_Uid == deviceUid);

    return device;
}

GetDeviceCount()

uint16_t GetDeviceCount ( ) const

inlineoverridevirtual

Implements ICounterDirectory.

Definition at line 52 of file CounterDirectory.hpp.

References armnn::numeric_cast().

Referenced by BOOST_AUTO_TEST_CASE().

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

GetDevices()

const Devices& GetDevices ( ) const

inlineoverridevirtual

Implements ICounterDirectory.

Definition at line 58 of file CounterDirectory.hpp.

{ return m_Devices;     }

IsCategoryRegistered()

bool IsCategoryRegistered

(

const std::string &

categoryName

)

const

Definition at line 389 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 424 of file CounterDirectory.cpp.

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

{
    auto it = FindCounter(counterUid);

    return it != m_Counters.end();
}

IsCounterRegistered() [2/2]

bool IsCounterRegistered

(

const std::string &

counterName

)

const

Definition at line 431 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 410 of file CounterDirectory.cpp.

Referenced by CounterDirectory::GetCounters(), 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 417 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 396 of file CounterDirectory.cpp.

Referenced by CounterDirectory::GetCounters(), 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 403 of file CounterDirectory.cpp.

{
    auto it = FindDevice(deviceName);

    return it != m_Devices.end();
}

RegisterCategory()

const Category * RegisterCategory ( const std::string &  categoryName )

overridevirtual

Implements ICounterRegistry.

Definition at line 23 of file CounterDirectory.cpp.

References ARMNN_ASSERT, and CounterDirectory::IsCategoryRegistered().

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

{
    // Check that the given category name is valid
    if (categoryName.empty() ||
            !arm::pipe::IsValidSwTraceString<arm::pipe::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(fmt::format("Trying to register a category already registered (\"{}\")",
                                       categoryName));
    }

    // Create the category
    CategoryPtr category = std::make_unique<Category>(categoryName);
    ARMNN_ASSERT(category);

    // Get the raw category pointer
    const Category* categoryPtr = category.get();
    ARMNN_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 181 of file CounterDirectory.cpp.

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

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

{
    IgnoreUnused(backendId);

    // Check that the given parent category name is valid
    if (parentCategoryName.empty() ||
            !arm::pipe::IsValidSwTraceString<arm::pipe::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() ||
            !arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceCharPolicy>(name))
    {
        throw InvalidArgumentException("Trying to register a counter with an invalid name");
    }

    // Check that the given description is valid
    if (description.empty() ||
            !arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceCharPolicy>(description))
    {
        throw InvalidArgumentException("Trying to register a counter with an invalid description");
    }

    // Check that the given units are valid
    if (units.has_value()
            && !arm::pipe::IsValidSwTraceString<arm::pipe::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(
                    fmt::format("Trying to connect a counter to a category that is not registered (name: \"{}\")",
                                parentCategoryName));
    }

    // Get the parent category
    const CategoryPtr& parentCategory = *categoryIt;
    ARMNN_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);
        ARMNN_ASSERT(parentCategoryCounter);

        if (parentCategoryCounter->m_Name == name)
        {
            throw InvalidArgumentException(
                        fmt::format("Trying to register a counter to category \"{}\" with a name that "
                                    "is already used within that category (name: \"{}\")",
                                    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(
                        fmt::format("Trying to connect a counter to a counter set that is "
                                    "not registered (counter set UID: {})",
                                    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);

    // Get the counter UIDs and calculate the max counter UID
    std::vector<uint16_t> counterUids = GetNextCounterUids(uid, deviceCores);
    ARMNN_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);
    ARMNN_ASSERT(counter);

    // Get the raw counter pointer
    const Counter* counterPtr = counter.get();
    ARMNN_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 114 of file CounterDirectory.cpp.

References ARMNN_ASSERT, armnn::profiling::GetNextUid(), OptionalBase::has_value(), CounterDirectory::IsCounterSetRegistered(), and OptionalReferenceSwitch< IsReference, T >::value().

Referenced by BOOST_AUTO_TEST_CASE().

{
    // Check that the given counter set name is valid
    if (counterSetName.empty() ||
            !arm::pipe::IsValidSwTraceString<arm::pipe::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(
                    fmt::format("Trying to register a counter set already registered (\"{}\")",
                                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
    if (parentCategoryName.has_value())
    {
        // Get the (optional) parent category name
        const std::string& parentCategoryNameValue = parentCategoryName.value();
        if (parentCategoryNameValue.empty())
        {
            throw InvalidArgumentException(
                        fmt::format("Trying to connect a counter set (UID: {}) to an invalid "
                                    "parent category (name: \"{}\")",
                                    counterSetUidPeek,
                                    parentCategoryNameValue));
        }

        // Check that the given parent category is already registered
        auto it = FindCategory(parentCategoryNameValue);
        if (it == m_Categories.end())
        {
            throw InvalidArgumentException(
                        fmt::format("Trying to connect a counter set (UID: {}) to a parent category "
                                    "that is not registered (name: \"{}\")",
                                    counterSetUidPeek,
                                    parentCategoryNameValue));
        }
    }

    // Get the counter set UID
    uint16_t counterSetUid = GetNextUid();
    ARMNN_ASSERT(counterSetUid == counterSetUidPeek);

    // Create the counter set
    CounterSetPtr counterSet = std::make_unique<CounterSet>(counterSetUid, counterSetName, count);
    ARMNN_ASSERT(counterSet);

    // Get the raw counter set pointer
    const CounterSet* counterSetPtr = counterSet.get();
    ARMNN_ASSERT(counterSetPtr);

    // Register the counter set
    m_CounterSets.insert(std::make_pair(counterSetUid, std::move(counterSet)));

    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 53 of file CounterDirectory.cpp.

References ARMNN_ASSERT, armnn::profiling::GetNextUid(), OptionalBase::has_value(), CounterDirectory::IsDeviceRegistered(), and OptionalReferenceSwitch< IsReference, T >::value().

Referenced by BOOST_AUTO_TEST_CASE().

{
    // Check that the given device name is valid
    if (deviceName.empty() ||
            !arm::pipe::IsValidSwTraceString<arm::pipe::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(fmt::format("Trying to register a device already registered (\"{}\")",
                                       deviceName));
    }

    // Check that a category with the given (optional) parent category name is already registered
    if (parentCategoryName.has_value())
    {
        // Get the (optional) parent category name
        const std::string& parentCategoryNameValue = parentCategoryName.value();
        if (parentCategoryNameValue.empty())
        {
            throw InvalidArgumentException(
                        fmt::format("Trying to connect a device (name: \"{}\") to an invalid "
                                    "parent category (name: \"{}\")",
                                    deviceName,
                                    parentCategoryNameValue));
        }

        // Check that the given parent category is already registered
        auto categoryIt = FindCategory(parentCategoryNameValue);
        if (categoryIt == m_Categories.end())
        {
            throw InvalidArgumentException(
                        fmt::format("Trying to connect a device (name: \"{}\") to a parent category that "
                                    "is not registered (name: \"{}\")",
                                    deviceName,
                                    parentCategoryNameValue));
        }
    }

    // Get the device UID
    uint16_t deviceUid = GetNextUid();

    // Create the device
    DevicePtr device = std::make_unique<Device>(deviceUid, deviceName, cores);
    ARMNN_ASSERT(device);

    // Get the raw device pointer
    const Device* devicePtr = device.get();
    ARMNN_ASSERT(devicePtr);

    // Register the device
    m_Devices.insert(std::make_pair(deviceUid, std::move(device)));

    return devicePtr;
}

---

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

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