blob: 93fb4b433c7a84e4253881dfd835385648440796 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
//
// Copyright © 2020 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "TestTimelinePacketHandler.hpp"
#include "IProfilingConnection.hpp"
#include <armnn/utility/IgnoreUnused.hpp>
#include <chrono>
#include <iostream>
#include <sstream>
namespace armnn
{
namespace profiling
{
std::vector<uint32_t> TestTimelinePacketHandler::GetHeadersAccepted()
{
std::vector<uint32_t> headers;
headers.push_back(m_DirectoryHeader); // message directory
headers.push_back(m_MessageHeader); // message
return headers;
}
void TestTimelinePacketHandler::HandlePacket(const Packet& packet)
{
if (packet.GetHeader() == m_DirectoryHeader)
{
ProcessDirectoryPacket(packet);
}
else if (packet.GetHeader() == m_MessageHeader)
{
ProcessMessagePacket(packet);
}
else
{
std::stringstream ss;
ss << "Received a packet with unknown header [" << packet.GetHeader() << "]";
throw armnn::Exception(ss.str());
}
}
void TestTimelinePacketHandler::Stop()
{
m_Connection->Close();
}
void TestTimelinePacketHandler::WaitOnInferenceCompletion(unsigned int timeout)
{
std::unique_lock<std::mutex> lck(m_InferenceCompletedMutex);
auto start = std::chrono::high_resolution_clock::now();
// Here we we will go back to sleep after a spurious wake up if
// m_InferenceCompleted is not yet true.
if (!m_InferenceCompletedConditionVariable.wait_for(lck,
std::chrono::milliseconds(timeout),
[&]{return m_InferenceCompleted == true;}))
{
auto finish = std::chrono::high_resolution_clock::now();
std::chrono::duration<double, std::milli> elapsed = finish - start;
std::stringstream ss;
ss << "Timed out waiting on inference completion for " << elapsed.count() << " ms";
throw armnn::TimeoutException(ss.str());
}
return;
}
void TestTimelinePacketHandler::SetInferenceComplete()
{
{ // only lock when we are updating the inference completed variable
std::unique_lock<std::mutex> lck(m_InferenceCompletedMutex);
m_InferenceCompleted = true;
}
m_InferenceCompletedConditionVariable.notify_one();
}
void TestTimelinePacketHandler::ProcessDirectoryPacket(const Packet& packet)
{
m_DirectoryDecoder(packet);
}
void TestTimelinePacketHandler::ProcessMessagePacket(const Packet& packet)
{
m_Decoder(packet);
}
// TimelineMessageDecoder functions
ITimelineDecoder::TimelineStatus TimelineMessageDecoder::CreateEntity(const Entity& entity)
{
m_TimelineModel.AddEntity(entity.m_Guid);
return ITimelineDecoder::TimelineStatus::TimelineStatus_Success;
}
ITimelineDecoder::TimelineStatus TimelineMessageDecoder::CreateEventClass(
const ITimelineDecoder::EventClass& eventClass)
{
// for the moment terminate the run here so we can get this code
// onto master prior to a major re-organisation
if (m_PacketHandler != nullptr)
{
m_PacketHandler->SetInferenceComplete();
}
IgnoreUnused(eventClass);
return ITimelineDecoder::TimelineStatus::TimelineStatus_Success;
}
ITimelineDecoder::TimelineStatus TimelineMessageDecoder::CreateEvent(const ITimelineDecoder::Event& event)
{
IgnoreUnused(event);
return ITimelineDecoder::TimelineStatus::TimelineStatus_Success;
}
ITimelineDecoder::TimelineStatus TimelineMessageDecoder::CreateLabel(const ITimelineDecoder::Label& label)
{
m_TimelineModel.AddLabel(label);
return ITimelineDecoder::TimelineStatus::TimelineStatus_Success;
}
ITimelineDecoder::TimelineStatus TimelineMessageDecoder::CreateRelationship(
const ITimelineDecoder::Relationship& relationship)
{
m_TimelineModel.AddRelationship(relationship);
return ITimelineDecoder::TimelineStatus::TimelineStatus_Success;
}
} // namespace profiling
} // namespace armnn
|
