Multitasking

PIC specific Multitasking@

• The Protothreads Library by Adam Dunkels with support from Oliver Schmidt written in plain C. Very similar to the PIC-specific "cooperative multitasking" @ .
• Add Multiple Tasks to Your Communication and Control Program A special kernel lets your 8080 run multiple tasks concurrently by Jerry Holter
• OSKD Simple 386 operating system kernel with drivers, D.Lindauer oskdl10.zip 546008 Jul 3 1995 (TASM source)
• "Minimal cooperative task-switcher for Cypress PSoC"

multitasking in general

Whenever you have multiple tasks on a single CPU, you have to ``context switch'' between the tasks. Task switching is changing the focus of the processor from one ``task'' (process) to a an independent task. If this is done often enough, you can make one CPU ``multitask'', appear to work on several independent things at once. The ``task switcher'' is the most basic part of a multitasking OS kernel.

Each task has a "main loop" of stuff it does over and over. The differences between various flavors of multitasking come down to when exactly we switch from one task's main loop to the next task's main loop.

If we can switch at practically any time (typically triggered by an interrupt), that's pre-emptive. The interrupt routine needs to be careful to save the status word and other crucial registers, and when it switches tasks it needs to preserve the stack ...

If we only switch at certain points in the task, when the task specifically calls or returns to the multitasking kernel (i.e., when the task has reached a "good stopping point"), that's co-operative.

If we only switch when we know the stack is empty, then we never need to save the stack. [FIXME: is there a name for this restricted co-operative multitasking flavor ?] This makes the "context-switching overhead" is lower (which is good). But the tradoff is when some subroutine takes a really long time before it returns to the multitasking kernel, all the other tasks have to wait until it is done.

For small systems where the programmer has complete control of every task, cooperative multitasking can be superior to pre-emptive multitasking. In other situations, pre-emptive multitasking is superior .. but unfortunately, I'm pretty sure it's impossible to implement pre-emptive multitasking on 12x and 16x series PIC chips. On 18x series, apparently it is possible.

Umm... there's probably a simpler way to explain this.

• Microchip Appnote 585 http://ww1.microchip.com/downloads/en/AppNotes/00585b.pdf has a good explaination of multitasking for those new to the idea, with a nice glossary of most of the jargon used by those who write multitasking kernels. It also has complete source code to a multitasking system. [ed.: the source code seems terribly complicated to understand. Is this complexity necessary to shoe-horn the inherent complexity of multitasking onto a PIC, or is there a better way ?] [ed.: I don't understand the diagram on p. 5-106: Isn't it possible for a process to go directly from ``Waiting'' to ``ISR'' ?]

Priorities

Priority handling can be done in a couple of ways:

1. A single linked list queue. This allows many different priorities and avoids the need to diminsion each que for the largest possible size.

2. Several queues - one for each priority. This allows you to have low/medium and high priorities. The code runs FAST - a queue insert doesn't have to traverse linked lists! You can also dimension each queue separately.

Things to look out for

make sure that your queue pointers or indexes can survive "simultaneous" accesses from both foreground & interrupt level!

This means do NOT do something like:

next_free++
if (next_free == LIMIT) next_free= 0;

but do ....

temp = next_free;
temp++;
if (temp == LIMIT) temp = 0;
next_free = temp;

This ensures that any other "parallel" code peeping at next_free will never see the transient illegal value of LIMIT.

Make the shared pointers volatile.

Ensure you don't make dumb mistakes with the que array like referencing QUE_ARRAY_SIZE rather then QUE_ARRAY_SIZE-1 when the que is zero based, or indexing element 0 when the array is based at one. Those sorts of errors cause intermittent failures that are very difficult to debug.

See also:

• http://www.chiark.greenend.org.uk/~sgtatham/coroutines.html Co-routines in C.

  .