ClBackendContext Class Reference

#include <ClBackendContext.hpp>

Inheritance diagram for ClBackendContext:

Public Member Functions
	ClBackendContext (const IRuntime::CreationOptions &options)
bool	BeforeLoadNetwork (NetworkId networkId) override
	Before and after Load network events. More...
bool	AfterLoadNetwork (NetworkId networkId) override
bool	BeforeUnloadNetwork (NetworkId networkId) override
	Before and after Unload network events. More...
bool	AfterUnloadNetwork (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 140 of file ClBackendContext.cpp.

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

Referenced by BOOST_AUTO_TEST_CASE().

    : 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:
                        {
                            ARMNN_ASSERT_MSG(false, "Tuning level not recognised.");
                            return TuningLevel::None;
                        }
                    }
                };

            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 |= ParseBoolean(value, false);
                } else if (name == "TuningFile")
                {
                    m_TuningFile = ParseFile(value, "");
                } else if (name == "TuningLevel")
                {
                    tuningLevel = ParseTuningLevel(value, defaultTuningLevel);
                }
                else if (name == "MLGOTuningFilePath")
                {
                    m_MLGOTuningFile = ParseFile(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() && tuningLevel == TuningLevel::None)
        {
            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)
            {
                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
    );
}

~ClBackendContext()

~ClBackendContext ( )

override

Definition at line 288 of file ClBackendContext.cpp.

References ARMNN_LOG, and armnn::warning.

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

Member Function Documentation

AfterLoadNetwork()

bool AfterLoadNetwork ( NetworkId  networkId )

overridevirtual

Implements IBackendContext.

Definition at line 257 of file ClBackendContext.cpp.

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

AfterUnloadNetwork()

bool AfterUnloadNetwork ( NetworkId  networkId )

overridevirtual

Implements IBackendContext.

Definition at line 271 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;
}

BeforeLoadNetwork()

bool BeforeLoadNetwork ( NetworkId  networkId )

overridevirtual

Before and after Load network events.

Implements IBackendContext.

Definition at line 252 of file ClBackendContext.cpp.

{
    return true;
}

BeforeUnloadNetwork()

bool BeforeUnloadNetwork ( NetworkId  networkId )

overridevirtual

Before and after Unload network events.

Implements IBackendContext.

Definition at line 266 of file ClBackendContext.cpp.

{
    return m_ClContextControlWrapper->Sync();
}

Member Data Documentation

m_MLGOTuner

arm_compute::CLGEMMHeuristicsHandle m_MLGOTuner

protected

Definition at line 41 of file ClBackendContext.hpp.

Referenced by ClBackendContext::ClBackendContext().

m_MLGOTuningFile

std::string m_MLGOTuningFile

protected

Definition at line 42 of file ClBackendContext.hpp.

Referenced by ClBackendContext::ClBackendContext().

---

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

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