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

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

Detailed Description

Definition at line 16 of file ClBackendContext.hpp.

Constructor & Destructor Documentation

ClBackendContext()

ClBackendContext

(

const IRuntime::CreationOptions &

options

)

Definition at line 153 of file ClBackendContext.cpp.

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

    : IBackendContext(options)
    , m_TuningFile()
{
    bool kernelProfiling = options.m_EnableGpuProfiling;

    arm_compute::CLTuner* tuner = nullptr;
    bool useLegacyTunerAPI = options.m_GpuAccTunedParameters.get() != nullptr;
    if (useLegacyTunerAPI)
    {
        auto clTunerParams = boost::polymorphic_downcast<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:
                        {
                            BOOST_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);
                }
            });

        // 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
            {
                m_Tuner->load_from_file(m_TuningFile.c_str());
            } catch (const std::exception& e)
            {
                ARMNN_LOG(warning) << "Could not load GpuAcc tuner data file.";
            }

            tuner = m_Tuner.get();
        }
    }

    m_ClContextControlWrapper = std::make_unique<ClContextControlWrapper>(
            tuner,
            kernelProfiling
        );
}

~ClBackendContext()

~ClBackendContext ( )

override

Definition at line 277 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 246 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 260 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 241 of file ClBackendContext.cpp.

{
    return true;
}

BeforeUnloadNetwork()

bool BeforeUnloadNetwork ( NetworkId  networkId )

overridevirtual

Before and after Unload network events.

Implements IBackendContext.

Definition at line 255 of file ClBackendContext.cpp.

{
    return m_ClContextControlWrapper->Sync();
}

---

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

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