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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
|
//
// Copyright © 2019 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "FileOnlyProfilingConnection.hpp"
#include "PacketVersionResolver.hpp"
#include <armnn/Exceptions.hpp>
#include <boost/numeric/conversion/cast.hpp>
#include <iostream>
#include <thread>
namespace armnn
{
namespace profiling
{
FileOnlyProfilingConnection::~FileOnlyProfilingConnection()
{
Close();
}
bool FileOnlyProfilingConnection::IsOpen() const
{
// This type of connection is always open.
return true;
}
void FileOnlyProfilingConnection::Close()
{
// Dump any unread packets out of the queue.
for (unsigned int i = 0; i < m_PacketQueue.size(); i++)
{
m_PacketQueue.pop();
}
}
bool FileOnlyProfilingConnection::WaitForStreamMeta(const unsigned char* buffer, uint32_t length)
{
boost::ignore_unused(length);
// The first word, stream_metadata_identifer, should always be 0.
if (ToUint32(buffer, TargetEndianness::BeWire) != 0)
{
Fail("Protocol error. The stream_metadata_identifer was not 0.");
}
// Before we interpret the length we need to read the pipe_magic word to determine endianness.
if (ToUint32(buffer + 8, TargetEndianness::BeWire) == PIPE_MAGIC)
{
m_Endianness = TargetEndianness::BeWire;
}
else if (ToUint32(buffer + 8, TargetEndianness::LeWire) == PIPE_MAGIC)
{
m_Endianness = TargetEndianness::LeWire;
}
else
{
Fail("Protocol read error. Unable to read PIPE_MAGIC value.");
}
return true;
}
void FileOnlyProfilingConnection::SendConnectionAck()
{
if (!m_QuietOp)
{
std::cout << "Sending connection acknowledgement." << std::endl;
}
std::unique_ptr<unsigned char[]> uniqueNullPtr = nullptr;
{
std::lock_guard<std::mutex> lck(m_PacketAvailableMutex);
m_PacketQueue.push(Packet(0x10000, 0, uniqueNullPtr));
}
m_ConditionPacketAvailable.notify_one();
}
bool FileOnlyProfilingConnection::SendCounterSelectionPacket()
{
uint32_t uint16_t_size = sizeof(uint16_t);
uint32_t uint32_t_size = sizeof(uint32_t);
uint32_t offset = 0;
uint32_t bodySize = uint32_t_size + boost::numeric_cast<uint32_t>(m_IdList.size()) * uint16_t_size;
auto uniqueData = std::make_unique<unsigned char[]>(bodySize);
unsigned char* data = reinterpret_cast<unsigned char*>(uniqueData.get());
// Copy capturePeriod
WriteUint32(data, offset, m_Options.m_CapturePeriod);
// Copy m_IdList
offset += uint32_t_size;
for (const uint16_t& id : m_IdList)
{
WriteUint16(data, offset, id);
offset += uint16_t_size;
}
{
std::lock_guard<std::mutex> lck(m_PacketAvailableMutex);
m_PacketQueue.push(Packet(0x40000, bodySize, uniqueData));
}
m_ConditionPacketAvailable.notify_one();
return true;
}
bool FileOnlyProfilingConnection::WritePacket(const unsigned char* buffer, uint32_t length)
{
BOOST_ASSERT(buffer);
// Read Header and determine case
uint32_t outgoingHeaderAsWords[2];
PackageActivity packageActivity = GetPackageActivity(buffer, outgoingHeaderAsWords);
switch (packageActivity)
{
case PackageActivity::StreamMetaData:
{
if (!WaitForStreamMeta(buffer, length))
{
return EXIT_FAILURE;
}
SendConnectionAck();
break;
}
case PackageActivity::CounterDirectory:
{
std::unique_ptr<unsigned char[]> uniqueCounterData = std::make_unique<unsigned char[]>(length - 8);
std::memcpy(uniqueCounterData.get(), buffer + 8, length - 8);
Packet directoryPacket(outgoingHeaderAsWords[0], length - 8, uniqueCounterData);
armnn::profiling::PacketVersionResolver packetVersionResolver;
DirectoryCaptureCommandHandler directoryCaptureCommandHandler(
0, 2, packetVersionResolver.ResolvePacketVersion(0, 2).GetEncodedValue());
directoryCaptureCommandHandler.operator()(directoryPacket);
const ICounterDirectory& counterDirectory = directoryCaptureCommandHandler.GetCounterDirectory();
for (auto& category : counterDirectory.GetCategories())
{
// Remember we need to translate the Uid's from our CounterDirectory instance to the parent one.
std::vector<uint16_t> translatedCounters;
for (auto const& copyUid : category->m_Counters)
{
translatedCounters.emplace_back(directoryCaptureCommandHandler.TranslateUIDCopyToOriginal(copyUid));
}
m_IdList.insert(std::end(m_IdList), std::begin(translatedCounters), std::end(translatedCounters));
}
SendCounterSelectionPacket();
break;
}
default:
{
break;
}
}
return true;
}
Packet FileOnlyProfilingConnection::ReadPacket(uint32_t timeout)
{
std::unique_lock<std::mutex> lck(m_PacketAvailableMutex);
// Here we are using m_PacketQueue.empty() as a predicate variable
// The conditional variable will wait until packetQueue is not empty or until a timeout
if(!m_ConditionPacketAvailable.wait_for(lck,
std::chrono::milliseconds(timeout),
[&]{return !m_PacketQueue.empty();}))
{
throw armnn::TimeoutException("Thread has timed out as per requested time limit");
}
Packet returnedPacket = std::move(m_PacketQueue.front());
m_PacketQueue.pop();
return returnedPacket;
}
PackageActivity FileOnlyProfilingConnection::GetPackageActivity(const unsigned char* buffer, uint32_t headerAsWords[2])
{
headerAsWords[0] = ToUint32(buffer, m_Endianness);
headerAsWords[1] = ToUint32(buffer + 4, m_Endianness);
if (headerAsWords[0] == 0x20000) // Packet family = 0 Packet Id = 2
{
return PackageActivity::CounterDirectory;
}
else if (headerAsWords[0] == 0) // Packet family = 0 Packet Id = 0
{
return PackageActivity::StreamMetaData;
}
else
{
return PackageActivity::Unknown;
}
}
uint32_t FileOnlyProfilingConnection::ToUint32(const unsigned char* data, TargetEndianness endianness)
{
// Extract the first 4 bytes starting at data and push them into a 32bit integer based on the
// specified endianness.
if (endianness == TargetEndianness::BeWire)
{
return static_cast<uint32_t>(data[0]) << 24 | static_cast<uint32_t>(data[1]) << 16 |
static_cast<uint32_t>(data[2]) << 8 | static_cast<uint32_t>(data[3]);
}
else
{
return static_cast<uint32_t>(data[3]) << 24 | static_cast<uint32_t>(data[2]) << 16 |
static_cast<uint32_t>(data[1]) << 8 | static_cast<uint32_t>(data[0]);
}
}
void FileOnlyProfilingConnection::Fail(const std::string& errorMessage)
{
Close();
throw RuntimeException(errorMessage);
}
} // namespace profiling
} // namespace armnn
|
