build system enhancements

[chaz/yoink] / src / moof / runloop.cc

diff --git a/src/moof/runloop.cc b/src/moof/runloop.cc
index db598145f17fbb7f14e40d6b02713109cd67cd94..98bc3a22cad4b1b2b46b1258b9fe3d03fb999e5a 100644 (file)
--- a/src/moof/runloop.cc
+++ b/src/moof/runloop.cc
@@ -9,7 +9,12 @@
 *
 **************************************************************************/
 
+#include "config.h"
+
+#include <algorithm>
+
 #include "hash.hh"
+#include "log.hh"
 #include "runloop.hh"
 #include "timer.hh"
 
@@ -17,83 +22,48 @@
 namespace moof {
 
 
-enum registry_action
+bool comp(timer* a, timer* b)
 {
-       lookup,
-       set
-};
+       return a->expiration() < b->expiration();
+}
 
-static uint32_t call_registry(runloop*& runloop, registry_action action)
+void runloop::run_once()
 {
-       typedef stlplus::hash<uint32_t,moof::runloop*,hash_function> table_t;
-       static table_t table;
-
-       uint32_t thread_id = thread::current_identifier();
-
-       static MOOF_DECLARE_MUTEX(table_mutex);
-       MOOF_MUTEX_LOCK(table_mutex);
+#if ENABLE_THREADS
+       thread_id_ = thread::current_identifier();
+#endif
 
-       switch (action)
+       //log_debug("------------------------------------");
+       //scalar next_event = SCALAR(0.0);
        {
-               case set:
-               {
-                       if (runloop) table[thread_id] = runloop;
-                       else         table.erase(thread_id);
-                       break;
-               }
+               MOOF_MUTEX_LOCK(timers_mutex_);
 
-               case lookup:
+               for (timers_it_ = timers_.begin();
+                        timers_it_ != timers_.end();
+                        ++timers_it_)
                {
-                       table_t::iterator it = table.find(thread_id);
-                       if (it != table.end()) runloop = (*it).second;
-                       break;
+                       (*timers_it_)->fire_if_expired();
                }
-       }
 
-       return thread_id;
+               std::sort(timers_.begin(), timers_.end(), comp);
+               //next_event = timers_[0]->expiration();
+       }
 }
 
-
 int runloop::run()
 {
-#if ENABLE_THREADS
-       runloop* runloop = this;
-       thread_id_ = call_registry(runloop, set);
-#endif
-
        stop_ = false;
        while (!stop_)
        {
-               scalar next_event = SCALAR(0.0);
-               {
-                       MOOF_MUTEX_LOCK(timers_mutex_);
-
-                       for (timers_it_ = timers_.begin();
-                                timers_it_ != timers_.end();
-                                ++timers_it_)
-                       {
-                               scalar absolute = (*timers_it_)->fire_if_expired();
-                               if (next_event == SCALAR(0.0) ||
-                                       (absolute != SCALAR(0.0) && absolute < next_event))
-                               {
-                                       next_event = absolute;
-                               }
-                       }
-               }
-               timer::sleep(next_event, timer::absolute);
+               run_once();
+               //timer::sleep(next_event, timer::absolute);
+               timer::sleep(SCALAR(0.0));
        }
 
        return code_;
 }
 
 
-runloop::~runloop()
-{
-       runloop* runloop = 0;
-       call_registry(runloop, set);
-}
-
-
 void runloop::stop(int code)
 {
        code_ = code;
@@ -101,44 +71,36 @@ void runloop::stop(int code)
 }
 
 
-runloop* runloop::current()
-{
-       runloop* runloop;
-       call_registry(runloop, lookup);
-       return runloop;
-}
-
-
-void runloop::add_timer(timer* timer)
+void runloop::add_timer(timer& timer)
 {
 #if ENABLE_THREADS
        if (thread_id_ != thread::current_identifier())
        {
                MOOF_MUTEX_LOCK(timers_mutex_);
-               timers_.insert(timer);
+               timers_.push_back(&timer);
                timers_it_ = timers_.end();
        }
        else
 #endif
        {
-               timers_.insert(timer);
+               timers_.push_back(&timer);
                timers_it_ = timers_.end();
        }
 }
 
-void runloop::remove_timer(timer* timer)
+void runloop::remove_timer(timer& timer)
 {
 #if ENABLE_THREADS
        if (thread_id_ != thread::current_identifier())
        {
                MOOF_MUTEX_LOCK(timers_mutex_);
-               timers_.erase(timer);
+               timers_.erase(std::find(timers_.begin(), timers_.end(), &timer));
                timers_it_ = timers_.end();
        }
        else
 #endif
        {
-               timers_.erase(timer);
+               timers_.erase(std::find(timers_.begin(), timers_.end(), &timer));
                timers_it_ = timers_.end();
        }
 }