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

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

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

~ProfilerImpl()

~ProfilerImpl

(

)

Definition at line 176 of file Profiling.cpp.

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

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.

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

References ProfilerImpl::m_ProfilingDetails.

AnalyzeEventsAndWriteResults()

void AnalyzeEventsAndWriteResults

(

std::ostream &

outStream

)

const

Definition at line 490 of file Profiling.cpp.

{
    // 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++;
        }
    }
}

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

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.

{
    // 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;
}

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.

{
    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;
}

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.

{
    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;
}

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.

{
    m_DetailsToStdOutMethod = details;
}

References ProfilerImpl::m_DetailsToStdOutMethod.

EnableProfiling()

void EnableProfiling

(

bool

enableProfiling

)

Definition at line 195 of file Profiling.cpp.

{
    m_ProfilingEnabled = enableProfiling;
}

References ProfilerImpl::m_ProfilingEnabled.

EndEvent()

void EndEvent

(

Event *

event

)

Definition at line 229 of file Profiling.cpp.

{
    event->Stop();
 
    if (!!m_Parents.empty())
    {
        throw armnn::Exception("m_Parents must not be empty.");
    }
 
    if (event != m_Parents.top())
    {
        throw armnn::Exception("event must match the top of m_Parents.");
    }
 
    m_Parents.pop();
 
    Event* parent = m_Parents.empty() ? nullptr : m_Parents.top();
 
    if (event->GetParentEvent() != parent)
    {
        throw armnn::Exception("parent events must match.");
    }
 
#if ARMNN_STREAMLINE_ENABLED
    ANNOTATE_CHANNEL_END(uint32_t(m_Parents.size()));
#endif
}

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

GetEventColor()

std::uint32_t GetEventColor

(

const BackendId &

backendId

)

const

Definition at line 572 of file Profiling.cpp.

{
    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;
    }
}

Referenced by ProfilerImpl::BeginEvent().

IsProfilingEnabled()

bool IsProfilingEnabled

(

)

Definition at line 190 of file Profiling.cpp.

{
    return m_ProfilingEnabled;
}

References ProfilerImpl::m_ProfilingEnabled.

PopulateDescendants()

void PopulateDescendants

(

std::map< const Event *, std::vector< const Event * >> &

outDescendantsMap

)

const

Definition at line 282 of file Profiling.cpp.

{
    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);
        }
    }
}

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 268 of file Profiling.cpp.

{
    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);
        }
    }
}

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 395 of file Profiling.cpp.

{
    // 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);
 
}

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

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