9.4 The basicSystemEnv Library

The systemEnv fragment contains abstract superpattern:s for describing the BETA concepts of concurrent systems. The basic ideas are:

9.4.1 Basic concepts

• Components (coroutines) can be executed concurrently.
• A primitive semaphore pattern is available for synchronization. The operations on a semaphore must be executed as an indivisible unit.
• An abstract pattern Monitor similar to the monitor proposed by Hoare and Brinch-Hansen.
• An abstract pattern System is defined. System defines communication between systems by means of synchronized rendezvous. A concurrency imperative conc and an alternation imperative alt are defined for system.

Currently an exploratory style is used to experiment with different variants of the abstract patterns. The current version is thus far from any final form of definition and may contain errors. The separation into interface and implementation has not been completely carried out.

The abstractions defined here are based on the ones described in chapter 12 of the BETA book.

9.4.2 Changes from original design

The implementation is identical to the design in the BETA book, except for the following changes:

• The syntax of fork is

S[]->fork

• and not S.fork.
• The syntax of conc is

conc(# do S1[]->start; S2[]->start; S3[]->start #)

• and not conc(# do S1.start; S2.start; S3.start #).
• The syntax of alt is

alt(#do S1[]->start; S2[]->start; S3[]->start #)

• and not alt(# do S1.start; S2.start; S3.start #).

9.4.3 New facilities

This implementation of systemenv included a few new facilities, not described in the BETA book:

• semaphore have an additional attribute: tryP, which is a non-blocking call of P.
• In addition to s[]->fork, s[]->kill is now possible, and in addition to pause, 100->sleep is possible.
• system have a new virtual attribute, onKilled, that is invoked before the system terminates
• systemenv has a new virtual attribute, deadlocked, that is invoked if all processes are deadlocked.
• Finally, systemenv defines three new attributes to cope with event driven user interfaces: windowEnvType, theWindowEnv, and setWindowEnv. See further details on cooperation with user interface environments below.

9.4.4 The Concurrency is Simulated

In order to implement real concurrency, an interrupt mechanism must be implemented. This is currently not done. A component/system will thus keep the control until it makes an explicit or implicit SUSPEND. An implicit SUSPEND is made when a component must wait for a semaphore, executes the pause pattern, executes the sleep pattern, or performs a blocking communication using the shellEnv distribution libraries (not described in this manual).

9.4.5 Concurrency and User Interface Environments

User interface environments (such as X Window System) are usually event-driven in the sense that actions in the program are executed as a response to user input events. To handle this, a number of separate implementations of SystemEnv exists for the different user interface libraries, such as xtEnv, awEnv, motifEnv, and guiEnv:

• Use systemenv.bet as origin for programs not using event-driven user-interface libraries.
• Use ~beta/Xt/xsystemenv.bet as origin for programs using xtEnv, awEnv or motifEnv.
• Use ~beta/guienv/guienvsystemenv.bet as origin for programs using GUIenv.

See xsystemenv and guienvsystemenv for a description of using systemenv in conjunction with X and GUIenv programs, respectively.

For examples of using SystemEnv, see the demo directory.

Please note, that programs should only use one of the systemenv, xsystemenv, and guienvsystemenv fragments. It is a fairly common mistake in systemEnv programs to find more than one of these fragments.