BackendSettings.hpp

Go to the documentation of this file.

//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
 
#pragma once
 
#include "DeviceSpec.hpp"
 
#include <armnn/BackendId.hpp>
#include <armnn/utility/PolymorphicDowncast.hpp>
 
#include <vector>
 
namespace armnn
{
 
struct BackendSettings
{
    BackendIdVector m_PreferredBackends;
    BackendIdSet    m_SupportedBackends;
    BackendIdSet    m_SelectedBackends;
    BackendIdSet    m_IgnoredBackends;
 
    BackendSettings() = default;
 
    BackendSettings(const BackendIdVector& preferredBackends,
                    const IDeviceSpec& deviceSpec)
    {
        Initialize(preferredBackends, deviceSpec);
    }
 
    BackendSettings(const BackendSettings& other)
        : m_PreferredBackends(other.m_PreferredBackends)
        , m_SupportedBackends(other.m_SupportedBackends)
        , m_SelectedBackends(other.m_SelectedBackends)
        , m_IgnoredBackends(other.m_IgnoredBackends)
    {
    }
 
    bool IsBackendPreferred(const BackendId& backend) const
    {
        return IsBackendInCollection(backend, m_PreferredBackends);
    }
 
    bool IsBackendSupported(const BackendId& backend) const
    {
        return IsBackendInCollection(backend, m_SupportedBackends);
    }
 
    bool IsBackendSelected(const BackendId& backend) const
    {
        return IsBackendInCollection(backend, m_SelectedBackends);
    }
 
    bool IsBackendIgnored(const BackendId& backend) const
    {
        return IsBackendInCollection(backend, m_IgnoredBackends);
    }
 
    bool IsCpuRefUsed() const
    {
        BackendId cpuBackendId(Compute::CpuRef);
        return IsBackendSupported(cpuBackendId) && IsBackendPreferred(cpuBackendId);
    }
 
    BackendIdVector GetAvailablePreferredBackends() const
    {
        BackendIdVector availablePreferredBackends;
        for (const BackendId& backend : m_PreferredBackends)
        {
            if (IsBackendSupported(backend) && !IsBackendIgnored(backend))
            {
                availablePreferredBackends.push_back(backend);
            }
        }
        return availablePreferredBackends;
    }
 
private:
    void Initialize(const BackendIdVector& preferredBackends,
                    const IDeviceSpec& deviceSpec)
    {
        // Copy preferred backends from input
        m_PreferredBackends = preferredBackends;
 
        // Obtain list of supported backends
        const DeviceSpec& spec = *PolymorphicDowncast<const DeviceSpec*>(&deviceSpec);
        m_SupportedBackends = spec.GetSupportedBackends();
    }
 
    template<typename Collection>
    bool IsBackendInCollection(const BackendId& backend, const Collection& collection) const
    {
        return std::find(collection.begin(), collection.end(), backend) != collection.end();
    }
};
 
} //namespace armnn