1 files changed, 240 insertions, 1 deletions

diff --git a/profiling/common/src/CommonProfilingUtils.cpp b/profiling/common/src/CommonProfilingUtils.cpp
index fe98e0aaa9..01bc461dd2 100644
--- a/profiling/common/src/CommonProfilingUtils.cpp
+++ b/profiling/common/src/CommonProfilingUtils.cpp
@@ -5,7 +5,10 @@
 
 #include <common/include/Assert.hpp>
 #include <common/include/CommonProfilingUtils.hpp>
+#include <common/include/ProfilingException.hpp>
 
+#include <iostream>
+#include <limits>
 #include <sstream>
 
 namespace arm
@@ -140,6 +143,242 @@ std::string CentreAlignFormatting(const std::string& stringToPass, const int spa
     return outputStream.str();
 }
 
+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";
+}
+
+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;
+}
 
 } // namespace pipe
-} // namespace arm
\ No newline at end of file
+} // namespace arm