Profiler Class Reference

#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 165 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 176 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 380 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 114 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 200 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 195 of file Profiling.cpp.

{
    m_ProfilingEnabled = enableProfiling;
}

EndEvent()

void EndEvent

(

Event *

event

)

Definition at line 217 of file Profiling.cpp.

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

{
    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 463 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 190 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 330 of file Profiling.cpp.

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

Referenced by BOOST_AUTO_TEST_CASE(), and 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 22 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