10 #include <TestUtils.hpp> 21 #include <client/include/CounterIdMap.hpp> 22 #include <client/include/Holder.hpp> 23 #include <client/include/ISendTimelinePacket.hpp> 24 #include <client/include/ProfilingOptions.hpp> 26 #include <client/src/PeriodicCounterCapture.hpp> 27 #include <client/src/PeriodicCounterSelectionCommandHandler.hpp> 28 #include <client/src/ProfilingStateMachine.hpp> 29 #include <client/src/ProfilingUtils.hpp> 30 #include <client/src/RequestCounterDirectoryCommandHandler.hpp> 32 #include <client/src/backends/BackendProfiling.hpp> 34 #include <common/include/CounterDirectory.hpp> 35 #include <common/include/PacketVersionResolver.hpp> 37 #include <doctest/doctest.h> 49 struct LogLevelSwapper
70 class ReadCounterVals :
public IReadCounterValues
72 virtual bool IsCounterRegistered(uint16_t counterUid)
const override 74 return (counterUid > 4 && counterUid < 11);
76 virtual bool IsCounterRegistered(
const std::string& counterName)
const override 81 virtual uint16_t GetCounterCount()
const override 85 virtual uint32_t GetAbsoluteCounterValue(uint16_t counterUid)
const override 89 virtual uint32_t GetDeltaCounterValue(uint16_t counterUid)
override 95 class MockBackendSendCounterPacket :
public ISendCounterPacket
98 using IndexValuePairsVector = std::vector<CounterValue>;
101 virtual void SendStreamMetaDataPacket() {}
104 virtual void SendCounterDirectoryPacket(
const ICounterDirectory& counterDirectory)
110 virtual void SendPeriodicCounterCapturePacket(uint64_t timestamp,
const IndexValuePairsVector& values)
112 m_timestamps.emplace_back(Timestamp{timestamp, values});
116 virtual void SendPeriodicCounterSelectionPacket(uint32_t capturePeriod,
117 const std::vector<uint16_t>& selectedCounterIds)
123 std::vector<Timestamp> GetTimestamps()
128 void ClearTimestamps()
130 m_timestamps.clear();
134 std::vector<Timestamp> m_timestamps;
137 arm::pipe::Packet
PacketWriter(uint32_t period, std::vector<uint16_t> countervalues)
139 const uint32_t packetId = 0x40000;
141 uint32_t dataLength =
static_cast<uint32_t
>(4 + countervalues.size() * 2);
142 std::unique_ptr<unsigned char[]> uniqueData = std::make_unique<unsigned char[]>(dataLength);
143 unsigned char* data1 =
reinterpret_cast<unsigned char*
>(uniqueData.get());
145 WriteUint32(data1, offset, period);
147 for (
auto countervalue : countervalues)
149 WriteUint16(data1, offset, countervalue);
153 return {packetId, dataLength, uniqueData};
158 TEST_CASE(
"BackendProfilingCounterRegisterMockBackendTest")
160 arm::pipe::LogLevelSwapper logLevelSwapper(arm::pipe::LogSeverity::Fatal);
170 unsigned int shiftedId = 0;
180 CHECK(counterMap.GetGlobalId(0, mockId) == 5 + shiftedId);
181 CHECK(counterMap.GetGlobalId(1, mockId) == 6 + shiftedId);
182 CHECK(counterMap.GetGlobalId(2, mockId) == 7 + shiftedId);
183 CHECK(counterMap.GetGlobalId(3, mockId) == 8 + shiftedId);
184 CHECK(counterMap.GetGlobalId(4, mockId) == 9 + shiftedId);
185 CHECK(counterMap.GetGlobalId(5, mockId) == 10 + shiftedId);
191 TEST_CASE(
"TestBackendCounters")
193 arm::pipe::LogLevelSwapper logLevelSwapper(arm::pipe::LogSeverity::Fatal);
196 arm::pipe::PacketVersionResolver packetVersionResolver;
197 ProfilingStateMachine stateMachine;
198 ReadCounterVals readCounterVals;
199 CounterIdMap counterIdMap;
200 MockBackendSendCounterPacket sendCounterPacket;
205 ProfilingOptions options;
206 options.m_EnableProfiling =
true;
209 std::unique_ptr<IProfilingService> profilingService = arm::pipe::IProfilingService::CreateProfilingService(
210 arm::pipe::MAX_ARMNN_COUNTER,
212 arm::pipe::ARMNN_SOFTWARE_INFO,
213 arm::pipe::ARMNN_SOFTWARE_VERSION,
214 arm::pipe::ARMNN_HARDWARE_VERSION);
216 std::unique_ptr<IBackendProfiling> cpuBackendProfilingPtr =
217 std::make_unique<BackendProfiling>(options, *profilingService.get(), cpuAccId);
218 std::unique_ptr<IBackendProfiling> gpuBackendProfilingPtr =
219 std::make_unique<BackendProfiling>(options, *profilingService.get(), gpuAccId);
221 std::shared_ptr<IBackendProfilingContext> cpuProfilingContextPtr =
222 std::make_shared<armnn::MockBackendProfilingContext>(cpuBackendProfilingPtr);
223 std::shared_ptr<IBackendProfilingContext> gpuProfilingContextPtr =
224 std::make_shared<armnn::MockBackendProfilingContext>(gpuBackendProfilingPtr);
226 std::unordered_map<std::string,
227 std::shared_ptr<IBackendProfilingContext>> backendProfilingContexts;
229 backendProfilingContexts[cpuAccId] = cpuProfilingContextPtr;
230 backendProfilingContexts[gpuAccId] = gpuProfilingContextPtr;
232 uint16_t globalId = 5;
234 counterIdMap.RegisterMapping(globalId++, 0, cpuAccId);
235 counterIdMap.RegisterMapping(globalId++, 1, cpuAccId);
236 counterIdMap.RegisterMapping(globalId++, 2, cpuAccId);
238 counterIdMap.RegisterMapping(globalId++, 0, gpuAccId);
239 counterIdMap.RegisterMapping(globalId++, 1, gpuAccId);
240 counterIdMap.RegisterMapping(globalId++, 2, gpuAccId);
242 backendProfilingContexts[cpuAccId] = cpuProfilingContextPtr;
243 backendProfilingContexts[gpuAccId] = gpuProfilingContextPtr;
245 PeriodicCounterCapture periodicCounterCapture(holder, sendCounterPacket, readCounterVals,
246 counterIdMap, backendProfilingContexts);
248 uint16_t maxArmnnCounterId = 4;
250 PeriodicCounterSelectionCommandHandler periodicCounterSelectionCommandHandler(0,
252 packetVersionResolver.ResolvePacketVersion(0, 4).GetEncodedValue(),
253 backendProfilingContexts,
257 periodicCounterCapture,
262 stateMachine.TransitionToState(ProfilingState::NotConnected);
263 stateMachine.TransitionToState(ProfilingState::WaitingForAck);
264 stateMachine.TransitionToState(ProfilingState::Active);
266 uint32_t period = 12345u;
268 std::vector<uint16_t> cpuCounters{5, 6, 7};
269 std::vector<uint16_t> gpuCounters{8, 9, 10};
272 periodicCounterSelectionCommandHandler(
PacketWriter(period, gpuCounters));
273 periodicCounterCapture.Stop();
275 std::set<std::string> activeIds = holder.GetCaptureData().GetActiveBackends();
276 CHECK(activeIds.size() == 1);
277 CHECK((activeIds.find(gpuAccId) != activeIds.end()));
279 std::vector<Timestamp> recievedTimestamp = sendCounterPacket.GetTimestamps();
281 CHECK(recievedTimestamp[0].timestamp == period);
282 CHECK(recievedTimestamp.size() == 1);
283 CHECK(recievedTimestamp[0].counterValues.size() == gpuCounters.size());
284 for (
unsigned long i=0; i< gpuCounters.size(); ++i)
286 CHECK(recievedTimestamp[0].counterValues[i].counterId == gpuCounters[i]);
287 CHECK(recievedTimestamp[0].counterValues[i].counterValue == i + 1u);
289 sendCounterPacket.ClearTimestamps();
292 periodicCounterSelectionCommandHandler(
PacketWriter(period, cpuCounters));
293 periodicCounterCapture.Stop();
295 activeIds = holder.GetCaptureData().GetActiveBackends();
296 CHECK(activeIds.size() == 1);
297 CHECK((activeIds.find(cpuAccId) != activeIds.end()));
299 recievedTimestamp = sendCounterPacket.GetTimestamps();
301 CHECK(recievedTimestamp[0].timestamp == period);
302 CHECK(recievedTimestamp.size() == 1);
303 CHECK(recievedTimestamp[0].counterValues.size() == cpuCounters.size());
304 for (
unsigned long i=0; i< cpuCounters.size(); ++i)
306 CHECK(recievedTimestamp[0].counterValues[i].counterId == cpuCounters[i]);
307 CHECK(recievedTimestamp[0].counterValues[i].counterValue == i + 1u);
309 sendCounterPacket.ClearTimestamps();
313 periodicCounterSelectionCommandHandler(
PacketWriter(period, {cpuCounters[0], gpuCounters[2],
314 gpuCounters[1], cpuCounters[1], gpuCounters[0]}));
315 periodicCounterCapture.Stop();
317 activeIds = holder.GetCaptureData().GetActiveBackends();
318 CHECK(activeIds.size() == 2);
319 CHECK((activeIds.find(cpuAccId) != activeIds.end()));
320 CHECK((activeIds.find(gpuAccId) != activeIds.end()));
322 recievedTimestamp = sendCounterPacket.GetTimestamps();
324 CHECK(recievedTimestamp[0].timestamp == period);
325 CHECK(recievedTimestamp[1].timestamp == period);
327 CHECK(recievedTimestamp.size() == 2);
328 CHECK(recievedTimestamp[0].counterValues.size() == 2);
329 CHECK(recievedTimestamp[1].counterValues.size() == gpuCounters.size());
331 CHECK(recievedTimestamp[0].counterValues[0].counterId == cpuCounters[0]);
332 CHECK(recievedTimestamp[0].counterValues[0].counterValue == 1u);
333 CHECK(recievedTimestamp[0].counterValues[1].counterId == cpuCounters[1]);
334 CHECK(recievedTimestamp[0].counterValues[1].counterValue == 2u);
336 for (
unsigned long i=0; i< gpuCounters.size(); ++i)
338 CHECK(recievedTimestamp[1].counterValues[i].counterId == gpuCounters[i]);
339 CHECK(recievedTimestamp[1].counterValues[i].counterValue == i + 1u);
342 sendCounterPacket.ClearTimestamps();
345 std::vector<uint16_t> counterValues;
346 counterValues.insert(counterValues.begin(), cpuCounters.begin(), cpuCounters.end());
347 counterValues.insert(counterValues.begin(), gpuCounters.begin(), gpuCounters.end());
349 periodicCounterSelectionCommandHandler(
PacketWriter(period, counterValues));
350 periodicCounterCapture.Stop();
352 activeIds = holder.GetCaptureData().GetActiveBackends();
353 CHECK(activeIds.size() == 2);
354 CHECK((activeIds.find(cpuAccId) != activeIds.end()));
355 CHECK((activeIds.find(gpuAccId) != activeIds.end()));
357 recievedTimestamp = sendCounterPacket.GetTimestamps();
359 CHECK(recievedTimestamp[0].counterValues.size() == cpuCounters.size());
360 for (
unsigned long i=0; i< cpuCounters.size(); ++i)
362 CHECK(recievedTimestamp[0].counterValues[i].counterId == cpuCounters[i]);
363 CHECK(recievedTimestamp[0].counterValues[i].counterValue == i + 1u);
366 CHECK(recievedTimestamp[1].counterValues.size() == gpuCounters.size());
367 for (
unsigned long i=0; i< gpuCounters.size(); ++i)
369 CHECK(recievedTimestamp[1].counterValues[i].counterId == gpuCounters[i]);
370 CHECK(recievedTimestamp[1].counterValues[i].counterValue == i + 1u);
372 sendCounterPacket.ClearTimestamps();
375 counterValues = {0, 0, 200, cpuCounters[2], gpuCounters[0],3 ,30, cpuCounters[0],cpuCounters[2], gpuCounters[1], 3,
376 90, 0, 30, gpuCounters[0], gpuCounters[0]};
378 periodicCounterSelectionCommandHandler(
PacketWriter(period, counterValues));
379 periodicCounterCapture.Stop();
381 activeIds = holder.GetCaptureData().GetActiveBackends();
382 CHECK(activeIds.size() == 2);
383 CHECK((activeIds.find(cpuAccId) != activeIds.end()));
384 CHECK((activeIds.find(gpuAccId) != activeIds.end()));
386 recievedTimestamp = sendCounterPacket.GetTimestamps();
388 CHECK(recievedTimestamp.size() == 2);
390 CHECK(recievedTimestamp[0].counterValues.size() == 2);
392 CHECK(recievedTimestamp[0].counterValues[0].counterId == cpuCounters[0]);
393 CHECK(recievedTimestamp[0].counterValues[0].counterValue == 1u);
394 CHECK(recievedTimestamp[0].counterValues[1].counterId == cpuCounters[2]);
395 CHECK(recievedTimestamp[0].counterValues[1].counterValue == 3u);
397 CHECK(recievedTimestamp[1].counterValues.size() == 2);
399 CHECK(recievedTimestamp[1].counterValues[0].counterId == gpuCounters[0]);
400 CHECK(recievedTimestamp[1].counterValues[0].counterValue == 1u);
401 CHECK(recievedTimestamp[1].counterValues[1].counterId == gpuCounters[1]);
402 CHECK(recievedTimestamp[1].counterValues[1].counterValue == 2u);
404 sendCounterPacket.ClearTimestamps();
407 periodicCounterSelectionCommandHandler(
PacketWriter(period, {}));
408 periodicCounterCapture.Stop();
410 activeIds = holder.GetCaptureData().GetActiveBackends();
411 CHECK(activeIds.size() == 0);
413 recievedTimestamp = sendCounterPacket.GetTimestamps();
414 CHECK(recievedTimestamp.size() == 0);
416 sendCounterPacket.ClearTimestamps();
419 periodicCounterSelectionCommandHandler(
PacketWriter(0, counterValues));
420 periodicCounterCapture.Stop();
422 activeIds = holder.GetCaptureData().GetActiveBackends();
423 CHECK(activeIds.size() == 0);
425 recievedTimestamp = sendCounterPacket.GetTimestamps();
426 CHECK(recievedTimestamp.size() == 0);
429 TEST_CASE(
"TestBackendCounterLogging")
431 std::stringstream ss;
437 : m_Stream(stream), m_BackupBuffer(m_Stream.rdbuf(newStreamBuffer))
441 { m_Stream.rdbuf(m_BackupBuffer); }
444 std::ostream &m_Stream;
445 std::streambuf *m_BackupBuffer;
449 arm::pipe::PacketVersionResolver packetVersionResolver;
450 ProfilingStateMachine stateMachine;
451 ReadCounterVals readCounterVals;
453 CounterIdMap counterIdMap;
454 MockBackendSendCounterPacket sendCounterPacket;
459 ProfilingOptions options;
460 options.m_EnableProfiling =
true;
463 std::unique_ptr<IProfilingService> profilingService = arm::pipe::IProfilingService::CreateProfilingService(
464 arm::pipe::MAX_ARMNN_COUNTER,
466 arm::pipe::ARMNN_SOFTWARE_INFO,
467 arm::pipe::ARMNN_SOFTWARE_VERSION,
468 arm::pipe::ARMNN_HARDWARE_VERSION);
470 std::unique_ptr<IBackendProfiling> cpuBackendProfilingPtr =
471 std::make_unique<BackendProfiling>(options, *profilingService.get(), cpuAccId);
473 std::shared_ptr<IBackendProfilingContext> cpuProfilingContextPtr =
474 std::make_shared<armnn::MockBackendProfilingContext>(cpuBackendProfilingPtr);
476 std::unordered_map<std::string,
477 std::shared_ptr<IBackendProfilingContext>> backendProfilingContexts;
479 uint16_t globalId = 5;
480 counterIdMap.RegisterMapping(globalId, 0, cpuAccId);
481 backendProfilingContexts[cpuAccId] = cpuProfilingContextPtr;
483 PeriodicCounterCapture periodicCounterCapture(holder, sendCounterPacket, readCounterVals,
484 counterIdMap, backendProfilingContexts);
486 uint16_t maxArmnnCounterId = 4;
488 PeriodicCounterSelectionCommandHandler periodicCounterSelectionCommandHandler(0,
490 packetVersionResolver.ResolvePacketVersion(0, 4).GetEncodedValue(),
491 backendProfilingContexts,
495 periodicCounterCapture,
500 stateMachine.TransitionToState(ProfilingState::NotConnected);
501 stateMachine.TransitionToState(ProfilingState::WaitingForAck);
502 stateMachine.TransitionToState(ProfilingState::Active);
504 uint32_t period = 15939u;
508 periodicCounterSelectionCommandHandler(
PacketWriter(period, {5}));
509 periodicCounterCapture.Stop();
512 CHECK(ss.str().find(
"ActivateCounters example test error") != std::string::npos);
515 TEST_CASE(
"BackendProfilingContextGetSendTimelinePacket")
517 arm::pipe::LogLevelSwapper logLevelSwapper(arm::pipe::LogSeverity::Fatal);
524 std::unique_ptr<IProfilingService> profilingService = arm::pipe::IProfilingService::CreateProfilingService(
525 arm::pipe::MAX_ARMNN_COUNTER,
527 arm::pipe::ARMNN_SOFTWARE_INFO,
528 arm::pipe::ARMNN_SOFTWARE_VERSION,
529 arm::pipe::ARMNN_HARDWARE_VERSION);
531 profilingService->ConfigureProfilingService(
540 CHECK(mockBackEndProfilingContext);
543 CHECK(backendProfilingIface);
547 std::unique_ptr<ISendTimelinePacket> timelinePacket =
548 backendProfilingIface->GetSendTimelinePacket();
550 const uint64_t entityBinaryPacketProfilingGuid = 123456u;
551 timelinePacket->SendTimelineEntityBinaryPacket(entityBinaryPacketProfilingGuid);
552 timelinePacket->Commit();
556 profilingService->ResetExternalProfilingOptions(
560 TEST_CASE(
"GetProfilingGuidGenerator")
562 arm::pipe::LogLevelSwapper logLevelSwapper(arm::pipe::LogSeverity::Fatal);
574 CHECK(mockBackEndProfilingContext);
577 CHECK(backendProfilingIface);
580 IProfilingGuidGenerator& guidGenerator = backendProfilingIface->GetProfilingGuidGenerator();
581 const ProfilingDynamicGuid& firstGuid = guidGenerator.NextGuid();
582 const ProfilingDynamicGuid& secondGuid = guidGenerator.NextGuid();
583 CHECK(secondGuid > firstGuid);
static IRuntimePtr Create(const CreationOptions &options)
void SetAllLoggingSinks(bool standardOut, bool debugOut, bool coloured)
void ConfigureLogging(bool printToStandardOutput, bool printToDebugOutput, LogSeverity severity)
Configures the logging behaviour of the ARMNN library.
std::unique_ptr< IRuntime, void(*)(IRuntime *runtime)> IRuntimePtr
constexpr const char * MockBackendId()
void IgnoreUnused(Ts &&...)
bool m_EnableProfiling
Indicates whether external profiling is enabled or not.
void SetLogFilter(LogSeverity level)
ProfilingOptions ConvertExternalProfilingOptions(const armnn::IRuntime::CreationOptions::ExternalProfilingOptions &options)
constexpr char const * GetComputeDeviceAsCString(Compute compute)
Deprecated function that will be removed together with the Compute enum.
GPU Execution: OpenCL: ArmCompute.
static MockBackendProfilingService & Instance()
TEST_SUITE("BackendProfilingTestSuite")
arm::pipe::Packet PacketWriter(uint32_t period, std::vector< uint16_t > countervalues)
MockBackendProfilingContext * GetContext()
std::unique_ptr< arm::pipe::IBackendProfiling > IBackendProfilingPtr
CPU Execution: NEON: ArmCompute.
IBackendInternal::IBackendProfilingPtr & GetBackendProfiling()
ExternalProfilingOptions m_ProfilingOptions
arm::pipe::IProfilingService & GetProfilingService(armnn::RuntimeImpl *runtime)