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
|
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "ProfilingService.hpp"
#include <boost/log/trivial.hpp>
#include <boost/format.hpp>
namespace armnn
{
namespace profiling
{
void ProfilingService::ResetExternalProfilingOptions(const ExternalProfilingOptions& options,
bool resetProfilingService)
{
// Update the profiling options
m_Options = options;
if (resetProfilingService)
{
// Reset the profiling service
m_CounterDirectory.Clear();
m_ProfilingConnection.reset();
m_StateMachine.Reset();
m_CounterIndex.clear();
m_CounterValues.clear();
}
// Re-initialize the profiling service
Initialize();
}
void ProfilingService::Run()
{
if (m_StateMachine.GetCurrentState() == ProfilingState::Uninitialised)
{
Initialize();
}
else if (m_StateMachine.GetCurrentState() == ProfilingState::NotConnected)
{
try
{
m_ProfilingConnectionFactory.GetProfilingConnection(m_Options);
m_StateMachine.TransitionToState(ProfilingState::WaitingForAck);
}
catch (const armnn::Exception& e)
{
std::cerr << e.what() << std::endl;
}
}
}
const ICounterDirectory& ProfilingService::GetCounterDirectory() const
{
return m_CounterDirectory;
}
ProfilingState ProfilingService::GetCurrentState() const
{
return m_StateMachine.GetCurrentState();
}
uint16_t ProfilingService::GetCounterCount() const
{
return m_CounterDirectory.GetCounterCount();
}
uint32_t ProfilingService::GetCounterValue(uint16_t counterUid) const
{
BOOST_ASSERT(counterUid < m_CounterIndex.size());
std::atomic<uint32_t>* counterValuePtr = m_CounterIndex.at(counterUid);
BOOST_ASSERT(counterValuePtr);
return counterValuePtr->load(std::memory_order::memory_order_relaxed);
}
void ProfilingService::SetCounterValue(uint16_t counterUid, uint32_t value)
{
BOOST_ASSERT(counterUid < m_CounterIndex.size());
std::atomic<uint32_t>* counterValuePtr = m_CounterIndex.at(counterUid);
BOOST_ASSERT(counterValuePtr);
counterValuePtr->store(value, std::memory_order::memory_order_relaxed);
}
uint32_t ProfilingService::AddCounterValue(uint16_t counterUid, uint32_t value)
{
BOOST_ASSERT(counterUid < m_CounterIndex.size());
std::atomic<uint32_t>* counterValuePtr = m_CounterIndex.at(counterUid);
BOOST_ASSERT(counterValuePtr);
return counterValuePtr->fetch_add(value, std::memory_order::memory_order_relaxed);
}
uint32_t ProfilingService::SubtractCounterValue(uint16_t counterUid, uint32_t value)
{
BOOST_ASSERT(counterUid < m_CounterIndex.size());
std::atomic<uint32_t>* counterValuePtr = m_CounterIndex.at(counterUid);
BOOST_ASSERT(counterValuePtr);
return counterValuePtr->fetch_sub(value, std::memory_order::memory_order_relaxed);
}
uint32_t ProfilingService::IncrementCounterValue(uint16_t counterUid)
{
BOOST_ASSERT(counterUid < m_CounterIndex.size());
std::atomic<uint32_t>* counterValuePtr = m_CounterIndex.at(counterUid);
BOOST_ASSERT(counterValuePtr);
return counterValuePtr->operator++(std::memory_order::memory_order_relaxed);
}
uint32_t ProfilingService::DecrementCounterValue(uint16_t counterUid)
{
BOOST_ASSERT(counterUid < m_CounterIndex.size());
std::atomic<uint32_t>* counterValuePtr = m_CounterIndex.at(counterUid);
BOOST_ASSERT(counterValuePtr);
return counterValuePtr->operator--(std::memory_order::memory_order_relaxed);
}
void ProfilingService::Initialize()
{
if (!m_Options.m_EnableProfiling)
{
// Skip the initialization if profiling is disabled
return;
}
// Register a category for the basic runtime counters
if (!m_CounterDirectory.IsCategoryRegistered("ArmNN_Runtime"))
{
m_CounterDirectory.RegisterCategory("ArmNN_Runtime");
}
// Register a counter for the number of loaded networks
if (!m_CounterDirectory.IsCounterRegistered("Loaded networks"))
{
const Counter* loadedNetworksCounter =
m_CounterDirectory.RegisterCounter("ArmNN_Runtime",
0,
0,
1.f,
"Loaded networks",
"The number of networks loaded at runtime",
std::string("networks"));
BOOST_ASSERT(loadedNetworksCounter);
InitializeCounterValue(loadedNetworksCounter->m_Uid);
}
// Register a counter for the number of registered backends
if (!m_CounterDirectory.IsCounterRegistered("Registered backends"))
{
const Counter* registeredBackendsCounter =
m_CounterDirectory.RegisterCounter("ArmNN_Runtime",
0,
0,
1.f,
"Registered backends",
"The number of registered backends",
std::string("backends"));
BOOST_ASSERT(registeredBackendsCounter);
InitializeCounterValue(registeredBackendsCounter->m_Uid);
}
// Register a counter for the number of inferences run
if (!m_CounterDirectory.IsCounterRegistered("Inferences run"))
{
const Counter* inferencesRunCounter =
m_CounterDirectory.RegisterCounter("ArmNN_Runtime",
0,
0,
1.f,
"Inferences run",
"The number of inferences run",
std::string("inferences"));
BOOST_ASSERT(inferencesRunCounter);
InitializeCounterValue(inferencesRunCounter->m_Uid);
}
// Initialization is done, update the profiling service state
m_StateMachine.TransitionToState(ProfilingState::NotConnected);
}
void ProfilingService::InitializeCounterValue(uint16_t counterUid)
{
// Increase the size of the counter index if necessary
if (counterUid >= m_CounterIndex.size())
{
m_CounterIndex.resize(boost::numeric_cast<size_t>(counterUid) + 1);
}
// Create a new atomic counter and add it to the list
m_CounterValues.emplace_back(0);
// Register the new counter to the counter index for quick access
std::atomic<uint32_t>* counterValuePtr = &(m_CounterValues.back());
m_CounterIndex.at(counterUid) = counterValuePtr;
}
} // namespace profiling
} // namespace armnn
|
