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 +
#include "MantidAPI/AlgorithmManager.h"
#include "MantidKernel/WarningSuppressions.h"
#include "MantidPythonInterface/api/AlgorithmIDProxy.h"
#include "MantidPythonInterface/core/ReleaseGlobalInterpreterLock.h"
 
#include <boost/python/class.hpp>
#include <boost/python/def.hpp>
#include <boost/python/list.hpp>
#include <boost/python/overloads.hpp>
 
using namespace Mantid::API;
using Mantid::PythonInterface::AlgorithmIDProxy;
using Mantid::PythonInterface::ReleaseGlobalInterpreterLock;
using namespace boost::python;
 
namespace {
 
std::once_flag INIT_FLAG;
 
AlgorithmManagerImpl &instance() {
  // start the framework (if necessary)
  auto &mgr = AlgorithmManager::Instance();
  std::call_once(INIT_FLAG, []() {
    PyRun_SimpleString("import atexit\n"
                       "from mantid.api import AlgorithmManager\n"
                       "atexit.register(lambda: AlgorithmManager.clear())");
  });
  return mgr;
}
 
IAlgorithm_sptr create(AlgorithmManagerImpl *self, const std::string &algName, const int &version = -1) {
  ReleaseGlobalInterpreterLock releaseGIL;
  return self->create(algName, version);
}
 
void clear(AlgorithmManagerImpl *self) {
  // ReleaseGlobalInterpreterLock releaseGIL;
  return self->clear();
}
 
void cancelAll(AlgorithmManagerImpl *self) {
  ReleaseGlobalInterpreterLock releaseGIL;
  return self->cancelAll();
}
 
IAlgorithm_sptr getAlgorithm(AlgorithmManagerImpl const *const self, AlgorithmIDProxy idHolder) {
  ReleaseGlobalInterpreterLock releaseGIL;
  return self->getAlgorithm(idHolder.id);
}
 
void removeById(AlgorithmManagerImpl &self, AlgorithmIDProxy idHolder) {
  ReleaseGlobalInterpreterLock releaseGIL;
  return self.removeById(idHolder.id);
}
 
boost::python::list runningInstancesOf(AlgorithmManagerImpl const *const self, const std::string &algName) {
  ReleaseGlobalInterpreterLock releaseGIL;
  boost::python::list algs;
  auto mgrAlgs = self->runningInstancesOf(algName);
  for (auto &mgrAlg : mgrAlgs) {
    algs.append(mgrAlg);
  }
 
  return algs;
}
 
//------------------------------------------------------------------------------------------------------
GNU_DIAG_OFF("unused-local-typedef")
// Ignore -Wconversion warnings coming from boost::python
// Seen with GCC 7.1.1 and Boost 1.63.0
GNU_DIAG_OFF("conversion")
BOOST_PYTHON_FUNCTION_OVERLOADS(create_overloads, create, 2, 3)
BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(createUnmanaged_overloads, AlgorithmManagerImpl::createUnmanaged, 1, 2)
GNU_DIAG_ON("conversion")
GNU_DIAG_ON("unused-local-typedef")
} // namespace
 
void export_AlgorithmManager() {
 
  class_<AlgorithmManagerImpl, boost::noncopyable>("AlgorithmManagerImpl", no_init)
      .def("create", &create, create_overloads((arg("name"), arg("version")), "Creates a managed algorithm."))
      .def("createUnmanaged", &AlgorithmManagerImpl::createUnmanaged,
           createUnmanaged_overloads((arg("name"), arg("version")), "Creates an unmanaged algorithm."))
      .def("size", &AlgorithmManagerImpl::size, arg("self"), "Returns the number of managed algorithms")
      .def("getAlgorithm", &getAlgorithm, (arg("self"), arg("id_holder")),
           "Return the algorithm instance identified by the given id.")
      .def("removeById", &removeById, (arg("self"), arg("id_holder")), "Remove an algorithm from the managed list")
      .def("runningInstancesOf", &runningInstancesOf, (arg("self"), arg("algorithm_name")),
           "Returns a list of managed algorithm instances that are "
           "currently executing")
      .def("clear", &clear, arg("self"), "Clears the current list of managed algorithms")
      .def("cancelAll", &cancelAll, arg("self"), "Requests that all currently running algorithms be cancelled")
      .def("Instance", instance, return_value_policy<reference_existing_object>(),
           "Return a reference to the singleton instance")
      .staticmethod("Instance");
}