IVGCVSW-4340 Backend profiling: Add tests for Timeline functions

* Add tests for the timeline functions that are part of
  IBackendProfiling: GetSendTimelinePacket & GetProfilingGuidGenerator
* Modify MockBackendProfilingService to store a
  MockBackendProfilingContext shared pointer.

Signed-off-by: Colm Donelan <Colm.Donelan@arm.com>
Change-Id: I99fc4b1da019858b9f29409cd59ef8f590c0d3a2

diff --git a/src/backends/backendsCommon/test/BackendProfilingTests.cpp b/src/backends/backendsCommon/test/BackendProfilingTests.cpp
index 6e4a020..4555336 100644 (file)
--- a/src/backends/backendsCommon/test/BackendProfilingTests.cpp
+++ b/src/backends/backendsCommon/test/BackendProfilingTests.cpp
@@ -16,6 +16,7 @@
 
 #include <armnn/BackendId.hpp>
 #include <armnn/Logging.hpp>
+#include <armnn/profiling/ISendTimelinePacket.hpp>
 
 #include <boost/algorithm/string.hpp>
 #include <boost/numeric/conversion/cast.hpp>
@@ -442,4 +443,69 @@ BOOST_AUTO_TEST_CASE(TestBackendCounterLogging)
     BOOST_CHECK(boost::contains(ss.str(), "ActivateCounters example test error"));
 }
 
-BOOST_AUTO_TEST_SUITE_END()
\ No newline at end of file
+BOOST_AUTO_TEST_CASE(BackendProfilingContextGetSendTimelinePacket)
+{
+    // Reset the profiling service to the uninitialized state
+    armnn::IRuntime::CreationOptions options;
+    options.m_ProfilingOptions.m_EnableProfiling = true;
+    armnn::profiling::ProfilingService& profilingService = armnn::profiling::ProfilingService::Instance();
+    profilingService.ConfigureProfilingService(options.m_ProfilingOptions, true);
+
+    armnn::MockBackendInitialiser initialiser;
+    // Create a runtime. During this the mock backend will be registered and context returned.
+    armnn::IRuntimePtr runtime(armnn::IRuntime::Create(options));
+    armnn::MockBackendProfilingService mockProfilingService = armnn::MockBackendProfilingService::Instance();
+    armnn::MockBackendProfilingContext *mockBackEndProfilingContext = mockProfilingService.GetContext();
+    // Check that there is a valid context set.
+    BOOST_CHECK(mockBackEndProfilingContext);
+    armnn::IBackendInternal::IBackendProfilingPtr& backendProfilingIface =
+        mockBackEndProfilingContext->GetBackendProfiling();
+    BOOST_CHECK(backendProfilingIface);
+
+    // Now for the meat of the test. We're just going to send a random packet and make sure there
+    // are no exceptions or errors. The sending of packets is already tested in SendTimelinePacketTests.
+    std::unique_ptr<armnn::profiling::ISendTimelinePacket> timelinePacket =
+        backendProfilingIface->GetSendTimelinePacket();
+    // Send TimelineEntityClassBinaryPacket
+    const uint64_t entityBinaryPacketProfilingGuid = 123456u;
+    timelinePacket->SendTimelineEntityBinaryPacket(entityBinaryPacketProfilingGuid);
+    timelinePacket->Commit();
+
+    // Reset the profiling servie after the test.
+    options.m_ProfilingOptions.m_EnableProfiling = false;
+    profilingService.ResetExternalProfilingOptions(options.m_ProfilingOptions, true);
+}
+
+BOOST_AUTO_TEST_CASE(GetProfilingGuidGenerator)
+{
+    // Reset the profiling service to the uninitialized state
+    armnn::IRuntime::CreationOptions options;
+    options.m_ProfilingOptions.m_EnableProfiling = true;
+    armnn::profiling::ProfilingService& profilingService = armnn::profiling::ProfilingService::Instance();
+    profilingService.ConfigureProfilingService(options.m_ProfilingOptions, true);
+
+    armnn::MockBackendInitialiser initialiser;
+    // Create a runtime. During this the mock backend will be registered and context returned.
+    armnn::IRuntimePtr runtime(armnn::IRuntime::Create(options));
+    armnn::MockBackendProfilingService mockProfilingService = armnn::MockBackendProfilingService::Instance();
+    armnn::MockBackendProfilingContext *mockBackEndProfilingContext = mockProfilingService.GetContext();
+    // Check that there is a valid context set.
+    BOOST_CHECK(mockBackEndProfilingContext);
+    armnn::IBackendInternal::IBackendProfilingPtr& backendProfilingIface =
+        mockBackEndProfilingContext->GetBackendProfiling();
+    BOOST_CHECK(backendProfilingIface);
+
+    // Get the Guid generator and check the getting two Guid's results in the second being greater than the first.
+    armnn::profiling::IProfilingGuidGenerator& guidGenerator = backendProfilingIface->GetProfilingGuidGenerator();
+    BOOST_CHECK(backendProfilingIface);
+    const armnn::profiling::ProfilingDynamicGuid& firstGuid = guidGenerator.NextGuid();
+    BOOST_CHECK(firstGuid);
+    const armnn::profiling::ProfilingDynamicGuid& secondGuid = guidGenerator.NextGuid();
+    BOOST_CHECK(secondGuid > firstGuid);
+
+    // Reset the profiling servie after the test.
+    options.m_ProfilingOptions.m_EnableProfiling = false;
+    profilingService.ResetExternalProfilingOptions(options.m_ProfilingOptions, true);
+}
+
+BOOST_AUTO_TEST_SUITE_END()

diff --git a/src/backends/backendsCommon/test/MockBackend.cpp b/src/backends/backendsCommon/test/MockBackend.cpp
index 7ad700c..b2388cf 100644 (file)
--- a/src/backends/backendsCommon/test/MockBackend.cpp
+++ b/src/backends/backendsCommon/test/MockBackend.cpp
@@ -109,8 +109,8 @@ IBackendInternal::IBackendProfilingContextPtr MockBackend::CreateBackendProfilin
     const IRuntime::CreationOptions& options, IBackendProfilingPtr& backendProfiling)
 {
     boost::ignore_unused(options);
-    IBackendInternal::IBackendProfilingContextPtr context =
-        std::make_shared<MockBackendProfilingContext>(MockBackendProfilingContext(backendProfiling));
+    std::shared_ptr<armnn::MockBackendProfilingContext> context =
+        std::make_shared<MockBackendProfilingContext>(backendProfiling);
     MockBackendProfilingService::Instance().SetProfilingContextPtr(context);
     return context;
 }

diff --git a/src/backends/backendsCommon/test/MockBackend.hpp b/src/backends/backendsCommon/test/MockBackend.hpp
index 641d67f..3227ce5 100644 (file)
--- a/src/backends/backendsCommon/test/MockBackend.hpp
+++ b/src/backends/backendsCommon/test/MockBackend.hpp
@@ -5,16 +5,16 @@
 
 #pragma once
 
+#include "MockBackendId.hpp"
 #include "armnn/backends/profiling/IBackendProfiling.hpp"
 #include "armnn/backends/profiling/IBackendProfilingContext.hpp"
-#include "MockBackendId.hpp"
 
 #include <LayerSupportCommon.hpp>
 #include <armnn/backends/IBackendInternal.hpp>
 #include <armnn/backends/OptimizationViews.hpp>
-#include <backendsCommon/LayerSupportBase.hpp>
 #include <armnn/backends/profiling/IBackendProfiling.hpp>
 #include <backends/BackendProfiling.hpp>
+#include <backendsCommon/LayerSupportBase.hpp>
 
 namespace armnn
 {
@@ -26,35 +26,11 @@ public:
     ~MockBackendInitialiser();
 };
 
-class MockBackendProfilingService
-{
-public:
-    // Getter for the singleton instance
-    static MockBackendProfilingService& Instance()
-    {
-        static MockBackendProfilingService instance;
-        return instance;
-    }
-
-    armnn::profiling::IBackendProfilingContext* GetContext()
-    {
-        return m_sharedContext.get();
-    }
-
-    void SetProfilingContextPtr(IBackendInternal::IBackendProfilingContextPtr& shared)
-    {
-        m_sharedContext = shared;
-    }
-
-private:
-    IBackendInternal::IBackendProfilingContextPtr m_sharedContext;
-};
-
 class MockBackendProfilingContext : public profiling::IBackendProfilingContext
 {
 public:
     MockBackendProfilingContext(IBackendInternal::IBackendProfilingPtr& backendProfiling)
-        : m_BackendProfiling(backendProfiling)
+        : m_BackendProfiling(std::move(backendProfiling))
         , m_CapturePeriod(0)
     {}
 
@@ -70,23 +46,23 @@ public:
         std::unique_ptr<profiling::IRegisterBackendCounters> counterRegistrar =
             m_BackendProfiling->GetCounterRegistrationInterface(currentMaxGlobalCounterId);
 
-            std::string categoryName("MockCounters");
-            counterRegistrar->RegisterCategory(categoryName);
-            uint16_t nextMaxGlobalCounterId = counterRegistrar->RegisterCounter(
-                0, categoryName, 0, 0, 1.f, "Mock Counter One", "Some notional counter");
+        std::string categoryName("MockCounters");
+        counterRegistrar->RegisterCategory(categoryName);
+        uint16_t nextMaxGlobalCounterId =
+            counterRegistrar->RegisterCounter(0, categoryName, 0, 0, 1.f, "Mock Counter One", "Some notional counter");
 
-            nextMaxGlobalCounterId = counterRegistrar->RegisterCounter(
-                1, categoryName, 0, 0, 1.f, "Mock Counter Two", "Another notional counter");
+        nextMaxGlobalCounterId = counterRegistrar->RegisterCounter(1, categoryName, 0, 0, 1.f, "Mock Counter Two",
+                                                                   "Another notional counter");
 
-            std::string units("microseconds");
-            nextMaxGlobalCounterId = counterRegistrar->RegisterCounter(
-                2, categoryName, 0, 0, 1.f, "Mock MultiCore Counter", "A dummy four core counter", units, 4);
-            return nextMaxGlobalCounterId;
+        std::string units("microseconds");
+        nextMaxGlobalCounterId = counterRegistrar->RegisterCounter(2, categoryName, 0, 0, 1.f, "Mock MultiCore Counter",
+                                                                   "A dummy four core counter", units, 4);
+        return nextMaxGlobalCounterId;
     }
 
     Optional<std::string> ActivateCounters(uint32_t capturePeriod, const std::vector<uint16_t>& counterIds)
     {
-        if ( capturePeriod == 0 || counterIds.size() == 0)
+        if (capturePeriod == 0 || counterIds.size() == 0)
         {
             m_ActiveCounters.clear();
         }
@@ -94,7 +70,7 @@ public:
         {
             return armnn::Optional<std::string>("ActivateCounters example test error");
         }
-        m_CapturePeriod = capturePeriod;
+        m_CapturePeriod  = capturePeriod;
         m_ActiveCounters = counterIds;
         return armnn::Optional<std::string>();
     }
@@ -103,25 +79,48 @@ public:
     {
         std::vector<profiling::CounterValue> counterValues;
 
-        for(auto counterId : m_ActiveCounters)
+        for (auto counterId : m_ActiveCounters)
         {
-            counterValues.emplace_back(profiling::CounterValue{counterId, counterId+1u});
+            counterValues.emplace_back(profiling::CounterValue{ counterId, counterId + 1u });
         }
 
         uint64_t timestamp = m_CapturePeriod;
-        return  {profiling::Timestamp{timestamp, counterValues}};
+        return { profiling::Timestamp{ timestamp, counterValues } };
     }
 
     void EnableProfiling(bool)
     {}
 
 private:
-
-    IBackendInternal::IBackendProfilingPtr& m_BackendProfiling;
+    IBackendInternal::IBackendProfilingPtr m_BackendProfiling;
     uint32_t m_CapturePeriod;
     std::vector<uint16_t> m_ActiveCounters;
 };
 
+class MockBackendProfilingService
+{
+public:
+    // Getter for the singleton instance
+    static MockBackendProfilingService& Instance()
+    {
+        static MockBackendProfilingService instance;
+        return instance;
+    }
+
+    MockBackendProfilingContext* GetContext()
+    {
+        return m_sharedContext.get();
+    }
+
+    void SetProfilingContextPtr(std::shared_ptr<MockBackendProfilingContext> shared)
+    {
+        m_sharedContext = shared;
+    }
+
+private:
+    std::shared_ptr<MockBackendProfilingContext> m_sharedContext;
+};
+
 class MockBackend : public IBackendInternal
 {
 public: