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
|
//
// Copyright © 2020 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "BackendProfiling.hpp"
#include "RegisterBackendCounters.hpp"
namespace armnn
{
namespace profiling
{
std::unique_ptr<IRegisterBackendCounters>
BackendProfiling::GetCounterRegistrationInterface(uint16_t currentMaxGlobalCounterID)
{
return std::make_unique<RegisterBackendCounters>(RegisterBackendCounters(currentMaxGlobalCounterID, m_BackendId));
}
std::unique_ptr<ISendTimelinePacket> BackendProfiling::GetSendTimelinePacket()
{
return m_ProfilingService.GetSendTimelinePacket();
}
IProfilingGuidGenerator& BackendProfiling::GetProfilingGuidGenerator()
{
// The profiling service is our Guid Generator.
return m_ProfilingService;
}
void BackendProfiling::ReportCounters(const std::vector<Timestamp>& timestamps)
{
for (const auto timestampInfo : timestamps)
{
std::vector<CounterValue> backendCounterValues = timestampInfo.counterValues;
for_each(backendCounterValues.begin(), backendCounterValues.end(), [&](CounterValue& backendCounterValue)
{
// translate the counterId to globalCounterId
backendCounterValue.counterId = m_ProfilingService.GetCounterMappings().GetGlobalId(
backendCounterValue.counterId, m_BackendId);
});
// Send Periodic Counter Capture Packet for the Timestamp
m_ProfilingService.GetSendCounterPacket().SendPeriodicCounterCapturePacket(
timestampInfo.timestamp, backendCounterValues);
}
}
CounterStatus BackendProfiling::GetCounterStatus(uint16_t backendCounterId)
{
uint16_t globalCounterId = m_ProfilingService.GetCounterMappings().GetGlobalId(backendCounterId, m_BackendId);
CaptureData captureData = m_ProfilingService.GetCaptureData();
CounterStatus counterStatus(backendCounterId, globalCounterId, false, 0);
if (captureData.IsCounterIdInCaptureData(globalCounterId))
{
counterStatus.m_Enabled = true;
counterStatus.m_SamplingRateInMicroseconds = captureData.GetCapturePeriod();
}
return counterStatus;
}
std::vector<CounterStatus> BackendProfiling::GetActiveCounters()
{
CaptureData captureData = m_ProfilingService.GetCaptureData();
const std::vector<uint16_t>& globalCounterIds = captureData.GetCounterIds();
std::vector<CounterStatus> activeCounterIds;
for (auto globalCounterId : globalCounterIds) {
// Get pair of local counterId and backendId using globalCounterId
const std::pair<uint16_t, armnn::BackendId>& backendCounterIdPair =
ProfilingService::Instance().GetCounterMappings().GetBackendId(globalCounterId);
if (backendCounterIdPair.second == m_BackendId)
{
activeCounterIds.emplace_back(backendCounterIdPair.first,
globalCounterId,
true,
captureData.GetCapturePeriod());
}
}
return activeCounterIds;
}
bool BackendProfiling::IsProfilingEnabled() const
{
return m_ProfilingService.IsProfilingEnabled();
}
} // namespace profiling
} // namespace armnn
|
