Developer info to improve scheduler
The simple scheduler used now (mainloop) will be improved so latency of some high-priority actions is improved. So we can
- move some high priority trigger-data processing to userspace
- move some tables from SRAM to EEPROM (to free space for MMC logging and networking), where there are limits of when it can be accessed for read (not during EPPROM write).
- the EEPROM write (if there is a demand) can only start right after all necessary variables for fuel VE/lambda/ign calc had been cached in SRAM (seach_table result and 2x2 grid of each table).
- Also, the above cached table-data cannot be updated during EEPROM write (new calc would be possible nevertheless, with some boundary-check consideration ; but easier to avoid it, and only recalc new injPW from changed MAP if it's absolutely needed within 8.5 msec; many competition controllers cannot even finish a full calc within that period)
- when these userspace calcs are allowed (not in EEPROM write and at least 4 msec passed since last) they can be medium priority
- implement more convenience features
Requirements
- prio0 must be absolute highest priority: if anything runnable in prio0, that must be run hopefully within 500 usec, and before any prio1..prio3; we must take care that the conditions are careful, and not consume all clocks
- max 1 queue is allowed to starve (the lowest priority, eg prio3)
- round-robin (or alike) within a queue for equality
- if possible, not preemptive (we have the eventqueue already for whatever needs immediate attention)
- low CPU clocks overhead (surprise)
- low memory footprint
- support the EEPROM write-start - calc "synchronization" above.
- it could be done with merging the EEPROM write-start and the calc to one function. However this is not desirable, the calc itself should be possible to split to several functions
- EEPROM write-start and calc functions can be apparently independent (likely in prio1), but ordered smartly and communicating through the "runnable condition", that use common variables (timestamp of when calc was last run, is EEPROM write in progress, etc...). I hope this will work
- it might sound like this requirement calls for dynamic prioritazation, but hopefully that is avoidable.
See the priority ideas on GenBoard/UnderDevelopment/FirmWare (TODO: delete from there)
Even though it is relatively simple, it's a good idea to model it in JAVA first (see package org.vemsgroup.firmware.scheduler in JTune CVS) to verify operation (and maybe tune some variables).
Similar scheduler is implemented in most real-time operating systems.
See task-states on an [an x86 RTOS].
However we don't need preemptive multitasking. Cooperative is fine. So no need for separate stack for each process. When the process returns, it's stack is back to normal anyway. Timing sensitive tasks must be done in interrupt or high-priority process.
A nice OS with non-preemptive multitasking running on the atmega16 (gpl and compilable with avr-gcc) can be found here [ethernut.de]
Non starving scheduler - actually max 1 queue (prio3) can be allowed to starve
- if there is anything runnable in prio0 (such as trigger data processing), that must be run. We take care that this is limited, and not starve prio1..prio3.
- else if there is nothing in prio1 and prio2, than prio3 can run (eg. LCD can be in prio3 with always runnable condition). This way prio3 can starve theoretically, but .. read below
- if there is sg. in prio1 or prio2, prio1 and prio2 are different "priority" (frequency of turn), but prio1 cannot starve prio2:
- run max 2 consequtives tasks from prio1 (eg. fuel/ign calcs, comm tx/rx data; wbo2)
- than run max 1 task from prio2. Note that prio2 always has it's turn after prio1 queue was checked twice (wether sg. from prio1 actually did run or not)
Runnable conditions
- flagged asynchronously, eg. from irq or other places. (such as trigger data available; or comm data available or sending buffer almost empty). The amount of events must be limited so this consumes max 10..60% of CPU.
- softelapsed: a certain amount of time passed since last run. With some tuning, this ensures that there are times when nothing is runnable in prio0..prio2 so prio3 can run. IMHO this is the key for the nice behaviour. If all process just asks "I want to be run" after they run, we more or less get back the mainloop behaviour.
- always runnable (only allowed in prio3)
- other condition ???
If scheduler does not see softelapsed type runnable conditions (because conditions are hidden inside the functions, so the scheduler itself does not see them; the conditions hidden in the functions can still be there and result in some functions decide themselves to not take their turn and return without doing much), that means we basically have 2 queues (prio3 is definitely meaningles than)
- prio0 (with just "flagged async conditions")
- and a lower priority queue. This can be divided as the prio1-prio2 trick above, so that prio1 tasks get more timeslot altogether (but prio1-prio2 is not "true" priority).
The simplification in STABLE1_1 from the Ultimate solution is that we cannot tell by a quick look if there is sg. runnable in prio1 or prio2. We just execute something that has it's turn, that can have it's own condition (eg. softelapsed()) and might not do anything.
In general lack of the knowledge of "explicite" (known by the scheduler) "runnable conditions" of tasks in a queue makes any lower priority queue of little use.
The trick of if ( not much time passed since time_old){ might be a simple yet efficient way to know if we have a free slot right now to execute sg. from prio3(). Not exactly the same condition as "if prio1 and prio2 has no runnable at all", though.
TODO: meet the EEPROM-write requirement
can probably be met as well.
That allows any number of upto 16x16 tables (psychological benefit...);painless, 0 overhead switching to alternative (95-98 octane) fuel ignition-map, etc...
The rx21 rip (already in STABLE1_0) allows easy addition of individual (per table) RPM and MAP ranges for each tables.