Removing the 'non-preemptible' madness before it could even be used.

3 files changed, 19 insertions, 40 deletions

diff --git a/includes/Task.h b/includes/Task.h
index 691d47f..64156ba 100644
--- a/includes/Task.h
+++ b/includes/Task.h
@@ -90,23 +90,29 @@ class Task {
     virtual const char * getName() = 0;
     Status getStatus() { return m_status; }
     static Task * getCurrentTask();
+    static void prepare(Events::BaseEvent * evt) {
+        Task * t = getCurrentTask();
+        t->waitFor(evt);
+    }
     static void yield(Events::BaseEvent * evt, bool interruptible = false) throw (GeneralException) {
         Task * t = getCurrentTask();
-        t->waitFor(evt, true);
+        t->waitFor(evt);
 
         do {
-            t->yield(true);
+            t->yield();
+            Printer::elog(E_TASK, "operation back from yielding; interruptible = %s; okayToEAgain = %s", interruptible ? "true" : "false", t->m_okayToEAgain ? "true" : "false");
         } while ((!interruptible || !t->m_okayToEAgain) && !evt->gotSignal());
-        if (interruptible && t->m_okayToEAgain && !evt->gotSignal())
+        if (interruptible && t->m_okayToEAgain && !evt->gotSignal()) {
+            Printer::elog(E_TASK, "operation is throwing an exception.");
             throw EAgain(evt);
+        }
     }
     TaskMan * getTaskMan() { return m_taskMan; }
     struct ev_loop * getLoop();
   protected:
-    void yield(bool override = false);
+    void yield();
     virtual void Do() = 0;
-    void waitFor(Events::BaseEvent * event, bool override = false);
-    bool setPreemptible(bool enable);
+    void waitFor(Events::BaseEvent * event);
     bool setOkayToEAgain(bool enable) {
         bool oldValue = m_okayToEAgain;
         m_okayToEAgain = enable;
@@ -125,7 +131,6 @@ class Task {
     friend class Events::TaskEvent;
     typedef std::vector<Events::TaskEvent *> waitedByList_t;
     waitedByList_t m_waitedBy;
-    struct ev_loop * m_loop;
     bool m_okayToEAgain;
 };
 
diff --git a/src/Task.cc b/src/Task.cc
index 8ad5cb7..202d6ab 100644
--- a/src/Task.cc
+++ b/src/Task.cc
@@ -21,15 +21,12 @@ Balau::Task::Task() {
     g_tlsManager->setTLS(oldTLS);
 
     m_status = STARTING;
-    m_loop = NULL;
     m_okayToEAgain = false;
 
     Printer::elog(E_TASK, "Created a Task at %p");
 }
 
 Balau::Task::~Task() {
-    if (m_loop)
-        ev_loop_destroy(m_loop);
     free(m_stack);
     free(m_tls);
 }
@@ -65,42 +62,22 @@ void Balau::Task::switchTo() {
         m_status = IDLE;
 }
 
-void Balau::Task::yield(bool override) {
-    if (m_loop && override) {
-        ev_run(m_loop, 0);
-    } else {
-        coro_transfer(&m_ctx, &m_taskMan->m_returnContext);
-    }
+void Balau::Task::yield() {
+    Printer::elog(E_TASK, "Task %p - %s yielding", this, getName());
+    coro_transfer(&m_ctx, &m_taskMan->m_returnContext);
 }
 
 Balau::Task * Balau::Task::getCurrentTask() {
     return localTask.get();
 }
 
-void Balau::Task::waitFor(Balau::Events::BaseEvent * e, bool override) {
-    struct ev_loop * loop = m_loop;
-    if (!override)
-        m_loop = NULL;
+void Balau::Task::waitFor(Balau::Events::BaseEvent * e) {
+    Printer::elog(E_TASK, "Task %p - %s waits for event %p (%s)", this, getName(), e, ClassName(e).c_str());
     e->registerOwner(this);
-    m_loop = loop;
-}
-
-bool Balau::Task::setPreemptible(bool enable) {
-    bool wasPreemptible = !m_loop;
-    if (!m_loop && !enable) {
-        m_loop = ev_loop_new(EVFLAG_AUTO);
-    } else if (m_loop) {
-        ev_loop_destroy(m_loop);
-        m_loop = NULL;
-    }
-    return wasPreemptible;
 }
 
 struct ev_loop * Balau::Task::getLoop() {
-    if (m_loop)
-        return m_loop;
-    else
-        return getTaskMan()->getLoop();
+    return getTaskMan()->getLoop();
 }
 
 void Balau::Events::BaseEvent::doSignal() {
diff --git a/tests/test-Tasks.cc b/tests/test-Tasks.cc
index bdafa8d..9f07dda 100644
--- a/tests/test-Tasks.cc
+++ b/tests/test-Tasks.cc
@@ -47,11 +47,8 @@ void MainTask::Do() {
 
     timeout.set(0.1);
     timeout.reset();
-    setPreemptible(false);
-    yieldingFunction();
-    Assert(!timeout.gotSignal());
     waitFor(&timeout);
-    yield();
+    yieldingFunction();
     Assert(timeout.gotSignal());
 
     Printer::log(M_STATUS, "Test::Tasks passed.");