JAVA-BASED REAL-TIME PROGRAMMING

2. Fundamentals
point. We may say that the system forces the application to give up the use
of the CPU.
The opposite to pre-emptive scheduling is non-pre-emptive scheduling,
which means that execution is only suspended when there is some call of
scheduling functions or resource allocation. For instance, an attempt to open
a network connection may include waiting for name-servers and remote computers
to reply. Even if it is not desirable to wait, we know (and the compiler
and run-time system knows) that execution may very well be suspended.
These so called blocking operations are handled the same when pre-emption
is used, but with pre-emption the suspension may also be enforced.
Different types of pre-emption exist. In general terms, there are three
alternatives for the granularity of execution suspension:
1. The most primitive case is when pre-emption is not supported; execution
is only suspended when certain system calls are made. The advantage is
efficiency since the state of the execution is well known by the compiler
and run-time system. For instance, all temporary registers that by the
compiler are assumed to be destroyed by a function call, need not be
saved. The disadvantage is that an application (or function) written
without considering the need for other activities to execute concurrently
will not give up the right to use the CPU, and may therefore lock the
system or make response times too long.
2. Execution may be interrupted/suspended between each line of source
code. From a programming point of view, it is very convenient to know
that each statement gets fully executed without interrupt. Early-days
Basic interpreters often worked this way. One disadvantage is that complex
statements may delay change of activity too long. Not to interfere
with other interrupt services, interrupts such as the timer interrupt is
served immediately and ongoing execution may be marked for suspension.
Another disadvantage is then that the checking between each statement
costs processing power. An interesting version of this technique
is implemented in the Lund Simula system which by utilization of the
hardware (Sun Sparc) performs the check at almost no cost. The key
drawback is, however, that concurrency requires support from compiler
and run-time system, which means that most available code (written in
C/C++) cannot be used when timing requirements are severe.
3. Execution may be interrupted/suspended between each machine instruction.
The advantages are that any sequential code (without compiler
support) can be interrupted, and that the interrupt and possible rescheduling
will be started immediately. There will, however, be some delay since
we must save the entire status of the execution (all registers etc.), and
that may for some types of hardware be slower than case 2. Another
28 2012-08-29 16:05