JAVA-BASED REAL-TIME PROGRAMMING

2. Fundamentals
Lack of reentrance is common problem in badly written C programs. The
reason is the use of static variables, i.e., variables that are allocated on a fixed
place in memory instead of on the stack or on the heap.
In most run-time systems, local variables in functions and blocks are allocated
(pushed) on the stack, which means that they are deallocated (popped
from the stack) when the PC leaves the scope. Data created dynamically,
using operator new in Java or C++, are allocated on the heap which is sometimes
called the free store. But also for heap allocation we usually have the
reference to the object declared locally in some scope which means that it is
put on the stack. This is a proper programming style which means that all
data is pushed on the stack of the caller. If, on the other hand, we use static
variables, two callers of one function will access the same local data (referred
to by absolute addresses in the compiled code of the function).
The real problem is when the one who wrote the function is not aware
of concurrent programming. Example: A numerical equation solver was implemented
in C, and then it was packaged together with other routines in a
library. To optimize the code for the hardware at that time, the temporary
variables of the algorithm were declared static. The function was then successfully
used for years on an old-style UNIX machine, where each program
only contains one point of execution (except for the signal handlers). Then,
the library was compiled and linked with applications running on the newer so
called multi-threaded UNIX dialects, such as Sun Solaris, HP-UX 10 and later,
and later versions of IRIX from SGI. It was also used on the Microsoft Win32
platform. In all these cases, when using the equation solver concurrently from
different parts of the application, the results were sometimes wrong. In this
case, the function was correct as a program, but not correct when used in a
concurrent program where some interleavings resulted in undesired mixing of
temporary data from different equations.
Also in Java it is easy to declare static variables, but we should only do
that for so called class variables needed for the structure of our program, and
in that case we should treat them as other types of shared data (which we will
return to). Note that when you write an ordinary function, you cannot know
if it later will be used concurrently. In conclusion, one should learn concurrent
programming before doing any type of professional programming.
2.6 Models of concurrent execution
The concurrency issues made our simple sequential execution model (from
Section 2.1) more complex because we now have several sequences that interact
with each other. With each sequence, there are:
• A PC (the Program Counter) which according to the previous section
refers to the next machine instruction to be executed.
30 2012-08-29 16:05