Algorithms and Data Structures

N.Wirth. Algorithms and Data Structures. Oberon version 31
We are now able to express the buffer module in a form that functions properly when used by individual,
concurrent processes:
MODULE Buffer;
IMPORT Signals;
CONST N = 1024; (*buffer size*)
VAR n, in, out: INTEGER;
nonfull: Signals.Signal; (*n < N*)
nonempty: Signals.Signal; (*n > 0*)
buf: ARRAY N OF CHAR;
PROCEDURE deposit (x: CHAR);
BEGIN
IF n = N THEN Signals.Wait(nonfull) END;
INC(n); buf[in] := x; in := (in + 1) MOD N;
IF n = 1 THEN Signals.Send(nonempty) END
END deposit;
PROCEDURE fetch (VAR x: CHAR);
BEGIN
IF n = 0 THEN Signals.Wait(nonempty) END;
DEC(n); x := buf[out]; out := (out + 1) MOD N;
IF n = N-1 THEN Signals.Send(nonfull) END
END fetch;
BEGIN n := 0; in := 0; out := 0; Signals.Init(nonfull); Signals.Init(nonempty)
END Buffer.
An additional caveat must be made, however. The scheme fails miserably, if by coincidence both
consumer and producer (or two producers or two consumers) fetch the counter value n simultaneously for
updating. Unpredictably, its resulting value will be either n+1, or n-1, but not n. It is indeed necessary to
protect the processes from dangerous interference. In general, all operations that alter the values of shared
variables constitute potential pitfalls.
A sufficient (but not always necessary) condition is that all shared variables be declared local to a
module whose procedures are guaranteed to be executed under mutual exclusion. Such a module is
called a monitor [1-7]. The mutual exclusion provision guarantees that at any time at most one process is
actively engaged in executing a procedure of the monitor. Should another process be calling a procedure of
the (same) monitor, it will automatically be delayed until the first process has terminated its procedure.
Note. By actively engaged is meant that a process execute a statement other than a wait statement.
At last we return now to the problem where the producer or the consumer (or both) require the data to
be available in a certain block size. The following module is a variant of the one previously shown,
assuming a block size of N p data elements for the producer, and of N c elements for the consumer. In these
cases, the buffer size N is usually chosen as a common multiple of N p and N c . In order to emphasise that
symmetry between the operations of fetching and depositing data, the single counter n is now represented
by two counters, namely ne and nf. They specify the numbers of empty and filled buffer slots respectively.
When the consumer is idle, nf indicates the number of elements needed for the consumer to proceed; and
when the producer is waiting, ne specifies the number of elements needed for the producer to resume.
(Therefore ne + nf = N does not always hold.)
MODULE Buffer;
IMPORT Signals;
CONST Np = 16; (*size of producer block*)