diff options
Diffstat (limited to 'src')
22 files changed, 33 insertions, 1578 deletions
diff --git a/src/armnn/ArmNNProfilingServiceInitialiser.cpp b/src/armnn/ArmNNProfilingServiceInitialiser.cpp index 03ca56288b..bbed43ae4c 100644 --- a/src/armnn/ArmNNProfilingServiceInitialiser.cpp +++ b/src/armnn/ArmNNProfilingServiceInitialiser.cpp @@ -9,7 +9,7 @@ #include <armnn/profiling/ArmNNProfiling.hpp> #include <armnn/utility/Assert.hpp> -#include <Counter.hpp> +#include <common/include/Counter.hpp> namespace armnn { diff --git a/src/backends/backendsCommon/test/BackendProfilingTests.cpp b/src/backends/backendsCommon/test/BackendProfilingTests.cpp index 164efb3b9d..9b80a8fa72 100644 --- a/src/backends/backendsCommon/test/BackendProfilingTests.cpp +++ b/src/backends/backendsCommon/test/BackendProfilingTests.cpp @@ -4,7 +4,6 @@ // #include "ArmNNProfilingServiceInitialiser.hpp" -#include "CounterDirectory.hpp" #include "CounterIdMap.hpp" #include "Holder.hpp" #include "MockBackendId.hpp" @@ -15,24 +14,28 @@ #include "ProfilingUtils.hpp" #include "RequestCounterDirectoryCommandHandler.hpp" -#include <armnn/profiling/ArmNNProfiling.hpp> - #include <TestUtils.hpp> -#include <armnn/utility/IgnoreUnused.hpp> #include <armnn/BackendId.hpp> #include <armnn/Logging.hpp> + +#include <armnn/profiling/ArmNNProfiling.hpp> #include <armnn/profiling/ISendTimelinePacket.hpp> #include <armnn/profiling/ProfilingOptions.hpp> + +#include <armnn/utility/IgnoreUnused.hpp> + #include <armnnTestUtils/MockBackend.hpp> +#include <backends/BackendProfiling.hpp> + +#include <common/include/CounterDirectory.hpp> + #include <doctest/doctest.h> -#include <vector> +#include <vector> #include <cstdint> #include <limits> -#include <backends/BackendProfiling.hpp> - namespace arm { diff --git a/src/profiling/Counter.hpp b/src/profiling/Counter.hpp deleted file mode 100644 index ff96d257e7..0000000000 --- a/src/profiling/Counter.hpp +++ /dev/null @@ -1,62 +0,0 @@ -// -// Copyright © 2022 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <string> - -namespace arm -{ - -namespace pipe -{ - -class Counter final -{ -public: - // Constructors - Counter(const std::string& backendId, - uint16_t counterUid, - uint16_t maxCounterUid, - uint16_t counterClass, - uint16_t interpolation, - double multiplier, - const std::string& name, - const std::string& description, - const std::string& units, - uint16_t deviceUid, - uint16_t counterSetUid) - : m_BackendId(backendId) - , m_Uid(counterUid) - , m_MaxCounterUid(maxCounterUid) - , m_Class(counterClass) - , m_Interpolation(interpolation) - , m_Multiplier(multiplier) - , m_Name(name) - , m_Description(description) - , m_Units(units) - , m_DeviceUid(deviceUid) - , m_CounterSetUid(counterSetUid) - {} - - // Fields - std::string m_BackendId; - uint16_t m_Uid; - uint16_t m_MaxCounterUid; - uint16_t m_Class; - uint16_t m_Interpolation; - double m_Multiplier; - std::string m_Name; - std::string m_Description; - std::string m_Units; // Optional, leave empty if the counter does not need units - - // Connections - 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 -}; - -} // namespace pipe - -} // namespace arm diff --git a/src/profiling/CounterDirectory.cpp b/src/profiling/CounterDirectory.cpp deleted file mode 100644 index 0f6147f833..0000000000 --- a/src/profiling/CounterDirectory.cpp +++ /dev/null @@ -1,546 +0,0 @@ -// -// Copyright © 2017 Arm Ltd and Contributors. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "CounterDirectory.hpp" -#include "ProfilingUtils.hpp" - -#include <common/include/Assert.hpp> -#include <common/include/SwTrace.hpp> - -#include <fmt/format.h> - -namespace arm -{ - -namespace pipe -{ - -const Category* CounterDirectory::RegisterCategory(const std::string& categoryName) -{ - // Check that the given category name is valid - if (categoryName.empty() || - !arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceNameCharPolicy>(categoryName)) - { - throw arm::pipe::InvalidArgumentException("Trying to register a category with an invalid name"); - } - - // Check that the given category is not already registered - if (IsCategoryRegistered(categoryName)) - { - throw arm::pipe::InvalidArgumentException(fmt::format( - "Trying to register a category already registered (\"{}\")", - categoryName)); - } - - // Create the category - CategoryPtr category = std::make_unique<Category>(categoryName); - ARM_PIPE_ASSERT(category); - - // Get the raw category pointer - const Category* categoryPtr = category.get(); - ARM_PIPE_ASSERT(categoryPtr); - - // Register the category - m_Categories.insert(std::move(category)); - - return categoryPtr; -} - -const Device* CounterDirectory::RegisterDevice(const std::string& deviceName, - uint16_t cores, - const arm::pipe::Optional<std::string>& parentCategoryName) -{ - // Check that the given device name is valid - if (deviceName.empty() || - !arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceCharPolicy>(deviceName)) - { - throw arm::pipe::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 arm::pipe::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 arm::pipe::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 arm::pipe::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); - ARM_PIPE_ASSERT(device); - - // Get the raw device pointer - const Device* devicePtr = device.get(); - ARM_PIPE_ASSERT(devicePtr); - - // Register the device - m_Devices.insert(std::make_pair(deviceUid, std::move(device))); - - return devicePtr; -} - -const CounterSet* CounterDirectory::RegisterCounterSet(const std::string& counterSetName, - uint16_t count, - const arm::pipe::Optional<std::string>& parentCategoryName) -{ - // Check that the given counter set name is valid - if (counterSetName.empty() || - !arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceNameCharPolicy>(counterSetName)) - { - throw arm::pipe::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 arm::pipe::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 arm::pipe::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 arm::pipe::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(); - ARM_PIPE_ASSERT(counterSetUid == counterSetUidPeek); - - // Create the counter set - CounterSetPtr counterSet = std::make_unique<CounterSet>(counterSetUid, counterSetName, count); - ARM_PIPE_ASSERT(counterSet); - - // Get the raw counter set pointer - const CounterSet* counterSetPtr = counterSet.get(); - ARM_PIPE_ASSERT(counterSetPtr); - - // Register the counter set - m_CounterSets.insert(std::make_pair(counterSetUid, std::move(counterSet))); - - return counterSetPtr; -} - -const Counter* CounterDirectory::RegisterCounter(const std::string& applicationName, - 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 arm::pipe::Optional<std::string>& units, - const arm::pipe::Optional<uint16_t>& numberOfCores, - const arm::pipe::Optional<uint16_t>& deviceUid, - const arm::pipe::Optional<uint16_t>& counterSetUid) -{ - // Check that the given parent category name is valid - if (parentCategoryName.empty() || - !arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceNameCharPolicy>(parentCategoryName)) - { - throw arm::pipe::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 arm::pipe::InvalidArgumentException("Trying to register a counter with an invalid class"); - } - - // Check that the given interpolation is valid - if (interpolation != 0 && interpolation != 1) - { - throw arm::pipe::InvalidArgumentException("Trying to register a counter with an invalid interpolation"); - } - - // Check that the given multiplier is valid - if (multiplier == .0f) - { - throw arm::pipe::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 arm::pipe::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 arm::pipe::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 arm::pipe::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 arm::pipe::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; - ARM_PIPE_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); - ARM_PIPE_ASSERT(parentCategoryCounter); - - if (parentCategoryCounter->m_Name == name) - { - throw arm::pipe::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); - ARM_PIPE_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>(applicationName, - counterUids.front(), - maxCounterUid, - counterClass, - interpolation, - multiplier, - name, - description, - unitsValue, - deviceUidValue, - counterSetUidValue); - ARM_PIPE_ASSERT(counter); - - // Get the raw counter pointer - const Counter* counterPtr = counter.get(); - ARM_PIPE_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; -} - -const Category* CounterDirectory::GetCategory(const std::string& categoryName) const -{ - auto it = FindCategory(categoryName); - if (it == m_Categories.end()) - { - return nullptr; - } - - const Category* category = it->get(); - ARM_PIPE_ASSERT(category); - - return category; -} - -const Device* CounterDirectory::GetDevice(uint16_t deviceUid) const -{ - auto it = FindDevice(deviceUid); - if (it == m_Devices.end()) - { - return nullptr; - } - - const Device* device = it->second.get(); - ARM_PIPE_ASSERT(device); - ARM_PIPE_ASSERT(device->m_Uid == deviceUid); - - return device; -} - -const CounterSet* CounterDirectory::GetCounterSet(uint16_t counterSetUid) const -{ - auto it = FindCounterSet(counterSetUid); - if (it == m_CounterSets.end()) - { - return nullptr; - } - - const CounterSet* counterSet = it->second.get(); - ARM_PIPE_ASSERT(counterSet); - ARM_PIPE_ASSERT(counterSet->m_Uid == counterSetUid); - - return counterSet; -} - -const Counter* CounterDirectory::GetCounter(uint16_t counterUid) const -{ - auto it = FindCounter(counterUid); - if (it == m_Counters.end()) - { - return nullptr; - } - - const Counter* counter = it->second.get(); - ARM_PIPE_ASSERT(counter); - ARM_PIPE_ASSERT(counter->m_Uid <= counterUid); - ARM_PIPE_ASSERT(counter->m_Uid <= counter->m_MaxCounterUid); - - return counter; -} - -bool CounterDirectory::IsCategoryRegistered(const std::string& categoryName) const -{ - auto it = FindCategory(categoryName); - - return it != m_Categories.end(); -} - -bool CounterDirectory::IsDeviceRegistered(uint16_t deviceUid) const -{ - auto it = FindDevice(deviceUid); - - return it != m_Devices.end(); -} - -bool CounterDirectory::IsDeviceRegistered(const std::string& deviceName) const -{ - auto it = FindDevice(deviceName); - - return it != m_Devices.end(); -} - -bool CounterDirectory::IsCounterSetRegistered(uint16_t counterSetUid) const -{ - auto it = FindCounterSet(counterSetUid); - - return it != m_CounterSets.end(); -} - -bool CounterDirectory::IsCounterSetRegistered(const std::string& counterSetName) const -{ - auto it = FindCounterSet(counterSetName); - - return it != m_CounterSets.end(); -} - -bool CounterDirectory::IsCounterRegistered(uint16_t counterUid) const -{ - auto it = FindCounter(counterUid); - - return it != m_Counters.end(); -} - -bool CounterDirectory::IsCounterRegistered(const std::string& counterName) const -{ - auto it = FindCounter(counterName); - - return it != m_Counters.end(); -} - -void CounterDirectory::Clear() -{ - // Clear all the counter directory contents - m_Categories.clear(); - m_Devices.clear(); - m_CounterSets.clear(); - m_Counters.clear(); -} - -CategoriesIt CounterDirectory::FindCategory(const std::string& categoryName) const -{ - return std::find_if(m_Categories.begin(), m_Categories.end(), [&categoryName](const CategoryPtr& category) - { - ARM_PIPE_ASSERT(category); - - return category->m_Name == categoryName; - }); -} - -DevicesIt CounterDirectory::FindDevice(uint16_t deviceUid) const -{ - return m_Devices.find(deviceUid); -} - -DevicesIt CounterDirectory::FindDevice(const std::string& deviceName) const -{ - return std::find_if(m_Devices.begin(), m_Devices.end(), [&deviceName](const auto& pair) - { - ARM_PIPE_ASSERT(pair.second); - ARM_PIPE_ASSERT(pair.second->m_Uid == pair.first); - - return pair.second->m_Name == deviceName; - }); -} - -CounterSetsIt CounterDirectory::FindCounterSet(uint16_t counterSetUid) const -{ - return m_CounterSets.find(counterSetUid); -} - -CounterSetsIt CounterDirectory::FindCounterSet(const std::string& counterSetName) const -{ - return std::find_if(m_CounterSets.begin(), m_CounterSets.end(), [&counterSetName](const auto& pair) - { - ARM_PIPE_ASSERT(pair.second); - ARM_PIPE_ASSERT(pair.second->m_Uid == pair.first); - - return pair.second->m_Name == counterSetName; - }); -} - -CountersIt CounterDirectory::FindCounter(uint16_t counterUid) const -{ - return m_Counters.find(counterUid); -} - -CountersIt CounterDirectory::FindCounter(const std::string& counterName) const -{ - return std::find_if(m_Counters.begin(), m_Counters.end(), [&counterName](const auto& pair) - { - ARM_PIPE_ASSERT(pair.second); - ARM_PIPE_ASSERT(pair.first >= pair.second->m_Uid && pair.first <= pair.second->m_MaxCounterUid); - - return pair.second->m_Name == counterName; - }); -} - -uint16_t CounterDirectory::GetNumberOfCores(const arm::pipe::Optional<uint16_t>& numberOfCores, - uint16_t deviceUid) -{ - // 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 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()) - { - // Get the number of cores - return numberOfCores.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 - if (deviceUid > 0) - { - // Check that the (optional) device is already registered - auto deviceIt = FindDevice(deviceUid); - if (deviceIt == m_Devices.end()) - { - throw arm::pipe::InvalidArgumentException( - fmt::format("Trying to connect a counter to a device that is not registered (device UID {})", - deviceUid)); - } - - // Get the associated device - const DevicePtr& device = deviceIt->second; - ARM_PIPE_ASSERT(device); - - - // Get the number of cores of the associated device - return device->m_Cores; - } - - // 3. If none of the above holds then set deviceCores to zero - return 0; -} - -} // namespace pipe - -} // namespace arm diff --git a/src/profiling/CounterDirectory.hpp b/src/profiling/CounterDirectory.hpp deleted file mode 100644 index ecc349edff..0000000000 --- a/src/profiling/CounterDirectory.hpp +++ /dev/null @@ -1,103 +0,0 @@ -// -// Copyright © 2017 Arm Ltd and Contributors. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include "ICounterDirectory.hpp" -#include "ICounterRegistry.hpp" - -#include <string> -#include <unordered_set> -#include <unordered_map> - -#include <common/include/NumericCast.hpp> - -namespace arm -{ - -namespace pipe -{ - -class CounterDirectory final : public ICounterDirectory, public ICounterRegistry -{ -public: - CounterDirectory() = default; - ~CounterDirectory() = default; - - // Register profiling objects - const Category* RegisterCategory (const std::string& categoryName) override; - const Device* RegisterDevice (const std::string& deviceName, - uint16_t cores = 0, - const arm::pipe::Optional<std::string>& parentCategoryName - = arm::pipe::EmptyOptional()) override; - const CounterSet* RegisterCounterSet(const std::string& counterSetName, - uint16_t count = 0, - const arm::pipe::Optional<std::string>& parentCategoryName - = arm::pipe::EmptyOptional()) override; - const Counter* RegisterCounter(const std::string& 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 arm::pipe::Optional<std::string>& units = arm::pipe::EmptyOptional(), - const arm::pipe::Optional<uint16_t>& numberOfCores = arm::pipe::EmptyOptional(), - const arm::pipe::Optional<uint16_t>& deviceUid = arm::pipe::EmptyOptional(), - const arm::pipe::Optional<uint16_t>& counterSetUid = arm::pipe::EmptyOptional()) override; - - // Getters for counts - uint16_t GetCategoryCount() const override { return arm::pipe::numeric_cast<uint16_t>(m_Categories.size()); } - uint16_t GetDeviceCount() const override { return arm::pipe::numeric_cast<uint16_t>(m_Devices.size()); } - uint16_t GetCounterSetCount() const override { return arm::pipe::numeric_cast<uint16_t>(m_CounterSets.size()); } - uint16_t GetCounterCount() const override { return arm::pipe::numeric_cast<uint16_t>(m_Counters.size()); } - - // Getters for collections - const Categories& GetCategories() const override { return m_Categories; } - const Devices& GetDevices() const override { return m_Devices; } - const CounterSets& GetCounterSets() const override { return m_CounterSets; } - const Counters& GetCounters() const override { return m_Counters; } - - // Getters for profiling objects - const Category* GetCategory(const std::string& name) const override; - const Device* GetDevice(uint16_t uid) const override; - const CounterSet* GetCounterSet(uint16_t uid) const override; - const Counter* GetCounter(uint16_t uid) const override; - - // Queries for profiling objects - 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; - - // Clears all the counter directory contents - void Clear(); - -private: - // The profiling collections owned by the counter directory - Categories m_Categories; - Devices m_Devices; - CounterSets m_CounterSets; - Counters m_Counters; - - // Helper functions - CategoriesIt FindCategory(const std::string& categoryName) const; - DevicesIt FindDevice(uint16_t deviceUid) const; - DevicesIt FindDevice(const std::string& deviceName) const; - CounterSetsIt FindCounterSet(uint16_t counterSetUid) const; - CounterSetsIt FindCounterSet(const std::string& counterSetName) const; - CountersIt FindCounter(uint16_t counterUid) const; - CountersIt FindCounter(const std::string& counterName) const; - uint16_t GetNumberOfCores(const arm::pipe::Optional<uint16_t>& numberOfCores, - uint16_t deviceUid); -}; - -} // namespace pipe - -} // namespace arm diff --git a/src/profiling/DirectoryCaptureCommandHandler.cpp b/src/profiling/DirectoryCaptureCommandHandler.cpp deleted file mode 100644 index 4011c9b1ff..0000000000 --- a/src/profiling/DirectoryCaptureCommandHandler.cpp +++ /dev/null @@ -1,341 +0,0 @@ -// -// Copyright © 2019 Arm Ltd and Contributors. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#include "DirectoryCaptureCommandHandler.hpp" - -#include "ProfilingUtils.hpp" - -#include <atomic> -#include <iostream> - -namespace arm -{ - -namespace pipe -{ - -// Utils -uint32_t uint16_t_size = sizeof(uint16_t); -uint32_t uint32_t_size = sizeof(uint32_t); - -void DirectoryCaptureCommandHandler::ParseData(const arm::pipe::Packet& packet) -{ - uint16_t categoryRecordCount; - uint16_t counterSetRecordCount; - uint16_t deviceRecordCount; - - uint32_t offset = 0; - - if (packet.GetLength() < 8) - { - std::cout << "Counter directory packet received." << std::endl; - return; - } - - const unsigned char* data = packet.GetData(); - // Body header word 0: - // 0:15 [16] reserved: all zeros - offset += uint16_t_size; - // 16:31 [16] device_records_count: number of entries in the device_records_pointer_table - deviceRecordCount = ReadUint16(data, offset); - offset += uint16_t_size; - - // Body header word 1: - // 0:31 [32] device_records_pointer_table_offset: offset to the device_records_pointer_table - // The offset is always zero here, as the device record pointer table field is always the first item in the pool - const uint32_t deviceRecordsPointerTableOffset = ReadUint32(data, offset); - offset += uint32_t_size; - - // Body header word 2: - // 0:15 [16] reserved: all zeros - offset += uint16_t_size; - // 16:31 [16] counter_set_count: number of entries in the counter_set_pointer_table - counterSetRecordCount = ReadUint16(data, offset); - offset += uint16_t_size; - - // Body header word 3: - // 0:31 [32] counter_set_pointer_table_offset: offset to the counter_set_pointer_table - const uint32_t counterPointerTableSetOffset = ReadUint32(data, offset); - offset += uint32_t_size; - - // Body header word 4: - // 0:15 [16] reserved: all zeros - offset += uint16_t_size; - // 16:31 [16] categories_count: number of entries in the categories_pointer_table - categoryRecordCount = ReadUint16(data, offset); - offset += uint16_t_size; - - // Body header word 5: - // 0:31 [32] categories_pointer_table_offset: offset to the categories_pointer_table - const uint32_t categoriesPointerTableOffset = ReadUint32(data, offset); - offset += uint32_t_size; - - std::vector<uint32_t> deviceRecordOffsets(deviceRecordCount); - std::vector<uint32_t> counterSetOffsets(counterSetRecordCount); - std::vector<uint32_t> categoryOffsets(categoryRecordCount); - - offset = deviceRecordsPointerTableOffset; - for (uint32_t i = 0; i < deviceRecordCount; ++i) - { - deviceRecordOffsets[i] = ReadUint32(data, offset); - offset += uint32_t_size; - } - - offset = counterPointerTableSetOffset; - for (uint32_t i = 0; i < counterSetRecordCount; ++i) - { - counterSetOffsets[i] = ReadUint32(data, offset); - offset += uint32_t_size; - } - - offset = categoriesPointerTableOffset; - for (uint32_t i = 0; i < categoryRecordCount; ++i) - { - categoryOffsets[i] = ReadUint32(data, offset); - offset += uint32_t_size; - } - - offset = deviceRecordsPointerTableOffset; - for (uint32_t deviceIndex = 0; deviceIndex < deviceRecordCount; ++deviceIndex) - { - uint32_t deviceRecordOffset = offset + deviceRecordOffsets[deviceIndex]; - // Device record word 0: - // 0:15 [16] cores: the number of individual streams of counters for one or more cores of some device - uint16_t deviceCores = ReadUint16(data, deviceRecordOffset); - // 16:31 [16] deviceUid: the unique identifier for the device - deviceRecordOffset += uint16_t_size; - uint16_t deviceUid = ReadUint16(data, deviceRecordOffset); - deviceRecordOffset += uint16_t_size; - - // Device record word 1: - // Offset from the beginning of the device record pool to the name field. - uint32_t nameOffset = ReadUint32(data, deviceRecordOffset); - - deviceRecordOffset = deviceRecordsPointerTableOffset + nameOffset; - - const std::string& deviceName = GetStringNameFromBuffer(data, deviceRecordOffset); - const Device* registeredDevice = m_CounterDirectory.RegisterDevice(deviceName, deviceCores); - m_UidTranslation[registeredDevice->m_Uid] = deviceUid; - } - - offset = counterPointerTableSetOffset; - for (uint32_t counterSetIndex = 0; counterSetIndex < counterSetRecordCount; ++counterSetIndex) - { - uint32_t counterSetOffset = offset + counterSetOffsets[counterSetIndex]; - - // Counter set record word 0: - // 0:15 [16] count: the number of counters which can be active in this set at any one time - uint16_t counterSetCount = ReadUint16(data, counterSetOffset); - counterSetOffset += uint16_t_size; - - // 16:31 [16] deviceUid: the unique identifier for the counter_set - uint16_t counterSetUid = ReadUint16(data, counterSetOffset); - counterSetOffset += uint16_t_size; - - // Counter set record word 1: - // 0:31 [32] name_offset: offset from the beginning of the counter set pool to the name field - // The offset is always zero here, as the name field is always the first (and only) item in the pool - counterSetOffset += uint32_t_size; - counterSetOffset += uint32_t_size; - - auto counterSet = - m_CounterDirectory.RegisterCounterSet(GetStringNameFromBuffer(data, counterSetOffset), counterSetCount); - m_UidTranslation[counterSet->m_Uid] = counterSetUid; - } - ReadCategoryRecords(data, categoriesPointerTableOffset, categoryOffsets); -} - -void DirectoryCaptureCommandHandler::ReadCategoryRecords(const unsigned char* const data, - uint32_t offset, - std::vector<uint32_t> categoryOffsets) -{ - uint32_t categoryRecordCount = static_cast<uint32_t>(categoryOffsets.size()); - - for (uint32_t categoryIndex = 0; categoryIndex < categoryRecordCount; ++categoryIndex) - { - uint32_t categoryRecordOffset = offset + categoryOffsets[categoryIndex]; - - // Category record word 1: - // 0:15 Reserved, value 0x0000. - categoryRecordOffset += uint16_t_size; - // 16:31 Number of events belonging to this category. - uint32_t eventCount = ReadUint16(data, categoryRecordOffset); - categoryRecordOffset += uint16_t_size; - - // Category record word 2 - // 0:31 Offset from the beginning of the category data pool to the event_pointer_table - uint32_t eventPointerTableOffset = ReadUint32(data, categoryRecordOffset); - categoryRecordOffset += uint32_t_size; - - // Category record word 3 - // 0:31 Offset from the beginning of the category data pool to the name field. - uint32_t nameOffset = ReadUint32(data, categoryRecordOffset); - categoryRecordOffset += uint32_t_size; - - std::vector<uint32_t> eventRecordsOffsets(eventCount); - - eventPointerTableOffset += offset + categoryOffsets[categoryIndex]; - - for (uint32_t eventIndex = 0; eventIndex < eventCount; ++eventIndex) - { - eventRecordsOffsets[eventIndex] = - ReadUint32(data, eventPointerTableOffset + uint32_t_size * eventIndex); - } - - const std::vector<CounterDirectoryEventRecord>& eventRecords = - ReadEventRecords(data, eventPointerTableOffset, eventRecordsOffsets); - - const Category* category = m_CounterDirectory.RegisterCategory( - GetStringNameFromBuffer(data, offset + categoryOffsets[categoryIndex] + nameOffset + uint32_t_size)); - for (auto& counter : eventRecords) - { - const Counter* registeredCounter = m_CounterDirectory.RegisterCounter(m_ApplicationName, - counter.m_CounterUid, - category->m_Name, - counter.m_CounterClass, - counter.m_CounterInterpolation, - counter.m_CounterMultiplier, - counter.m_CounterName, - counter.m_CounterDescription, - counter.m_CounterUnits); - m_UidTranslation[registeredCounter->m_Uid] = counter.m_CounterUid; - } - } -} - -std::vector<CounterDirectoryEventRecord> DirectoryCaptureCommandHandler::ReadEventRecords( - const unsigned char* data, uint32_t offset, std::vector<uint32_t> eventRecordsOffsets) -{ - uint32_t eventCount = static_cast<uint32_t>(eventRecordsOffsets.size()); - - std::vector<CounterDirectoryEventRecord> eventRecords(eventCount); - for (unsigned long i = 0; i < eventCount; ++i) - { - uint32_t eventRecordOffset = eventRecordsOffsets[i] + offset; - - // Event record word 0: - // 0:15 [16] count_uid: unique ID for the counter. Must be unique across all counters in all categories - eventRecords[i].m_CounterUid = ReadUint16(data, eventRecordOffset); - eventRecordOffset += uint16_t_size; - // 16:31 [16] max_counter_uid: if the device this event is associated with has more than one core and there - // is one of these counters per core this value will be set to - // (counter_uid + cores (from device_record)) - 1. - // If there is only a single core then this value will be the same as - // the counter_uid value - eventRecords[i].m_MaxCounterUid = ReadUint16(data, eventRecordOffset); - eventRecordOffset += uint16_t_size; - - // Event record word 1: - // 0:15 [16] counter_set: UID of the counter_set this event is associated with. Set to zero if the event - // is NOT associated with a counter_set - eventRecords[i].m_CounterSetUid = ReadUint16(data, eventRecordOffset); - eventRecordOffset += uint16_t_size; - - // 16:31 [16] device: UID of the device this event is associated with. Set to zero if the event is NOT - // associated with a device - eventRecords[i].m_DeviceUid = ReadUint16(data, eventRecordOffset); - eventRecordOffset += uint16_t_size; - - // Event record word 2: - // 0:15 [16] interpolation: type describing how to interpolate each data point in a stream of data points - eventRecords[i].m_CounterInterpolation = ReadUint16(data, eventRecordOffset); - eventRecordOffset += uint16_t_size; - - // 16:31 [16] class: type describing how to treat each data point in a stream of data points - eventRecords[i].m_CounterClass = ReadUint16(data, eventRecordOffset); - eventRecordOffset += uint16_t_size; - - // Event record word 3-4: - // 0:63 [64] multiplier: internal data stream is represented as integer values, this allows scaling of - // those values as if they are fixed point numbers. Zero is not a valid value - uint32_t multiplier[2] = { 0u, 0u }; - - multiplier[0] = ReadUint32(data, eventRecordOffset); - eventRecordOffset += uint32_t_size; - multiplier[1] = ReadUint32(data, eventRecordOffset); - eventRecordOffset += uint32_t_size; - - std::memcpy(&eventRecords[i].m_CounterMultiplier, &multiplier, sizeof(multiplier)); - - // Event record word 5: - // 0:31 [32] name_eventRecordOffset: eventRecordOffset from the - // beginning of the event record pool to the name field - // The eventRecordOffset is always zero here, as the name field is always the first item in the pool - uint32_t nameOffset = ReadUint32(data, eventRecordOffset); - eventRecordOffset += uint32_t_size; - - // Event record word 6: - // 0:31 [32] description_eventRecordOffset: eventRecordOffset from the - // beginning of the event record pool to the description field - // The size of the name buffer in bytes - uint32_t descriptionOffset = ReadUint32(data, eventRecordOffset); - eventRecordOffset += uint32_t_size; - - // Event record word 7: - // 0:31 [32] units_eventRecordOffset: (optional) eventRecordOffset from the - // beginning of the event record pool to the units field. - // An eventRecordOffset value of zero indicates this field is not provided - uint32_t unitsOffset = ReadUint32(data, eventRecordOffset); - - eventRecords[i].m_CounterName = GetStringNameFromBuffer(data, offset + - eventRecordsOffsets[i] + - nameOffset + - uint32_t_size); - - eventRecords[i].m_CounterDescription = GetStringNameFromBuffer(data, offset + - eventRecordsOffsets[i] + - descriptionOffset + - uint32_t_size); - - eventRecords[i].m_CounterUnits = unitsOffset == 0 ? arm::pipe::Optional<std::string>() : - GetStringNameFromBuffer(data, eventRecordsOffsets[i] + offset + unitsOffset + uint32_t_size); - } - - return eventRecords; -} - -void DirectoryCaptureCommandHandler::operator()(const arm::pipe::Packet& packet) -{ - if (!m_QuietOperation) // Are we supposed to print to stdout? - { - std::cout << "Counter directory packet received." << std::endl; - } - - // The ArmNN counter directory is static per ArmNN instance. Ensure we don't parse it a second time. - if (!ParsedCounterDirectory()) - { - ParseData(packet); - m_AlreadyParsed = true; - } - - if (!m_QuietOperation) - { - PrintCounterDirectory(m_CounterDirectory); - } -} - -const ICounterDirectory& DirectoryCaptureCommandHandler::GetCounterDirectory() const -{ - return m_CounterDirectory; -} - -std::string DirectoryCaptureCommandHandler::GetStringNameFromBuffer(const unsigned char* const data, uint32_t offset) -{ - std::string deviceName; - uint8_t nextChar = ReadUint8(data, offset); - - while (isprint(nextChar)) - { - deviceName += static_cast<char>(nextChar); - offset++; - nextChar = ReadUint8(data, offset); - } - - return deviceName; -} - -} // namespace pipe - -} // namespace arm diff --git a/src/profiling/DirectoryCaptureCommandHandler.hpp b/src/profiling/DirectoryCaptureCommandHandler.hpp deleted file mode 100644 index 007cf05d18..0000000000 --- a/src/profiling/DirectoryCaptureCommandHandler.hpp +++ /dev/null @@ -1,91 +0,0 @@ -// -// Copyright © 2019 Arm Ltd and Contributors. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include "CounterDirectory.hpp" - -#include <common/include/CommandHandlerFunctor.hpp> - -#include <atomic> - -namespace arm -{ - -namespace pipe -{ - -struct CounterDirectoryEventRecord -{ - uint16_t m_CounterClass; - std::string m_CounterDescription; - uint16_t m_CounterInterpolation; - double m_CounterMultiplier; - std::string m_CounterName; - uint16_t m_CounterSetUid; - uint16_t m_CounterUid; - arm::pipe::Optional<std::string> m_CounterUnits; - uint16_t m_DeviceUid; - uint16_t m_MaxCounterUid; -}; - -class DirectoryCaptureCommandHandler : public arm::pipe::CommandHandlerFunctor -{ - -public: - DirectoryCaptureCommandHandler(const std::string& applicationName, - uint32_t familyId, - uint32_t packetId, - uint32_t version, - bool quietOperation = true) - : CommandHandlerFunctor(familyId, packetId, version) - , m_ApplicationName(applicationName) - , m_QuietOperation(quietOperation) - , m_AlreadyParsed(false) - {} - - void operator()(const arm::pipe::Packet& packet) override; - - const ICounterDirectory& GetCounterDirectory() const; - - bool ParsedCounterDirectory() - { - return m_AlreadyParsed.load(); - } - - /** - * Given a Uid that came from a copy of the counter directory translate it to the original. - * - * @param copyUid - * @return the original Uid that the copy maps to. - */ - uint16_t TranslateUIDCopyToOriginal(uint16_t copyUid) - { - return m_UidTranslation[copyUid]; - } - -private: - void ParseData(const arm::pipe::Packet& packet); - - void ReadCategoryRecords(const unsigned char* data, uint32_t offset, std::vector<uint32_t> categoryOffsets); - - std::vector<CounterDirectoryEventRecord> - ReadEventRecords(const unsigned char* data, uint32_t offset, std::vector<uint32_t> eventRecordsOffsets); - - std::string GetStringNameFromBuffer(const unsigned char* data, uint32_t offset); - bool IsValidChar(unsigned char c); - - std::string m_ApplicationName; - CounterDirectory m_CounterDirectory; - std::unordered_map<uint16_t, uint16_t> m_UidTranslation; - bool m_QuietOperation; - // We can only parse the counter directory once per instance. It won't change anyway as it's static - // per instance of ArmNN. - std::atomic<bool> m_AlreadyParsed; -}; - -} // namespace pipe - -} // namespace arm diff --git a/src/profiling/FileOnlyProfilingConnection.hpp b/src/profiling/FileOnlyProfilingConnection.hpp index 48fb4d37f2..9d40420ec8 100644 --- a/src/profiling/FileOnlyProfilingConnection.hpp +++ b/src/profiling/FileOnlyProfilingConnection.hpp @@ -8,13 +8,14 @@ #include <armnn/profiling/ILocalPacketHandler.hpp> #include <armnn/profiling/ProfilingOptions.hpp> -#include "DirectoryCaptureCommandHandler.hpp" #include "IProfilingConnection.hpp" #include "ProfilingUtils.hpp" #include <common/include/Assert.hpp> #include <common/include/Packet.hpp> +#include <server/include/timelineDecoder/DirectoryCaptureCommandHandler.hpp> + #include <atomic> #include <condition_variable> #include <fstream> diff --git a/src/profiling/ICounterDirectory.hpp b/src/profiling/ICounterDirectory.hpp deleted file mode 100644 index d024516ab8..0000000000 --- a/src/profiling/ICounterDirectory.hpp +++ /dev/null @@ -1,118 +0,0 @@ -// -// Copyright © 2019 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include "Counter.hpp" - -#include <string> -#include <vector> -#include <memory> -#include <unordered_set> -#include <unordered_map> - -namespace arm -{ - -namespace pipe -{ - -// Forward declarations -class Category; -class Device; -class CounterSet; - -// Profiling objects smart pointer types -using CategoryPtr = std::unique_ptr<Category>; -using DevicePtr = std::unique_ptr<Device>; -using CounterSetPtr = std::unique_ptr<CounterSet>; -using CounterPtr = std::shared_ptr<Counter>; - -// Profiling objects collection types -using Categories = std::unordered_set<CategoryPtr>; -using Devices = std::unordered_map<uint16_t, DevicePtr>; -using CounterSets = std::unordered_map<uint16_t, CounterSetPtr>; -using Counters = std::unordered_map<uint16_t, CounterPtr>; - -// Profiling objects collection iterator types -using CategoriesIt = Categories::const_iterator; -using DevicesIt = Devices::const_iterator; -using CounterSetsIt = CounterSets::const_iterator; -using CountersIt = Counters::const_iterator; - -class Category final -{ -public: - // Constructors - Category(const std::string& name) - : m_Name(name) - {} - - // Fields - std::string m_Name; - - // Connections - std::vector<uint16_t> m_Counters; // The UIDs of the counters associated with this category -}; - -class Device final -{ -public: - // Constructors - Device(uint16_t deviceUid, const std::string& name, uint16_t cores) - : m_Uid(deviceUid) - , m_Name(name) - , m_Cores(cores) - {} - - // Fields - uint16_t m_Uid; - std::string m_Name; - uint16_t m_Cores; -}; - -class CounterSet final -{ -public: - // Constructors - CounterSet(uint16_t counterSetUid, const std::string& name, uint16_t count) - : m_Uid(counterSetUid) - , m_Name(name) - , m_Count(count) - {} - - // Fields - uint16_t m_Uid; - std::string m_Name; - uint16_t m_Count; -}; - -class ICounterDirectory -{ -public: - virtual ~ICounterDirectory() {} - - // Getters for counts - virtual uint16_t GetCategoryCount() const = 0; - virtual uint16_t GetDeviceCount() const = 0; - virtual uint16_t GetCounterSetCount() const = 0; - virtual uint16_t GetCounterCount() const = 0; - - // Getters for collections - virtual const Categories& GetCategories() const = 0; - virtual const Devices& GetDevices() const = 0; - virtual const CounterSets& GetCounterSets() const = 0; - virtual const Counters& GetCounters() const = 0; - - // Getters for profiling objects - virtual const Category* GetCategory(const std::string& name) const = 0; - virtual const Device* GetDevice(uint16_t uid) const = 0; - virtual const CounterSet* GetCounterSet(uint16_t uid) const = 0; - virtual const Counter* GetCounter(uint16_t uid) const = 0; -}; - -} // namespace pipe - -} // namespace arm diff --git a/src/profiling/ICounterRegistry.hpp b/src/profiling/ICounterRegistry.hpp deleted file mode 100644 index 5c34e7a3de..0000000000 --- a/src/profiling/ICounterRegistry.hpp +++ /dev/null @@ -1,49 +0,0 @@ -// -// Copyright © 2020 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include <common/include/Optional.hpp> - -namespace arm -{ - -namespace pipe -{ - -class ICounterRegistry -{ -public: - virtual ~ICounterRegistry() {} - - // Register profiling objects - virtual const Category* RegisterCategory (const std::string& categoryName) = 0; - - virtual const Device* RegisterDevice (const std::string& deviceName, - uint16_t cores, - const arm::pipe::Optional<std::string>& parentCategoryName) = 0; - - virtual const CounterSet* RegisterCounterSet(const std::string& counterSetName, - uint16_t count, - const arm::pipe::Optional<std::string>& parentCategoryName) = 0; - - virtual const Counter* RegisterCounter(const std::string& 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 arm::pipe::Optional<std::string>& units = arm::pipe::EmptyOptional(), - const arm::pipe::Optional<uint16_t>& numberOfCores = arm::pipe::EmptyOptional(), - const arm::pipe::Optional<uint16_t>& deviceUid = arm::pipe::EmptyOptional(), - const arm::pipe::Optional<uint16_t>& counterSetUid = arm::pipe::EmptyOptional()) = 0; - -}; - -} // namespace pipe - -} // namespace arm diff --git a/src/profiling/IProfilingService.hpp b/src/profiling/IProfilingService.hpp index 6486b6f246..353059aec3 100644 --- a/src/profiling/IProfilingService.hpp +++ b/src/profiling/IProfilingService.hpp @@ -8,7 +8,6 @@ #include "CounterIdMap.hpp" #include "Holder.hpp" #include "ICounterValues.hpp" -#include "ICounterRegistry.hpp" #include "IInitialiseProfilingService.hpp" #include "IProfilingServiceStatus.hpp" #include "ISendCounterPacket.hpp" @@ -18,9 +17,11 @@ #include <armnn/backends/profiling/IBackendProfilingContext.hpp> #include <armnn/profiling/ProfilingOptions.hpp> +#include <common/include/ICounterRegistry.hpp> #include <common/include/Optional.hpp> #include <common/include/ProfilingGuidGenerator.hpp> + namespace arm { diff --git a/src/profiling/ISendCounterPacket.hpp b/src/profiling/ISendCounterPacket.hpp index 0e3ae6faf2..522dc7c7cb 100644 --- a/src/profiling/ISendCounterPacket.hpp +++ b/src/profiling/ISendCounterPacket.hpp @@ -6,7 +6,7 @@ #pragma once #include <armnn/backends/profiling/IBackendProfiling.hpp> -#include "ICounterDirectory.hpp" +#include <common/include/ICounterDirectory.hpp> namespace arm { @@ -38,4 +38,3 @@ public: } // namespace pipe } // namespace arm - diff --git a/src/profiling/ProfilingService.hpp b/src/profiling/ProfilingService.hpp index 9e788fd4b3..58bfd3afcf 100644 --- a/src/profiling/ProfilingService.hpp +++ b/src/profiling/ProfilingService.hpp @@ -9,12 +9,10 @@ #include "BufferManager.hpp" #include "CommandHandler.hpp" #include "ConnectionAcknowledgedCommandHandler.hpp" -#include "CounterDirectory.hpp" #include "CounterIdMap.hpp" #include "DeactivateTimelineReportingCommandHandler.hpp" -#include "ICounterRegistry.hpp" #include "ICounterValues.hpp" -#include <armnn/profiling/ILocalPacketHandler.hpp> +#include "INotifyBackends.hpp" #include "IProfilingService.hpp" #include "IReportStructure.hpp" #include "PeriodicCounterCapture.hpp" @@ -27,9 +25,12 @@ #include "SendThread.hpp" #include "SendTimelinePacket.hpp" #include "TimelinePacketWriterFactory.hpp" -#include "INotifyBackends.hpp" + #include <armnn/backends/profiling/IBackendProfilingContext.hpp> +#include <armnn/profiling/ILocalPacketHandler.hpp> + +#include <common/include/CounterDirectory.hpp> #include <list> diff --git a/src/profiling/ProfilingUtils.cpp b/src/profiling/ProfilingUtils.cpp index e403b1cacf..2963a98621 100644 --- a/src/profiling/ProfilingUtils.cpp +++ b/src/profiling/ProfilingUtils.cpp @@ -23,71 +23,6 @@ namespace arm namespace pipe { -namespace -{ - -void ThrowIfCantGenerateNextUid(uint16_t uid, uint16_t cores = 0) -{ - // Check that it is possible to generate the next UID without causing an overflow - switch (cores) - { - case 0: - case 1: - // Number of cores not specified or set to 1 (a value of zero indicates the device is not capable of - // running multiple parallel workloads and will not provide multiple streams of data for each event) - if (uid == std::numeric_limits<uint16_t>::max()) - { - throw arm::pipe::ProfilingException("Generating the next UID for profiling would result in an overflow"); - } - break; - default: // cores > 1 - // Multiple cores available, as max_counter_uid has to be set to: counter_uid + cores - 1, the maximum - // allowed value for a counter UID is consequently: uint16_t_max - cores + 1 - if (uid >= std::numeric_limits<uint16_t>::max() - cores + 1) - { - throw arm::pipe::ProfilingException("Generating the next UID for profiling would result in an overflow"); - } - break; - } -} - -} // Anonymous namespace - -uint16_t GetNextUid(bool peekOnly) -{ - // The UID used for profiling objects and events. The first valid UID is 1, as 0 is a reserved value - static uint16_t uid = 1; - - // Check that it is possible to generate the next UID without causing an overflow (throws in case of error) - ThrowIfCantGenerateNextUid(uid); - - if (peekOnly) - { - // Peek only - return uid; - } - else - { - // Get the next UID - return uid++; - } -} - -std::vector<uint16_t> GetNextCounterUids(uint16_t firstUid, uint16_t cores) -{ - // Check that it is possible to generate the next counter UID without causing an overflow (throws in case of error) - ThrowIfCantGenerateNextUid(firstUid, cores); - - // Get the next counter UIDs - size_t counterUidsSize = cores == 0 ? 1 : cores; - std::vector<uint16_t> counterUids(counterUidsSize, 0); - for (size_t i = 0; i < counterUidsSize; i++) - { - counterUids[i] = firstUid++; - } - return counterUids; -} - void WriteBytes(const IPacketBufferPtr& packetBuffer, unsigned int offset, const void* value, unsigned int valueSize) { ARM_PIPE_ASSERT(packetBuffer); @@ -656,178 +591,6 @@ TimelinePacketStatus WriteTimelineEventBinary(uint64_t timestamp, return TimelinePacketStatus::Ok; } -void PrintDeviceDetails(const std::pair<const unsigned short, std::unique_ptr<Device>>& devicePair) -{ - std::string body; - - body.append(CentreAlignFormatting(devicePair.second->m_Name, 20)); - body.append(" | "); - body.append(CentreAlignFormatting(std::to_string(devicePair.first), 13)); - body.append(" | "); - body.append(CentreAlignFormatting(std::to_string(devicePair.second->m_Cores), 10)); - body.append("\n"); - - std::cout << std::string(body.size(), '-') << "\n"; - std::cout<< body; -} - -void PrintCounterSetDetails(const std::pair<const unsigned short, std::unique_ptr<CounterSet>>& counterSetPair) -{ - std::string body; - - body.append(CentreAlignFormatting(counterSetPair.second->m_Name, 20)); - body.append(" | "); - body.append(CentreAlignFormatting(std::to_string(counterSetPair.first), 13)); - body.append(" | "); - body.append(CentreAlignFormatting(std::to_string(counterSetPair.second->m_Count), 10)); - body.append("\n"); - - std::cout << std::string(body.size(), '-') << "\n"; - - std::cout<< body; -} - -void PrintCounterDetails(std::shared_ptr<Counter>& counter) -{ - std::string body; - - body.append(CentreAlignFormatting(counter->m_Name, 20)); - body.append(" | "); - body.append(CentreAlignFormatting(counter->m_Description, 50)); - body.append(" | "); - body.append(CentreAlignFormatting(counter->m_Units, 14)); - body.append(" | "); - body.append(CentreAlignFormatting(std::to_string(counter->m_Uid), 6)); - body.append(" | "); - body.append(CentreAlignFormatting(std::to_string(counter->m_MaxCounterUid), 10)); - body.append(" | "); - body.append(CentreAlignFormatting(std::to_string(counter->m_Class), 8)); - body.append(" | "); - body.append(CentreAlignFormatting(std::to_string(counter->m_Interpolation), 14)); - body.append(" | "); - body.append(CentreAlignFormatting(std::to_string(counter->m_Multiplier), 20)); - body.append(" | "); - body.append(CentreAlignFormatting(std::to_string(counter->m_CounterSetUid), 16)); - body.append(" | "); - body.append(CentreAlignFormatting(std::to_string(counter->m_DeviceUid), 14)); - - body.append("\n"); - - std::cout << std::string(body.size(), '-') << "\n"; - - std::cout << body; -} - -void PrintCategoryDetails(const std::unique_ptr<Category>& category, - std::unordered_map<unsigned short, std::shared_ptr<Counter>> counterMap) -{ - std::string categoryBody; - std::string categoryHeader; - - categoryHeader.append(CentreAlignFormatting("Name", 20)); - 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_Counters.size()), 14)); - - std::cout << "\n" << "\n"; - std::cout << CentreAlignFormatting("CATEGORY", static_cast<int>(categoryHeader.size())); - std::cout << "\n"; - std::cout << std::string(categoryHeader.size(), '=') << "\n"; - - std::cout << categoryHeader; - - std::cout << std::string(categoryBody.size(), '-') << "\n"; - - std::cout << categoryBody; - - std::string counterHeader; - - counterHeader.append(CentreAlignFormatting("Counter Name", 20)); - counterHeader.append(" | "); - counterHeader.append(CentreAlignFormatting("Description", 50)); - counterHeader.append(" | "); - counterHeader.append(CentreAlignFormatting("Units", 14)); - counterHeader.append(" | "); - counterHeader.append(CentreAlignFormatting("UID", 6)); - counterHeader.append(" | "); - counterHeader.append(CentreAlignFormatting("Max UID", 10)); - counterHeader.append(" | "); - counterHeader.append(CentreAlignFormatting("Class", 8)); - counterHeader.append(" | "); - counterHeader.append(CentreAlignFormatting("Interpolation", 14)); - counterHeader.append(" | "); - counterHeader.append(CentreAlignFormatting("Multiplier", 20)); - counterHeader.append(" | "); - counterHeader.append(CentreAlignFormatting("Counter set UID", 16)); - counterHeader.append(" | "); - counterHeader.append(CentreAlignFormatting("Device UID", 14)); - counterHeader.append("\n"); - - std::cout << "\n" << "\n"; - std::cout << CentreAlignFormatting("EVENTS IN CATEGORY: " + category->m_Name, - static_cast<int>(counterHeader.size())); - std::cout << "\n"; - std::cout << std::string(counterHeader.size(), '=') << "\n"; - std::cout << counterHeader; - for (auto& it: category->m_Counters) { - auto search = counterMap.find(it); - if(search != counterMap.end()) { - PrintCounterDetails(search->second); - } - } -} - -void PrintCounterDirectory(ICounterDirectory& counterDirectory) -{ - std::string devicesHeader; - - devicesHeader.append(CentreAlignFormatting("Device name", 20)); - devicesHeader.append(" | "); - devicesHeader.append(CentreAlignFormatting("UID", 13)); - devicesHeader.append(" | "); - devicesHeader.append(CentreAlignFormatting("Cores", 10)); - devicesHeader.append("\n"); - - std::cout << "\n" << "\n"; - std::cout << CentreAlignFormatting("DEVICES", static_cast<int>(devicesHeader.size())); - std::cout << "\n"; - std::cout << std::string(devicesHeader.size(), '=') << "\n"; - std::cout << devicesHeader; - for (auto& it: counterDirectory.GetDevices()) { - PrintDeviceDetails(it); - } - - std::string counterSetHeader; - - counterSetHeader.append(CentreAlignFormatting("Counter set name", 20)); - counterSetHeader.append(" | "); - counterSetHeader.append(CentreAlignFormatting("UID", 13)); - counterSetHeader.append(" | "); - counterSetHeader.append(CentreAlignFormatting("Count", 10)); - counterSetHeader.append("\n"); - - std::cout << "\n" << "\n"; - std::cout << CentreAlignFormatting("COUNTER SETS", static_cast<int>(counterSetHeader.size())); - std::cout << "\n"; - std::cout << std::string(counterSetHeader.size(), '=') << "\n"; - - std::cout << counterSetHeader; - - for (auto& it: counterDirectory.GetCounterSets()) { - PrintCounterSetDetails(it); - } - - auto counters = counterDirectory.GetCounters(); - for (auto& it: counterDirectory.GetCategories()) { - PrintCategoryDetails(it, counters); - } - std::cout << "\n"; -} - uint64_t GetTimestamp() { #if USE_CLOCK_MONOTONIC_RAW diff --git a/src/profiling/ProfilingUtils.hpp b/src/profiling/ProfilingUtils.hpp index 649ebfa63a..593dd6b924 100644 --- a/src/profiling/ProfilingUtils.hpp +++ b/src/profiling/ProfilingUtils.hpp @@ -5,11 +5,11 @@ #pragma once +#include <common/include/ICounterDirectory.hpp> #include <common/include/ProfilingException.hpp> #include <armnn/profiling/ISendTimelinePacket.hpp> -#include "ICounterDirectory.hpp" #include "IPacketBuffer.hpp" #include <common/include/Packet.hpp> @@ -29,10 +29,6 @@ namespace pipe constexpr unsigned int ThreadIdSize = sizeof(int); // Is platform dependent -uint16_t GetNextUid(bool peekOnly = false); - -std::vector<uint16_t> GetNextCounterUids(uint16_t firstUid, uint16_t cores); - void WriteBytes(const IPacketBuffer& packetBuffer, unsigned int offset, const void* value, unsigned int valueSize); uint32_t ConstructHeader(uint32_t packetFamily, uint32_t packetId); @@ -132,8 +128,6 @@ TimelinePacketStatus WriteTimelineEventBinary(uint64_t timestamp, std::string CentreAlignFormatting(const std::string& stringToPass, const int spacingWidth); -void PrintCounterDirectory(ICounterDirectory& counterDirectory); - uint64_t GetTimestamp(); arm::pipe::Packet ReceivePacket(const unsigned char* buffer, uint32_t length); diff --git a/src/profiling/RegisterBackendCounters.hpp b/src/profiling/RegisterBackendCounters.hpp index e3045b2b8c..3d3b11a626 100644 --- a/src/profiling/RegisterBackendCounters.hpp +++ b/src/profiling/RegisterBackendCounters.hpp @@ -5,11 +5,13 @@ #pragma once -#include "armnn/backends/profiling/IBackendProfiling.hpp" #include "CounterIdMap.hpp" -#include "CounterDirectory.hpp" #include "IProfilingService.hpp" +#include "armnn/backends/profiling/IBackendProfiling.hpp" + +#include <common/include/CounterDirectory.hpp> + namespace arm { diff --git a/src/profiling/SendCounterPacket.hpp b/src/profiling/SendCounterPacket.hpp index c33bdcc025..047dd3c7c9 100644 --- a/src/profiling/SendCounterPacket.hpp +++ b/src/profiling/SendCounterPacket.hpp @@ -6,7 +6,6 @@ #pragma once #include "IBufferManager.hpp" -#include "ICounterDirectory.hpp" #include "ISendCounterPacket.hpp" #include "ProfilingUtils.hpp" diff --git a/src/profiling/SendThread.hpp b/src/profiling/SendThread.hpp index 6512c8aac6..f68a74c1d3 100644 --- a/src/profiling/SendThread.hpp +++ b/src/profiling/SendThread.hpp @@ -7,13 +7,14 @@ #include "IBufferManager.hpp" #include "IConsumer.hpp" -#include "ICounterDirectory.hpp" #include "ISendCounterPacket.hpp" #include "ISendThread.hpp" #include "IProfilingConnection.hpp" #include "ProfilingStateMachine.hpp" #include "ProfilingUtils.hpp" +#include <common/include/ICounterDirectory.hpp> + #include <atomic> #include <condition_variable> #include <mutex> diff --git a/src/profiling/test/ProfilingMocks.hpp b/src/profiling/test/ProfilingMocks.hpp index cfc1096b8d..80ac1fed0e 100644 --- a/src/profiling/test/ProfilingMocks.hpp +++ b/src/profiling/test/ProfilingMocks.hpp @@ -17,6 +17,7 @@ #include <armnn/profiling/ArmNNProfiling.hpp> #include <common/include/Assert.hpp> +#include <common/include/CommonProfilingUtils.hpp> #include <common/include/IgnoreUnused.hpp> #include <common/include/NumericCast.hpp> #include <common/include/Optional.hpp> diff --git a/src/profiling/test/ProfilingTests.cpp b/src/profiling/test/ProfilingTests.cpp index 19e5f1baa6..22b2ae233a 100644 --- a/src/profiling/test/ProfilingTests.cpp +++ b/src/profiling/test/ProfilingTests.cpp @@ -9,7 +9,6 @@ #include <ArmNNProfilingServiceInitialiser.hpp> #include <CommandHandler.hpp> #include <ConnectionAcknowledgedCommandHandler.hpp> -#include <CounterDirectory.hpp> #include <CounterIdMap.hpp> #include <Holder.hpp> #include <ICounterValues.hpp> @@ -34,6 +33,7 @@ #include <common/include/CommandHandlerKey.hpp> #include <common/include/CommandHandlerRegistry.hpp> +#include <common/include/CounterDirectory.hpp> #include <common/include/EncodeVersion.hpp> #include <common/include/IgnoreUnused.hpp> #include <common/include/NumericCast.hpp> diff --git a/src/profiling/test/RequestCountersPacketHandler.cpp b/src/profiling/test/RequestCountersPacketHandler.cpp index 0a71d3cd62..6a757c2c0b 100644 --- a/src/profiling/test/RequestCountersPacketHandler.cpp +++ b/src/profiling/test/RequestCountersPacketHandler.cpp @@ -5,12 +5,12 @@ #include "RequestCountersPacketHandler.hpp" -#include "DirectoryCaptureCommandHandler.hpp" - #include <common/include/NumericCast.hpp> #include <common/include/PacketVersionResolver.hpp> #include <common/include/ProfilingException.hpp> +#include <server/include/timelineDecoder/DirectoryCaptureCommandHandler.hpp> + namespace arm { diff --git a/src/profiling/test/SendCounterPacketTests.cpp b/src/profiling/test/SendCounterPacketTests.cpp index 4f7886afe3..4ba5eed6ac 100644 --- a/src/profiling/test/SendCounterPacketTests.cpp +++ b/src/profiling/test/SendCounterPacketTests.cpp @@ -8,7 +8,6 @@ #include "SendCounterPacketTests.hpp" #include <BufferManager.hpp> -#include <CounterDirectory.hpp> #include <ProfilingUtils.hpp> #include <SendCounterPacket.hpp> @@ -17,6 +16,7 @@ #include <common/include/Assert.hpp> #include <common/include/Conversion.hpp> #include <common/include/Constants.hpp> +#include <common/include/CounterDirectory.hpp> #include <common/include/EncodeVersion.hpp> #include <common/include/NumericCast.hpp> #include <common/include/Processes.hpp> |