Removed the EventLoop class

The EventLoop was an interesting concept: the combination of an
EventQueue and a Thread. The idea was that the EventLoop would provide
a convenient coupling of these two concepts for use in module
boundaries, and the EventLoop could abstract out some of the
complexities with running an event queue in a thread.

However, with the addition of the chain function, event queues can be
easily composed without threads or indirect references to event queues.
Threads can still be spawned dynamically in default-constructors,
although the overhead is much more explicit and tangible.

Additionally, it turned out there weren't that many complexities with
running an event queue in a thread.

There were, surprisingly, several problems with just passing the
EventQueue::dispatch function to mbed's Thread constructor.

1. Split EventQueue::dispatch into overloaded functions

   Apparently, default parameters don't create another target for
   infering member-function-pointers.

2. Remove problematic template overloads in Thread constructor

   Issue is actually here ARMmbed/mbed-os#2395.
   The indirection in the nested callback templates prevented correct
   overload resolution and let to template-expansion errors.

3. Exposed break_

   Allows threaded event queues to shutdown cleanly.

With these changes, this code:

    EventLoop loop;
    loop.start();
    loop.call(F);
    loop.stop();

Becomes:

    EventQueue queue;
    Thread thread;
    thread.start(&queue, &EventQueue::dispatch);
    queue.call(F);
    queue.break_();
    thread.join();

Except now with 182 less lines to maintain

Author: geky

EventLoop.cpp

@@ -24,7 +24,7 @@ void EventQueue::break_() {
     return equeue_break(&_equeue);
 }
 
-unsigned EventQueue::get_tick() {
+unsigned EventQueue::tick() {
     return equeue_tick();
 }
 

EventLoop.h

@@ -31,10 +31,10 @@ namespace events {
 #define EVENTS_EVENT_SIZE \
     (EQUEUE_EVENT_SIZE - 2*sizeof(void*) + sizeof(mbed::Callback<void()>))
 
-/** DEFAULT_QUEUE_SIZE
- *  default size of buffer for events
+/** EVENTS_QUEUE_SIZE
+ *  Default size of buffer for events
  */
-#define DEFAULT_QUEUE_SIZE (32*EVENTS_EVENT_SIZE)
+#define EVENTS_QUEUE_SIZE (32*EVENTS_EVENT_SIZE)
 
 
 /** EventQueue
@@ -46,11 +46,11 @@ class EventQueue {
     /** Create an event queue
      *
      *  @param queue_size       Size of buffer to use for events
-     *                          (default: DEFAULT_QUEUE_SIZE)
+     *                          (default: EVENTS_QUEUE_SIZE)
      *  @param queue_pointer    Pointer to memory region to use for events
      *                          (default: NULL)
      */
-    EventQueue(unsigned queue_size=DEFAULT_QUEUE_SIZE,
+    EventQueue(unsigned queue_size=EVENTS_QUEUE_SIZE,
                unsigned char *queue_pointer=NULL);
 
     /** Destroy an event queue
@@ -65,11 +65,18 @@ class EventQueue {
      */
     void dispatch(int ms=-1);
 
+    /** Break out of a running event loop
+     *
+     *  Already pending events may finish executing, but the queue will not
+     *  continue to loop indefinitely.
+     */
+    void break_();
+
     /*  Monotonic counter for the event queue
      *  @return     A monotonically incrementing counter in milliseconds
      *              this count intentionally overflows to 0 after 2^32-1
      */
-    unsigned get_tick();
+    unsigned tick();
 
     /** Cancel events that are in flight
      *
@@ -241,7 +248,6 @@ class EventQueue {
     }
 
 protected:
-    void break_();
 
     struct equeue _equeue;
     mbed::Callback<void(int)> _update;

EventQueue.cpp

@@ -102,40 +102,6 @@ void call_every_test() {
     queue.dispatch(N*100);
 }
 
-#ifdef MBED_CONF_RTOS_PRESENT
-void event_loop_test1() {
-    EventLoop loop;
-    osStatus status = loop.start();
-    TEST_ASSERT_EQUAL(osOK, status);
-
-    touched = false;
-    loop.call(func0);
-    Thread::yield();
-    TEST_ASSERT(touched);
-
-    status = loop.stop();
-    TEST_ASSERT_EQUAL(osOK, status);
-}
-
-template <int N>
-void event_loop_test2() {
-    EventLoop loop(osPriorityHigh);
-    osStatus status = loop.start();
-    TEST_ASSERT_EQUAL(osOK, status);
-
-    Timer tickers[N];
-
-    for (int i = 0; i < N; i++) {
-        tickers[i].start();
-        loop.call_every((i+1)*100, time_func, &tickers[i], (i+1)*100);
-        Thread::yield();
-        wait_ms(75);
-    }
-
-    wait_ms(N*100);
-}
-#endif
-
 struct big { char data[4096]; } big;
 
 void allocate_failure_test1() {
@@ -176,28 +142,6 @@ void cancel_test1() {
     queue.dispatch(0);
 }
 
-#ifdef MBED_CONF_RTOS_PRESENT
-template <int N>
-void cancel_test2() {
-    EventLoop loop;
-    osStatus status = loop.start();
-    TEST_ASSERT_EQUAL(osOK, status);
-
-    int ids[N];
-
-    for (int i = 0; i < N; i++) {
-        ids[i] = loop.call_in(1000, no);
-    }
-
-    for (int i = N-1; i >= 0; i--) {
-        loop.cancel(ids[i]);
-    }
-
-    status = loop.stop();
-    TEST_ASSERT_EQUAL(osOK, status);
-}
-#endif
-
 
 // Test setup
 utest::v1::status_t test_setup(const size_t number_of_cases) {
@@ -216,18 +160,10 @@ const Case cases[] = {
     Case("Testing call_in",    call_in_test<20>),
     Case("Testing call_every", call_every_test<20>),
 
-#ifdef MBED_CONF_RTOS_PRESENT
-    Case("Testing event loop 1", event_loop_test1),
-    Case("Testing event loop 2", event_loop_test2<20>),
-#endif
-
     Case("Testing allocate failure 1", allocate_failure_test1),
     Case("Testing allocate failure 2", allocate_failure_test2),
 
     Case("Testing event cancel 1", cancel_test1<20>),
-#ifdef MBED_CONF_RTOS_PRESENT
-    Case("Testing event cancel 2", cancel_test2<20>),
-#endif
 };
 
 Specification specification(test_setup, cases);

EventQueue.h

@@ -23,7 +23,6 @@
 #ifdef __cplusplus
 
 #include "EventQueue.h"
-#include "EventLoop.h"
 
 using namespace events;