AlgorithmManager.cpp

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
//----------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------
#include "MantidAPI/AlgorithmManager.h"
#include "MantidAPI/Algorithm.h"
#include "MantidAPI/AlgorithmFactory.h"
#include "MantidKernel/ConfigService.h"
 
namespace Mantid::API {
namespace {
Kernel::Logger g_log("AlgorithmManager");
} // namespace
 
AlgorithmManagerImpl::AlgorithmManagerImpl() : m_managed_algs() { g_log.debug() << "Algorithm Manager created.\n"; }
 
AlgorithmManagerImpl::~AlgorithmManagerImpl() = default;
 
Algorithm_sptr AlgorithmManagerImpl::createUnmanaged(const std::string &algName, const int &version) const {
  return AlgorithmFactory::Instance().create(algName,
                                             version); // Throws on fail:
}
 
IAlgorithm_sptr AlgorithmManagerImpl::create(const std::string &algName, const int &version) {
  std::lock_guard<std::mutex> _lock(this->m_managedMutex);
  IAlgorithm_sptr alg;
  try {
    alg = AlgorithmFactory::Instance().create(algName,
                                              version); // Throws on fail:
    auto count = removeFinishedAlgorithms();
    g_log.debug() << count << " Finished algorithms removed from the managed algorithms list. " << m_managed_algs.size()
                  << " remaining.\n";
 
    // Add to list of managed ones
    m_managed_algs.emplace_back(alg);
    alg->initialize();
  } catch (std::runtime_error &ex) {
    g_log.error() << "AlgorithmManager:: Unable to create algorithm " << algName << ' ' << ex.what() << '\n';
    throw std::runtime_error("AlgorithmManager:: Unable to create algorithm " + algName + ' ' + ex.what());
  }
  return alg;
}
 
void AlgorithmManagerImpl::clear() {
  std::lock_guard<std::mutex> _lock(this->m_managedMutex);
  for (auto itAlg = m_managed_algs.begin(); itAlg != m_managed_algs.end();) {
    if (!(*itAlg)->isRunning()) {
      itAlg = m_managed_algs.erase(itAlg);
    } else {
      ++itAlg;
    }
  }
}
 
std::size_t AlgorithmManagerImpl::size() const { return m_managed_algs.size(); }
 
IAlgorithm_sptr AlgorithmManagerImpl::getAlgorithm(AlgorithmID id) const {
  std::lock_guard<std::mutex> _lock(this->m_managedMutex);
  const auto found = std::find_if(m_managed_algs.cbegin(), m_managed_algs.cend(),
                                  [id](const auto &algorithm) { return algorithm->getAlgorithmID() == id; });
  if (found == m_managed_algs.cend()) {
    return IAlgorithm_sptr();
  } else {
    return *found;
  }
}
 
void AlgorithmManagerImpl::removeById(AlgorithmID id) {
  std::lock_guard<std::mutex> _lock(this->m_managedMutex);
  auto itend = m_managed_algs.end();
  for (auto it = m_managed_algs.begin(); it != itend; ++it) {
    if ((**it).getAlgorithmID() == id) {
      if (!(*it)->isRunning()) {
        g_log.debug() << "Removing algorithm " << (*it)->name() << '\n';
        m_managed_algs.erase(it);
      } else {
        g_log.debug() << "Unable to remove algorithm " << (*it)->name() << ". The algorithm is running.\n";
      }
      break;
    }
  }
}
 
void AlgorithmManagerImpl::notifyAlgorithmStarting(AlgorithmID id) {
  auto alg = this->getAlgorithm(id);
  if (!alg)
    return;
  notificationCenter.postNotification(new AlgorithmStartingNotification(alg));
}
 
std::vector<IAlgorithm_const_sptr> AlgorithmManagerImpl::runningInstancesOf(const std::string &algorithmName) const {
  std::vector<IAlgorithm_const_sptr> theRunningInstances;
  std::lock_guard<std::mutex> _lock(this->m_managedMutex);
  std::copy_if(
      m_managed_algs.cbegin(), m_managed_algs.cend(), std::back_inserter(theRunningInstances),
      [&algorithmName](const auto &algorithm) { return algorithm->name() == algorithmName && algorithm->isRunning(); });
  return theRunningInstances;
}
 
std::vector<IAlgorithm_const_sptr> AlgorithmManagerImpl::runningInstances() const {
  std::vector<IAlgorithm_const_sptr> theRunningInstances;
  std::lock_guard<std::mutex> _lock(this->m_managedMutex);
  std::copy_if(m_managed_algs.cbegin(), m_managed_algs.cend(), std::back_inserter(theRunningInstances),
               [](const auto &algorithm) { return algorithm->isRunning(); });
  return theRunningInstances;
}
 
void AlgorithmManagerImpl::cancelAll() {
  std::lock_guard<std::mutex> _lock(this->m_managedMutex);
  for (auto &managed_alg : m_managed_algs) {
    if (managed_alg->isRunning())
      managed_alg->cancel();
  }
}
 
size_t AlgorithmManagerImpl::removeFinishedAlgorithms() {
  std::vector<IAlgorithm_const_sptr> theCompletedInstances;
  std::copy_if(m_managed_algs.cbegin(), m_managed_algs.cend(), std::back_inserter(theCompletedInstances),
               [](const auto &algorithm) { return (algorithm->isReadyForGarbageCollection()); });
  for (auto completedAlg : theCompletedInstances) {
    auto itend = m_managed_algs.end();
    for (auto it = m_managed_algs.begin(); it != itend; ++it) {
      if ((**it).getAlgorithmID() == completedAlg->getAlgorithmID()) {
        m_managed_algs.erase(it);
        break;
      }
    }
  }
  return theCompletedInstances.size();
}
 
void AlgorithmManagerImpl::shutdown() { clear(); }
} // namespace Mantid::API