Merge pull request #7 from wizard97/strict-priorities

Strict priorities

Author: wizard97

src/ProcessScheduler.h

@@ -35,7 +35,6 @@ typedef enum ProcessWarning
 
 #define OVERSCHEDULED_NO_WARNING 0
 
-// PICK INT VALUES PEOPLE UNLIKLEY TO USE
 #define LONGJMP_ISR_CODE -1000
 #define LONGJMP_YIELD_CODE -1001
 

src/ProcessScheduler/Config.h

@@ -59,8 +59,9 @@
 
     bool Process::needsServicing(uint32_t start)
     {
-        return (isEnabled() && (_force ||
-            ((getPeriod() == SERVICE_CONSTANTLY || start - getScheduledTS() >= getPeriod()) &&
+        return (isEnabled() &&
+            (_force ||
+            ((getPeriod() == SERVICE_CONSTANTLY || timeToNextRun(start) <= 0) &&
             (getIterations() == RUNTIME_FOREVER || getIterations() > 0))));
     }
 
@@ -84,6 +85,21 @@
     }
 
 
+    // both must need servicing
+    Process *Process::runWhich(Process *p1, Process *p2)
+    {
+        // All things being equal pick yes
+
+        // Compare forces
+        if (p1->forceSet() || p2->forceSet())
+            return p1->forceSet() ? p1 : p2;
+
+        // whichever one is more behind goes first
+        return (p1->timeToNextRun() <= p2->timeToNextRun()) ? p1 : p2;
+
+    }
+
+
 
     /*********** PROTECTED *************/
 

src/ProcessScheduler/Includes.h

@@ -31,6 +31,15 @@ class Process
     bool destroy();
     bool restart();
 
+
+    /*
+    * Give both processes that need to run p1 and p2
+    * return the process that should run first
+    *
+    * @return: p1 or p2
+    */
+    static Process *runWhich(Process *p1, Process *p2);
+
     ///////////////////// GETTERS /////////////////////////
 
     // These methods are also the same as calling calling scheduler.method(process)
@@ -75,7 +84,9 @@ class Process
     *
     * @return: int32_t time offset
     */
-    inline int32_t timeToNextRun() { return (_scheduledTS + _period) - _scheduler.getCurrTS(); }
+    inline int32_t timeToNextRun() { return timeToNextRun(_scheduler.getCurrTS()); }
+
+    inline int32_t timeToNextRun(uint32_t curr) { return (int32_t)((_scheduledTS + _period) - curr); }
 
 
     /*

src/ProcessScheduler/Process.cpp

@@ -133,86 +133,109 @@ uint8_t Scheduler::countProcesses(int priority, bool enabledOnly)
     return count;
 }
 
+
 int Scheduler::run()
 {
     // Already running in another call frame
     if (_active) return 0;
 
     uint8_t count = 0;
+    uint32_t start = getCurrTS();
     for (uint8_t pLevel=0; pLevel < NUM_PRIORITY_LEVELS; pLevel++)
     {
         processQueue();
 
-        _active = _pLevels[pLevel].next;
-        if (!_active)
+        // Resume looking where we left off in the list
+        Process *torun = getRunnable(start, _pLevels[pLevel].next, NULL);
+
+        if (!torun && _pLevels[pLevel].next != _pLevels[pLevel].head)
+            torun = getRunnable(start, _pLevels[pLevel].head, _pLevels[pLevel].next);
+
+        // No ready process found at this priority level
+        if (!torun)
             continue;
 
-        /////////// Run the correct process /////////
-        uint32_t start = getCurrTS();
+        _pLevels[pLevel].next = torun->hasNext() ? torun->getNext() : _pLevels[pLevel].head;
 
-        if (_active->needsServicing(start))
-        {
-            bool force = _active->forceSet(); // Store whether it was a forced iteraiton
-            _active->willService(start);
+        /////////// Run the correct process /////////
+        _active = torun;
+        start = getCurrTS(); //update
+        bool force = _active->forceSet(); // Store whether it was a forced iteraiton
+        _active->willService(start);
 
 #ifdef _PROCESS_EXCEPTION_HANDLING
-            int ret = setjmp(_env);
+        int ret = setjmp(_env);
 
-#ifdef _PROCESS_TIMEOUT_INTERRUPTS
-            ENABLE_SCHEDULER_ISR();
-#endif
-            if (!ret) {
-                _active->service();
-            } else {
-                jmpHandler(ret);
-            }
-#else
+    // Enable the interrupts
+    #ifdef _PROCESS_TIMEOUT_INTERRUPTS
+        ENABLE_SCHEDULER_ISR();
+    #endif
+
+        if (!ret) {
             _active->service();
+        } else {
+            jmpHandler(ret);
+        }
+#else
+        _active->service();
 #endif
 
+// Disable the interrupts after the process returned
 #ifdef _PROCESS_TIMEOUT_INTERRUPTS
             DISABLE_SCHEDULER_ISR();
 #endif
+        //////////////////////END PROCESS SERVICING//////////////////////
 
 #ifdef _PROCESS_STATISTICS
-            uint32_t runTime = getCurrTS() - start;
-            // Make sure no overflow happens
-            if (_active->statsWillOverflow(1, runTime))
-                handleHistOverFlow(HISTORY_DIV_FACTOR);
+        uint32_t runTime = getCurrTS() - start;
+        // Make sure no overflow happens
+        if (_active->statsWillOverflow(1, runTime))
+            handleHistOverFlow(HISTORY_DIV_FACTOR);
 
-            _active->setHistIterations(_active->getHistIterations()+1);
-            _active->setHistRuntime(_active->getHistRunTime()+runTime);
+        _active->setHistIterations(_active->getHistIterations()+1);
+        _active->setHistRuntime(_active->getHistRunTime()+runTime);
 
 #endif
-            // Is it time to disable?
-            if (_active->wasServiced(force)) {
-                disable(*_active);
-            }
-
-            count++; // incr counter
+        // Is it time to disable?
+        if (_active->wasServiced(force)) {
+            disable(*_active);
         }
-        //////////////////////END PROCESS SERVICING//////////////////////
+        _active = NULL; //done!
+
+        count++; // incr counter
+        processQueue();
         delay(0); // For esp8266
+        break; // We found the process and serviced it, so were done
+    }
+    delay(0); // For esp8266
+
+    return count;
+}
+
+
+// end is exclusive, end=NULL means go to entire end of list
+Process *Scheduler::getRunnable(uint32_t start, Process *begin, Process *end)
+{
+    if (!start)
+        return NULL;
+
+    Process *torun = NULL;
+    Process *tmp = begin;
 
-        // Determine what to do next ///
-        if (!_active->hasNext()) {
-#ifdef _PROCESS_REORDERING
-            if(++_pLevels[pLevel].passes >= _PROCESS_REORDERING_AGGRESSIVENESS) {
-                reOrderProcs((ProcPriority)pLevel);
-                ++_pLevels[pLevel].passes = 0;
+    // Search for the best process
+    while(tmp != end) {
+        if (tmp->needsServicing(start)) {
+            if (torun) { //Compare which one needs to run more
+                torun = Process::runWhich(torun, tmp);
+            } else { //torun is NULL so this is the best one to run
+                torun = tmp;
             }
-#endif
-            _pLevels[pLevel].next = _pLevels[pLevel].head; // Set next to first
-        } else {
-            _pLevels[pLevel].next = _active->getNext(); // Set next and break
-            _active = NULL;
-            break;
         }
 
-        _active = NULL;
+        tmp = tmp->getNext();
     }
-    processQueue();
-    return count;
+
+    return torun;
 }
 
 
@@ -434,9 +457,15 @@ void Scheduler::handleHistOverFlow(uint8_t div)
         longjmp(_env, e);
     }
 
-    void Scheduler::handleException(Process &process, int e)
+    void Scheduler::handleException(Process *process, int e)
     {
-        process.restart();
+        // Exception came from process
+        if (process) {
+            process.restart();
+        } else {
+            // Exception came from scheduler
+
+        }
     }
 
 
@@ -457,7 +486,7 @@ void Scheduler::handleHistOverFlow(uint8_t div)
 
                 default:
                     if (!_active->handleException(e))
-                        handleException(*_active, e);
+                        handleException(_active, e);
                     break;
 
             }

src/ProcessScheduler/Process.h

@@ -191,7 +191,7 @@ class Scheduler
     * Handle uncaught Process exceptions from Process process with Exception code e
     * By default just restart it
     */
-    virtual void handleException(Process &process, int e);
+    virtual void handleException(Process *process, int e);
 #endif
     // Inner queue object class to queue scheduler jobs
     class QueableOperation
@@ -245,6 +245,9 @@ class Scheduler
     void procRestart(Process &process);
     void procHalt();
 
+    // Get runnable process in process linked list chain
+    Process *getRunnable(uint32_t start, Process *begin, Process *end=NULL);
+
     // Process the scheduler job queue
     void processQueue();