Search

The development of capsules, a high-level facility for encapsulating and regulating access to shared memory, was prompted by the porting of Concurrent C/C++ to a shared memory multiprocessor. Capsules are operationally similar to other shared memory mechanisms such as path expressions, monitors, conditional critical regions, critical regions and semaphores, but they are better because they can be formulated to operate in parallel. They match T. Bloom's parameters of expressiveness for synchronization mechanisms.

The languages C and PASCAL are growing in popularity, particularly among programmers of small computers. In this paper we summarize and compare the two languages covering their design philosophies, their handling of data types, the programming facilities they provide, the impact of these facilities on the quality of programs, and how useful the facilities are for programming in a variety of application domains. [ABSTRACT FROM AUTHOR]

Researchers at Bell Labs have recently developed a silicon compiler, named Plex, that automatically generates VLSI layouts of high performance and area efficient microprocessors. Plex takes as input a specification of the function to be executed and generates a complete mask-level layout of a customized microprocessor to execute that function. The Plex microprocessor interacts with the external world, via input and output wires, and interrupts. The dedicated function performed by a Plex microprocessor typically involves real-time handling of inputs and interrupts and the real-time generation of output signals. The objective of Plex is to provide high-level logic building blocks on a chip. Using Plex to generate designs of customized chips is attractive because it cuts the initial design time from months to hours; moreover, the designer need not be cognizant of VLSI design techniques and other details. Currently, flex specifications are programs written in an Assembly-like language. We have designed a higher level specification language, called Flex, for describing Plex-like microprocessors. Although the design of Flex has been motivated by Plex, Flex is not specific to Plex and it can be used with other silicon compilers. Flex has been designed for the silicon environment in which input- output is performed on wires and chip area severely limits program complexity. Flex is unique in that it provides very high-level facilities for dealing with low-level inputs. It provides facilities for describing input-output wires, processing based on the state of these wires, and concurrent processing. En this paper, we discuss the motivation for the advantages of a high- level language for specifying customized microprocessors, give an informal description of Flex, and illustrate its use with examples. We also discuss some Flex design decisions and examine some implementation issues. [ABSTRACT FROM AUTHOR]

Communication in a broadcast protocol multiprocessor (BPM) is inherently different from that in distributed systems formed by explicit links between processors. A message broadcast by a processor in a BPM is received directly by all other processors in the network instead of being restricted to only one processor. Broadcasting is an inexpensive way of communicating with a large number of processors on a BPM. In this paper I will describe a new approach to user-level distributed programming called broadcast programming, i.e., distributed programs written as cooperating broadcasting sequential processes (BSP). Existing concurrent programming languages do not provide facilities to exploit the broadcast capability of a 8PM. The idea of distributed pro- grams written as BSP is tailored to exploiting a BPM architecture but is not restricted to such an architecture-however, implementation of the broadcast capability may not be as efficient on other architectures. I will illustrate the utility and convenience of broadcast programming with many examples. These examples will also be used to explore the suitability and advantages of BSP and to determine appropriate facilities for BSP. [ABSTRACT FROM AUTHOR]

A serious impediment to the integrated use of databases across international boundaries, scientific disciplines and application areas is the use of different units of measure, e.g., miles or kilometers for distance, dollars or rupees for currency, and Btu or kWh for energy. Units of measure are not specified in the data definition language but associated by convention with values in the database. Inconsistent usage of values with different units cannot be checked automatically. Retrieval, storage, and manipulation of data values in units other than those associated with the values requires that the user perform the appropriate conversions. This process is inconvenient and error prone. These problems are illustrated by an international database example. To eliminate this impediment, this paper proposes that data definition languages be extended to allow the specification of the units of measure just as types (domains) of attributes are specified. Conversion between values with different but equivalent units of measure will be performed automatically and inconsistent usage of values with different units will be detected automatically. Specification of units also provides better self-documentation of data. [ABSTRACT FROM AUTHOR]

Many current robot systems exhibit a significant degree of concurrency, doing many activities in parallel. Future sensor-based robots are expected to exhibit even more concurrency. Programs to control such robots are characterized by the need to wait for external events and/or handle interrupts, deal with concurrent activities, synchronize actions with external events, and communicate with other robots and processes. In this paper, we focus on the advantages of concurrent programming for robotics and suggest that a general-purpose language with the right facilities is a good vehicle for robot programming. In this context we will discuss Concurrent C, an upward-compatible extension of the C language that provides high-level concurrent programming facilities. We give an historical perspective of concurrent programming followed by a brief description of Concurrent C and how Concurrent C programs communicate with robots and devices. We show by examples how Concurrent C simplifies writing robot programs. Of specific interest are the process interaction and related interrupt handling facilities. We conclude that high-level concurrent programming facilities provide significant advantages for robot programming. In particular, transaction facilities provide an elegant means by which to synchronize with external events and communicate with interacting robots and manufacturing processes. Interrupts may also be mapped to high-level transaction calls within the language. A concurrent programming language provides a framework in which to describe and develop concurrent solutions and can hide many details associated with distributed processing from the user. Finally, we believe that a high-level concurrent programming language such as Concurrent C is not only useful for robotics but also for manufacturing processes in general. [ABSTRACT FROM AUTHOR]