#include <BackendManager.h>

Public Types
using	backend_create_t = backend::Backend ()()

using	backend_destroy_t = void()(backend::Backend )

using	dlhandle_destroy_t = std::function< void(void *)>

Public Member Functions
backend::Backend *	get (const std::string &key)

const backend::Backend *	get (const std::string &key) const

const backend::Backend *	getBuiltin () const

const std::vector< const backend::Backend * >	getAll () const

size_t	num_backends () const

void	loadBackend (const std::string &backend)
	load backend plugin

Static Public Member Functions
static BackendManager &	get ()

Detailed Description

Definition at line 31 of file BackendManager.h.

Member Typedef Documentation

◆ backend_create_t

using onert::compiler::BackendManager::backend_create_t = backend::Backend *(*)()

Definition at line 34 of file BackendManager.h.

◆ backend_destroy_t

using onert::compiler::BackendManager::backend_destroy_t = void (*)(backend::Backend *)

Definition at line 35 of file BackendManager.h.

◆ dlhandle_destroy_t

using onert::compiler::BackendManager::dlhandle_destroy_t = std::function<void(void *)>

Definition at line 36 of file BackendManager.h.

Member Function Documentation

◆ get() [1/3]

BackendManager & onert::compiler::BackendManager::get ( )

static

Definition at line 37 of file BackendManager.cc.

{
  static BackendManager object;
  return object;
}

Referenced by loadBackend(), and onert::compiler::ManualScheduler::schedule().

◆ get() [2/3]

backend::Backend * onert::compiler::BackendManager::get ( const std::string & key )

Definition at line 130 of file BackendManager.cc.

{
  if (_gen_map.find(key) != _gen_map.end())
  {
    return _gen_map.at(key).get();
  }
 
  return nullptr;
}

◆ get() [3/3]

const backend::Backend * onert::compiler::BackendManager::get ( const std::string & key ) const

Definition at line 140 of file BackendManager.cc.

{
  if (_gen_map.find(key) != _gen_map.end())
  {
    return _gen_map.at(key).get();
  }
 
  return nullptr;
}

◆ getAll()

const std::vector< const backend::Backend * > onert::compiler::BackendManager::getAll ( ) const

inline

Definition at line 44 of file BackendManager.h.

  {
    std::vector<const backend::Backend *> v;
    for (const auto &p : _gen_map)
      v.emplace_back(p.second.get());
    return v;
  }

◆ getBuiltin()

const backend::Backend * onert::compiler::BackendManager::getBuiltin ( ) const

Definition at line 150 of file BackendManager.cc.

150{ return _builtin; }

◆ loadBackend()

void onert::compiler::BackendManager::loadBackend ( const std::string & backend )

load backend plugin

Parameters

backend backend to be loaded

Returns

Definition at line 60 of file BackendManager.cc.

{
  if (get(backend) != nullptr)
  {
    return;
  }
 
  const std::string backend_so = "libbackend_" + backend + SHARED_LIB_EXT;
  void *handle = dlopen(backend_so.c_str(), RTLD_LAZY | RTLD_LOCAL);
 
  if (handle == nullptr)
  {
    VERBOSE(BackendManager) << "Failed to load backend '" << backend << "' - " << dlerror() << "\n";
    return;
  }
 
  VERBOSE(BackendManager) << "Successfully loaded '" << backend << "'(" << backend_so << ")\n";
 
  {
    // load object creator function
    auto backend_create = (backend_create_t)dlsym(handle, "onert_backend_create");
    if (backend_create == nullptr)
    {
      // TODO replace `fprintf` with `VERBOSE`
      fprintf(stderr, "BackendManager: unable to find function `onert_backend_create` : %s\n",
              dlerror());
      dlclose(handle);
      return;
    }
 
    // load object creator function
    auto backend_destroy = (backend_destroy_t)dlsym(handle, "onert_backend_destroy");
    if (backend_destroy == nullptr)
    {
      // TODO replace `fprintf` with `VERBOSE`
      fprintf(stderr, "BackendManager: unable to find `function onert_backend_destroy` : %s\n",
              dlerror());
      dlclose(handle);
      return;
    }
 
    auto backend_object =
      std::unique_ptr<backend::Backend, backend_destroy_t>(backend_create(), backend_destroy);
    bool initialized = backend_object->config()->initialize(); // Call initialize here?
    if (!initialized)
    {
      VERBOSE(BackendManager) << backend.c_str()
                              << " backend initialization failed. Don't use this backend"
                              << std::endl;
      dlclose(handle);
      return;
    }
    _gen_map.emplace(backend_object->config()->id(), std::move(backend_object));
  }
 
  // Save backend handle (avoid warning by handle lost without dlclose())
  auto u_handle = std::unique_ptr<void, dlhandle_destroy_t>{
    handle, [id = backend, filename = backend_so](void *h) {
      if (dlclose(h) == 0)
      {
        VERBOSE(BackendManager) << "Successfully unloaded '" << id << "'(" << filename << ")\n";
      }
      else
      {
        VERBOSE(BackendManager) << "Failed to unload backend '" << id << "'- " << dlerror() << "\n";
      }
    }};
  _handle_map.emplace(backend, std::move(u_handle));
}

References get(), and VERBOSE.

◆ num_backends()

size_t onert::compiler::BackendManager::num_backends ( ) const