Lawrence A. Crowl

Running control engineering experiments over the internet

Abstract An important, issue in engineering education is the availability of laboratory resources for student use. Using a computer network to link geographically distant students with laboratory teaching resources makes expensive and innovative equipment available to more students. A working environment is now available where remotely-located students can develop and run controllers on experiments in the Oregon State University (OSU) control engineering laboratory. Remote users can watch the experiment in real time from a remote workstation, hear the sounds in the laboratory, and interact with other laboratory users. Remote power control, network reliability, and safety features are integrated into the experimental hardware and software design.

The Elmwood multiprocessor operating system

Elmwood is an object‐oriented, multiprocessor operating system designed and implemented during a graduate seminar. It consists of a minimal kernel and a collection of user‐implemented services. The kernel provides two major abstractions: objects, which consist of code and data, and processes, which represent asynchronous activity. Objects, like programs, are passive. To operate on an abstraction or to request a service, processes invoke an entry procedure defined by the corresponding object. Objects implement their own protection and synchronization policies using minimal kernel mechanisms. We describe the Elmwood kernel interface, an implementation on the BBN Butterfly parallel processor, and our experiences in developing a multiprocessor operating system under rigid time constraints. These experiences illustrate several general lessons regarding kernel design and trade‐offs for implementation expedience.

Control abstraction in parallel programming languages

Control abstraction is the process by which programmers define new control constructs, specifying a statement ordering separately from an implementation of that ordering. It is argued that control abstraction can and should play a central role in parallel programming. Control abstraction can be used to build new control constructs for the expression of parallelism. A control construct can have several implementations, representing the varying degrees of parallelism to be exploited on different architectures. Control abstraction also reduces the need for explicit synchronization, since it admits a precise specification of control flow. Several examples are used to illustrate the benefits of control abstraction. It is also shown that one can efficiently implement a parallel programming language based on control abstraction. It is argued that, because of the enormous benefits and reasonable costs of control abstraction, it should be included in explicitly parallel programming languages.<<ETX>>

Parallel programming with control abstraction

Parallel programming involves finding the potential parallelism in an application and mapping it to the architecture at hand. Since a typical application has more potential parallelism than any single architecture can exploit effectively, programmers usually limit their focus to the parallelism that the available control constructs express easily and that the given architecture exploits efficiently. This approach produces programs that exhibit much less parallelism that exists in the application, and whose performance depends critically on the underlying hardware and software. We argue for an alternative approach based on control abstraction. Control abstraction is the process by which programmers define new control constructs, specifying constraints on statement ordering separately from an implementation of that ordering. With control abstraction programmers can define and use a rich variety of control constructs to represent an algorithms potential parallelism. Since control abstraction separates the definition of a construct from its implementation, a construct may have several different implementations, each exploiting a different subset of the parallelism admitted by the construct. By selecting an implementation for each control construct using annotations, a programmer can vary the parallelism in a program to best exploit the underlying hardware without otherwise changing the source code. This approach produces programs that exhibit most of the potential parallelism in an algorithm, and whose performance can be tuned simply by choosing among the various implementations for the control constructs in use.