Scheduler can now terminate long running processes

Author: wizard97

src/ProcessScheduler/Config.h

@@ -4,21 +4,21 @@
 #include <Arduino.h>
 
 /* Uncomment this to allow Exception Handling functionality */
-//#define _PROCESS_EXCEPTION_HANDLING
+#define _PROCESS_EXCEPTION_HANDLING
+
+/* Uncomment this to allow the scheduler to interrupt long running processes */
+// This requires _PROCESS_EXCEPTION_HANDLING to also be enabled
+#define _PROCESS_TIMEOUT_INTERRUPTS
 
 /* Uncomment this to allow Process timing statistics functionality */
 #define _PROCESS_STATISTICS
 
 /* Uncomment this to use microseconds instead of milliseconds for timestamp unit (more precise) */
 //#define _MICROS_PRECISION
 
+
 /* The size of the scheduler job queue, */
 //increase if add(), destroy(), enable(), disable(), or updateStats() is returning false*/
-
-//#define _PROCESS_REORDERING
-
-#define _PROCESS_REORDERING_AGGRESSIVENESS 50000
-
 #define SCHEDULER_JOB_QUEUE_SIZE 20
 
 typedef enum ProcPriority

src/ProcessScheduler/Includes.h

@@ -9,6 +9,19 @@
 class Scheduler;
 class Process;
 
+typedef enum ProcessWarning
+{
+    WARNING_PROC_OVERSCHEDULED = 0,
+
+#ifdef _PROCESS_TIMEOUT_INTERRUPTS
+    WARNING_PROC_TIMED_OUT
+#endif
+} ProcessWarning;
+
+// PICK INT VALUES PEOPLE UNLIKLEY TO USE
+#define LONGJMP_ISR_CODE -1000
+#define LONGJMP_YIELD_CODE -1001
+
 #if defined(ARDUINO_ARCH_AVR)
     #include <setjmp.h>
     #include <util/atomic.h>
@@ -19,6 +32,13 @@ class Process;
     #define HALT_PROCESSOR() \
             do { noInterrupts(); sleep_enable(); sleep_cpu(); } while(0)
 
+    #define ENABLE_SCHEDULER_ISR() \
+            do { OCR0A = 0xAA; TIMSK0 |= _BV(OCIE0A); } while(0)
+
+
+    #define DISABLE_SCHEDULER_ISR() \
+            do { TIMSK0 &= ~_BV(OCIE0A); } while(0)
+
 
 #elif defined(ARDUINO_ARCH_ESP8266)
     #ifndef __STRINGIFY
@@ -38,6 +58,11 @@ class Process;
 
     #define HALT_PROCESSOR() \
             ESP.deepSleep(0)
+
+    // Not supported on ESP8266
+    #define ENABLE_SCHEDULER_ISR()
+    #define DISABLE_SCHEDULER_ISR()
+
 #else
     #error “This library only supports AVR and ESP8266 Boards.”
 #endif

src/ProcessScheduler/Process.cpp

@@ -65,7 +65,11 @@
     //called on enable/disable
     void Process::onEnable() { return; }
     void Process::onDisable() { return; }
-    void Process::overScheduledHandler(uint32_t behind) { resetSchedulerWarning(); }
+    void Process::handleWarning(ProcessWarning warning)
+    {
+        if (warning == WARNING_PROC_OVERSCHEDULED)
+            resetOverSchedWarning();
+    }
 
     /*********** PRIVATE *************/
     bool Process::isPBehind(uint32_t curr)
@@ -92,9 +96,9 @@
         if (getOverSchedThresh() != OVERSCHEDULED_NO_WARNING && isPBehind(now)) {
             incrPBehind();
             if (getCurrPBehind() >= getOverSchedThresh())
-                overScheduledHandler(now - getScheduledTS());
+                handleWarning(WARNING_PROC_OVERSCHEDULED);
         } else {
-            resetSchedulerWarning();
+            resetOverSchedWarning();
         }
     }
 

src/ProcessScheduler/Process.h

@@ -45,12 +45,15 @@ class Process
 
     inline void force() { _force = true; }
 
-    inline void resetSchedulerWarning() { _pBehind = 0; }
+    inline void resetOverSchedWarning() { _pBehind = 0; }
     inline uint16_t getOverSchedThresh() { return _overSchedThresh; }
     inline uint16_t getCurrPBehind() { return _pBehind; }
 
     inline ProcPriority getPriority() { return _pLevel; }
 
+    // Timeout
+    virtual uint32_t getTimeout() { return 0; };
+
 protected:
     inline uint32_t getStartDelay() { return _actualTS - _scheduledTS; }
     // Fired on creation/destroy
@@ -62,7 +65,7 @@ class Process
     // Process routine
     virtual void service() = 0;
     // Overscheduled warning
-    virtual void overScheduledHandler(uint32_t behind);
+    virtual void handleWarning(ProcessWarning warning);
 
 private:
     enum ProcessFlags
@@ -107,6 +110,10 @@ class Process
     const ProcPriority _pLevel;
 
 
+#ifdef _PROCESS_TIMEOUT_INTERRUPTS
+
+
+#endif
 
 #ifdef _PROCESS_STATISTICS
 public:

src/ProcessScheduler/Scheduler.cpp

@@ -1,6 +1,18 @@
 #include "Scheduler.h"
 #include "Process.h"
 
+Process *Scheduler::_active = NULL;
+jmp_buf Scheduler::_env = {};
+
+ISR(TIMER0_COMPA_vect)
+{
+    if (Scheduler::getActive()) { // routine is running
+        uint32_t timeout = Scheduler::getActive()->getTimeout();
+        if (timeout && Scheduler::getCurrTS() - Scheduler::getActive()->getActualRunTS() >= timeout)
+            longjmp(Scheduler::_env, LONGJMP_ISR_CODE);
+    }
+}
+
 
 Scheduler::Scheduler()
 : _pLevels{}
@@ -21,7 +33,7 @@ uint32_t Scheduler::getCurrTS()
     return TIMESTAMP();
 }
 
-Process *Scheduler::getCurrProcess()
+Process *Scheduler::getActive()
 {
     return _active;
 }
@@ -134,15 +146,22 @@ int Scheduler::run()
 
 #ifdef _PROCESS_EXCEPTION_HANDLING
             int ret = setjmp(_env);
+
+#ifdef _PROCESS_TIMEOUT_INTERRUPTS
+            ENABLE_SCHEDULER_ISR();
+#endif
             if (!ret) {
                 _active->service();
             } else {
-                eDispatcher(ret);
+                jmpHandler(ret);
             }
 #else
             _active->service();
 #endif
 
+#ifdef _PROCESS_TIMEOUT_INTERRUPTS
+            DISABLE_SCHEDULER_ISR();
+#endif
 
 #ifdef _PROCESS_STATISTICS
             uint32_t runTime = getCurrTS() - start;
@@ -383,12 +402,15 @@ void Scheduler::handleHistOverFlow(uint8_t div)
     }
 
 
-    bool Scheduler::eDispatcher(int e)
+    bool Scheduler::jmpHandler(int e)
     {
         if (e != 0 && _active)
         {
-            if (!_active->handleException(e))
+            if (e == LONGJMP_ISR_CODE)
+                _active->handleWarning(WARNING_PROC_TIMED_OUT);
+            else if (!_active->handleException(e))
                 handleException(*_active, e);
+
             return true;
         }
         return false;

src/ProcessScheduler/Scheduler.h

@@ -13,6 +13,8 @@ typedef struct RingBuf RingBuf;
 
 class Process;
 
+
+
 class Scheduler
 {
 
@@ -30,10 +32,10 @@ class Scheduler
     bool isNotDestroyed(Process &process);
     bool isEnabled(Process &process);
 
-    Process *getCurrProcess();
+    static Process *getActive();
     Process *findProcById(uint8_t id);
     uint8_t countProcesses(int priority = ALL_PRIORITY_LEVELS, bool enabledOnly = true);
-    uint32_t getCurrTS();
+    static uint32_t getCurrTS();
 
     int run();
 protected:
@@ -83,7 +85,7 @@ class Scheduler
     Process *findPrevNode(Process &node);
 
 
-    Process *_active;
+    static Process *_active;
     uint8_t _lastID;
     RingBuf *_queue;
 
@@ -115,9 +117,9 @@ class Scheduler
 public:
     void raiseException(int e);
     virtual void handleException(Process &process, int e) { };
+    static jmp_buf _env; // have to do this to access it from ISR
 protected:
-    bool eDispatcher(int e);
-    jmp_buf _env;
+    bool jmpHandler(int e);
 #endif
 
 };