Changeset 415ddd for src


Ignore:
Timestamp:
May 20, 2014, 9:14:56 AM (11 years ago)
Author:
Frederik Heber <heber@…>
Branches:
Action_Thermostats, Add_AtomRandomPerturbation, Add_FitFragmentPartialChargesAction, Add_RotateAroundBondAction, Add_SelectAtomByNameAction, Added_ParseSaveFragmentResults, AddingActions_SaveParseParticleParameters, Adding_Graph_to_ChangeBondActions, Adding_MD_integration_tests, Adding_ParticleName_to_Atom, Adding_StructOpt_integration_tests, AtomFragments, Automaking_mpqc_open, AutomationFragmentation_failures, Candidate_v1.5.4, Candidate_v1.6.0, Candidate_v1.6.1, ChangeBugEmailaddress, ChangingTestPorts, ChemicalSpaceEvaluator, CombiningParticlePotentialParsing, Combining_Subpackages, Debian_Package_split, Debian_package_split_molecuildergui_only, Disabling_MemDebug, Docu_Python_wait, EmpiricalPotential_contain_HomologyGraph, EmpiricalPotential_contain_HomologyGraph_documentation, Enable_parallel_make_install, Enhance_userguide, Enhanced_StructuralOptimization, Enhanced_StructuralOptimization_continued, Example_ManyWaysToTranslateAtom, Exclude_Hydrogens_annealWithBondGraph, FitPartialCharges_GlobalError, Fix_BoundInBox_CenterInBox_MoleculeActions, Fix_ChargeSampling_PBC, Fix_ChronosMutex, Fix_FitPartialCharges, Fix_FitPotential_needs_atomicnumbers, Fix_ForceAnnealing, Fix_IndependentFragmentGrids, Fix_ParseParticles, Fix_ParseParticles_split_forward_backward_Actions, Fix_PopActions, Fix_QtFragmentList_sorted_selection, Fix_Restrictedkeyset_FragmentMolecule, Fix_StatusMsg, Fix_StepWorldTime_single_argument, Fix_Verbose_Codepatterns, Fix_fitting_potentials, Fixes, ForceAnnealing_goodresults, ForceAnnealing_oldresults, ForceAnnealing_tocheck, ForceAnnealing_with_BondGraph, ForceAnnealing_with_BondGraph_continued, ForceAnnealing_with_BondGraph_continued_betteresults, ForceAnnealing_with_BondGraph_contraction-expansion, FragmentAction_writes_AtomFragments, FragmentMolecule_checks_bonddegrees, GeometryObjects, Gui_Fixes, Gui_displays_atomic_force_velocity, ImplicitCharges, IndependentFragmentGrids, IndependentFragmentGrids_IndividualZeroInstances, IndependentFragmentGrids_IntegrationTest, IndependentFragmentGrids_Sole_NN_Calculation, JobMarket_RobustOnKillsSegFaults, JobMarket_StableWorkerPool, JobMarket_unresolvable_hostname_fix, MoreRobust_FragmentAutomation, ODR_violation_mpqc_open, PartialCharges_OrthogonalSummation, PdbParser_setsAtomName, PythonUI_with_named_parameters, QtGui_reactivate_TimeChanged_changes, Recreated_GuiChecks, Rewrite_FitPartialCharges, RotateToPrincipalAxisSystem_UndoRedo, SaturateAtoms_findBestMatching, SaturateAtoms_singleDegree, StoppableMakroAction, Subpackage_CodePatterns, Subpackage_JobMarket, Subpackage_LinearAlgebra, Subpackage_levmar, Subpackage_mpqc_open, Subpackage_vmg, Switchable_LogView, ThirdParty_MPQC_rebuilt_buildsystem, TrajectoryDependenant_MaxOrder, TremoloParser_IncreasedPrecision, TremoloParser_MultipleTimesteps, TremoloParser_setsAtomName, Ubuntu_1604_changes, stable
Children:
74459a
Parents:
975b83
git-author:
Frederik Heber <heber@…> (08/26/13 22:56:36)
git-committer:
Frederik Heber <heber@…> (05/20/14 09:14:56)
Message:

ActionQueue now contains a run thread.

  • otherwise the progress bar of the QtMainWindow cannot be seen as waitForResults() takes up all of the executing thread.
  • added mutex for operations modifying the queue.
  • added ActionQueue::run() and ::stop(), used by friend stopQueue().
  • insertAction() now makes use of a tempqueue that is added to true queue during run() instead of calling the actions directly.
  • new stopQueue() in cleanUp.hpp is used by module_exit in pyMoleCuilder and in main() before saveAll().
  • cleanup: printTiming() requires now list of action tokens and added new stopAndPurgeQueue() to place waiting for Actions to end into extra function.
  • added ActionQueue::wait() which allows for synchronization in python scripts, is ignored in session python scripts. Otherwise we wait for ActionQueue's queue to empty during execution of load-session which hangs.
  • DOCU: added note to python documentation.
  • added waitQueue() also to purgeStaticInstances().
  • static UIFactory::isFactoryPresent() added that allows checking whether we have a UI or are executed within a python script (i.e. pyMoleCuilder).
  • DOCU: Extended docu on threads and who this affects python scripts.
  • TESTFIX: changed regression tests on storing python sessions.
Location:
src
Files:
1 added
11 edited

Legend:

Unmodified
Added
Removed

  • src/Actions/ActionQueue.cpp

    r975b83 r415ddd  
    4242#include "CodePatterns/Singleton_impl.hpp"
    4343
     44#include <boost/date_time/posix_time/posix_time.hpp>
     45#include <boost/version.hpp>
    4446#include <string>
    4547#include <sstream>
    … …  
    5658    AR(new ActionRegistry()),
    5759    history(new ActionHistory),
    58     CurrentAction(0)
     60    CurrentAction(0),
     61    run_thread(boost::bind(&ActionQueue::run, this)),
     62    run_thread_isIdle(true)
    5963{}
    6064
    6165ActionQueue::~ActionQueue()
    6266{
     67  stop();
     68
    6369  // free all actions contained in actionqueue
    6470  for (ActionQueue_t::iterator iter = actionqueue.begin(); !actionqueue.empty(); iter = actionqueue.begin()) {
    … …  
    8086  Action *newaction = _action->clone(state);
    8187  newaction->prepare(state);
     88  mtx_queue.lock();
    8289  actionqueue.push_back( newaction );
    83   try {
    84     newaction->call();
    85   } catch(ActionFailureException &e) {
    86     std::cerr << "Action " << *boost::get_error_info<ActionNameString>(e) << " has failed." << std::endl;
    87     World::getInstance().setExitFlag(5);
    88   }
     90  {
     91    boost::lock_guard<boost::mutex> lock(mtx_idle);
     92    run_thread_isIdle = (CurrentAction == actionqueue.size());
     93  }
     94  mtx_queue.unlock();
    8995}
    9096
    9197void ActionQueue::insertAction(Action *_action, enum Action::QueryOptions state)
    9298{
    93   queueAction(_action, state);
     99  Action *newaction = _action->clone(state);
     100  newaction->prepare(state);
     101  mtx_queue.lock();
     102  tempqueue.push_back( newaction );
     103  {
     104    boost::lock_guard<boost::mutex> lock(mtx_idle);
     105    run_thread_isIdle = !((CurrentAction != actionqueue.size()) || !tempqueue.empty());
     106  }
     107  mtx_queue.unlock();
     108}
     109
     110void ActionQueue::run()
     111{
     112  bool Interrupted = false;
     113  do {
     114    // sleep for some time and wait for queue to fill up again
     115    try {
     116#if BOOST_VERSION < 105000
     117      run_thread.sleep(boost::get_system_time() + boost::posix_time::milliseconds(100));
     118#else
     119      run_thread.sleep_for(100);
     120#endif
     121    } catch(boost::thread_interrupted &e) {
     122      LOG(2, "INFO: ActionQueue has received stop signal.");
     123      Interrupted = true;
     124    }
     125//    LOG(1, "DEBUG: Start of ActionQueue's run() loop.");
     126    // call all currently present Actions
     127    mtx_queue.lock();
     128    insertTempQueue();
     129    bool status = (CurrentAction != actionqueue.size());
     130    mtx_queue.unlock();
     131    while (status) {
     132      //      boost::this_thread::disable_interruption di;
     133      LOG(0, "Calling Action " << actionqueue[CurrentAction]->getName() << " ... ");
     134      try {
     135        actionqueue[CurrentAction]->call();
     136      } catch(ActionFailureException &e) {
     137        std::cerr << "Action " << *boost::get_error_info<ActionNameString>(e) << " has failed." << std::endl;
     138        World::getInstance().setExitFlag(5);
     139      }
     140      // access actionqueue, hence using mutex
     141      mtx_queue.lock();
     142      // step on to next action and check for end
     143      CurrentAction++;
     144      // insert new actions (before [CurrentAction]) if they have been spawned
     145      // we must have an extra vector for this, as we cannot change actionqueue
     146      // while an action instance is "in-use"
     147      insertTempQueue();
     148      status = (CurrentAction != actionqueue.size());
     149      mtx_queue.unlock();
     150    }
     151    {
     152      boost::lock_guard<boost::mutex> lock(mtx_idle);
     153      run_thread_isIdle = !((CurrentAction != actionqueue.size()) || !tempqueue.empty());
     154    }
     155    cond_idle.notify_one();
     156//    LOG(1, "DEBUG: End of ActionQueue's run() loop.");
     157  } while (!Interrupted);
     158}
     159
     160void ActionQueue::insertTempQueue()
     161{
     162  if (!tempqueue.empty()) {
     163    ActionQueue_t::iterator InsertionIter = actionqueue.begin();
     164    std::advance(InsertionIter, CurrentAction);
     165    actionqueue.insert( InsertionIter, tempqueue.begin(), tempqueue.end() );
     166    tempqueue.clear();
     167  }
     168}
     169
     170void ActionQueue::wait()
     171{
     172  boost::unique_lock<boost::mutex> lock(mtx_idle);
     173  while(!run_thread_isIdle)
     174  {
     175      cond_idle.wait(lock);
     176  }
     177}
     178
     179void ActionQueue::stop()
     180{
     181  // notify actionqueue thread that we wish to terminate
     182  run_thread.interrupt();
     183  // wait till it ends
     184  run_thread.join();
    94185}
    95186

  • src/Actions/ActionQueue.hpp

    r975b83 r415ddd  
    1616#include "CodePatterns/Singleton.hpp"
    1717
     18#include <boost/thread.hpp>
    1819#include <vector>
    1920
    2021#include "Actions/Action.hpp"
    2122#include "Actions/ActionState.hpp"
     23
     24void stopQueue();
     25void waitQueue();
    2226
    2327namespace MoleCuilder {
    … …  
    113117  void redoLast();
    114118
    115   /** Getter for the last executed action.
    116    *
    117    * \note this is necessary for Reactions to actually have a chance of getting
    118    * the calculated value as Action's are always cloned.
    119    *
    120    * \return const ref to last action
    121    */
    122   const Action &getLastAction() const {
    123     return *(actionqueue.back());
    124   }
     119  boost::thread &getRunThread()
     120  { return run_thread; }
    125121
    126122private:
    … …  
    140136  void clear();
    141137
     138  /** Runs the ActionQueue.
     139   *
     140   */
     141  void run();
     142
     143  friend void ::stopQueue();
     144
     145  /** Stops the internal thread.
     146   *
     147   */
     148  void stop();
     149
     150  friend void ::waitQueue();
     151
     152  /** Wait till all currently queued actions are processed.
     153   *
     154   */
     155  void wait();
     156
    142157  /** Insert an action after CurrentAction.
    143158   *
    … …  
    148163  void insertAction(Action *_action, enum Action::QueryOptions state);
    149164
     165  /** Moves all action from tempqueue into real queue.
     166   *
     167   */
     168  void insertTempQueue();
     169
    150170private:
    151171  /** Private cstor for ActionQueue.
    … …  
    172192  //!> point to current action in actionqueue
    173193  size_t CurrentAction;
     194
     195  //!> internal temporary actionqueue of actions used by insertAction()
     196  ActionQueue_t tempqueue;
     197
     198  //!> internal thread to call Actions
     199  boost::thread run_thread;
     200
     201  //!> internal mutex to synchronize access to queue
     202  boost::mutex mtx_queue;
     203
     204  //!> conditional variable notifying when run_thread is idling
     205  boost::condition_variable cond_idle;
     206
     207  //!> flag indicating whether run_thread is idle or not
     208  bool run_thread_isIdle;
     209
     210  //!> internal mutex to synchronize access to run_thread_isIdle
     211  boost::mutex mtx_idle;
    174212};
    175213

  • src/Python/Makefile.am

    r975b83 r415ddd  
    88        Python/getSelectedMolarMass.cpp \
    99        Python/PythonScripting.cpp \
    10         Python/reinit.cpp
     10        Python/reinit.cpp \
     11        Python/wait.cpp
    1112                                 
    1213PYTHONHEADER = \

  • src/Python/PythonScripting_impl.hpp

    r975b83 r415ddd  
    8585      "Reinitializes the internal state of the python module as if it had been freshly imported,saves all input files beforehand."
    8686  );
     87  boost::python::def(
     88      "wait",
     89      MoleCuilder::detail::module_wait,
     90      "Waits until all currently queued actions have been processed."
     91  );
    8792  boost::python::def< MoleCuilder::detail::doubleVec() >(
    8893      "getBoundingBox",

  • src/UIElements/UIFactory.hpp

    r975b83 r415ddd  
    7777  static void makeUserInterface(std::string type);
    7878  static void registerFactory(factoryDescription *factoryDesc);
     79  static bool isFactoryPresent() { return !factories.empty(); }
    7980  virtual std::string getUIName(){  return "none";  }
    8081protected:

  • src/builder.cpp

    r975b83 r415ddd  
    4949  doUI();
    5050
     51  waitQueue();
     52  stopQueue();
    5153  if (UIFactory::getInstance().getUIName() == "CommandLine")
    5254    return saveAll();

  • src/builder_init.hpp

    r975b83 r415ddd  
    2020void doUI();
    2121
    22 
    2322#endif /* BUILDER_INIT_HPP_ */

  • src/cleanUp.cpp

    r975b83 r415ddd  
    9292void purgeStaticInstances()
    9393{
     94  // make sure that ActionQueue is already purged!
     95
    9496  Chronos::purgeInstance();
    9597  RandomNumberDistributionFactory::purgeInstance();
    … …  
    105107  UIFactory::purgeInstance();
    106108  CommandLineParser::purgeInstance();
    107   MoleCuilder::ActionQueue::purgeInstance();
    108   MoleCuilder::OptionRegistry::purgeInstance();
    109109  logger::purgeInstance();
    110110  errorLogger::purgeInstance();
    … …  
    112112}
    113113
     114void stopAndPurgeQueue()
     115{
     116  // adding a wait here such that ActionQueue's run_thread is done any may stop
     117  waitQueue();
     118  MoleCuilder::ActionQueue::purgeInstance();
     119  MoleCuilder::OptionRegistry::purgeInstance();
     120}
     121
     122void printTimings(const MoleCuilder::ActionQueue::ActionTokens_t &tokens);
     123
    114124/** Cleans all singleton instances in an orderly fashion.
    115125 * C++ does not guarantee any specific sequence of removal of single instances
    116126 * which have static/global variables. Some singletons depend on others hence we
    117  * acertain a specific ordering here, which is is used via the atexit() hook.
     127 * ascertain a specific ordering here, which is is used via the atexit() hook.
    118128 */
    119129void cleanUp()
    120130{
    121   // give timings per Action
    122   printTimings();
     131  // stop queue
     132  const MoleCuilder::ActionQueue::ActionTokens_t tokens = MoleCuilder::ActionQueue::getInstance().getListOfActions();
     133  stopAndPurgeQueue();
     134  // give timings per Action, requires still present Chronos
     135  printTimings(tokens);
     136
    123137  // purge static instances from memory
    124138  purgeStaticInstances();
    … …  
    138152/** We give a list of all times per action and a total time.
    139153 *
    140  */
    141 void printTimings()
    142 {
    143   const MoleCuilder::ActionQueue::ActionTokens_t tokens = MoleCuilder::ActionQueue::getInstance().getListOfActions();
     154 * We require a list of Action tokens such that we do not access the ActionQueue.
     155 * Timings are printed when Actions have all been performed, hence the queue should
     156 * already be purged and we cannot access it anymore.
     157 *
     158 * \param tokens
     159 */
     160void printTimings(const MoleCuilder::ActionQueue::ActionTokens_t &tokens)
     161{
     162//  const MoleCuilder::ActionQueue::ActionTokens_t tokens = MoleCuilder::ActionQueue::getInstance().getListOfActions();
    144163  const Chronos &Chron = Chronos::getInstance();
    145164  if (!DoLog(2)) {
    … …  
    198217  return (ExitFlag == 1 ? 0 : ExitFlag);
    199218}
     219
     220/** Stops the queue such that all Actions are done.
     221 *
     222 */
     223void stopQueue()
     224{
     225  MoleCuilder::ActionQueue::getInstance().stop();
     226}
     227
     228/** Waits for the queue to idle.
     229 *
     230 */
     231void waitQueue()
     232{
     233  MoleCuilder::ActionQueue::getInstance().wait();
     234}

  • src/cleanUp.hpp

    r975b83 r415ddd  
    1717void cleanUp();
    1818void dumpMemory();
    19 void printTimings();
    2019void purgeStaticInstances();
    2120int saveAll();
     21void stopQueue();
     22void waitQueue();
    2223
    2324#endif /* CLEANUP_HPP_ */

  • src/documentation/Makefile.am

    r975b83 r415ddd  
    1313        ${top_srcdir}/src/documentation/constructs/constructs.dox \
    1414        ${top_srcdir}/src/documentation/constructs/descriptors.dox \
     15        ${top_srcdir}/src/documentation/constructs/filling.dox \
    1516        ${top_srcdir}/src/documentation/constructs/fragmentation.dox \
    1617        ${top_srcdir}/src/documentation/constructs/linearalgebra.dox \
    … …  
    1819        ${top_srcdir}/src/documentation/constructs/molecules.dox \
    1920        ${top_srcdir}/src/documentation/constructs/observers_observables.dox \
     21        ${top_srcdir}/src/documentation/constructs/parameters.dox \
    2022        ${top_srcdir}/src/documentation/constructs/parsers.dox \
     23        ${top_srcdir}/src/documentation/constructs/potentials.dox \
     24        ${top_srcdir}/src/documentation/constructs/qt-gui.dox \
     25        ${top_srcdir}/src/documentation/constructs/queries.dox \
    2126        ${top_srcdir}/src/documentation/constructs/randomnumbers.dox \
    2227        ${top_srcdir}/src/documentation/constructs/serialization.dox \
     28        ${top_srcdir}/src/documentation/constructs/shaperegistry.dox \
    2329        ${top_srcdir}/src/documentation/constructs/shapes.dox \
    2430        ${top_srcdir}/src/documentation/constructs/tesselation.dox \
     31        ${top_srcdir}/src/documentation/constructs/validators.dox \
     32        ${top_srcdir}/src/documentation/constructs/values.dox \
    2533        ${top_srcdir}/src/documentation/constructs/world.dox \
    2634        ${top_srcdir}/src/documentation/howtos/action.dox \

  • src/documentation/userinterfaces/python.dox

    r975b83 r415ddd  
    2020 *  script.
    2121 *
    22  *  This is done in \b src/Actions/pyMoleCuilder.cpp.
     22 *  This is done in \b src/Python/PythonScripting.cpp.
    2323 *
    2424 *  There again some preprocessor magic is happening. One the one hand we
    … …  
    4343 *  mol.SelectAtomById("0")
    4444 *  mol.AtomRemove()
     45 *  mol.wait()
     46 *  mol.getSelectedMolarMass()
     47 *  mol.wait()
    4548 *  \endcode
    4649 *  which loads a file \b test.xyz into the (internal) World, selects the first
    47  *  atom and removes it.
     50 *  atom and removes it. Notice \b mol.wait() at the end. This might be necessary
     51 *  as actions are executed in a different thread than the python script itself.
     52 *  Hence, if you require values from molecuilder you have to make sure that
     53 *  all your actions have been processed by this second thread. That's what
     54 *  wait() is good for. It waits until action queue thread is idle. Then you
     55 *  can be sure that molecuilder has removed all atoms, performed all selections
     56 *  and any value you retrieve is up-to-date.
     57 *
     58 *  Note that there are two \b wait()s present in the example. As the Actions
     59 *  are executed in another thread and the above commands just tell the MoleCuilder
     60 *  library (the ActionQueue to be precise) to enqueue the requested action,
     61 *  we have to wait (in the main thread) until the actions actually have been
     62 *  executed before we continue (i.e. when we need the new state where the
     63 *  atoms have been removed) and before we \b terminate!
    4864 *
    4965 *  \section userinterfaces-python-running Running a test script
    … …  
    7288 *  \code
    7389 *  pyMoleCuilder.WorldInput("test.xyz")
     90 *  pyMoleCuilder.wait()
    7491 *  \endcode
    7592 *
    … …  
    7895 *  \code
    7996 *  pyMoleCuilder.SelectionAllMolecules()
     97 *  pyMoleCuilder.wait()
    8098 *  \endcode
    8199 *
    … …  
    84102 *  \code
    85103 *  pyMoleCuilder.SelectAtomById("0")
     104 *  pyMoleCuilder.wait()
    86105 *  \endcode
     106 *
     107 *  \warning Again, take note of the added wait()s that ensure the all enqueued
     108 *  actions also have been executed. This is especially important in scripts as
     109 *  otherwise your script may deadlock. That's because ActionQueue's destructor
     110 *  waits for the thread that executes the actions to end, and in another thread
     111 *  we still want to access to ActionQueue whose instance is however locked as
     112 *  it is about the get destroyed.
    87113 *
    88114 *  \subsection userinterfaces-python-notes-cleanup Cleaning up or reset state ...
    … …  
    115141 *  gives you the docu string on WorldInputAction.
    116142 *
     143 * \subsection userinterfaces-python-notes-wait Waiting for the action queue
    117144 *
    118  * \date 2013-03-18
     145 * Note again that actions are executed in a different thread as the python
     146 * script. Hence, we require synchronization at certain intervals where you
     147 * require molecuilder to be up to speed. All commands you executed such
     148 * as
     149 * \code
     150 * import pyMoleCuilder as mol
     151 * mol.WorldInput("foo.xyz")
     152 * mol.wait()
     153 * \endcode
     154 * just queue this specific input action but not execute it right away. That's
     155 * left to the other thread. Hence, you need to wait() before:
     156 * -# you access mol.get...() functions as these are not actions themselves.
     157 * -# you need to have files written by molecuilder to be parsed in the python
     158 *    script.
     159 *
     160 *
     161 * \date 2013-09-28
    119162 *
    120163 */
Note: See TracChangeset for help on using the changeset viewer.