+ +

#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 ()

Event *	BeginEvent (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, ProfilingEventStats >	CalculateProfilingEventStats () 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< EventPtr >	m_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()

+ +

+

+ + + + + + + +

ProfilerImpl ( )

+

+ +

Definition at line 164 of file Profiling.cpp.

+ +

References ProfilerImpl::m_EventSequence.

+

     : m_ProfilingEnabled(false),
       m_DetailsToStdOutMethod(ProfilingDetailsMethod::Undefined)
 {
     m_EventSequence.reserve(g_ProfilingEventCountHint);
 
 #if ARMNN_STREAMLINE_ENABLED
     // Initialises streamline annotations.
     ANNOTATE_SETUP;
 #endif
 }

+
+
+
+
+

+

+ +

◆ ~ProfilerImpl()

+ +

+

+ + + + + + + +

~ProfilerImpl ( )

+

+ +

Definition at line 176 of file Profiling.cpp.

+ +

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

+

 {
     if (m_ProfilingEnabled)
     {
         if (g_WriteReportToStdOutOnProfilerDestruction)
         {
             Print(std::cout);
         }
     }
 
     // Un-register this profiler from the current thread.
     ProfilerManager::GetInstance().RegisterProfiler(nullptr);
 }

+
+
+
+
+

+

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.

+ +

References ProfilerImpl::AnalyzeEventsAndWriteResults(), ProfilerImpl::EnableNetworkDetailsToStdOut(), ProfilerImpl::EnableProfiling(), ProfilerImpl::EndEvent(), ProfilerImpl::GetEventColor(), ProfilerImpl::IsProfilingEnabled(), ProfilerImpl::m_ProfilingDetails, ProfilerImpl::Print(), and ProfilerImpl::UpdateEventTag().

+

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

+

+

+ +

◆ AnalyzeEventsAndWriteResults()

+ +

+

+ + + + + + + + +

void AnalyzeEventsAndWriteResults ( std::ostream & outStream ) const

+

+ +

Definition at line 460 of file Profiling.cpp.

+ +

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

+ +

Referenced by ProfilerImpl::AddLayerDetails().

+

 {
     // Stack should be empty now.
     const bool saneMarkerSequence = m_Parents.empty();
 
     // Abort if the sequence of markers was found to have incorrect information:
     // The stats cannot be trusted.
     if (!saneMarkerSequence)
     {
         outStream << "Cannot write profiling stats. "
                      "Unexpected errors were found when analyzing the sequence of logged events, "
                      "which may lead to plainly wrong stats. The profiling system may contain implementation "
                      "issues or could have been used in an unsafe manner." << std::endl;
         return;
     }
 
     // Analyzes the full sequence of events.
     AnalyzeEventSequenceAndWriteResults(m_EventSequence.cbegin(),
                                         m_EventSequence.cend(),
                                         outStream);
 
     // Aggregates events by tag if requested (spams the output stream if done for all tags).
     if (g_AggregateProfilingEventsByInference)
     {
         outStream << std::endl;
         outStream << "***" << std::endl;
         outStream << "*** Per Inference Stats" << std::endl;
         outStream << "***" << std::endl;
         outStream << std::endl;
 
         int baseLevel = -1;
         std::vector<const Event*> inferences;
         PopulateParent(inferences, baseLevel, "EnqueueWorkload");
 
         // Second map out descendants hierarchy
         std::map<const Event*, std::vector<const Event*>> descendantsMap;
         PopulateDescendants(descendantsMap);
 
         std::function<void(const Event*, std::vector<const Event*>&)>
             FindDescendantEvents = [&](const Event* eventPtr, std::vector<const Event*>& sequence)
             {
                 sequence.push_back(eventPtr);
 
                 if (CalcLevel(eventPtr) > baseLevel+2) //We only care about levels as deep as workload executions.
                 {
                     return;
                 }
 
                 auto children = descendantsMap.find(eventPtr);
                 if (children == descendantsMap.end())
                 {
                     return;
                 }
 
                 if (!(children->second.empty()))
                 {
                     return FindDescendantEvents(children->second[0], sequence);
                 }
             };
 
         // Third, find events belonging to each inference
         int inferenceIdx = 0;
         for (auto inference : inferences)
         {
             std::vector<const Event*> sequence;
 
             //build sequence, depth first
             FindDescendantEvents(inference, sequence);
 
             outStream << "> Begin Inference: " << inferenceIdx << std::endl;
             outStream << std::endl;
             AnalyzeEventSequenceAndWriteResults(sequence.cbegin(),
                                                 sequence.cend(),
                                                 outStream);
             outStream << std::endl;
             outStream << "> End Inference: " << inferenceIdx << std::endl;
 
             inferenceIdx++;
         }
     }
 }

+
+
+
+
+
+
+
+

+

+ +

◆ AnalyzeEventSequenceAndWriteResults() [1/2]

+ +

+

+ + + + + + + + + + + + + + + + + + + + + + + + +

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

+

+ +

Referenced by ProfilerImpl::AnalyzeEventsAndWriteResults().

+ +

+

+ +

◆ AnalyzeEventSequenceAndWriteResults() [2/2]

+ +

+

+ + + + + + + + + + + + + + + + + + + + + + + + +

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

+

+ +

Definition at line 113 of file Profiling.cpp.

+ +

References ProfilerImpl::CalculateProfilingEventStats(), armnn::FindMeasurement(), 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.

+

 {
     // Outputs event sequence, if needed.
     if (g_WriteProfilingEventSequence)
     {
         // Makes sure timestamps are output with 6 decimals, and save old settings.
         std::streamsize oldPrecision = outStream.precision();
         outStream.precision(6);
         std::ios_base::fmtflags oldFlags = outStream.flags();
         outStream.setf(std::ios::fixed);
         // Outputs fields.
         outStream << "Event Sequence - Name | Duration (ms) | Start (ms) | Stop (ms) | Device" << std::endl;
         for (auto event = first; event != last; ++event)
         {
             const Event* eventPtr = GetEventPtr((*event));
             double startTimeMs = FindMeasurement(WallClockTimer::WALL_CLOCK_TIME_START, eventPtr).m_Value;
             double stopTimeMs = FindMeasurement(WallClockTimer::WALL_CLOCK_TIME_STOP, eventPtr).m_Value;
 
             // Find the WallClock measurement if there is one.
             double durationMs = FindMeasurement(WallClockTimer::WALL_CLOCK_TIME, eventPtr).m_Value;
             outStream << std::setw(50) << eventPtr->GetName() << " "
                       << std::setw(20) << durationMs
                       << std::setw(20) << startTimeMs
                       << std::setw(20) << stopTimeMs
                       << std::setw(20) << eventPtr->GetBackendId().Get()
                       << std::endl;
         }
         outStream << std::endl;
         // Restores previous precision settings.
         outStream.flags(oldFlags);
         outStream.precision(oldPrecision);
     }
 
     // Aggregates results per event name.
     std::map<std::string, ProfilingEventStats> nameToStatsMap = CalculateProfilingEventStats();
 
     // Outputs aggregated stats.
     outStream << "Event Stats - Name | Avg (ms) | Min (ms) | Max (ms) | Total (ms) | Count" << std::endl;
     for (const auto& pair : nameToStatsMap)
     {
         const std::string& eventLabel = pair.first;
         const ProfilingEventStats& eventStats = pair.second;
         const double avgMs = eventStats.m_TotalMs / double(eventStats.m_Count);
 
         outStream << "\t" << std::setw(50) << eventLabel << " " << std::setw(9) << avgMs << " "
                   << std::setw(9) << eventStats.m_MinMs << " " << std::setw(9) << eventStats.m_MaxMs << " "
                   << std::setw(9) << eventStats.m_TotalMs << " " << std::setw(9) << eventStats.m_Count << std::endl;
     }
     outStream << std::endl;
 }

+
+
+
+
+
+
+
+
+

+

+ +

◆ 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.

+ +

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

+

 {
     Event* parent = m_Parents.empty() ? nullptr : m_Parents.top();
     m_EventSequence.push_back(std::make_unique<Event>(label,
                                                       profiler,
                                                       parent,
                                                       backendId,
                                                       std::move(instruments),
                                                       guid));
     Event* event = m_EventSequence.back().get();
     event->Start();
 
 #if ARMNN_STREAMLINE_ENABLED
     ANNOTATE_CHANNEL_COLOR(uint32_t(m_Parents.size()), GetEventColor(backendId), label.c_str());
 #endif
 
     m_Parents.push(event);
     return event;
 }

+
+
+
+

+

+ +

◆ CalculateProfilingEventStats()

+ +

+

+ + + + + + + +

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

+

+ +

Definition at line 82 of file Profiling.cpp.

+ +

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().

+

 {
     std::map<std::string, ProfilingEventStats> nameToStatsMap;
 
     for (const auto& event : m_EventSequence)
     {
         Measurement measurement = FindMeasurement(WallClockTimer::WALL_CLOCK_TIME, event.get());
 
         double durationMs = measurement.m_Value;
         auto it = nameToStatsMap.find(event->GetName());
         if (it != nameToStatsMap.end())
         {
             ProfilingEventStats& stats = it->second;
             stats.m_TotalMs += durationMs;
             stats.m_MinMs = std::min(stats.m_MinMs, durationMs);
             stats.m_MaxMs = std::max(stats.m_MaxMs, durationMs);
             ++stats.m_Count;
         }
         else
         {
             nameToStatsMap.emplace(event->GetName(), ProfilingEventStats{ durationMs, durationMs, durationMs, 1 });
         }
     }
 
     return nameToStatsMap;
 }

+
+
+
+
+

+

+ +

◆ EnableNetworkDetailsToStdOut()

+ +

+

+ + + + + + + + +

void EnableNetworkDetailsToStdOut ( ProfilingDetailsMethod detailsMethod )

+

+ +

Definition at line 200 of file Profiling.cpp.

+ +

References ProfilerImpl::m_DetailsToStdOutMethod.

+ +

Referenced by ProfilerImpl::AddLayerDetails().

+

 {
     m_DetailsToStdOutMethod = details;
 }

+

+

+ +

◆ EnableProfiling()

+ +

+

+ + + + + + + + +

void EnableProfiling ( bool enableProfiling )

+

+ +

Definition at line 195 of file Profiling.cpp.

+ +

References ProfilerImpl::m_ProfilingEnabled.

+ +

Referenced by ProfilerImpl::AddLayerDetails().

+

 {
     m_ProfilingEnabled = enableProfiling;
 }

+

+

+ +

◆ EndEvent()

+ +

+

+ + + + + + + + +

void EndEvent ( Event * event )

+

+ +

Definition at line 229 of file Profiling.cpp.

+ +

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

+ +

Referenced by ProfilerImpl::AddLayerDetails().

+

 {
     event->Stop();
 
     ARMNN_ASSERT(!m_Parents.empty());
     ARMNN_ASSERT(event == m_Parents.top());
     m_Parents.pop();
 
     Event* parent = m_Parents.empty() ? nullptr : m_Parents.top();
     IgnoreUnused(parent);
     ARMNN_ASSERT(event->GetParentEvent() == parent);
 
 #if ARMNN_STREAMLINE_ENABLED
     ANNOTATE_CHANNEL_END(uint32_t(m_Parents.size()));
 #endif
 }

+
+
+
+

+

+ +

◆ GetEventColor()

+ +

+

+ + + + + + + + +

std::uint32_t GetEventColor ( const BackendId & backendId ) const

+

+ +

Definition at line 542 of file Profiling.cpp.

+ +

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

+

 {
     static BackendId cpuRef("CpuRef");
     static BackendId cpuAcc("CpuAcc");
     static BackendId gpuAcc("GpuAcc");
     if (backendId == cpuRef)
     {
         // Cyan
         return 0xffff001b;
     }
     else if (backendId == cpuAcc)
     {
         // Green
         return 0x00ff001b;
     }
     else if (backendId == gpuAcc)
     {
         // Purple
         return 0xff007f1b;
     }
     else
     {
         // Dark gray
         return 0x5555551b;
     }
 }

+

+ +

◆ IsProfilingEnabled()

+ +

+

+ + + + + + + +

bool IsProfilingEnabled ( )

+

+ +

Definition at line 190 of file Profiling.cpp.

+ +

References ProfilerImpl::m_ProfilingEnabled.

+ +

Referenced by ProfilerImpl::AddLayerDetails().

+

 {
     return m_ProfilingEnabled;
 }

+

+

+ +

◆ PopulateDescendants()

+ +

+

+ + + + + + + + +

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

+

+ +

Definition at line 271 of file Profiling.cpp.

+ +

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

+ +

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

+

 {
     for (const auto& event : m_EventSequence)
     {
         const Event* eventPtrRaw = event.get();
         const Event* parent = eventPtrRaw->GetParentEvent();
 
         if (!parent)
         {
             continue;
         }
 
         auto it = outDescendantsMap.find(parent);
         if (it == outDescendantsMap.end())
         {
             outDescendantsMap.emplace(parent, std::vector<const Event*>({ eventPtrRaw }));
         }
         else
         {
             it->second.push_back(eventPtrRaw);
         }
     }
 }

+
+

+

+ +

◆ PopulateParent()

+ +

+

+ + + + + + + + + + + + + + + + + + + + + + + + +

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

+

+ +

Definition at line 257 of file Profiling.cpp.

+ +

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

+ +

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

+

 {
     outEvents.reserve(m_EventSequence.size());
     for (const auto& event : m_EventSequence)
     {
         const Event* eventPtrRaw = event.get();
         if (eventPtrRaw->GetName() == parentName)
         {
             outBaseLevel = (outBaseLevel == -1) ? CalcLevel(eventPtrRaw) : outBaseLevel;
             outEvents.push_back(eventPtrRaw);
         }
     }
 }

+
+
+

+

+ +

◆ Print()

+ +

+

+ + + + + + + + +

void Print ( std::ostream & outStream ) const

+

+ +

Definition at line 360 of file Profiling.cpp.

+ +

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::AddLayerDetails(), and ProfilerImpl::~ProfilerImpl().

+

 {
     // Makes sure timestamps are output with 6 decimals, and save old settings.
     std::streamsize oldPrecision = outStream.precision();
     outStream.precision(6);
     std::ios_base::fmtflags oldFlags = outStream.flags();
     outStream.setf(std::ios::fixed);
     JsonPrinter printer(outStream);
 
     // First find all the parent Events and print out duration measurements.
     int baseLevel = -1;
 
     std::vector<const Event*> optimizations;
     PopulateParent(optimizations, baseLevel, "Optimizer");
 
     std::vector<const Event*> loadedNetworks;
     PopulateParent(loadedNetworks, baseLevel, "LoadedNetwork");
 
     std::vector<const Event*> inferences;
     PopulateParent(inferences, baseLevel, "EnqueueWorkload");
 
     // Second map out descendants hierarchy
     std::map<const Event*, std::vector<const Event*>> descendantsMap;
     PopulateDescendants(descendantsMap);
 
     // Extract json objects for each parent event type
     JsonChildObject optimizeObject{ "optimize_measurements" };
 
     for (unsigned int optimizeIndex = 0; optimizeIndex < optimizations.size(); ++optimizeIndex)
     {
         auto optimization = optimizations[optimizeIndex];
         ExtractJsonObjects(optimizeIndex, optimization, optimizeObject, descendantsMap);
     }
 
     JsonChildObject loadedNetworkObject{ "loaded_network_measurements" };
 
     for (unsigned int loadedNetworkIndex = 0; loadedNetworkIndex < loadedNetworks.size(); ++loadedNetworkIndex)
     {
         auto loadedNetwork = loadedNetworks[loadedNetworkIndex];
         ExtractJsonObjects(loadedNetworkIndex, loadedNetwork, loadedNetworkObject, descendantsMap);
     }
 
     JsonChildObject inferenceObject{ "inference_measurements" };
 
     for (unsigned int inferenceIndex = 0; inferenceIndex < inferences.size(); ++inferenceIndex)
     {
         auto inference = inferences[inferenceIndex];
         ExtractJsonObjects(inferenceIndex, inference, inferenceObject, descendantsMap);
     }
 
     printer.PrintHeader();
     printer.PrintArmNNHeader();
 
     if (m_ProfilingDetails.get()->DetailsExist() &&
         (m_DetailsToStdOutMethod == ProfilingDetailsMethod::DetailsOnly
          || m_DetailsToStdOutMethod == ProfilingDetailsMethod::DetailsWithEvents))
     {
         JsonChildObject detailsObject{ "layer_details" };
         if (m_DetailsToStdOutMethod == ProfilingDetailsMethod::DetailsOnly)
         {
             detailsObject.EnableDetailsOnly();
         }
         detailsObject.SetType(JsonObjectType::ExecObjectDesc);
         detailsObject.SetAndParseDetails(m_ProfilingDetails.get()->GetProfilingDetails());
 
         size_t id = 0;
         printer.PrintJsonChildObject(detailsObject, id);
     }
 
     // print inference object, also prints child layer and kernel measurements
     size_t id = 0;
     if (m_DetailsToStdOutMethod != ProfilingDetailsMethod::DetailsOnly)
     {
         printer.PrintJsonChildObject(optimizeObject, id);
         printer.PrintSeparator();
         printer.PrintNewLine();
         printer.PrintJsonChildObject(loadedNetworkObject, id);
         printer.PrintSeparator();
         printer.PrintNewLine();
         printer.PrintJsonChildObject(inferenceObject, id);
         printer.PrintNewLine();
     }
     // end of ArmNN
     printer.PrintFooter();
 
     // end of main JSON object
     printer.PrintNewLine();
     printer.PrintFooter();
     printer.PrintNewLine();
 
     // Restores previous precision settings.
     outStream.flags(oldFlags);
     outStream.precision(oldPrecision);
 
     if (m_DetailsToStdOutMethod == ProfilingDetailsMethod::DetailsOnly)
     {
         exit(0);
     }
 }

+
+
+
+
+
+
+
+

+

+ +

◆ UpdateEventTag()

+ +

+

+ + + + + + + +

void UpdateEventTag ( )

+

+ +

Referenced by ProfilerImpl::AddLayerDetails().

+ +

+

Member Data Documentation

+ +

◆ m_DetailsToStdOutMethod

+ +

+

+ + + + +

ProfilingDetailsMethod m_DetailsToStdOutMethod

+

+ +

Definition at line 105 of file Profiling.hpp.

+ +

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

+ +

+

+ +

◆ m_EventSequence

+ +

+

+ + + + +

std::vector<EventPtr> m_EventSequence

+

+ +

Definition at line 102 of file Profiling.hpp.

+ +

Referenced by ProfilerImpl::AnalyzeEventsAndWriteResults(), ProfilerImpl::BeginEvent(), ProfilerImpl::CalculateProfilingEventStats(), ProfilerImpl::PopulateDescendants(), ProfilerImpl::PopulateParent(), and ProfilerImpl::ProfilerImpl().

+ +

+

+ +

◆ m_Parents

+ +

+

+ + + + +

std::stack<Event*> m_Parents

+

+ +

Definition at line 101 of file Profiling.hpp.

+ +

Referenced by ProfilerImpl::AnalyzeEventsAndWriteResults(), ProfilerImpl::BeginEvent(), and ProfilerImpl::EndEvent().

+ +

+

+ +

◆ 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

+

+ +

Definition at line 104 of file Profiling.hpp.

+ +

Referenced by ProfilerImpl::EnableProfiling(), ProfilerImpl::IsProfilingEnabled(), and ProfilerImpl::~ProfilerImpl().

+ +

+

The documentation for this class was generated from the following files:

src/armnn/Profiling.hpp
src/armnn/Profiling.cpp

+

+Classes

+Public Types

+Public Member Functions

+Public Attributes

Detailed Description

Member Typedef Documentation

◆ DescPtr

◆ EventPtr

◆ InstrumentPtr

Constructor & Destructor Documentation

◆ ProfilerImpl()

◆ ~ProfilerImpl()

Member Function Documentation

◆ AddLayerDetails()

◆ AnalyzeEventsAndWriteResults()

◆ AnalyzeEventSequenceAndWriteResults() [1/2]

◆ AnalyzeEventSequenceAndWriteResults() [2/2]

◆ BeginEvent()

◆ CalculateProfilingEventStats()

◆ EnableNetworkDetailsToStdOut()

◆ EnableProfiling()

◆ EndEvent()

◆ GetEventColor()

◆ IsProfilingEnabled()

◆ PopulateDescendants()

◆ PopulateParent()

◆ Print()

◆ UpdateEventTag()

Member Data Documentation

◆ m_DetailsToStdOutMethod

◆ m_EventSequence

◆ m_Parents

◆ m_ProfilingDetails

◆ m_ProfilingEnabled