remove scheduled functions complexity overhead, change recurrent functions api

Author: d-a-v

cores/esp8266/Schedule.cpp

@@ -6,23 +6,30 @@
 #include "interrupts.h"
 #include "coredecls.h"
 
-typedef std::function<bool(void)> mFuncT;
+typedef std::function<void(void)> mSchedFuncT;
+typedef std::function<bool(void)> mRecFuncT;
 
 struct scheduled_fn_t
 {
     scheduled_fn_t* mNext = nullptr;
-    mFuncT mFunc;
-    esp8266::polledTimeout::periodicFastUs callNow;
-    schedule_e policy;
-
-    scheduled_fn_t() : callNow(esp8266::polledTimeout::periodicFastUs::alwaysExpired) { }
+    mSchedFuncT mFunc;
 };
 
 static scheduled_fn_t* sFirst = nullptr;
 static scheduled_fn_t* sLast = nullptr;
 static scheduled_fn_t* sUnused = nullptr;
 static int sCount = 0;
 
+struct recurrent_fn_t
+{
+    recurrent_fn_t* mNext = nullptr;
+    mRecFuncT mFunc;
+    esp8266::polledTimeout::periodicFastUs callNow;
+    recurrent_fn_t(esp8266::polledTimeout::periodicFastUs interval) : callNow(interval) { }
+};
+
+static recurrent_fn_t* rFirst = nullptr; // stack, fifo not needed
+
 IRAM_ATTR // called from ISR
 static scheduled_fn_t* get_fn_unsafe()
 {
@@ -33,7 +40,6 @@ static scheduled_fn_t* get_fn_unsafe()
         result = sUnused;
         sUnused = sUnused->mNext;
         result->mNext = nullptr;
-        result->callNow.reset(esp8266::polledTimeout::periodicFastUs::alwaysExpired);
     }
     // if no unused items, and count not too high, allocate a new one
     else if (sCount < SCHEDULED_FN_MAX_COUNT)
@@ -52,19 +58,14 @@ static void recycle_fn_unsafe(scheduled_fn_t* fn)
 }
 
 IRAM_ATTR // (not only) called from ISR
-bool schedule_function_us(std::function<bool(void)>&& fn, uint32_t repeat_us, schedule_e policy)
+bool schedule_function_us(std::function<void(void)>&& fn)
 {
-    assert(repeat_us < decltype(scheduled_fn_t::callNow)::neverExpires); //~26800000us (26.8s)
-
     InterruptLock lockAllInterruptsInThisScope;
 
     scheduled_fn_t* item = get_fn_unsafe();
     if (!item)
         return false;
 
-    if (repeat_us)
-        item->callNow.reset(repeat_us);
-    item->policy = policy;
     item->mFunc = fn;
 
     if (sFirst)
@@ -76,90 +77,106 @@ bool schedule_function_us(std::function<bool(void)>&& fn, uint32_t repeat_us, sc
     return true;
 }
 
-IRAM_ATTR // (not only) called from ISR
-bool schedule_function_us(const std::function<bool(void)>& fn, uint32_t repeat_us, schedule_e policy)
+IRAM_ATTR // called from ISR
+bool schedule_function (const std::function<void(void)>& fn)
 {
-    return schedule_function_us(std::function<bool(void)>(fn), repeat_us, policy);
+    return schedule_function(std::function<void(void)>(fn));
 }
 
-IRAM_ATTR // called from ISR
-bool schedule_function(std::function<void(void)>&& fn, schedule_e policy)
+IRAM_ATTR // (not only) called from ISR
+bool schedule_recurrent_function_us (std::function<bool(void)>&& fn, uint32_t repeat_us)
 {
-    return schedule_function_us([fn]() { fn(); return false; }, 0, policy);
+    assert(repeat_us < decltype(recurrent_fn_t::callNow)::neverExpires); //~26800000us (26.8s)
+
+    InterruptLock lockAllInterruptsInThisScope;
+
+    recurrent_fn_t* item = new recurrent_fn_t(repeat_us);
+    if (!item)
+        return false;
+
+    item->mFunc = fn;
+
+    if (rFirst)
+    {
+        item->mNext = rFirst;
+        rFirst = item;
+    }
+    else
+        rFirst = item;
+
+    return true;
 }
 
-IRAM_ATTR // called from ISR
-bool schedule_function(const std::function<void(void)>& fn, schedule_e policy)
+void run_scheduled_functions()
 {
-    return schedule_function(std::function<void(void)>(fn), policy);
+    esp8266::polledTimeout::periodicFastMs yieldNow(100); // yield every 100ms
+
+    while (sFirst)
+    {
+        sFirst->mFunc();
+
+        {
+            InterruptLock lockAllInterruptsInThisScope;
+
+            auto to_recycle = sFirst;
+            sFirst = sFirst->mNext;
+            if (!sFirst)
+                sLast = nullptr;
+            recycle_fn_unsafe(to_recycle);
+        }
+
+        if (yieldNow)
+        {
+            // because scheduled function are allowed to last:
+            // this is yield() in cont stack:
+            esp_schedule();
+            cont_yield(g_pcont);
+        }
+    }
 }
 
-void run_scheduled_functions(schedule_e policy)
+void run_scheduled_recurrent_functions ()
 {
     // Note to the reader:
     // There is no exposed API to remove a scheduled function:
     // Scheduled functions are removed only from this function, and
     // its purpose is that it is never called from an interrupt
     // (always on cont stack).
 
+    if (!rFirst)
+        return;
+
     static bool fence = false;
     {
         InterruptLock lockAllInterruptsInThisScope;
         if (fence)
             // prevent recursive calls from yield()
+            // (even if they are not allowed)
             return;
         fence = true;
     }
 
-    esp8266::polledTimeout::periodicFastMs yieldNow(100); // yield every 100ms
-    scheduled_fn_t* lastRecurring = nullptr;
-    scheduled_fn_t* nextCall = sFirst;
-    while (nextCall)
-    {
-        scheduled_fn_t* toCall = nextCall;
-        nextCall = nextCall->mNext;
-
-        // run scheduled function:
-        // - when its schedule policy allows it anytime
-        // - or if we are called at loop() time
-        // and
-        // - its time policy allows it
-        if (   (   toCall->policy == SCHEDULED_FUNCTION_WITHOUT_YIELDELAYCALLS
-                || policy == SCHEDULED_FUNCTION_ONCE_PER_LOOP)
-            && toCall->callNow)
-        {
-            if (toCall->mFunc())
-            {
-                // function stays in list
-                lastRecurring = toCall;
-            }
-            else
-            {
-                // function removed from list
-                InterruptLock lockAllInterruptsInThisScope;
-
-                if (sFirst == toCall)
-                    sFirst = sFirst->mNext;
-                else if (lastRecurring)
-                    lastRecurring->mNext = toCall->mNext;
+    recurrent_fn_t* prev = nullptr;
+    recurrent_fn_t* current = rFirst;
 
-                if (sLast == toCall)
-                    sLast = lastRecurring;
+    while (current)
+        if (current->callNow && !current->mFunc())
+        {
+            // remove function from stack
+            InterruptLock lockAllInterruptsInThisScope;
 
-                recycle_fn_unsafe(toCall);
-            }
+            auto to_ditch = current;
+            if (prev)
+                prev->mNext = current = current->mNext;
+            else
+                current = rFirst = rFirst->mNext;
+            delete(to_ditch);
         }
         else
-            // function stays in list
-            lastRecurring = toCall;
-
-        if (policy == SCHEDULED_FUNCTION_ONCE_PER_LOOP && yieldNow)
         {
-            // this is yield() in cont stack:
-            esp_schedule();
-            cont_yield(g_pcont);
+            prev = current;
+            current = current->mNext;
         }
-    }
 
     fence = false;
 }

cores/esp8266/Schedule.h

@@ -26,33 +26,25 @@
 
 #define SCHEDULED_FN_MAX_COUNT 32
 
-enum schedule_e
-{
-    SCHEDULED_FUNCTION_ONCE_PER_LOOP,
-    SCHEDULED_FUNCTION_WITHOUT_YIELDELAYCALLS
-};
-
 // * Run the lambda only once next time
-bool schedule_function(std::function<void(void)>&& fn,
-                       schedule_e policy = SCHEDULED_FUNCTION_ONCE_PER_LOOP);
-bool schedule_function(const std::function<void(void)>& fn,
-                       schedule_e policy = SCHEDULED_FUNCTION_ONCE_PER_LOOP);
+// * long running operations, yield() and delay() are allowed
+bool schedule_function(std::function<void(void)>&& fn);
+bool schedule_function(const std::function<void(void)>& fn);
+
+// Run all scheduled functions.
+// Use this function if your are not using `loop`, or `loop` does not return
+// on a regular basis.
+void run_scheduled_functions();
 
 // * Run the lambda periodically about every <repeat_us> microseconds until
 //   it returns false.
 // * Note that it may be more than <repeat_us> microseconds between calls if
 //   `yield` is not called frequently, and therefore should not be used for
 //   timing critical operations.
-bool schedule_function_us(std::function<bool(void)>&& fn,
-                          uint32_t repeat_us,
-                          schedule_e policy = SCHEDULED_FUNCTION_ONCE_PER_LOOP);
-bool schedule_function_us(const std::function<bool(void)>& fn,
-                          uint32_t repeat_us,
-                          schedule_e policy = SCHEDULED_FUNCTION_ONCE_PER_LOOP);
+// * long running operations, yield() and delay() are not wise
+// * No exposed API to remove a scheduled function
 
-// Run all scheduled functions.
-// Use this function if your are not using `loop`, or `loop` does not return
-// on a regular basis.
-void run_scheduled_functions(schedule_e policy = SCHEDULED_FUNCTION_ONCE_PER_LOOP);
+bool schedule_recurrent_function_us(std::function<bool(void)>&& fn, uint32_t repeat_us);
+void run_scheduled_recurrent_functions();
 
 #endif //ESP_SCHEDULE_H

cores/esp8266/core_esp8266_main.cpp

@@ -87,7 +87,7 @@ void preloop_update_frequency() {
 static inline void esp_yield_within_cont() __attribute__((always_inline));
 static void esp_yield_within_cont() {
         cont_yield(g_pcont);
-        run_scheduled_functions(SCHEDULED_FUNCTION_WITHOUT_YIELDELAYCALLS);
+        run_scheduled_recurrent_functions();
 }
 
 extern "C" void esp_yield() {
@@ -129,7 +129,8 @@ static void loop_wrapper() {
         setup_done = true;
     }
     loop();
-    run_scheduled_functions(SCHEDULED_FUNCTION_ONCE_PER_LOOP);
+    run_scheduled_functions();
+    run_scheduled_recurrent_functions();
     esp_schedule();
 }