GpuFsaBackendContext Class Reference

#include <GpuFsaBackendContext.hpp>

Inheritance diagram for GpuFsaBackendContext:

Collaboration diagram for GpuFsaBackendContext:

Public Member Functions
	GpuFsaBackendContext (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
bool	AfterEnqueueWorkload (NetworkId networkId) override
	~GpuFsaBackendContext () 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 GpuFsaBackendContext.hpp.

Constructor & Destructor Documentation

GpuFsaBackendContext()

GpuFsaBackendContext

(

const IRuntime::CreationOptions &

options

)

Definition at line 61 of file GpuFsaBackendContext.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:
                        {
                            ARMNN_LOG(warning) << "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, "GpuFsa", [&](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 GpuFsa 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 GpuFsa MLGO tuner data file.";
            }
        }
 
        tuner = m_Tuner.get();
    }
 
    m_GpuFsaContextControlWrapper = std::make_unique<GpuFsaContextControlWrapper>(
            tuner,
            mlgoTuner,
            kernelProfiling
    );
}

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

~GpuFsaBackendContext()

~GpuFsaBackendContext ( )

override

Definition at line 218 of file GpuFsaBackendContext.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 GpuFsa tuner data to file " << m_TuningFile;
        }
    }
}

References ARMNN_LOG, and armnn::warning.

Member Function Documentation

AfterEnqueueWorkload()

bool AfterEnqueueWorkload ( NetworkId  networkId )

overridevirtual

Implements IBackendContext.

Definition at line 213 of file GpuFsaBackendContext.cpp.

{
    return m_GpuFsaContextControlWrapper->Sync();
}

AfterLoadNetwork()

bool AfterLoadNetwork ( NetworkId  networkId )

overridevirtual

Implements IBackendContext.

Definition at line 182 of file GpuFsaBackendContext.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 196 of file GpuFsaBackendContext.cpp.

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

BeforeLoadNetwork()

bool BeforeLoadNetwork ( NetworkId  networkId )

overridevirtual

Before and after Load network events.

Implements IBackendContext.

Definition at line 177 of file GpuFsaBackendContext.cpp.

{
    return true;
}

BeforeUnloadNetwork()

bool BeforeUnloadNetwork ( NetworkId  networkId )

overridevirtual

Before and after Unload network events.

Implements IBackendContext.

Definition at line 191 of file GpuFsaBackendContext.cpp.

{
    return m_GpuFsaContextControlWrapper->Sync();
}

Member Data Documentation

m_MLGOTuner

arm_compute::CLGEMMHeuristicsHandle m_MLGOTuner

protected

Definition at line 43 of file GpuFsaBackendContext.hpp.

Referenced by GpuFsaBackendContext::GpuFsaBackendContext().

m_MLGOTuningFile

std::string m_MLGOTuningFile

protected

Definition at line 44 of file GpuFsaBackendContext.hpp.

Referenced by GpuFsaBackendContext::GpuFsaBackendContext().

---

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

• src/backends/gpuFsa/GpuFsaBackendContext.hpp
• src/backends/gpuFsa/GpuFsaBackendContext.cpp