Since I happened to be chatting with Richard Gooch
about an area related to timers offline, although
in a different context, I'll toss my ideas into the
First, I spent nearly 10 years doing
real time process control type things.
We never used Unix because it lacked the ability
to accurately control time-based events where
you simply could NOT get things out of sequence or
have two events execute at other than a correct
time +/- some delta. Mostly I was not dealing
with life and death... mostly.
Unix has improved in this, more due to processor
speed and finer time slicing, but I'd still be
leary of controlling seriously critical stuff
with it (go ahead, convince me :-)
I started thinking about this again while
doing a user land serial protocol driver that
requires two indep timers. The only way to do it
is to take a high speed SIGALRM and execute
call backs on timed events from within your
program. This is seriously inefficient when
you may only need a handful of asynch time
interrupts per second.
This has always struck me as a weakness in
Unix vs say, DEC OS's (or more commonly,
dedicated assembly coded controllers.) If you
are going to do process control, you would really
like to register a time based event with the
OS and be awakened to process it within
some reasonably *guaranteeable* delta.
(Otherwise, something might just go
BOOM and give your employer very bad PR.)
I'm pretty sure some Unices have since added
real time extensions. I've not thought about
it much in years so I haven't really kept
up. However Linux apparently does not. And
I may have some very interesting applications
in about 2 years that will need top notch
industrial strength process control abilities
from a Linux kernel. That's plenty of time
to become second to none.
So has anyone been thinking about this set of
problems? Would it be within the two year
timeframe? Anyone want to chat about it?
On Sat, Jul 10, 1999 at 01:25:27AM +0100, Dale Amon wrote:
> First, I spent nearly 10 years doing
> real time process control type things.
> We never used Unix because it lacked the ability
> to accurately control time-based events where
> you simply could NOT get things out of sequence or
> have two events execute at other than a correct
> time +/- some delta. Mostly I was not dealing
> with life and death... mostly.
Look at either POSIX real-time extensions (man
sched_setscheduler()), or if that is not good
enough, use RTLinux, a hard real-time extension
to Linux. (http://www.rtlinux.org) People routinely
report performance that can only be envied by other