+ +

#include <Profiling.hpp>

+

+Inheritance diagram for Profiler:

+

+ + + +

+ + + + +

+Public Types
using	InstrumentPtr = std::unique_ptr< Instrument >

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

+Public Member Functions
	Profiler ()

	~Profiler ()

Event *	BeginEvent (const BackendId &backendId, const std::string &name, std::vector< InstrumentPtr > &&instruments)

void	EndEvent (Event *event)

void	EnableProfiling (bool enableProfiling) override
	Enables/disables profiling for this profiler. More...

bool	IsProfilingEnabled () override
	Checks whether profiling is enabled. More...

void	UpdateEventTag ()

void	AnalyzeEventsAndWriteResults (std::ostream &outStream) const override
	Analyzes the tracked events and writes the results to the given output stream. More...

void	Print (std::ostream &outStream) const override
	Print stats for events in JSON Format to the given output stream. More...

uint32_t	GetEventColor (const BackendId &backendId) const

template<typename ItertType >
void	AnalyzeEventSequenceAndWriteResults (ItertType first, ItertType last, std::ostream &outStream) const

+ + + +

+Friends
size_t	GetProfilerEventSequenceSize (armnn::Profiler *profiler)

+ + + + +

+Additional Inherited Members
Protected Member Functions inherited from IProfiler
	~IProfiler ()

+

Detailed Description

+

Definition at line 27 of file Profiling.hpp.

+

Member Typedef Documentation

+ +

◆ InstrumentPtr

+ +

+

+ + + + +

using InstrumentPtr = std::unique_ptr<Instrument>

+

+ +

Definition at line 32 of file Profiling.hpp.

+ +

+

Constructor & Destructor Documentation

+ +

◆ Profiler()

+ +

+

+ + + + + + + +

Profiler ( )

+

+ +

Definition at line 166 of file Profiling.cpp.

+

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

+

+

+ +

◆ ~Profiler()

+ +

+

+ + + + + + + +

~Profiler ( )

+

+ +

Definition at line 177 of file Profiling.cpp.

+ +

References ProfilerManager::GetInstance(), Profiler::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

+ +

◆ AnalyzeEventsAndWriteResults()

+ +

+

+ + + + + +

+ + + + + + + + +

void AnalyzeEventsAndWriteResults ( std::ostream & outStream ) const

+

+overridevirtual

+

+ +

Analyzes the tracked events and writes the results to the given output stream.

+

Please refer to the configuration variables in Profiling.cpp to customize the information written.

Parameters

+ + +

[out] outStream The stream where to write the profiling results to.

+

+ +

Implements IProfiler.

+ +

Definition at line 381 of file Profiling.cpp.

+ +

References armnn::CalcLevel().

+

 {
     // 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;
         PopulateInferences(inferences, baseLevel);
 
         // 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;
                 }
 
                 for (const Event* child : children->second)
                 {
                     return FindDescendantEvents(child, 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()

+ +

+

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

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

+

+ +

Definition at line 115 of file Profiling.cpp.

+ +

References armnn::FindMeasurement(), BackendId::Get(), Event::GetBackendId(), armnn::GetEventPtr(), Event::GetName(), 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	(	const BackendId &	backendId,
		const std::string &	name,
		std::vector< InstrumentPtr > &&	instruments
	)

+

+ +

Definition at line 201 of file Profiling.cpp.

+ +

References Profiler::GetEventColor().

+

 {
     Event* parent = m_Parents.empty() ? nullptr : m_Parents.top();
     m_EventSequence.push_back(std::make_unique<Event>(label, this, parent, backendId, std::move(instruments)));
     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;
 }

+
+

+

+ +

◆ EnableProfiling()

+ +

+

+ + + + + +

+ + + + + + + + +

void EnableProfiling ( bool enableProfiling )

+

+overridevirtual

+

+ +

Enables/disables profiling for this profiler.

+

Parameters

+ + +

[in] enableProfiling A flag that indicates whether profiling should be enabled or not.

+

+ +

Implements IProfiler.

+ +

Definition at line 196 of file Profiling.cpp.

+

 {
     m_ProfilingEnabled = enableProfiling;
 }

+

+ +

◆ EndEvent()

+ +

+

+ + + + + + + + +

void EndEvent ( Event * event )

+

+ +

Definition at line 218 of file Profiling.cpp.

+ +

References Event::GetParentEvent(), and armnn::IgnoreUnused().

+

 {
     event->Stop();
 
     BOOST_ASSERT(!m_Parents.empty());
     BOOST_ASSERT(event == m_Parents.top());
     m_Parents.pop();
 
     Event* parent = m_Parents.empty() ? nullptr : m_Parents.top();
     IgnoreUnused(parent);
     BOOST_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 464 of file Profiling.cpp.

+ +

Referenced by Profiler::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 ( )

+

+overridevirtual

+

+ +

Checks whether profiling is enabled.

+

Profiling is disabled by default.

Returns: true if profiling is enabled, false otherwise.

+ +

Implements IProfiler.

+ +

Definition at line 191 of file Profiling.cpp.

+

 {
     return m_ProfilingEnabled;
 }

+

+ +

◆ Print()

+ +

+

+ + + + + +

+ + + + + + + + +

void Print ( std::ostream & outStream ) const

+

+overridevirtual

+

+ +

Print stats for events in JSON Format to the given output stream.

+

Parameters

+ + +

[out] outStream The stream where to write the profiling results to.

+

+ +

Implements IProfiler.

+ +

Definition at line 331 of file Profiling.cpp.

+ +

References armnn::ExtractJsonObjects(), JsonPrinter::PrintArmNNHeader(), JsonPrinter::PrintFooter(), JsonPrinter::PrintHeader(), JsonPrinter::PrintJsonChildObject(), and JsonPrinter::PrintNewLine().

+ +

Referenced by Profiler::~Profiler().

+

 {
     // 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 "inference" Events and print out duration measurements.
     int baseLevel = -1;
     std::vector<const Event*> inferences;
     PopulateInferences(inferences, baseLevel);
 
     // Second map out descendants hierarchy
     std::map<const Event*, std::vector<const Event*>> descendantsMap;
     PopulateDescendants(descendantsMap);
 
     JsonChildObject inferenceObject{"inference_measurements"};
     JsonChildObject layerObject{"layer_measurements"};
     std::vector<JsonChildObject> workloadObjects;
     std::map<unsigned int, std::vector<JsonChildObject>> workloadToKernelObjects;
 
     for (unsigned int inferenceIndex = 0; inferenceIndex < inferences.size(); ++inferenceIndex)
     {
         auto inference = inferences[inferenceIndex];
         ExtractJsonObjects(inferenceIndex, inference, inferenceObject, descendantsMap);
     }
 
     printer.PrintHeader();
     printer.PrintArmNNHeader();
 
     // print inference object, also prints child layer and kernel measurements
     size_t id=0;
     printer.PrintJsonChildObject(inferenceObject, id);
 
     // end of ArmNN
     printer.PrintNewLine();
     printer.PrintFooter();
 
     // end of main JSON object
     printer.PrintNewLine();
     printer.PrintFooter();
     printer.PrintNewLine();
 
     // Restores previous precision settings.
     outStream.flags(oldFlags);
     outStream.precision(oldPrecision);
 }

+

+

+ +

◆ UpdateEventTag()

+ +

+

+ + + + + + + +

void UpdateEventTag ( )

+

+ +

+

Friends And Related Function Documentation

+ +

◆ GetProfilerEventSequenceSize

+ +

+

+ + + + + +

+ + + + + + + + +

size_t GetProfilerEventSequenceSize ( armnn::Profiler * profiler )

+

+friend

+

+ +

Definition at line 23 of file ProfilerTests.cpp.

+

 {
     if (!profiler)
     {
         return static_cast<size_t>(-1);
     }
 
     return profiler->m_EventSequence.size();
 }

+

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

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

+

+Public Types

+Public Member Functions

+Friends

+Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ InstrumentPtr

Constructor & Destructor Documentation

◆ Profiler()

◆ ~Profiler()

Member Function Documentation

◆ AnalyzeEventsAndWriteResults()

◆ AnalyzeEventSequenceAndWriteResults()

◆ BeginEvent()

◆ EnableProfiling()

◆ EndEvent()

◆ GetEventColor()

◆ IsProfilingEnabled()

◆ Print()

◆ UpdateEventTag()

Friends And Related Function Documentation

◆ GetProfilerEventSequenceSize