ClBackendContext Class Reference

#include <ClBackendContext.hpp>

Inheritance diagram for ClBackendContext:

Collaboration diagram for ClBackendContext:

Public Member Functions
	ClBackendContext (const IRuntime::CreationOptions &options)
bool	BeforeLoadNetwork (NetworkId networkId) override
	Before and after Load network events.
bool	AfterLoadNetwork (NetworkId networkId) override
bool	BeforeUnloadNetwork (NetworkId networkId) override
	Before and after Unload network events.
bool	AfterUnloadNetwork (NetworkId networkId) override
bool	AfterEnqueueWorkload (NetworkId networkId) override
	~ClBackendContext () override
Public Member Functions inherited from IBackendContext
virtual	~IBackendContext ()

Protected Attributes
arm_compute::CLGEMMHeuristicsHandle	m_MLGOTuner
std::string	m_MLGOTuningFile

Additional Inherited Members
Protected Member Functions inherited from IBackendContext
	IBackendContext (const IRuntime::CreationOptions &)

Detailed Description

Definition at line 17 of file ClBackendContext.hpp.

Constructor & Destructor Documentation

ClBackendContext()

ClBackendContext

(

const IRuntime::CreationOptions &

options

)

Definition at line 61 of file ClBackendContext.cpp.

    : IBackendContext(options)
    , m_TuningFile()
{
    bool kernelProfiling = options.m_EnableGpuProfiling;
 
    arm_compute::CLTuner* tuner = nullptr;
    arm_compute::CLGEMMHeuristicsHandle* mlgoTuner = nullptr;
    bool useLegacyTunerAPI = options.m_GpuAccTunedParameters.get() != nullptr;
    if (useLegacyTunerAPI)
    {
        auto clTunerParams = PolymorphicDowncast<ClTunedParameters*>(
                                options.m_GpuAccTunedParameters.get());
        tuner = &clTunerParams->m_Tuner;
 
        if (tuner)
        {
            auto ConvertTuningLevel = [](IGpuAccTunedParameters::TuningLevel level,
                                         armnn::IGpuAccTunedParameters::Mode mode)
                {
                    if (mode == armnn::IGpuAccTunedParameters::Mode::UseTunedParameters)
                    {
                        return TuningLevel::None;
                    }
 
                    switch(level)
                    {
                        case IGpuAccTunedParameters::TuningLevel::Rapid:
                            return TuningLevel::Rapid;
                        case IGpuAccTunedParameters::TuningLevel::Normal:
                            return TuningLevel::Normal;
                        case IGpuAccTunedParameters::TuningLevel::Exhaustive:
                            return TuningLevel::Exhaustive;
                        default:
                        {
                            throw InvalidArgumentException("Invalid value of tuning level specified.");
                        }
                    }
                };
 
            TuningLevel tuningLevel = ConvertTuningLevel(clTunerParams->m_TuningLevel, clTunerParams->m_Mode);
            ConfigureTuner(*tuner, tuningLevel);
        }
    }
    else //New backend options API
    {
        const TuningLevel defaultTuningLevel = TuningLevel::None;
        auto tuningLevel = defaultTuningLevel;
 
        ParseOptions(options.m_BackendOptions, "GpuAcc", [&](std::string name, const BackendOptions::Var& value)
            {
                if (name == "KernelProfilingEnabled")
                {
                    kernelProfiling |= ParseBooleanBackendOption(value, false);
                } else if (name == "TuningFile")
                {
                    m_TuningFile = ParseStringBackendOption(value, "");
                } else if (name == "TuningLevel")
                {
                    tuningLevel = ParseTuningLevel(value, defaultTuningLevel);
                }
                else if (name == "MLGOTuningFilePath")
                {
                    m_MLGOTuningFile = ParseStringBackendOption(value, "");
                }
            });
 
        // Create the tuner, in tuning mode initially.
        m_Tuner = std::make_unique<arm_compute::CLTuner>(true);
 
        ConfigureTuner(*(m_Tuner.get()), tuningLevel);
 
        if (!m_TuningFile.empty())
        {
            try
            {
                ARMNN_LOG(info) << "Loading Gpu tuning data from file: " << m_TuningFile;
                m_Tuner->load_from_file(m_TuningFile.c_str());
            }
            catch (const std::exception& e)
            {
                // Warn if not tuning, otherwise tuning will generate new params
                if (tuningLevel == TuningLevel::None)
                {
                    ARMNN_LOG(warning) << "Could not load GpuAcc tuner data file.";
                }
            }
        }
 
        if (!m_MLGOTuningFile.empty())
        {
            try
            {
                ARMNN_LOG(info) << "Loading Gpu MLGO tuning data from file: " << m_TuningFile;
                if(m_MLGOTuner.reload_from_file(m_MLGOTuningFile.c_str()))
                {
                    mlgoTuner = &m_MLGOTuner;
                }
            }
            catch (const std::exception& e)
            {
                ARMNN_LOG(warning) << "Could not load GpuAcc MLGO tuner data file.";
            }
        }
 
        tuner = m_Tuner.get();
    }
 
    m_ClContextControlWrapper = std::make_unique<ClContextControlWrapper>(
            tuner,
            mlgoTuner,
            kernelProfiling
    );
}

References ARMNN_LOG, armnn::ConfigureTuner(), IGpuAccTunedParameters::Exhaustive, armnn::Exhaustive, IBackendContext::IBackendContext(), armnn::info, IRuntime::CreationOptions::m_BackendOptions, IRuntime::CreationOptions::m_EnableGpuProfiling, IRuntime::CreationOptions::m_GpuAccTunedParameters, m_MLGOTuner, m_MLGOTuningFile, armnn::None, IGpuAccTunedParameters::Normal, armnn::Normal, armnn::ParseOptions(), armnn::ParseStringBackendOption(), armnn::ParseTuningLevel(), armnn::PolymorphicDowncast(), IGpuAccTunedParameters::Rapid, armnn::Rapid, IGpuAccTunedParameters::UseTunedParameters, and armnn::warning.

~ClBackendContext()

~ClBackendContext ( )

override

Definition at line 217 of file ClBackendContext.cpp.

{
    if (m_Tuner && !m_TuningFile.empty())
    {
        try
        {
            m_Tuner->save_to_file(m_TuningFile.c_str());
        }
        catch(const std::exception& e)
        {
            ARMNN_LOG(warning) << "Could not save GpuAcc tuner data to file " << m_TuningFile;
        }
    }
}

References ARMNN_LOG, armnn::warning, and ~ClBackendContext().

Referenced by ~ClBackendContext().

Member Function Documentation

AfterEnqueueWorkload()

bool AfterEnqueueWorkload ( NetworkId networkId )

overridevirtual

Implements IBackendContext.

Definition at line 212 of file ClBackendContext.cpp.

{
    return m_ClContextControlWrapper->Sync();
}

References AfterEnqueueWorkload().

Referenced by AfterEnqueueWorkload().

AfterLoadNetwork()

bool AfterLoadNetwork ( NetworkId networkId )

overridevirtual

Implements IBackendContext.

Definition at line 181 of file ClBackendContext.cpp.

{
    {
        std::lock_guard<std::mutex> lockGuard(m_Mutex);
        m_NetworkIds.insert(networkId);
    }
    return true;
}

References AfterLoadNetwork().

Referenced by AfterLoadNetwork().

AfterUnloadNetwork()

bool AfterUnloadNetwork ( NetworkId networkId )

overridevirtual

Implements IBackendContext.

Definition at line 195 of file ClBackendContext.cpp.

{
    bool clearCache = false;
    {
        std::lock_guard<std::mutex> lockGuard(m_Mutex);
        m_NetworkIds.erase(networkId);
        clearCache = m_NetworkIds.empty();
    }
 
    if (clearCache)
    {
        m_ClContextControlWrapper->ClearClCache();
    }
 
    return true;
}

References AfterUnloadNetwork().

Referenced by AfterUnloadNetwork().

BeforeLoadNetwork()

bool BeforeLoadNetwork ( NetworkId networkId )

overridevirtual

Before and after Load network events.

Implements IBackendContext.

Definition at line 176 of file ClBackendContext.cpp.

{
    return true;
}

References BeforeLoadNetwork().

Referenced by BeforeLoadNetwork().

BeforeUnloadNetwork()

bool BeforeUnloadNetwork ( NetworkId networkId )

overridevirtual

Before and after Unload network events.

Implements IBackendContext.

Definition at line 190 of file ClBackendContext.cpp.

{
    return m_ClContextControlWrapper->Sync();
}

References BeforeUnloadNetwork().

Referenced by BeforeUnloadNetwork().

Member Data Documentation

m_MLGOTuner

arm_compute::CLGEMMHeuristicsHandle m_MLGOTuner

protected

Definition at line 43 of file ClBackendContext.hpp.

Referenced by ClBackendContext().

m_MLGOTuningFile

std::string m_MLGOTuningFile

protected

Definition at line 44 of file ClBackendContext.hpp.

Referenced by ClBackendContext().

---

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

• src/backends/cl/ClBackendContext.hpp
• src/backends/cl/ClBackendContext.cpp