Shrink interrupts-locked regions.

Add check for periodic yield to scheduled functions run-loop.

Author: dok-net

cores/esp8266/Schedule.cpp

@@ -26,7 +26,7 @@ struct recurrent_fn_t
     esp8266::polledTimeout::periodicFastUs callNow;
     const std::atomic<bool>* wakeupToken = nullptr;
     bool wakeupTokenCmp = false;
-    recurrent_fn_t (esp8266::polledTimeout::periodicFastUs interval): callNow(interval) { }
+    recurrent_fn_t(esp8266::polledTimeout::periodicFastUs interval) : callNow(interval) { }
 };
 
 static recurrent_fn_t rFirst(0); // fifo not needed
@@ -35,7 +35,7 @@ static recurrent_fn_t rFirst(0); // fifo not needed
 // or if none are available allocates a new one,
 // or nullptr if limit is reached
 IRAM_ATTR // called from ISR
-static scheduled_fn_t* get_fn_unsafe ()
+static scheduled_fn_t* get_fn_unsafe()
 {
     scheduled_fn_t* result = nullptr;
     // try to get an item from unused items list
@@ -54,15 +54,15 @@ static scheduled_fn_t* get_fn_unsafe ()
     return result;
 }
 
-static void recycle_fn_unsafe (scheduled_fn_t* fn)
+static void recycle_fn_unsafe(scheduled_fn_t* fn)
 {
     fn->mFunc = nullptr; // special overload in c++ std lib
     fn->mNext = sUnused;
     sUnused = fn;
 }
 
 IRAM_ATTR // (not only) called from ISR
-bool schedule_function (const std::function<void(void)>& fn)
+bool schedule_function(const std::function<void(void)>& fn)
 {
     if (!fn)
         return false;
@@ -85,16 +85,14 @@ bool schedule_function (const std::function<void(void)>& fn)
     return true;
 }
 
-bool schedule_recurrent_function_us (const std::function<bool(void)>& fn, uint32_t repeat_us,
+bool schedule_recurrent_function_us(const std::function<bool(void)>& fn, uint32_t repeat_us,
     const std::atomic<bool>* wakeupToken)
 {
     assert(repeat_us < decltype(recurrent_fn_t::callNow)::neverExpires); //~26800000us (26.8s)
 
     if (!fn)
         return false;
 
-    esp8266::InterruptLock lockAllInterruptsInThisScope;
-
     recurrent_fn_t* item = new (std::nothrow) recurrent_fn_t(repeat_us);
     if (!item)
         return false;
@@ -103,13 +101,15 @@ bool schedule_recurrent_function_us (const std::function<bool(void)>& fn, uint32
     item->wakeupToken = wakeupToken;
     item->wakeupTokenCmp = wakeupToken && wakeupToken->load();
 
+    esp8266::InterruptLock lockAllInterruptsInThisScope;
+
     item->mNext = rFirst.mNext;
     rFirst.mNext = item;
 
     return true;
 }
 
-void run_scheduled_functions ()
+void run_scheduled_functions()
 {
     esp8266::polledTimeout::periodicFastMs yieldNow(100); // yield every 100ms
 
@@ -124,9 +124,9 @@ void run_scheduled_functions ()
             sFirst = sFirst->mNext;
             if (!sFirst)
                 sLast = nullptr;
-            recycle_fn_unsafe(to_recycle);
-        }
-
+			recycle_fn_unsafe(to_recycle);
+		}
+    	
         if (yieldNow)
         {
             // because scheduled function are allowed to last:
@@ -137,8 +137,10 @@ void run_scheduled_functions ()
     }
 }
 
-void run_scheduled_recurrent_functions ()
+void run_scheduled_recurrent_functions()
 {
+    esp8266::polledTimeout::periodicFastMs yieldNow(100); // yield every 100ms
+
     // Note to the reader:
     // There is no exposed API to remove a scheduled function:
     // Scheduled functions are removed only from this function, and
@@ -178,8 +180,8 @@ void run_scheduled_recurrent_functions ()
 
             auto to_ditch = current;
 
-        // current function recursively scheduled something
-        if (prev->mNext != current) prev = prev->mNext;
+            // current function recursively scheduled something
+            if (prev->mNext != current) prev = prev->mNext;
 
             current = current->mNext;
             prev->mNext = current;
@@ -191,8 +193,15 @@ void run_scheduled_recurrent_functions ()
             prev = current;
             current = current->mNext;
         }
-    }
-    while (current);
+
+        if (yieldNow)
+        {
+            // because scheduled function might last too long for watchdog etc,
+            // this is yield() in cont stack:
+            esp_schedule();
+            cont_yield(g_pcont);
+        }
+    } while (current);
 
     fence = false;
 }

cores/esp8266/Schedule.h

@@ -11,7 +11,7 @@
 // in user stack (called CONT stack) without the common restrictions from
 // system context.  Details are below.
 
-// The purpose of recurrent scheduled function is to independantly execute
+// The purpose of recurrent scheduled function is to independently execute
 // user code in CONT stack on a regular basis.
 // It has been introduced with ethernet service in mind, it can also be used
 // for all libraries in the need of a regular `libdaemon_handlestuff()`.
@@ -37,7 +37,7 @@
 // * Run the lambda only once next time.
 // * A scheduled function can schedule a function.
 
-bool schedule_function (const 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`,
@@ -59,16 +59,14 @@ void run_scheduled_functions();
 //   functions.  However a user function returning false will cancel itself.
 // * Long running operations or yield() or delay() are not allowed in the
 //   recurrent function.
-// * A recurrent function currently must not schedule another recurrent
-//   functions.
 // * If a wakeupToken is used, if its value toggles, any remaining
 //   delay is disregarded, and the lambda runs on the next scheduler iteration.
-bool schedule_recurrent_function_us (const std::function<bool(void)>& fn, uint32_t repeat_us,
+bool schedule_recurrent_function_us(const std::function<bool(void)>& fn, uint32_t repeat_us,
     const std::atomic<bool>* wakeupToken = nullptr);
 
 // Test recurrence and run recurrent scheduled functions.
 // (internally called at every `yield()` and `loop()`)
 
-void run_scheduled_recurrent_functions ();
+void run_scheduled_recurrent_functions();
 
 #endif // ESP_SCHEDULE_H