ArmNN
 24.02
ProfilerImpl Class Reference

#include <Profiling.hpp>

Classes

struct  Marker
 
struct  ProfilingEventStats
 

Public Types

using InstrumentPtr = std::unique_ptr< Instrument >
 
using EventPtr = std::unique_ptr< Event >
 
using DescPtr = std::unique_ptr< ProfilingDetails >
 

Public Member Functions

 ProfilerImpl ()
 
 ~ProfilerImpl ()
 
EventBeginEvent (armnn::IProfiler *profiler, const BackendId &backendId, const std::string &name, std::vector< InstrumentPtr > &&instruments, const Optional< arm::pipe::ProfilingGuid > &guid)
 
template<typename DescriptorType >
void AddLayerDetails (const std::string &label, const DescriptorType &desc, const WorkloadInfo &infos, const arm::pipe::ProfilingGuid guid)
 
void EndEvent (Event *event)
 
void EnableProfiling (bool enableProfiling)
 
bool IsProfilingEnabled ()
 
void EnableNetworkDetailsToStdOut (ProfilingDetailsMethod detailsMethod)
 
void UpdateEventTag ()
 
void AnalyzeEventsAndWriteResults (std::ostream &outStream) const
 
void Print (std::ostream &outStream) const
 
uint32_t GetEventColor (const BackendId &backendId) const
 
template<typename EventIterType >
void AnalyzeEventSequenceAndWriteResults (EventIterType first, EventIterType last, std::ostream &outStream) const
 
std::map< std::string, ProfilingEventStatsCalculateProfilingEventStats () const
 
void PopulateParent (std::vector< const Event * > &outEvents, int &outBaseLevel, std::string parentName) const
 
void PopulateDescendants (std::map< const Event *, std::vector< const Event * >> &outDescendantsMap) const
 
template<typename ItertType >
void AnalyzeEventSequenceAndWriteResults (ItertType first, ItertType last, std::ostream &outStream) const
 

Public Attributes

std::stack< Event * > m_Parents
 
std::vector< EventPtrm_EventSequence
 
DescPtr m_ProfilingDetails = std::make_unique<ProfilingDetails>()
 
bool m_ProfilingEnabled
 
ProfilingDetailsMethod m_DetailsToStdOutMethod
 

Detailed Description

Definition at line 29 of file Profiling.hpp.

Member Typedef Documentation

◆ DescPtr

using DescPtr = std::unique_ptr<ProfilingDetails>

Definition at line 79 of file Profiling.hpp.

◆ EventPtr

using EventPtr = std::unique_ptr<Event>

Definition at line 78 of file Profiling.hpp.

◆ InstrumentPtr

using InstrumentPtr = std::unique_ptr<Instrument>

Definition at line 34 of file Profiling.hpp.

Constructor & Destructor Documentation

◆ ProfilerImpl()

Definition at line 164 of file Profiling.cpp.

165  : m_ProfilingEnabled(false),
167 {
169 
170 #if ARMNN_STREAMLINE_ENABLED
171  // Initialises streamline annotations.
172  ANNOTATE_SETUP;
173 #endif
174 }

References armnn::g_ProfilingEventCountHint, ProfilerImpl::m_EventSequence, and armnn::Undefined.

◆ ~ProfilerImpl()

Definition at line 176 of file Profiling.cpp.

177 {
178  if (m_ProfilingEnabled)
179  {
181  {
182  Print(std::cout);
183  }
184  }
185 
186  // Un-register this profiler from the current thread.
188 }

References armnn::g_WriteReportToStdOutOnProfilerDestruction, ProfilerManager::GetInstance(), ProfilerImpl::m_ProfilingEnabled, ProfilerImpl::Print(), and ProfilerManager::RegisterProfiler().

Member Function Documentation

◆ AddLayerDetails()

void AddLayerDetails ( const std::string &  label,
const DescriptorType &  desc,
const WorkloadInfo infos,
const arm::pipe::ProfilingGuid  guid 
)
inline

Definition at line 45 of file Profiling.hpp.

49  {
50  m_ProfilingDetails->AddDetailsToString(label, desc, infos, guid);
51  }

References ProfilerImpl::m_ProfilingDetails.

◆ AnalyzeEventsAndWriteResults()

void AnalyzeEventsAndWriteResults ( std::ostream &  outStream) const

Definition at line 481 of file Profiling.cpp.

482 {
483  // Stack should be empty now.
484  const bool saneMarkerSequence = m_Parents.empty();
485 
486  // Abort if the sequence of markers was found to have incorrect information:
487  // The stats cannot be trusted.
488  if (!saneMarkerSequence)
489  {
490  outStream << "Cannot write profiling stats. "
491  "Unexpected errors were found when analyzing the sequence of logged events, "
492  "which may lead to plainly wrong stats. The profiling system may contain implementation "
493  "issues or could have been used in an unsafe manner." << std::endl;
494  return;
495  }
496 
497  // Analyzes the full sequence of events.
499  m_EventSequence.cend(),
500  outStream);
501 
502  // Aggregates events by tag if requested (spams the output stream if done for all tags).
504  {
505  outStream << std::endl;
506  outStream << "***" << std::endl;
507  outStream << "*** Per Inference Stats" << std::endl;
508  outStream << "***" << std::endl;
509  outStream << std::endl;
510 
511  int baseLevel = -1;
512  std::vector<const Event*> inferences;
513  PopulateParent(inferences, baseLevel, "EnqueueWorkload");
514 
515  // Second map out descendants hierarchy
516  std::map<const Event*, std::vector<const Event*>> descendantsMap;
517  PopulateDescendants(descendantsMap);
518 
519  std::function<void(const Event*, std::vector<const Event*>&)>
520  FindDescendantEvents = [&](const Event* eventPtr, std::vector<const Event*>& sequence)
521  {
522  sequence.push_back(eventPtr);
523 
524  if (CalcLevel(eventPtr) > baseLevel+2) //We only care about levels as deep as workload executions.
525  {
526  return;
527  }
528 
529  auto children = descendantsMap.find(eventPtr);
530  if (children == descendantsMap.end())
531  {
532  return;
533  }
534 
535  if (!(children->second.empty()))
536  {
537  return FindDescendantEvents(children->second[0], sequence);
538  }
539  };
540 
541  // Third, find events belonging to each inference
542  int inferenceIdx = 0;
543  for (auto inference : inferences)
544  {
545  std::vector<const Event*> sequence;
546 
547  //build sequence, depth first
548  FindDescendantEvents(inference, sequence);
549 
550  outStream << "> Begin Inference: " << inferenceIdx << std::endl;
551  outStream << std::endl;
552  AnalyzeEventSequenceAndWriteResults(sequence.cbegin(),
553  sequence.cend(),
554  outStream);
555  outStream << std::endl;
556  outStream << "> End Inference: " << inferenceIdx << std::endl;
557 
558  inferenceIdx++;
559  }
560  }
561 }

References ProfilerImpl::AnalyzeEventSequenceAndWriteResults(), armnn::CalcLevel(), armnn::g_AggregateProfilingEventsByInference, ProfilerImpl::m_EventSequence, ProfilerImpl::m_Parents, ProfilerImpl::PopulateDescendants(), and ProfilerImpl::PopulateParent().

◆ AnalyzeEventSequenceAndWriteResults() [1/2]

void AnalyzeEventSequenceAndWriteResults ( EventIterType  first,
EventIterType  last,
std::ostream &  outStream 
) const

◆ AnalyzeEventSequenceAndWriteResults() [2/2]

void AnalyzeEventSequenceAndWriteResults ( ItertType  first,
ItertType  last,
std::ostream &  outStream 
) const

Definition at line 113 of file Profiling.cpp.

114 {
115  // Outputs event sequence, if needed.
117  {
118  // Makes sure timestamps are output with 6 decimals, and save old settings.
119  std::streamsize oldPrecision = outStream.precision();
120  outStream.precision(6);
121  std::ios_base::fmtflags oldFlags = outStream.flags();
122  outStream.setf(std::ios::fixed);
123  // Outputs fields.
124  outStream << "Event Sequence - Name | Duration (ms) | Start (ms) | Stop (ms) | Device" << std::endl;
125  for (auto event = first; event != last; ++event)
126  {
127  const Event* eventPtr = GetEventPtr((*event));
128  double startTimeMs = FindMeasurement(WallClockTimer::WALL_CLOCK_TIME_START, eventPtr).m_Value;
129  double stopTimeMs = FindMeasurement(WallClockTimer::WALL_CLOCK_TIME_STOP, eventPtr).m_Value;
130 
131  // Find the WallClock measurement if there is one.
132  double durationMs = FindMeasurement(WallClockTimer::WALL_CLOCK_TIME, eventPtr).m_Value;
133  outStream << std::setw(50) << eventPtr->GetName() << " "
134  << std::setw(20) << durationMs
135  << std::setw(20) << startTimeMs
136  << std::setw(20) << stopTimeMs
137  << std::setw(20) << eventPtr->GetBackendId().Get()
138  << std::endl;
139  }
140  outStream << std::endl;
141  // Restores previous precision settings.
142  outStream.flags(oldFlags);
143  outStream.precision(oldPrecision);
144  }
145 
146  // Aggregates results per event name.
147  std::map<std::string, ProfilingEventStats> nameToStatsMap = CalculateProfilingEventStats();
148 
149  // Outputs aggregated stats.
150  outStream << "Event Stats - Name | Avg (ms) | Min (ms) | Max (ms) | Total (ms) | Count" << std::endl;
151  for (const auto& pair : nameToStatsMap)
152  {
153  const std::string& eventLabel = pair.first;
154  const ProfilingEventStats& eventStats = pair.second;
155  const double avgMs = eventStats.m_TotalMs / double(eventStats.m_Count);
156 
157  outStream << "\t" << std::setw(50) << eventLabel << " " << std::setw(9) << avgMs << " "
158  << std::setw(9) << eventStats.m_MinMs << " " << std::setw(9) << eventStats.m_MaxMs << " "
159  << std::setw(9) << eventStats.m_TotalMs << " " << std::setw(9) << eventStats.m_Count << std::endl;
160  }
161  outStream << std::endl;
162 }

References ProfilerImpl::CalculateProfilingEventStats(), armnn::FindMeasurement(), armnn::g_WriteProfilingEventSequence, BackendId::Get(), Event::GetBackendId(), armnn::GetEventPtr(), Event::GetName(), ProfilerImpl::ProfilingEventStats::m_Count, ProfilerImpl::ProfilingEventStats::m_MaxMs, ProfilerImpl::ProfilingEventStats::m_MinMs, ProfilerImpl::ProfilingEventStats::m_TotalMs, Measurement::m_Value, WallClockTimer::WALL_CLOCK_TIME, WallClockTimer::WALL_CLOCK_TIME_START, and WallClockTimer::WALL_CLOCK_TIME_STOP.

◆ BeginEvent()

Event * BeginEvent ( armnn::IProfiler profiler,
const BackendId backendId,
const std::string &  name,
std::vector< InstrumentPtr > &&  instruments,
const Optional< arm::pipe::ProfilingGuid > &  guid 
)

Definition at line 205 of file Profiling.cpp.

210 {
211  Event* parent = m_Parents.empty() ? nullptr : m_Parents.top();
212  m_EventSequence.push_back(std::make_unique<Event>(label,
213  profiler,
214  parent,
215  backendId,
216  std::move(instruments),
217  guid));
218  Event* event = m_EventSequence.back().get();
219  event->Start();
220 
221 #if ARMNN_STREAMLINE_ENABLED
222  ANNOTATE_CHANNEL_COLOR(uint32_t(m_Parents.size()), GetEventColor(backendId), label.c_str());
223 #endif
224 
225  m_Parents.push(event);
226  return event;
227 }

References ProfilerImpl::GetEventColor(), ProfilerImpl::m_EventSequence, and ProfilerImpl::m_Parents.

◆ CalculateProfilingEventStats()

std::map< std::string, ProfilerImpl::ProfilingEventStats > CalculateProfilingEventStats ( ) const

Definition at line 82 of file Profiling.cpp.

83 {
84  std::map<std::string, ProfilingEventStats> nameToStatsMap;
85 
86  for (const auto& event : m_EventSequence)
87  {
89 
90  double durationMs = measurement.m_Value;
91  auto it = nameToStatsMap.find(event->GetName());
92  if (it != nameToStatsMap.end())
93  {
94  ProfilingEventStats& stats = it->second;
95  stats.m_TotalMs += durationMs;
96  stats.m_MinMs = std::min(stats.m_MinMs, durationMs);
97  stats.m_MaxMs = std::max(stats.m_MaxMs, durationMs);
98  ++stats.m_Count;
99  }
100  else
101  {
102  nameToStatsMap.emplace(event->GetName(), ProfilingEventStats{ durationMs, durationMs, durationMs, 1 });
103  }
104  }
105 
106  return nameToStatsMap;
107 }

References armnn::FindMeasurement(), ProfilerImpl::ProfilingEventStats::m_Count, ProfilerImpl::m_EventSequence, ProfilerImpl::ProfilingEventStats::m_MaxMs, ProfilerImpl::ProfilingEventStats::m_MinMs, ProfilerImpl::ProfilingEventStats::m_TotalMs, Measurement::m_Value, and WallClockTimer::WALL_CLOCK_TIME.

Referenced by ProfilerImpl::AnalyzeEventSequenceAndWriteResults().

◆ EnableNetworkDetailsToStdOut()

void EnableNetworkDetailsToStdOut ( ProfilingDetailsMethod  detailsMethod)

Definition at line 200 of file Profiling.cpp.

201 {
202  m_DetailsToStdOutMethod = details;
203 }

References ProfilerImpl::m_DetailsToStdOutMethod.

◆ EnableProfiling()

void EnableProfiling ( bool  enableProfiling)

Definition at line 195 of file Profiling.cpp.

196 {
197  m_ProfilingEnabled = enableProfiling;
198 }

References ProfilerImpl::m_ProfilingEnabled.

◆ EndEvent()

void EndEvent ( Event event)

Definition at line 229 of file Profiling.cpp.

230 {
231  event->Stop();
232 
233  ARMNN_ASSERT(!m_Parents.empty());
234  ARMNN_ASSERT(event == m_Parents.top());
235  m_Parents.pop();
236 
237  Event* parent = m_Parents.empty() ? nullptr : m_Parents.top();
238  IgnoreUnused(parent);
239  ARMNN_ASSERT(event->GetParentEvent() == parent);
240 
241 #if ARMNN_STREAMLINE_ENABLED
242  ANNOTATE_CHANNEL_END(uint32_t(m_Parents.size()));
243 #endif
244 }

References ARMNN_ASSERT, Event::GetParentEvent(), armnn::IgnoreUnused(), and ProfilerImpl::m_Parents.

◆ GetEventColor()

std::uint32_t GetEventColor ( const BackendId backendId) const

Definition at line 563 of file Profiling.cpp.

564 {
565  static BackendId cpuRef("CpuRef");
566  static BackendId cpuAcc("CpuAcc");
567  static BackendId gpuAcc("GpuAcc");
568  if (backendId == cpuRef)
569  {
570  // Cyan
571  return 0xffff001b;
572  }
573  else if (backendId == cpuAcc)
574  {
575  // Green
576  return 0x00ff001b;
577  }
578  else if (backendId == gpuAcc)
579  {
580  // Purple
581  return 0xff007f1b;
582  }
583  else
584  {
585  // Dark gray
586  return 0x5555551b;
587  }
588 }

Referenced by ProfilerImpl::BeginEvent().

◆ IsProfilingEnabled()

bool IsProfilingEnabled ( )

Definition at line 190 of file Profiling.cpp.

191 {
192  return m_ProfilingEnabled;
193 }

References ProfilerImpl::m_ProfilingEnabled.

◆ PopulateDescendants()

void PopulateDescendants ( std::map< const Event *, std::vector< const Event * >> &  outDescendantsMap) const

Definition at line 271 of file Profiling.cpp.

272 {
273  for (const auto& event : m_EventSequence)
274  {
275  const Event* eventPtrRaw = event.get();
276  const Event* parent = eventPtrRaw->GetParentEvent();
277 
278  if (!parent)
279  {
280  continue;
281  }
282 
283  auto it = outDescendantsMap.find(parent);
284  if (it == outDescendantsMap.end())
285  {
286  outDescendantsMap.emplace(parent, std::vector<const Event*>({ eventPtrRaw }));
287  }
288  else
289  {
290  it->second.push_back(eventPtrRaw);
291  }
292  }
293 }

References Event::GetParentEvent(), and ProfilerImpl::m_EventSequence.

Referenced by ProfilerImpl::AnalyzeEventsAndWriteResults(), and ProfilerImpl::Print().

◆ PopulateParent()

void PopulateParent ( std::vector< const Event * > &  outEvents,
int &  outBaseLevel,
std::string  parentName 
) const

Definition at line 257 of file Profiling.cpp.

258 {
259  outEvents.reserve(m_EventSequence.size());
260  for (const auto& event : m_EventSequence)
261  {
262  const Event* eventPtrRaw = event.get();
263  if (eventPtrRaw->GetName() == parentName)
264  {
265  outBaseLevel = (outBaseLevel == -1) ? CalcLevel(eventPtrRaw) : outBaseLevel;
266  outEvents.push_back(eventPtrRaw);
267  }
268  }
269 }

References armnn::CalcLevel(), Event::GetName(), and ProfilerImpl::m_EventSequence.

Referenced by ProfilerImpl::AnalyzeEventsAndWriteResults(), and ProfilerImpl::Print().

◆ Print()

void Print ( std::ostream &  outStream) const

Definition at line 381 of file Profiling.cpp.

382 {
383  // Makes sure timestamps are output with 6 decimals, and save old settings.
384  std::streamsize oldPrecision = outStream.precision();
385  outStream.precision(6);
386  std::ios_base::fmtflags oldFlags = outStream.flags();
387  outStream.setf(std::ios::fixed);
388  JsonPrinter printer(outStream);
389 
390  // First find all the parent Events and print out duration measurements.
391  int baseLevel = -1;
392 
393  std::vector<const Event*> optimizations;
394  PopulateParent(optimizations, baseLevel, "Optimizer");
395 
396  std::vector<const Event*> loadedNetworks;
397  PopulateParent(loadedNetworks, baseLevel, "LoadedNetwork");
398 
399  std::vector<const Event*> inferences;
400  PopulateParent(inferences, baseLevel, "EnqueueWorkload");
401 
402  // Second map out descendants hierarchy
403  std::map<const Event*, std::vector<const Event*>> descendantsMap;
404  PopulateDescendants(descendantsMap);
405 
406  // Extract json objects for each parent event type
407  JsonChildObject optimizeObject{ "optimize_measurements" };
408 
409  for (unsigned int optimizeIndex = 0; optimizeIndex < optimizations.size(); ++optimizeIndex)
410  {
411  auto optimization = optimizations[optimizeIndex];
412  ExtractJsonObjects(optimizeIndex, optimization, optimizeObject, descendantsMap);
413  }
414 
415  JsonChildObject loadedNetworkObject{ "loaded_network_measurements" };
416 
417  for (unsigned int loadedNetworkIndex = 0; loadedNetworkIndex < loadedNetworks.size(); ++loadedNetworkIndex)
418  {
419  auto loadedNetwork = loadedNetworks[loadedNetworkIndex];
420  ExtractJsonObjects(loadedNetworkIndex, loadedNetwork, loadedNetworkObject, descendantsMap);
421  }
422 
423  JsonChildObject inferenceObject{ "inference_measurements" };
424 
425  for (unsigned int inferenceIndex = 0; inferenceIndex < inferences.size(); ++inferenceIndex)
426  {
427  auto inference = inferences[inferenceIndex];
428  ExtractJsonObjects(inferenceIndex, inference, inferenceObject, descendantsMap);
429  }
430 
431  printer.PrintHeader();
432  printer.PrintArmNNHeader();
433 
434  if (m_ProfilingDetails.get()->DetailsExist() &&
437  {
438  JsonChildObject detailsObject{ "layer_details" };
440  {
441  detailsObject.EnableDetailsOnly();
442  }
443  detailsObject.SetType(JsonObjectType::ExecObjectDesc);
444  detailsObject.SetAndParseDetails(m_ProfilingDetails.get()->GetProfilingDetails());
445 
446  size_t id = 0;
447  printer.PrintJsonChildObject(detailsObject, id);
448  }
449 
450  // print inference object, also prints child layer and kernel measurements
451  size_t id = 0;
453  {
454  printer.PrintJsonChildObject(optimizeObject, id);
455  printer.PrintSeparator();
456  printer.PrintNewLine();
457  printer.PrintJsonChildObject(loadedNetworkObject, id);
458  printer.PrintSeparator();
459  printer.PrintNewLine();
460  printer.PrintJsonChildObject(inferenceObject, id);
461  printer.PrintNewLine();
462  }
463  // end of ArmNN
464  printer.PrintFooter();
465 
466  // end of main JSON object
467  printer.PrintNewLine();
468  printer.PrintFooter();
469  printer.PrintNewLine();
470 
471  // Restores previous precision settings.
472  outStream.flags(oldFlags);
473  outStream.precision(oldPrecision);
474 
476  {
477  exit(0);
478  }
479 }

References armnn::DetailsOnly, armnn::DetailsWithEvents, JsonChildObject::EnableDetailsOnly(), armnn::ExecObjectDesc, armnn::ExtractJsonObjects(), ProfilerImpl::m_DetailsToStdOutMethod, ProfilerImpl::m_ProfilingDetails, ProfilerImpl::PopulateDescendants(), ProfilerImpl::PopulateParent(), JsonUtils::PrintArmNNHeader(), JsonUtils::PrintFooter(), JsonUtils::PrintHeader(), JsonPrinter::PrintJsonChildObject(), JsonUtils::PrintNewLine(), and JsonUtils::PrintSeparator().

Referenced by ProfilerImpl::~ProfilerImpl().

◆ UpdateEventTag()

void UpdateEventTag ( )

Member Data Documentation

◆ m_DetailsToStdOutMethod

ProfilingDetailsMethod m_DetailsToStdOutMethod

◆ m_EventSequence

◆ m_Parents

std::stack<Event*> m_Parents

◆ m_ProfilingDetails

DescPtr m_ProfilingDetails = std::make_unique<ProfilingDetails>()

Definition at line 103 of file Profiling.hpp.

Referenced by ProfilerImpl::AddLayerDetails(), and ProfilerImpl::Print().

◆ m_ProfilingEnabled

bool m_ProfilingEnabled

The documentation for this class was generated from the following files:
armnn::Measurement::m_Value
double m_Value
Definition: Instrument.hpp:43
ARMNN_ASSERT
#define ARMNN_ASSERT(COND)
Definition: Assert.hpp:14
armnn::CalcLevel
int CalcLevel(const Event *eventPtr)
Definition: Profiling.cpp:246
armnn::ProfilerImpl::m_Parents
std::stack< Event * > m_Parents
Definition: Profiling.hpp:101
armnn::ProfilerManager::RegisterProfiler
void RegisterProfiler(IProfiler *profiler)
Definition: Profiling.cpp:600
armnn::WallClockTimer::WALL_CLOCK_TIME_STOP
static const std::string WALL_CLOCK_TIME_STOP
Definition: WallClockTimer.hpp:65
armnn::ProfilerImpl::m_EventSequence
std::vector< EventPtr > m_EventSequence
Definition: Profiling.hpp:102
armnn::JsonObjectType::Measurement
@ Measurement
armnn::GetEventPtr
const Event * GetEventPtr(const Event *ptr)
Definition: Profiling.cpp:109
armnn::ProfilerImpl::CalculateProfilingEventStats
std::map< std::string, ProfilingEventStats > CalculateProfilingEventStats() const
Definition: Profiling.cpp:82
armnn::ProfilingDetailsMethod::Undefined
@ Undefined
armnn::ProfilerImpl::PopulateParent
void PopulateParent(std::vector< const Event * > &outEvents, int &outBaseLevel, std::string parentName) const
Definition: Profiling.cpp:257
armnn::ProfilerImpl::m_ProfilingEnabled
bool m_ProfilingEnabled
Definition: Profiling.hpp:104
armnn::g_AggregateProfilingEventsByInference
constexpr bool g_AggregateProfilingEventsByInference
Definition: Profiling.cpp:37
armnn::WallClockTimer::WALL_CLOCK_TIME
static const std::string WALL_CLOCK_TIME
Definition: WallClockTimer.hpp:63
armnn::FindMeasurement
Measurement FindMeasurement(const std::string &name, const Event *event)
Definition: Profiling.cpp:43
armnn::ProfilerImpl::Print
void Print(std::ostream &outStream) const
Definition: Profiling.cpp:381
armnn::g_WriteProfilingEventSequence
constexpr bool g_WriteProfilingEventSequence
Definition: Profiling.cpp:32
armnn::ProfilerImpl::m_DetailsToStdOutMethod
ProfilingDetailsMethod m_DetailsToStdOutMethod
Definition: Profiling.hpp:105
armnn::ProfilerImpl::GetEventColor
uint32_t GetEventColor(const BackendId &backendId) const
Definition: Profiling.cpp:563
armnn::JsonObjectType::ExecObjectDesc
@ ExecObjectDesc
armnn::JsonObjectType::Event
@ Event
armnn::ExtractJsonObjects
void ExtractJsonObjects(unsigned int inferenceIndex, const Event *parentEvent, JsonChildObject &parentObject, std::map< const Event *, std::vector< const Event * >> descendantsMap)
Definition: Profiling.cpp:303
armnn::ProfilingDetailsMethod::DetailsOnly
@ DetailsOnly
armnn::g_WriteReportToStdOutOnProfilerDestruction
constexpr bool g_WriteReportToStdOutOnProfilerDestruction
Definition: Profiling.cpp:41
armnn::ProfilerManager::GetInstance
static ProfilerManager & GetInstance()
Definition: Profiling.cpp:593
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::ProfilerImpl::PopulateDescendants
void PopulateDescendants(std::map< const Event *, std::vector< const Event * >> &outDescendantsMap) const
Definition: Profiling.cpp:271
armnn::ProfilingDetailsMethod::DetailsWithEvents
@ DetailsWithEvents
armnn::ProfilerImpl::AnalyzeEventSequenceAndWriteResults
void AnalyzeEventSequenceAndWriteResults(EventIterType first, EventIterType last, std::ostream &outStream) const
armnn::g_ProfilingEventCountHint
constexpr std::size_t g_ProfilingEventCountHint
Definition: Profiling.cpp:29
armnn::WallClockTimer::WALL_CLOCK_TIME_START
static const std::string WALL_CLOCK_TIME_START
Definition: WallClockTimer.hpp:64
armnn::ProfilerImpl::m_ProfilingDetails
DescPtr m_ProfilingDetails
Definition: Profiling.hpp:103