🚀 go-pugleaf

"robertwessel2@yahoo.com" <robertwessel2@yahoo.com> writes:
> Windows, like pretty much any other OS, will dole out CPU time in
> time-slice increments to threads that run CPU bound, but only rarely
> does a thread (in most systems) ever run out a time slice before
> blocking on some event (and thus threads are rarely CPU bound).

i had done dynamic adaptive scheduling back in the 60s as an
undergraduate. this was sometimes referred to as fairshare (or
wheeler) scheduler ... because the default scheduling policy
was fairshare

basically light-weight interactive tasks got shorter quanta than more
heavy-weight longer running tasks. advistory deadline was calculated
proportional to size of the quanta and the recent resource
utilization.  quanta could span certain short i/os (disk, etc) ...  so
heavy utilization wasn't necessary restricted to absolutely pure cpu
bound (just reasonably high rate of cpu consumption).

light-weight interactive tasks would tend to have more frequent quanta
with shorter deadlines ... and heavy weight tasks would have less
frequent larger quanta. interactive tasks would appear to be more
responsive if they could complete within a few of the shorter quanta
and/or if they haven't been using a lot of resources recently.
basically the objective was to uniformally control of the overall rate
of resource consumption (regardless of the quanta size).

the other issue was that this was done as modifications to existing
cp67 system that had an extremely complex scheduler that wasn't
directly controlling resource utilization ... just moving priorities
up & done and itself could consumer 10-15 percent of total cpu
utilization.  so a major objective of the scheduler change was to not
only implement effective resource consumption supporting a variety of
scheduling policies ... but do it with as close as possible to zero
pathlength.
http://www.garlic.com/~lynn/subtopic.html#fairshare

-- 
Anne & Lynn Wheeler | http://www.garlic.com/~lynn/