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>
 
#include <chrono>
#include <thread>
 
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"
                       "def cleanupAlgorithmManager():\n"
                       "    from mantid.api import AlgorithmManager\n"
                       "    AlgorithmManager.shutdown()\n"
                       "atexit.register(cleanupAlgorithmManager)");
  });
  return mgr;
}
 
IAlgorithm_sptr create(AlgorithmManagerImpl *self, const std::string &algName, const int &version = -1) {
  ReleaseGlobalInterpreterLock releaseGIL;
  return self->create(algName, version);
}
 
std::shared_ptr<Algorithm> createUnmanaged(AlgorithmManagerImpl *self, const std::string &algName,
                                           const int &version = -1) {
  ReleaseGlobalInterpreterLock releaseGIL;
  return self->createUnmanaged(algName, version);
}
 
void clear(AlgorithmManagerImpl *self) {
  // ReleaseGlobalInterpreterLock releaseGIL;
  return self->clear();
}
 
constexpr auto SLEEP_100_MS = std::chrono::milliseconds(100);
 
void shutdown(AlgorithmManagerImpl *self) {
  {
    ReleaseGlobalInterpreterLock releaseGIL;
    self->cancelAll();
  }
  while (!self->runningInstances().empty()) {
    // A Python algorithm needs the GIL to finish after its execution method returns.
    ReleaseGlobalInterpreterLock releaseGIL;
    std::this_thread::sleep_for(SLEEP_100_MS);
  }
  // Keep the GIL while clearing because managed algorithms can own Python objects. See #33924.
  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) {
  std::vector<IAlgorithm_const_sptr> mgrAlgs;
 
  {
    ReleaseGlobalInterpreterLock releaseGIL;
    mgrAlgs = self->runningInstancesOf(algName);
  }
 
  boost::python::list algs;
  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")
// cppcheck-suppress unknownMacro
BOOST_PYTHON_FUNCTION_OVERLOADS(create_overloads, create, 2, 3)
BOOST_PYTHON_FUNCTION_OVERLOADS(createUnmanaged_overloads, createUnmanaged, 2, 3)
 
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", &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("shutdown", &shutdown, arg("self"), "Cancels all running algorithms and waits for them to exit")
      .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");
}