Instances of lazy scheduling and timeslice donation in L4 implementations

[Kevin Elphinstone]

Arrgghhh, here we go again.... I don't have enough time in my life for
yet another scheduling debate, so I'll summarize my view in the hope
that it is helpful (note I'm only roughly following the thread, so
aplogies in advance if I missed the point).

There are roughly three approaches to scheduling in practice (plus lots
more involving substantial changes to the typical multi-level round
robin in place)

* System-level best effort
	Chasing outright performance using the lazy scheduling 			technique
that is priority ambivelant, historically what L4 has done.
	 

* System-level priority ceiling protocol (static assignment of
priorities) with priority preserving lazy scheduling, i.e. lazy switch
only happens if destination is (equal) highest priority thread.

	- I beleive we have something that approximates this at NICTA, maybe
dresden has this also. 

* system-level priority inheritance (or call it persistent time-slice
donation if you wish), this is what I believe dresden is talking about,
has proposed, and I gather have not implemented. It requires tracking of
dependencies of IPC in some manner.

My point, everybody is "correct" depending on what you are
doing/expecting at the system level.


So rather than argue over details of how lazy-scheduling "should" or
does behave, one should have a clear idea of what is required at the
system level, and what model of the three above is required (or maybe an
alternative), or maybe an existing model with restrictions on what one
can do.

And no matter which model you require (except for maybe the first), your
likely to have to audit the code to confirm your expected behaviour if
your relying on it.

cheers

    - Kevin