JAVA-BASED REAL-TIME PROGRAMMING

3.4. Message-based communication – Mailboxes
copy messages for reasons of memory management (since Java provides
GC). Posting an event object therefore means passing the (one word)
reference to that object, which also saves the time for the copying.
2. The RTEventBuffer is not useful for communication between OS processes:
they normally work in different address spaces and object references
cannot be shared, and hence objects are to be represented by
data that is copied to the buffer. The actions to convert a Java object
to a sequence of bytes are referred to as serialization. That is supported
in Java, partly in terms of the interface java.io.Serializable, but that is
outside the scope of this chapter.
3. Buffers used for concurrent programming, such as the java.util.Vector,
are usually unbounded. That is, they expand in size when full, or a
java.lang.OutOfMemoryError is thrown. Our aim at real-time aware concurrency,
to prepare for even hard real time later, motivates some care
concerning resources, such as memory. Even if we for flexible real-time
systems do not know exactly how many bytes our application needs, we
need some bounds on the used resources. For buffering, this means that
we work with bounded buffers as the default. If, in some cases, there
should be a need for unbounded buffers, it is simple to override post or
fetch methods to expand the buffer size on demand.
Other reasons for our own buffer implementation include: shrinkage without
losing buffer content, support for RTEvent and object ownership, design
suitable for embedded/native implementation on small-memory systems, and
licensing issues for such systems. For the purpose of subclassing, the internals
of the buffer is useful to know; the se.lth.cs.realtime.event.RTEventBuffer
is implemented as follows.
Storage and synchronization Since the buffer is to be used mainly as a
FIFO queue, with a bounded size that is normally kept constant, it is
best represented by an array. That is of course not visible from the outside,
but to subclasses it is. When the index needs to advance beyond
the maximum index of the array it flips over and continues at index
zero. Therefore this type of buffer is also called ring buffer, as depicted
in Figure 3-10. The methods of the buffer could be considered being synchronized,
that is, the buffer is thread safe. To prevent interference with
wait/notify internally from external code synchronizing on the buffer
object, the synchronization of the buffer methods are accomplished by
synchronized(lock){...}
where the lock is declared as
protected Object lock = new Object();
That monitor lock can then be replaced in subclasses or in the construc-
91