IVGCVSW-4015 Add input and output workload to post-optimisation structure

Signed-off-by: Narumol Prangnawarat <narumol.prangnawarat@arm.com>
Change-Id: Ic9fbe1300cf8c4b8a78bad5934f0b2d18b205090

3 files changed, 301 insertions, 2 deletions

diff --git a/src/armnn/LoadedNetwork.cpp b/src/armnn/LoadedNetwork.cpp
index 36a56b044e..778c469043 100644
--- a/src/armnn/LoadedNetwork.cpp
+++ b/src/armnn/LoadedNetwork.cpp
@@ -510,9 +510,18 @@ void LoadedNetwork::EnqueueInput(const BindableLayer& layer, ITensorHandle* tens
     else
     {
         // Create a mem copy workload for input since we did not import
-        auto inputWorkload = std::make_unique<CopyMemGenericWorkload>(inputQueueDescriptor, info);
+        std::unique_ptr<IWorkload> inputWorkload = std::make_unique<CopyMemGenericWorkload>(inputQueueDescriptor, info);
 
         BOOST_ASSERT_MSG(inputWorkload, "No input workload created");
+
+        std::unique_ptr<TimelineUtilityMethods> timelineUtils = TimelineUtilityMethods::GetTimelineUtils();
+        if (timelineUtils)
+        {
+            // Add Input Workload to the post-optimisation network structure
+            AddWorkloadStructure(timelineUtils, inputWorkload, layer);
+            timelineUtils->Commit();
+        }
+
         m_InputQueue.push_back(move(inputWorkload));
     }
 }
@@ -593,8 +602,18 @@ void LoadedNetwork::EnqueueOutput(const BindableLayer& layer, ITensorHandle* ten
         outputQueueDescriptor.m_Inputs.push_back(inputTensorHandle);
         info.m_InputTensorInfos.push_back(inputTensorInfo);
 
-        auto outputWorkload = std::make_unique<CopyMemGenericWorkload>(outputQueueDescriptor, info);
+        std::unique_ptr<IWorkload> outputWorkload =
+            std::make_unique<CopyMemGenericWorkload>(outputQueueDescriptor, info);
         BOOST_ASSERT_MSG(outputWorkload, "No output workload created");
+
+        std::unique_ptr<TimelineUtilityMethods> timelineUtils = TimelineUtilityMethods::GetTimelineUtils();
+        if (timelineUtils)
+        {
+            // Add Output Workload to the post-optimisation network structure
+            AddWorkloadStructure(timelineUtils, outputWorkload, layer);
+            timelineUtils->Commit();
+        }
+
         m_OutputQueue.push_back(move(outputWorkload));
     }
 }
diff --git a/src/armnn/test/RuntimeTests.cpp b/src/armnn/test/RuntimeTests.cpp
index f84f73d810..2567e86862 100644
--- a/src/armnn/test/RuntimeTests.cpp
+++ b/src/armnn/test/RuntimeTests.cpp
@@ -637,6 +637,146 @@ BOOST_AUTO_TEST_CASE(ProfilingEnableCpuRef)
                                            offset);
     
     bufferManager.MarkRead(readableBuffer);
+
+    // Creates structures for input & output.
+    std::vector<float> inputData(16);
+    std::vector<float> outputData(16);
+
+    InputTensors inputTensors
+    {
+        {0, ConstTensor(runtime->GetInputTensorInfo(netId, 0), inputData.data())}
+    };
+    OutputTensors outputTensors
+    {
+        {0, Tensor(runtime->GetOutputTensorInfo(netId, 0), outputData.data())}
+    };
+
+    // Does the inference.
+    runtime->EnqueueWorkload(netId, inputTensors, outputTensors);
+
+    // Get readable buffer for output workload
+    auto outputReadableBuffer = bufferManager.GetReadableBuffer();
+    BOOST_CHECK(outputReadableBuffer != nullptr);
+
+    // Get readable buffer for input workload
+    auto inputReadableBuffer = bufferManager.GetReadableBuffer();
+    BOOST_CHECK(inputReadableBuffer != nullptr);
+
+    // Validate input workload data
+    size = inputReadableBuffer->GetSize();
+    BOOST_CHECK(size == 252);
+
+    readableData = inputReadableBuffer->GetReadableData();
+    BOOST_CHECK(readableData != nullptr);
+
+    offset = 0;
+
+    // Input workload
+    // Input workload entity
+    VerifyTimelineEntityBinaryPacket(EmptyOptional(), readableData, offset);
+
+    // Entity - Type relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           readableData,
+                                           offset);
+
+    // Type label relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           LabelsAndEventClasses::TYPE_GUID,
+                                           readableData,
+                                           offset);
+
+    // BackendId entity
+    VerifyTimelineLabelBinaryPacket(EmptyOptional(), "CpuRef", readableData, offset);
+
+    // Entity - BackendId relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           readableData,
+                                           offset);
+
+    // BackendId label relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           LabelsAndEventClasses::BACKENDID_GUID,
+                                           readableData,
+                                           offset);
+
+    // Input layer - Input workload relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::RetentionLink,
+                                           EmptyOptional(),
+                                           input->GetGuid(),
+                                           EmptyOptional(),
+                                           readableData,
+                                           offset);
+
+    bufferManager.MarkRead(inputReadableBuffer);
+
+    // Validate output workload data
+    size = outputReadableBuffer->GetSize();
+    BOOST_CHECK(size == 252);
+
+    readableData = outputReadableBuffer->GetReadableData();
+    BOOST_CHECK(readableData != nullptr);
+
+    offset = 0;
+
+    // Output workload
+    // Output workload entity
+    VerifyTimelineEntityBinaryPacket(EmptyOptional(), readableData, offset);
+
+    // Entity - Type relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           readableData,
+                                           offset);
+
+    // Type label relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           LabelsAndEventClasses::TYPE_GUID,
+                                           readableData,
+                                           offset);
+
+    // BackendId entity
+    VerifyTimelineLabelBinaryPacket(EmptyOptional(), "CpuRef", readableData, offset);
+
+    // Entity - BackendId relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           readableData,
+                                           offset);
+
+    // BackendId label relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           LabelsAndEventClasses::BACKENDID_GUID,
+                                           readableData,
+                                           offset);
+
+    // Output layer - Output workload relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::RetentionLink,
+                                           EmptyOptional(),
+                                           output->GetGuid(),
+                                           EmptyOptional(),
+                                           readableData,
+                                           offset);
+
+    bufferManager.MarkRead(outputReadableBuffer);
 }
 
 BOOST_AUTO_TEST_CASE(ProfilingPostOptimisationStructureCpuRef)
diff --git a/src/profiling/test/ProfilingTestUtils.cpp b/src/profiling/test/ProfilingTestUtils.cpp
index 7f18ef33d6..862dcf0bf3 100644
--- a/src/profiling/test/ProfilingTestUtils.cpp
+++ b/src/profiling/test/ProfilingTestUtils.cpp
@@ -815,4 +815,144 @@ void VerifyPostOptimisationStructureTestImpl(armnn::BackendId backendId)
                                            offset);
 
     bufferManager.MarkRead(readableBuffer);
+
+    // Creates structures for input & output.
+    std::vector<float> inputData(inputInfo.GetNumElements());
+    std::vector<float> outputData(outputInfo.GetNumElements());
+
+    InputTensors inputTensors
+    {
+        {0, ConstTensor(runtime->GetInputTensorInfo(netId, 0), inputData.data())}
+    };
+    OutputTensors outputTensors
+    {
+        {0, Tensor(runtime->GetOutputTensorInfo(netId, 0), outputData.data())}
+    };
+
+    // Does the inference.
+    runtime->EnqueueWorkload(netId, inputTensors, outputTensors);
+
+    // Get readable buffer for output workload
+    auto outputReadableBuffer = bufferManager.GetReadableBuffer();
+    BOOST_CHECK(outputReadableBuffer != nullptr);
+
+    // Get readable buffer for input workload
+    auto inputReadableBuffer = bufferManager.GetReadableBuffer();
+    BOOST_CHECK(inputReadableBuffer != nullptr);
+
+    // Validate input workload data
+    size = inputReadableBuffer->GetSize();
+    BOOST_CHECK(size == 252);
+
+    readableData = inputReadableBuffer->GetReadableData();
+    BOOST_CHECK(readableData != nullptr);
+
+    offset = 0;
+
+    // Input workload
+    // Input workload entity
+    VerifyTimelineEntityBinaryPacket(EmptyOptional(), readableData, offset);
+
+    // Entity - Type relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           readableData,
+                                           offset);
+
+    // Type label relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           LabelsAndEventClasses::TYPE_GUID,
+                                           readableData,
+                                           offset);
+
+    // BackendId entity
+    VerifyTimelineLabelBinaryPacket(EmptyOptional(), backendId.Get(), readableData, offset);
+
+    // Entity - BackendId relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           readableData,
+                                           offset);
+
+    // BackendId label relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           LabelsAndEventClasses::BACKENDID_GUID,
+                                           readableData,
+                                           offset);
+
+    // Input layer - Input workload relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::RetentionLink,
+                                           EmptyOptional(),
+                                           input->GetGuid(),
+                                           EmptyOptional(),
+                                           readableData,
+                                           offset);
+
+    bufferManager.MarkRead(inputReadableBuffer);
+
+    // Validate output workload data
+    size = outputReadableBuffer->GetSize();
+    BOOST_CHECK(size == 252);
+
+    readableData = outputReadableBuffer->GetReadableData();
+    BOOST_CHECK(readableData != nullptr);
+
+    offset = 0;
+
+    // Output workload
+    // Output workload entity
+    VerifyTimelineEntityBinaryPacket(EmptyOptional(), readableData, offset);
+
+    // Entity - Type relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           readableData,
+                                           offset);
+
+    // Type label relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           LabelsAndEventClasses::TYPE_GUID,
+                                           readableData,
+                                           offset);
+
+    // BackendId entity
+    VerifyTimelineLabelBinaryPacket(EmptyOptional(), backendId.Get(), readableData, offset);
+
+    // Entity - BackendId relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           readableData,
+                                           offset);
+
+    // BackendId label relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           LabelsAndEventClasses::BACKENDID_GUID,
+                                           readableData,
+                                           offset);
+
+    // Output layer - Output workload relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::RetentionLink,
+                                           EmptyOptional(),
+                                           output->GetGuid(),
+                                           EmptyOptional(),
+                                           readableData,
+                                           offset);
+
+    bufferManager.MarkRead(outputReadableBuffer);
 }