Changes in / [7e6c0d:eea0bb]

Location:

src/Actions

Files:

• ActionQueue.cpp (modified) (11 diffs)
• ActionQueue.hpp (modified) (4 diffs)

src/Actions/ActionQueue.cpp

@@ -65 +65 @@
     lastActionOk(true)
 #else
+    CurrentAction(0),
     lastActionOk(true),
-    CurrentAction(0),
-    run_thread_isIdle(true),
-    run_thread_running(false),
-    run_thread(boost::bind(&ActionQueue::run, this))
+    run_thread(boost::bind(&ActionQueue::run, this)),
+    run_thread_isIdle(true)
 #endif
 {
@@ -105 +104 @@
   newaction->prepare(state);
 #ifdef HAVE_ACTION_THREAD
-  mtx_actionqueue.lock();
+  mtx_queue.lock();
 #endif
   actionqueue.push_back( newaction );
@@ -115 +114 @@
     std::cerr << "Action " << *boost::get_error_info<ActionNameString>(e) << " has failed." << std::endl;
     World::getInstance().setExitFlag(5);
-//    clearQueue(actionqueue.size()-1);
+    clearQueue(actionqueue.size()-1);
     lastActionOk = false;
-//    std::cerr << "Remaining Actions cleared from queue." << std::endl;
+    std::cerr << "Remaining Actions cleared from queue." << std::endl;
   } catch (std::exception &e) {
     pushStatus("FAIL: General exception caught, aborting.");
     World::getInstance().setExitFlag(134);
-//    clearQueue(actionqueue.size()-1);
+    clearQueue(actionqueue.size()-1);
     lastActionOk = false;
-//    std::cerr << "Remaining Actions cleared from queue." << std::endl;
+    std::cerr << "Remaining Actions cleared from queue." << std::endl;
   }
   if (lastActionOk) {
@@ -131 +130 @@
   }
 #else
-  mtx_actionqueue.unlock();
-  const bool new_run_thread_isIdle = isActionQueueDone();
-  setrun_thread_isIdle(new_run_thread_isIdle);
-#endif
-}
-
-#ifdef HAVE_ACTION_THREAD
-bool ActionQueue::isActionQueueDone() const
-{
-  boost::lock_guard<boost::mutex> lock(mtx_actionqueue);
-  return (CurrentAction == actionqueue.size());
-}
-
-bool ActionQueue::isTempQueueDone() const
-{
-  boost::lock_guard<boost::mutex> lock(mtx_tempqueue);
-  return tempqueue.empty();
-}
-#endif
+  setRunThreadIdle(CurrentAction == actionqueue.size());
+  mtx_queue.unlock();
+#endif
+}
 
 void ActionQueue::insertAction(Action *_action, enum Action::QueryOptions state)
@@ -158 +142 @@
   Action *newaction = _action->clone(state);
   newaction->prepare(state);
-  {
-    boost::lock_guard<boost::mutex> lock(mtx_tempqueue);
-    tempqueue.push_back( newaction );
-  }
-  {
-    bool new_run_thread_isIdle = getrun_thread_isIdle();
-    new_run_thread_isIdle &= isTempQueueDone();
-    setrun_thread_isIdle(new_run_thread_isIdle);
-  }
+  mtx_queue.lock();
+  tempqueue.push_back( newaction );
+  setRunThreadIdle( !((CurrentAction != actionqueue.size()) || !tempqueue.empty()) );
+  mtx_queue.unlock();
 #endif
 }
@@ -173 +152 @@
 void ActionQueue::run()
 {
-  {
-    boost::lock_guard<boost::mutex> lock(mtx_run_thread_isIdle);
-    run_thread_running = true;
-  }
   bool Interrupted = false;
   do {
@@ -182 +157 @@
     try {
 #if BOOST_VERSION < 105000
-      boost::this_thread::sleep(boost::get_system_time() + boost::posix_time::milliseconds(100));
+      run_thread.sleep(boost::get_system_time() + boost::posix_time::milliseconds(100));
 #else
       boost::this_thread::sleep_for(boost::chrono::milliseconds(100));
@@ -192 +167 @@
 //    LOG(1, "DEBUG: Start of ActionQueue's run() loop.");
     // call all currently present Actions
+    mtx_queue.lock();
     insertTempQueue();
-    while ((!Interrupted) && (!isActionQueueDone())) {
+    bool status = (CurrentAction != actionqueue.size());
+    mtx_queue.unlock();
+    while (status) {
       //      boost::this_thread::disable_interruption di;
-      // access actionqueue, hence using mutex
-      mtx_actionqueue.lock();
       LOG(0, "Calling Action " << actionqueue[CurrentAction]->getName() << " ... ");
       try {
@@ -216 +192 @@
         std::cerr << "Remaining Actions cleared from queue." << std::endl;
       }
-      // remember action we juse executed
-      const Action *lastaction = actionqueue[CurrentAction];
-      // step on to next action and check for end
-      CurrentAction++;
+      if (lastActionOk) {
+        OBSERVE;
+        NOTIFY(ActionQueued);
+        _lastchangedaction = actionqueue[CurrentAction];
+        mtx_queue.lock();
+        CurrentAction++;
+        mtx_queue.unlock();
+      }
+      // access actionqueue, hence using mutex
+      mtx_queue.lock();
       // insert new actions (before [CurrentAction]) if they have been spawned
       // we must have an extra vector for this, as we cannot change actionqueue
       // while an action instance is "in-use"
-      mtx_actionqueue.unlock();
-
       insertTempQueue();
-
-      // set last action
-      if (lastActionOk) {
-        OBSERVE;
-        NOTIFY(ActionQueued);
-        _lastchangedaction = lastaction;
-      }
+      status = (CurrentAction != actionqueue.size());
+      mtx_queue.unlock();
     }
-    {
-      bool new_run_thread_isIdle = isActionQueueDone();
-      new_run_thread_isIdle &= isTempQueueDone();
-      setrun_thread_isIdle(new_run_thread_isIdle);
-    }
+    setRunThreadIdle( !((CurrentAction != actionqueue.size()) || !tempqueue.empty()) );
     cond_idle.notify_one();
 //    LOG(1, "DEBUG: End of ActionQueue's run() loop.");
   } while (!Interrupted);
-  {
-    boost::lock_guard<boost::mutex> lock(mtx_run_thread_isIdle);
-    run_thread_running = false;
-  }
 }
 
 void ActionQueue::insertTempQueue()
 {
-  boost::lock_guard<boost::mutex> lock(mtx_tempqueue);
   if (!tempqueue.empty()) {
-    boost::lock_guard<boost::mutex> lock(mtx_actionqueue);
     ActionQueue_t::iterator InsertionIter = actionqueue.begin();
     std::advance(InsertionIter, CurrentAction);
@@ -260 +225 @@
 }
 
-void ActionQueue::setrun_thread_isIdle(
-    const bool _run_thread_isIdle)
-{
-  boost::unique_lock<boost::mutex> lock(mtx_run_thread_isIdle);
-  run_thread_isIdle = _run_thread_isIdle;
-}
-
-bool ActionQueue::getrun_thread_isIdle() const
-{
-  boost::unique_lock<boost::mutex> lock(mtx_run_thread_isIdle);
-  return run_thread_isIdle;
-}
-
 void ActionQueue::wait()
 {
-  if (run_thread_running) {
-    boost::unique_lock<boost::mutex> lock(mtx_run_thread_isIdle);
-    while(!run_thread_isIdle)
-    {
-        cond_idle.wait(lock);
-    }
-  }
-}
-
+  boost::unique_lock<boost::mutex> lock(mtx_idle);
+  while(!run_thread_isIdle)
+  {
+      cond_idle.wait(lock);
+  }
+}
+#endif
+
+#ifdef HAVE_ACTION_THREAD
 void ActionQueue::stop()
 {
@@ -359 +311 @@
 void ActionQueue::clearQueue(const size_t _fromAction)
 {
-  // free all actions contained in actionqueue
+#ifdef HAVE_ACTION_THREAD
+  mtx_queue.lock();
+#endif
+  LOG(1, "Removing all Actions from position " << _fromAction << " onward.");
+  // free all actions still to be called contained in actionqueue
+  ActionQueue_t::iterator inititer = actionqueue.begin();
+  std::advance(inititer, _fromAction);
+  for (ActionQueue_t::iterator iter = inititer; iter != actionqueue.end(); ++iter)
+    delete *iter;
+  actionqueue.erase(inititer, actionqueue.end());
+  LOG(1, "There are " << actionqueue.size() << " remaining Actions.");
+#ifdef HAVE_ACTION_THREAD
+  CurrentAction = actionqueue.size();
+  mtx_queue.unlock();
+#endif
+}
+
+#ifdef HAVE_ACTION_THREAD
+void ActionQueue::clearTempQueue()
+{
+  // free all actions contained in tempqueue
+  for (ActionQueue_t::iterator iter = tempqueue.begin();
+      !tempqueue.empty(); iter = tempqueue.begin()) {
+    delete *iter;
+    tempqueue.erase(iter);
+  }
+}
+
+void ActionQueue::setRunThreadIdle(const bool _flag)
+{
   {
-#ifdef HAVE_ACTION_THREAD
-    boost::lock_guard<boost::mutex> lock(mtx_actionqueue);
-#endif
-    LOG(1, "Removing all Actions from position " << _fromAction << " onward.");
-    // free all actions still to be called contained in actionqueue
-    ActionQueue_t::iterator inititer = actionqueue.begin();
-    std::advance(inititer, _fromAction);
-    for (ActionQueue_t::iterator iter = inititer; iter != actionqueue.end(); ++iter)
-      delete *iter;
-    actionqueue.erase(inititer, actionqueue.end());
-    LOG(1, "There are " << actionqueue.size() << " remaining Actions.");
-#ifdef HAVE_ACTION_THREAD
-    CurrentAction = actionqueue.size();
-#endif
-  }
-}
-
-#ifdef HAVE_ACTION_THREAD
-void ActionQueue::clearTempQueue()
-{
-  // free all actions contained in tempqueue
-  {
-    boost::lock_guard<boost::mutex> lock(mtx_tempqueue);
-    for (ActionQueue_t::iterator iter = tempqueue.begin();
-        !tempqueue.empty(); iter = tempqueue.begin()) {
-      delete *iter;
-      tempqueue.erase(iter);
-    }
+    boost::unique_lock<boost::mutex> lock(mtx_idle);
+    run_thread_isIdle = _flag;
   }
 }

src/Actions/ActionQueue.hpp

@@ -215 +215 @@
   void clearTempQueue();
 
+  /** Sets the run_thread_isIdle flag.
+   *
+   * @param _flag state to set to
+   */
+  void setRunThreadIdle(const bool _flag);
+
   /** Runs the ActionQueue.
    *
@@ -249 +255 @@
   void insertAction(Action *_action, enum Action::QueryOptions state);
 
-#ifdef HAVE_ACTION_THREAD
-  /** Helper to check whether there are more actions in actionqueue for
-   * run_thread.
-   *
-   * \return false - more actions, true - CurrentAction is beyond last action.
-   */
-  bool isActionQueueDone() const;
-
-  /** Helper to check whether there are more actions in tempqueue for
-   * run_thread.
-   *
-   * \return false - more actions, true - tempqueue is empty
-   */
-  bool isTempQueueDone() const;
-
-  /** Getter to run_thread_isIdle wrapped in mutex.
-   *
-   * \return true - run_thread is idle, false - it is not
-   */
-  bool getrun_thread_isIdle() const;
-
-  /** Setter for run_thread_isIdle wrapped in mutex.
-   *
-   * \param _run_thread_isIdle new idle status for run_thread
-   */
-  void setrun_thread_isIdle(
-      const bool _run_thread_isIdle);
-#endif
-
 private:
   /** Private cstor for ActionQueue.
@@ -314 +291 @@
   ActionQueue_t tempqueue;
 
+  //!> internal thread to call Actions
+  boost::thread run_thread;
+
   //!> internal mutex to synchronize access to queue
-  mutable boost::mutex mtx_actionqueue;
-
-  //!> internal mutex to synchronize access to queue
-  mutable boost::mutex mtx_tempqueue;
+  boost::mutex mtx_queue;
 
   //!> conditional variable notifying when run_thread is idling
@@ -327 +304 @@
 
   //!> internal mutex to synchronize access to run_thread_isIdle
-  mutable boost::mutex mtx_run_thread_isIdle;
+  boost::mutex mtx_idle;
 #endif
 
   //!> internal list of status messages from Actions for UIs to display
   ActionStatusList StatusList;
-
-  // set run_thread to end such that others are initialized first (especially mutexes)
-#ifdef HAVE_ACTION_THREAD
-  //!> internal flag to tell whether run_thread is still running
-  bool run_thread_running;
-
-  //!> internal thread to call Actions
-  boost::thread run_thread;
-#endif
 };
 namespace Queuedetail {