Merge commit 1b1ed81 into mbed-events/equeue

1b1ed81 Added support for low-power timers in mbed implementation
65d27b2 Moved to statically allocated Semaphores in mbed implementation
b5a79ea Fixed race-conditions in non-rtos mbed wfi implementation
f8dd3b0 Fixed compilation error on Cortex A platforms
90f2b7d Fixed underflow issue in deadline calculation

Author: geky

equeue/equeue.c

@@ -352,7 +352,9 @@ void equeue_dispatch(equeue_t *q, int ms) {
         equeue_mutex_lock(&q->queuelock);
         if (q->queue) {
             int diff = equeue_tickdiff(q->queue->target, tick);
-            if (deadline < 0 || diff < deadline) {
+            if (diff <= 0) {
+                deadline = 0;
+            } else if (deadline < 0 || diff < deadline) {
                 deadline = diff;
             }
         }

equeue/equeue_mbed.cpp

@@ -13,21 +13,18 @@
 
 #include <stdbool.h>
 #include "mbed.h"
-#ifdef MBED_CONF_RTOS_PRESENT
-#include "rtos.h"
-#endif
 
 
 // Ticker operations
-static class GlobalTicker {
+class EqueueTicker {
 public:
-    GlobalTicker() {
+    EqueueTicker() {
         _tick = 0;
         _timer.start();
-        _ticker.attach_us(this, &GlobalTicker::step, (1 << 16) * 1000);
+        _ticker.attach_us(this, &EqueueTicker::update, (1 << 16) * 1000);
     };
 
-    void step() {
+    void update() {
         _timer.reset();
         _tick += 1 << 16;
     }
@@ -38,12 +35,19 @@ static class GlobalTicker {
 
 private:
     unsigned _tick;
+#ifdef DEVICE_LOWPOWERTIMER
+    LowPowerTimer _timer;
+    LowPowerTicker _ticker;
+#else
     Timer _timer;
     Ticker _ticker;
-} gticker;
+#endif
+};
+
+static EqueueTicker equeue_ticker;
 
 unsigned equeue_tick() {
-    return gticker.tick();
+    return equeue_ticker.tick();
 }
 
 
@@ -63,42 +67,55 @@ void equeue_mutex_unlock(equeue_mutex_t *m) {
 // Semaphore operations
 #ifdef MBED_CONF_RTOS_PRESENT
 
-static inline Semaphore *sema(equeue_sema_t *s) {
-    return static_cast<Semaphore*>(*s);
-}
-
 int equeue_sema_create(equeue_sema_t *s) {
-    *s = new Semaphore(0);
-    return sema(s) ? 0 : -1;
+    MBED_ASSERT(sizeof(equeue_sema_t) >= sizeof(Semaphore));
+    new (s) Semaphore(0);
+    return 0;
 }
 
 void equeue_sema_destroy(equeue_sema_t *s) {
-    delete sema(s);
+    reinterpret_cast<Semaphore*>(s)->~Semaphore();
 }
 
 void equeue_sema_signal(equeue_sema_t *s) {
-    sema(s)->release();
+    reinterpret_cast<Semaphore*>(s)->release();
 }
 
 bool equeue_sema_wait(equeue_sema_t *s, int ms) {
-    int t = sema(s)->wait(ms < 0 ? osWaitForever : ms);
-    return t > 0;
+    if (ms < 0) {
+        ms = osWaitForever;
+    }
+
+    return (reinterpret_cast<Semaphore*>(s)->wait(ms) > 0);
 }
 
 #else
 
 // Semaphore operations
-int equeue_sema_create(equeue_sema_t *s) { return 0; }
-void equeue_sema_destroy(equeue_sema_t *s) {}
-void equeue_sema_signal(equeue_sema_t *s) {}
+int equeue_sema_create(equeue_sema_t *s) {
+    *s = false;
+    return 0;
+}
 
-static void equeue_sema_wakeup() {}
+void equeue_sema_destroy(equeue_sema_t *s) {
+}
+
+void equeue_sema_signal(equeue_sema_t *s) {
+    *s = true;
+}
 
 bool equeue_sema_wait(equeue_sema_t *s, int ms) {
     Timeout timeout;
-    timeout.attach_us(equeue_sema_wakeup, ms*1000);
+    timeout.attach_us(s, equeue_sema_signal, ms*1000);
 
-    __WFI();
+    core_util_critical_section_enter();
+    while (!*(volatile equeue_sema_t *)s) {
+        __WFI();
+        core_util_critical_section_exit();
+        core_util_critical_section_enter();
+    }
+    *s = false;
+    core_util_critical_section_exit();
 
     return true;
 }

equeue/equeue_sema.h

@@ -23,9 +23,9 @@ extern "C" {
 typedef sem_t equeue_sema_t;
 #elif defined(__MBED__)
 #ifdef MBED_CONF_RTOS_PRESENT
-typedef void *equeue_sema_t;
+typedef unsigned equeue_sema_t[8];
 #else
-typedef struct {} equeue_sema_t;
+typedef bool equeue_sema_t;
 #endif
 #endif
 

equeue/tests/tests.c

@@ -46,6 +46,11 @@ void simple_func(void *p) {
     (*(int *)p)++;
 }
 
+void sloth_func(void *p) {
+    usleep(10000);
+    (*(int *)p)++;
+}
+
 struct indirect {
     int *touched;
     uint8_t buffer[7];
@@ -102,6 +107,19 @@ void cancel_func(void *p) {
     equeue_cancel(cancel->q, cancel->id);
 }
 
+struct nest {
+    equeue_t *q;
+    void (*cb)(void *);
+    void *data;
+};
+
+void nest_func(void *p) {
+    struct nest *nest = (struct nest *)p;
+    equeue_call(nest->q, nest->cb, nest->data);
+
+    usleep(10000);
+}
+
 
 // Simple call tests
 void simple_call_test(void) {
@@ -375,6 +393,92 @@ void period_test(void) {
     equeue_destroy(&q);
 }
 
+void nested_test(void) {
+    equeue_t q;
+    int err = equeue_create(&q, 2048);
+    test_assert(!err);
+
+    int touched = 0;
+    struct nest *nest = equeue_alloc(&q, sizeof(struct nest));
+    test_assert(nest);
+    nest->q = &q;
+    nest->cb = simple_func;
+    nest->data = &touched;
+
+    int id = equeue_post(&q, nest_func, nest);
+    test_assert(id);
+
+    equeue_dispatch(&q, 5);
+    test_assert(touched == 0);
+
+    equeue_dispatch(&q, 5);
+    test_assert(touched == 1);
+
+    touched = 0;
+    nest = equeue_alloc(&q, sizeof(struct nest));
+    test_assert(nest);
+    nest->q = &q;
+    nest->cb = simple_func;
+    nest->data = &touched;
+
+    id = equeue_post(&q, nest_func, nest);
+    test_assert(id);
+
+    equeue_dispatch(&q, 20);
+    test_assert(touched == 1);
+
+    equeue_destroy(&q);
+}
+
+void sloth_test(void) {
+    equeue_t q;
+    int err = equeue_create(&q, 2048);
+    test_assert(!err);
+
+    int touched = 0;
+    int id = equeue_call(&q, sloth_func, &touched);
+    test_assert(id);
+
+    id = equeue_call_in(&q, 5, simple_func, &touched);
+    test_assert(id);
+
+    id = equeue_call_in(&q, 15, simple_func, &touched);
+    test_assert(id);
+
+    equeue_dispatch(&q, 20);
+    test_assert(touched == 3);
+
+    equeue_destroy(&q);
+}
+
+void *multithread_thread(void *p) {
+    equeue_t *q = (equeue_t *)p;
+    equeue_dispatch(q, -1);
+    return 0;
+}
+
+void multithread_test(void) {
+    equeue_t q;
+    int err = equeue_create(&q, 2048);
+    test_assert(!err);
+
+    bool touched = false;
+    equeue_call_every(&q, 1, simple_func, &touched);
+
+    pthread_t thread;
+    err = pthread_create(&thread, 0, multithread_thread, &q);
+    test_assert(!err);
+
+    usleep(10000);
+    equeue_break(&q);
+    err = pthread_join(thread, 0);
+    test_assert(!err);
+
+    test_assert(touched);
+
+    equeue_destroy(&q);
+}
+
 // Barrage tests
 void simple_barrage_test(int N) {
     equeue_t q;
@@ -483,6 +587,9 @@ int main() {
     test_run(loop_protect_test);
     test_run(break_test);
     test_run(period_test);
+    test_run(nested_test);
+    test_run(sloth_test);
+    test_run(multithread_test);
     test_run(simple_barrage_test, 20);
     test_run(fragmenting_barrage_test, 20);
     test_run(multithreaded_barrage_test, 20);