ClBackendContext Class Reference

#include <ClBackendContext.hpp>

Inheritance diagram for ClBackendContext:

Public Member Functions
	ClBackendContext (const IRuntime::CreationOptions &options)
bool	BeforeLoadNetwork (NetworkId networkId) override
bool	AfterLoadNetwork (NetworkId networkId) override
bool	BeforeUnloadNetwork (NetworkId networkId) override
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

Implements IBackendContext.

Definition at line 241 of file ClBackendContext.cpp.

{
    return true;
}

BeforeUnloadNetwork()

bool BeforeUnloadNetwork ( NetworkId  networkId )

overridevirtual

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