Changeset 415ddd for src/Actions


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/Actions
Files:
2 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
Note: See TracChangeset for help on using the changeset viewer.