Test of strict priorities

Author: wizard97

src/ProcessScheduler/Includes.h

@@ -35,7 +35,12 @@ typedef enum ProcessWarning
 
 #define OVERSCHEDULED_NO_WARNING 0
 
-// PICK INT VALUES PEOPLE UNLIKLEY TO USE
+// Only can use negative values
+typedef SchedulerException
+{
+    ProcTimeout = -1000,
+    ProcYield,
+};
 #define LONGJMP_ISR_CODE -1000
 #define LONGJMP_YIELD_CODE -1001
 

src/ProcessScheduler/Process.cpp

@@ -84,6 +84,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/Process.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 *Process::runWhich(Process *p1, Process *p2);
+
     ///////////////////// GETTERS /////////////////////////
 
     // These methods are also the same as calling calling scheduler.method(process)

src/ProcessScheduler/Scheduler.cpp

@@ -143,75 +143,84 @@ int Scheduler::run()
     {
         processQueue();
 
-        _active = _pLevels[pLevel].next;
-        if (!_active)
+        Process *tmp = _pLevels[pLevel].head;
+
+        // No processes at this priority level
+        if (!tmp)
             continue;
 
-        /////////// Run the correct process /////////
+        // find the highest priority process that needs to run
         uint32_t start = getCurrTS();
+        Process *torun = NULL;
+
+        // Search for the best process
+        while(tmp) {
+            if (tmp->needsServicing(start)) {
+                if (torun) { //Compare which one needs to run more
+                    _active = Process::runWhich(torun, tmp);
+                } else { //torun is NULL so this is the best one to run
+                    torun = tmp;
+                }
+            }
+            tmp = tmp->getNext();
+        }
 
-        if (_active->needsServicing(start))
-        {
-            bool force = _active->forceSet(); // Store whether it was a forced iteraiton
-            _active->willService(start);
+        // No ready process found at this priority level
+        if (!torun)
+            continue;
+
+        /////////// 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
+        _active = NULL; //done!
+        //////////////////////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//////////////////////
-        delay(0); // For esp8266
 
-        // 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;
-            }
-#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;
+        count++; // incr counter
+        processQueue();
+        delay(0); // For esp8266
+        break; // We found the process and serviced it, so were done
     }
-    processQueue();
+    delay(0); // For esp8266
+
     return count;
 }
 
@@ -434,9 +443,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 +472,7 @@ void Scheduler::handleHistOverFlow(uint8_t div)
 
                 default:
                     if (!_active->handleException(e))
-                        handleException(*_active, e);
+                        handleException(_active, e);
                     break;
 
             }

src/ProcessScheduler/Scheduler.h

@@ -184,7 +184,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