ArmNN
 22.08
Namespaces | Functions
BackendProfilingTests.cpp File Reference
#include "ArmNNProfilingServiceInitialiser.hpp"
#include "MockBackendId.hpp"
#include "ProfilingOptionsConverter.hpp"
#include <TestUtils.hpp>
#include <armnn/BackendId.hpp>
#include <armnn/Logging.hpp>
#include <armnn/profiling/ArmNNProfiling.hpp>
#include <armnn/utility/IgnoreUnused.hpp>
#include <armnnTestUtils/MockBackend.hpp>
#include <client/include/CounterIdMap.hpp>
#include <client/include/Holder.hpp>
#include <client/include/ISendTimelinePacket.hpp>
#include <client/include/ProfilingOptions.hpp>
#include <client/src/PeriodicCounterCapture.hpp>
#include <client/src/PeriodicCounterSelectionCommandHandler.hpp>
#include <client/src/ProfilingStateMachine.hpp>
#include <client/src/ProfilingUtils.hpp>
#include <client/src/RequestCounterDirectoryCommandHandler.hpp>
#include <client/src/backends/BackendProfiling.hpp>
#include <common/include/CounterDirectory.hpp>
#include <common/include/PacketVersionResolver.hpp>
#include <doctest/doctest.h>
#include <vector>
#include <cstdint>
#include <limits>

Go to the source code of this file.

Namespaces

 arm
 
 arm::pipe
 

Functions

arm::pipe::Packet PacketWriter (uint32_t period, std::vector< uint16_t > countervalues)
 
 TEST_SUITE ("BackendProfilingTestSuite")
 

Function Documentation

◆ PacketWriter()

arm::pipe::Packet PacketWriter ( uint32_t  period,
std::vector< uint16_t >  countervalues 
)

Definition at line 137 of file BackendProfilingTests.cpp.

Referenced by TEST_SUITE().

138 {
139  const uint32_t packetId = 0x40000;
140  uint32_t offset = 0;
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());
144 
145  WriteUint32(data1, offset, period);
146  offset += 4;
147  for (auto countervalue : countervalues)
148  {
149  WriteUint16(data1, offset, countervalue);
150  offset += 2;
151  }
152 
153  return {packetId, dataLength, uniqueData};
154 }

◆ TEST_SUITE()

TEST_SUITE ( "BackendProfilingTestSuite"  )

Definition at line 156 of file BackendProfilingTests.cpp.

References arm::pipe::ConvertExternalProfilingOptions(), armnn::CpuAcc, IRuntime::Create(), MockBackendProfilingContext::GetBackendProfiling(), armnn::GetComputeDeviceAsCString(), MockBackendProfilingService::GetContext(), armnn::GetProfilingService(), armnn::GpuAcc, MockBackendProfilingService::Instance(), IRuntime::CreationOptions::ExternalProfilingOptions::m_EnableProfiling, IRuntime::CreationOptions::m_ProfilingOptions, armnn::MockBackendId(), PacketWriter(), armnn::SetAllLoggingSinks(), and armnn::SetLogFilter().

157 {
158 TEST_CASE("BackendProfilingCounterRegisterMockBackendTest")
159 {
160  arm::pipe::LogLevelSwapper logLevelSwapper(arm::pipe::LogSeverity::Fatal);
161 
162  // Reset the profiling service to the uninitialized state
163  armnn::IRuntime::CreationOptions options;
164  options.m_ProfilingOptions.m_EnableProfiling = true;
165 
166  armnn::MockBackendInitialiser initialiser;
167  // Create a runtime
168  armnn::RuntimeImpl runtime(options);
169 
170  unsigned int shiftedId = 0;
171 
172  if (armnn::BackendRegistry().IsBackendRegistered("EthosNAcc"))
173  {
174  shiftedId = 4;
175  }
176 
177  // Check if the MockBackends 3 dummy counters {0, 1, 2-5 (four cores)} are registered
178  armnn::BackendId mockId = armnn::MockBackendId();
179  const ICounterMappings& counterMap = GetProfilingService(&runtime).GetCounterMappings();
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);
186  options.m_ProfilingOptions.m_EnableProfiling = false;
187  GetProfilingService(&runtime).ResetExternalProfilingOptions(
188  ConvertExternalProfilingOptions(options.m_ProfilingOptions), true);
189 }
190 
191 TEST_CASE("TestBackendCounters")
192 {
193  arm::pipe::LogLevelSwapper logLevelSwapper(arm::pipe::LogSeverity::Fatal);
194 
195  Holder holder;
196  arm::pipe::PacketVersionResolver packetVersionResolver;
197  ProfilingStateMachine stateMachine;
198  ReadCounterVals readCounterVals;
199  CounterIdMap counterIdMap;
200  MockBackendSendCounterPacket sendCounterPacket;
201 
202  const std::string cpuAccId(GetComputeDeviceAsCString(armnn::Compute::CpuAcc));
203  const std::string gpuAccId(GetComputeDeviceAsCString(armnn::Compute::GpuAcc));
204 
205  ProfilingOptions options;
206  options.m_EnableProfiling = true;
207 
208  armnn::ArmNNProfilingServiceInitialiser initialiser;
209  std::unique_ptr<IProfilingService> profilingService = arm::pipe::IProfilingService::CreateProfilingService(
210  arm::pipe::MAX_ARMNN_COUNTER,
211  initialiser,
212  arm::pipe::ARMNN_SOFTWARE_INFO,
213  arm::pipe::ARMNN_SOFTWARE_VERSION,
214  arm::pipe::ARMNN_HARDWARE_VERSION);
215 
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);
220 
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);
225 
226  std::unordered_map<std::string,
227  std::shared_ptr<IBackendProfilingContext>> backendProfilingContexts;
228 
229  backendProfilingContexts[cpuAccId] = cpuProfilingContextPtr;
230  backendProfilingContexts[gpuAccId] = gpuProfilingContextPtr;
231 
232  uint16_t globalId = 5;
233 
234  counterIdMap.RegisterMapping(globalId++, 0, cpuAccId);
235  counterIdMap.RegisterMapping(globalId++, 1, cpuAccId);
236  counterIdMap.RegisterMapping(globalId++, 2, cpuAccId);
237 
238  counterIdMap.RegisterMapping(globalId++, 0, gpuAccId);
239  counterIdMap.RegisterMapping(globalId++, 1, gpuAccId);
240  counterIdMap.RegisterMapping(globalId++, 2, gpuAccId);
241 
242  backendProfilingContexts[cpuAccId] = cpuProfilingContextPtr;
243  backendProfilingContexts[gpuAccId] = gpuProfilingContextPtr;
244 
245  PeriodicCounterCapture periodicCounterCapture(holder, sendCounterPacket, readCounterVals,
246  counterIdMap, backendProfilingContexts);
247 
248  uint16_t maxArmnnCounterId = 4;
249 
250  PeriodicCounterSelectionCommandHandler periodicCounterSelectionCommandHandler(0,
251  4,
252  packetVersionResolver.ResolvePacketVersion(0, 4).GetEncodedValue(),
253  backendProfilingContexts,
254  counterIdMap,
255  holder,
256  maxArmnnCounterId,
257  periodicCounterCapture,
258  readCounterVals,
259  sendCounterPacket,
260  stateMachine);
261 
262  stateMachine.TransitionToState(ProfilingState::NotConnected);
263  stateMachine.TransitionToState(ProfilingState::WaitingForAck);
264  stateMachine.TransitionToState(ProfilingState::Active);
265 
266  uint32_t period = 12345u;
267 
268  std::vector<uint16_t> cpuCounters{5, 6, 7};
269  std::vector<uint16_t> gpuCounters{8, 9, 10};
270 
271  // Request only gpu counters
272  periodicCounterSelectionCommandHandler(PacketWriter(period, gpuCounters));
273  periodicCounterCapture.Stop();
274 
275  std::set<std::string> activeIds = holder.GetCaptureData().GetActiveBackends();
276  CHECK(activeIds.size() == 1);
277  CHECK((activeIds.find(gpuAccId) != activeIds.end()));
278 
279  std::vector<Timestamp> recievedTimestamp = sendCounterPacket.GetTimestamps();
280 
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)
285  {
286  CHECK(recievedTimestamp[0].counterValues[i].counterId == gpuCounters[i]);
287  CHECK(recievedTimestamp[0].counterValues[i].counterValue == i + 1u);
288  }
289  sendCounterPacket.ClearTimestamps();
290 
291  // Request only cpu counters
292  periodicCounterSelectionCommandHandler(PacketWriter(period, cpuCounters));
293  periodicCounterCapture.Stop();
294 
295  activeIds = holder.GetCaptureData().GetActiveBackends();
296  CHECK(activeIds.size() == 1);
297  CHECK((activeIds.find(cpuAccId) != activeIds.end()));
298 
299  recievedTimestamp = sendCounterPacket.GetTimestamps();
300 
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)
305  {
306  CHECK(recievedTimestamp[0].counterValues[i].counterId == cpuCounters[i]);
307  CHECK(recievedTimestamp[0].counterValues[i].counterValue == i + 1u);
308  }
309  sendCounterPacket.ClearTimestamps();
310 
311  // Request combination of cpu & gpu counters with new period
312  period = 12222u;
313  periodicCounterSelectionCommandHandler(PacketWriter(period, {cpuCounters[0], gpuCounters[2],
314  gpuCounters[1], cpuCounters[1], gpuCounters[0]}));
315  periodicCounterCapture.Stop();
316 
317  activeIds = holder.GetCaptureData().GetActiveBackends();
318  CHECK(activeIds.size() == 2);
319  CHECK((activeIds.find(cpuAccId) != activeIds.end()));
320  CHECK((activeIds.find(gpuAccId) != activeIds.end()));
321 
322  recievedTimestamp = sendCounterPacket.GetTimestamps();
323 //
324  CHECK(recievedTimestamp[0].timestamp == period);
325  CHECK(recievedTimestamp[1].timestamp == period);
326 
327  CHECK(recievedTimestamp.size() == 2);
328  CHECK(recievedTimestamp[0].counterValues.size() == 2);
329  CHECK(recievedTimestamp[1].counterValues.size() == gpuCounters.size());
330 
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);
335 
336  for (unsigned long i=0; i< gpuCounters.size(); ++i)
337  {
338  CHECK(recievedTimestamp[1].counterValues[i].counterId == gpuCounters[i]);
339  CHECK(recievedTimestamp[1].counterValues[i].counterValue == i + 1u);
340  }
341 
342  sendCounterPacket.ClearTimestamps();
343 
344  // Request all counters
345  std::vector<uint16_t> counterValues;
346  counterValues.insert(counterValues.begin(), cpuCounters.begin(), cpuCounters.end());
347  counterValues.insert(counterValues.begin(), gpuCounters.begin(), gpuCounters.end());
348 
349  periodicCounterSelectionCommandHandler(PacketWriter(period, counterValues));
350  periodicCounterCapture.Stop();
351 
352  activeIds = holder.GetCaptureData().GetActiveBackends();
353  CHECK(activeIds.size() == 2);
354  CHECK((activeIds.find(cpuAccId) != activeIds.end()));
355  CHECK((activeIds.find(gpuAccId) != activeIds.end()));
356 
357  recievedTimestamp = sendCounterPacket.GetTimestamps();
358 
359  CHECK(recievedTimestamp[0].counterValues.size() == cpuCounters.size());
360  for (unsigned long i=0; i< cpuCounters.size(); ++i)
361  {
362  CHECK(recievedTimestamp[0].counterValues[i].counterId == cpuCounters[i]);
363  CHECK(recievedTimestamp[0].counterValues[i].counterValue == i + 1u);
364  }
365 
366  CHECK(recievedTimestamp[1].counterValues.size() == gpuCounters.size());
367  for (unsigned long i=0; i< gpuCounters.size(); ++i)
368  {
369  CHECK(recievedTimestamp[1].counterValues[i].counterId == gpuCounters[i]);
370  CHECK(recievedTimestamp[1].counterValues[i].counterValue == i + 1u);
371  }
372  sendCounterPacket.ClearTimestamps();
373 
374  // Request random counters with duplicates and invalid counters
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]};
377 
378  periodicCounterSelectionCommandHandler(PacketWriter(period, counterValues));
379  periodicCounterCapture.Stop();
380 
381  activeIds = holder.GetCaptureData().GetActiveBackends();
382  CHECK(activeIds.size() == 2);
383  CHECK((activeIds.find(cpuAccId) != activeIds.end()));
384  CHECK((activeIds.find(gpuAccId) != activeIds.end()));
385 
386  recievedTimestamp = sendCounterPacket.GetTimestamps();
387 
388  CHECK(recievedTimestamp.size() == 2);
389 
390  CHECK(recievedTimestamp[0].counterValues.size() == 2);
391 
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);
396 
397  CHECK(recievedTimestamp[1].counterValues.size() == 2);
398 
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);
403 
404  sendCounterPacket.ClearTimestamps();
405 
406  // Request no counters
407  periodicCounterSelectionCommandHandler(PacketWriter(period, {}));
408  periodicCounterCapture.Stop();
409 
410  activeIds = holder.GetCaptureData().GetActiveBackends();
411  CHECK(activeIds.size() == 0);
412 
413  recievedTimestamp = sendCounterPacket.GetTimestamps();
414  CHECK(recievedTimestamp.size() == 0);
415 
416  sendCounterPacket.ClearTimestamps();
417 
418  // Request period of zero
419  periodicCounterSelectionCommandHandler(PacketWriter(0, counterValues));
420  periodicCounterCapture.Stop();
421 
422  activeIds = holder.GetCaptureData().GetActiveBackends();
423  CHECK(activeIds.size() == 0);
424 
425  recievedTimestamp = sendCounterPacket.GetTimestamps();
426  CHECK(recievedTimestamp.size() == 0);
427 }
428 
429 TEST_CASE("TestBackendCounterLogging")
430 {
431  std::stringstream ss;
432 
433  struct StreamRedirector
434  {
435  public:
436  StreamRedirector(std::ostream &stream, std::streambuf *newStreamBuffer)
437  : m_Stream(stream), m_BackupBuffer(m_Stream.rdbuf(newStreamBuffer))
438  {}
439 
440  ~StreamRedirector()
441  { m_Stream.rdbuf(m_BackupBuffer); }
442 
443  private:
444  std::ostream &m_Stream;
445  std::streambuf *m_BackupBuffer;
446  };
447 
448  Holder holder;
449  arm::pipe::PacketVersionResolver packetVersionResolver;
450  ProfilingStateMachine stateMachine;
451  ReadCounterVals readCounterVals;
452  StreamRedirector redirect(std::cout, ss.rdbuf());
453  CounterIdMap counterIdMap;
454  MockBackendSendCounterPacket sendCounterPacket;
455 
456  const std::string cpuAccId(GetComputeDeviceAsCString(armnn::Compute::CpuAcc));
457  const std::string gpuAccId(GetComputeDeviceAsCString(armnn::Compute::GpuAcc));
458 
459  ProfilingOptions options;
460  options.m_EnableProfiling = true;
461 
462  armnn::ArmNNProfilingServiceInitialiser initialiser;
463  std::unique_ptr<IProfilingService> profilingService = arm::pipe::IProfilingService::CreateProfilingService(
464  arm::pipe::MAX_ARMNN_COUNTER,
465  initialiser,
466  arm::pipe::ARMNN_SOFTWARE_INFO,
467  arm::pipe::ARMNN_SOFTWARE_VERSION,
468  arm::pipe::ARMNN_HARDWARE_VERSION);
469 
470  std::unique_ptr<IBackendProfiling> cpuBackendProfilingPtr =
471  std::make_unique<BackendProfiling>(options, *profilingService.get(), cpuAccId);
472 
473  std::shared_ptr<IBackendProfilingContext> cpuProfilingContextPtr =
474  std::make_shared<armnn::MockBackendProfilingContext>(cpuBackendProfilingPtr);
475 
476  std::unordered_map<std::string,
477  std::shared_ptr<IBackendProfilingContext>> backendProfilingContexts;
478 
479  uint16_t globalId = 5;
480  counterIdMap.RegisterMapping(globalId, 0, cpuAccId);
481  backendProfilingContexts[cpuAccId] = cpuProfilingContextPtr;
482 
483  PeriodicCounterCapture periodicCounterCapture(holder, sendCounterPacket, readCounterVals,
484  counterIdMap, backendProfilingContexts);
485 
486  uint16_t maxArmnnCounterId = 4;
487 
488  PeriodicCounterSelectionCommandHandler periodicCounterSelectionCommandHandler(0,
489  4,
490  packetVersionResolver.ResolvePacketVersion(0, 4).GetEncodedValue(),
491  backendProfilingContexts,
492  counterIdMap,
493  holder,
494  maxArmnnCounterId,
495  periodicCounterCapture,
496  readCounterVals,
497  sendCounterPacket,
498  stateMachine);
499 
500  stateMachine.TransitionToState(ProfilingState::NotConnected);
501  stateMachine.TransitionToState(ProfilingState::WaitingForAck);
502  stateMachine.TransitionToState(ProfilingState::Active);
503 
504  uint32_t period = 15939u;
505 
506  arm::pipe::SetAllLoggingSinks(true, false, false);
507  arm::pipe::SetLogFilter(arm::pipe::LogSeverity::Warning);
508  periodicCounterSelectionCommandHandler(PacketWriter(period, {5}));
509  periodicCounterCapture.Stop();
510  arm::pipe::SetLogFilter(arm::pipe::LogSeverity::Fatal);
511 
512  CHECK(ss.str().find("ActivateCounters example test error") != std::string::npos);
513 }
514 
515 TEST_CASE("BackendProfilingContextGetSendTimelinePacket")
516 {
517  arm::pipe::LogLevelSwapper logLevelSwapper(arm::pipe::LogSeverity::Fatal);
518 
519  // Reset the profiling service to the uninitialized state
520  armnn::IRuntime::CreationOptions options;
521  options.m_ProfilingOptions.m_EnableProfiling = true;
522 
523  armnn::ArmNNProfilingServiceInitialiser psInitialiser;
524  std::unique_ptr<IProfilingService> profilingService = arm::pipe::IProfilingService::CreateProfilingService(
525  arm::pipe::MAX_ARMNN_COUNTER,
526  psInitialiser,
527  arm::pipe::ARMNN_SOFTWARE_INFO,
528  arm::pipe::ARMNN_SOFTWARE_VERSION,
529  arm::pipe::ARMNN_HARDWARE_VERSION);
530 
531  profilingService->ConfigureProfilingService(
532  ConvertExternalProfilingOptions(options.m_ProfilingOptions), true);
533 
534  armnn::MockBackendInitialiser initialiser;
535  // Create a runtime. During this the mock backend will be registered and context returned.
536  armnn::IRuntimePtr runtime(armnn::IRuntime::Create(options));
537  armnn::MockBackendProfilingService mockProfilingService = armnn::MockBackendProfilingService::Instance();
538  armnn::MockBackendProfilingContext* mockBackEndProfilingContext = mockProfilingService.GetContext();
539  // Check that there is a valid context set.
540  CHECK(mockBackEndProfilingContext);
541  armnn::IBackendInternal::IBackendProfilingPtr& backendProfilingIface =
542  mockBackEndProfilingContext->GetBackendProfiling();
543  CHECK(backendProfilingIface);
544 
545  // Now for the meat of the test. We're just going to send a random packet and make sure there
546  // are no exceptions or errors. The sending of packets is already tested in SendTimelinePacketTests.
547  std::unique_ptr<ISendTimelinePacket> timelinePacket =
548  backendProfilingIface->GetSendTimelinePacket();
549  // Send TimelineEntityClassBinaryPacket
550  const uint64_t entityBinaryPacketProfilingGuid = 123456u;
551  timelinePacket->SendTimelineEntityBinaryPacket(entityBinaryPacketProfilingGuid);
552  timelinePacket->Commit();
553 
554  // Reset the profiling servie after the test.
555  options.m_ProfilingOptions.m_EnableProfiling = false;
556  profilingService->ResetExternalProfilingOptions(
557  ConvertExternalProfilingOptions(options.m_ProfilingOptions), true);
558 }
559 
560 TEST_CASE("GetProfilingGuidGenerator")
561 {
562  arm::pipe::LogLevelSwapper logLevelSwapper(arm::pipe::LogSeverity::Fatal);
563 
564  // Reset the profiling service to the uninitialized state
565  armnn::IRuntime::CreationOptions options;
566  options.m_ProfilingOptions.m_EnableProfiling = true;
567 
568  armnn::MockBackendInitialiser initialiser;
569  // Create a runtime. During this the mock backend will be registered and context returned.
570  armnn::IRuntimePtr runtime(armnn::IRuntime::Create(options));
571  armnn::MockBackendProfilingService mockProfilingService = armnn::MockBackendProfilingService::Instance();
572  armnn::MockBackendProfilingContext *mockBackEndProfilingContext = mockProfilingService.GetContext();
573  // Check that there is a valid context set.
574  CHECK(mockBackEndProfilingContext);
575  armnn::IBackendInternal::IBackendProfilingPtr& backendProfilingIface =
576  mockBackEndProfilingContext->GetBackendProfiling();
577  CHECK(backendProfilingIface);
578 
579  // Get the Guid generator and check the getting two Guid's results in the second being greater than the first.
580  IProfilingGuidGenerator& guidGenerator = backendProfilingIface->GetProfilingGuidGenerator();
581  const ProfilingDynamicGuid& firstGuid = guidGenerator.NextGuid();
582  const ProfilingDynamicGuid& secondGuid = guidGenerator.NextGuid();
583  CHECK(secondGuid > firstGuid);
584 
585  // Reset the profiling servie after the test.
586  options.m_ProfilingOptions.m_EnableProfiling = false;
587 }
588 
589 }
armnn::IRuntime::Create
static IRuntimePtr Create(const CreationOptions &options)
Definition: Runtime.cpp:49
armnn::SetAllLoggingSinks
void SetAllLoggingSinks(bool standardOut, bool debugOut, bool coloured)
Definition: Logging.cpp:191
armnn::IRuntimePtr
std::unique_ptr< IRuntime, void(*)(IRuntime *runtime)> IRuntimePtr
Definition: IRuntime.hpp:33
armnn::MockBackendId
constexpr const char * MockBackendId()
Definition: MockBackendId.hpp:11
armnn::IRuntime::CreationOptions::ExternalProfilingOptions::m_EnableProfiling
bool m_EnableProfiling
Indicates whether external profiling is enabled or not.
Definition: IRuntime.hpp:138
armnn::SetLogFilter
void SetLogFilter(LogSeverity level)
Definition: Logging.cpp:73
arm::pipe::ConvertExternalProfilingOptions
ProfilingOptions ConvertExternalProfilingOptions(const armnn::IRuntime::CreationOptions::ExternalProfilingOptions &options)
Definition: ProfilingOptionsConverter.cpp:17
armnn::GetComputeDeviceAsCString
constexpr char const * GetComputeDeviceAsCString(Compute compute)
Deprecated function that will be removed together with the Compute enum.
Definition: BackendId.hpp:34
armnn::Compute::GpuAcc
GPU Execution: OpenCL: ArmCompute.
armnn::MockBackendProfilingService::Instance
static MockBackendProfilingService & Instance()
Definition: MockBackend.hpp:223
PacketWriter
arm::pipe::Packet PacketWriter(uint32_t period, std::vector< uint16_t > countervalues)
Definition: BackendProfilingTests.cpp:137
armnn::MockBackendProfilingService::GetContext
MockBackendProfilingContext * GetContext()
Definition: MockBackend.hpp:229
armnn::IBackendInternal::IBackendProfilingPtr
std::unique_ptr< arm::pipe::IBackendProfiling > IBackendProfilingPtr
Definition: IBackendInternal.hpp:93
armnn::Compute::CpuAcc
CPU Execution: NEON: ArmCompute.
armnn::MockBackendProfilingContext::GetBackendProfiling
IBackendInternal::IBackendProfilingPtr & GetBackendProfiling()
Definition: MockBackend.hpp:140
armnn::IRuntime::CreationOptions::m_ProfilingOptions
ExternalProfilingOptions m_ProfilingOptions
Definition: IRuntime.hpp:153
armnn::GetProfilingService
arm::pipe::IProfilingService & GetProfilingService(armnn::RuntimeImpl *runtime)
Definition: TestUtils.cpp:59