In a dataflow program, an instruction is enabled whenever all of its operands have been produced; at that time, the instruction packet is eligible for execution by a free processor. Compared to a von Neumann computer, the major sources of overhead are (1) the need for matching of token destined for the same instruction, (2) routing of tokens among processors, and (3) the fact that instructions are scheduled for execution individually, one at a time. In this paper, we present an execution model that reduces much of this overhead. A dataflow program is broken into sequences of instructions that must be executed sequentially due to their data dependencies. Each sequence is loaded into execution memory as a whole, were it forms a very simple process. A processor is then multiplexed among the ready processes in its local memory. The states of these processes change between running, ready, and blocked, depending on the arrival of operands. The main advantage is that operands produced and consumed within the same sequence are stored directly in one memory operation, thus bypassing the token matching and routing units. Consequently, when executing highly sequential programs, the dataflow machine "degenerates" to an efficient von Neumann computer.

This thesis presents a study of problems in protection and security that arise in a general-purpose computing facility. We study these problems in the context of a dataflow system. The protection mechanisms are based on attaching keys to values exchanged among different subjects (users) of the system. Subjects are modelled as dataflow resource managers. A key attached to a value does not prevent that value from being propagated to any place within the system; rather, it guarantees that the value and any information derived from that value cannot leave the system (cannot be output) unless the same key is presented. The idea of attaching a key to a value is also used to allow the origin of that value to be verified. This facility is employed to provide a basis for private/secret interprocess communication. The operations of attaching and detaching keys in the low-level system are controlled by the user via special primitives incorporated in the high-level dataflow language Id.

The capabilities of the protection system are demonstrated by giving solutions to several well-known protection problems, e.g. "The Selective Confinement Problem", "The Trojan Horse Problem", "Mutual Suspicion", "The Prison Mail System Problem", and others. Also discussed is the inherently difficult problem of "sneaky signaling" using time delays, absence of information, and the error of handling facility itself.

Object-oriented programming, due to its encapsulation and message-passing principles, is a suitable basis for the programming of multicomputers. We present mechanisms which allow sequential C++ programs to be transformed into parallel programs, executable on an MIMD architecture, such as the Intel iPSC/2 Hypercube. The basic idea is to provide mechanical transformations, which allow arrays of objects to be distributed over different processors. At run time, a master processor may command other processors, considered slaves, to each create a different subrange of the original array. Subsequently, it may command the slave processors to execute any member functions of the remote array elements. Parallelism is achieved by segregating the send and receive commands issued by the master, which allows the slave processors to operate concurrently.

A protection model is presented for a multi-user dataflow computing system which is incorporated into its functional high-level language. The model is based on tags attached as 'seals' to values exchanged among processes to prevent leaking of information. A tag attached to a value, as a 'seal' does not prevent that value from being propagated to any place within the system; rather, it guarantees that the value cannot leave the system unless a matching tag is presented. Any function applied to sealed values will produce results that carry the union of all seals carried by the argument values. Thus, it is also guaranteed that no information derived from a sealed value will be able to leave the system unless it is explicitly unsealed.

The functioning of the system is demonstrated by giving solutions to well known protection problems, for example from the area of proprietary services, such as the 'Selective Confinement Problem' and the 'Trojan Horse Problem.'

A model of a relational database system based on the principles of functional, data-driven computation is proposed. Relations (sets of data tuples) are represented as streams of values carried by independent tokens among operators of an unraveling dataflow network.

Values may be “updated” by circulating the database through an update operator. To perform a query on the database, streams involved in that query are replicated and submitted as inputs to dataflow programs (graphs) obtained by translating relational algebra expressions.

A protection model is presented for a general-purpose computing system based on keys attached as ‘seals’ and ‘signatures’ to values exchanged among processes. A key attached to a value as a ‘seal’ does not prevent that value from being propagated to any place within the system; rather, it guarantees that the value and any information derived from it cannot leave the system unless the same key is presented. A key attached to a value as a ‘signature’ is used by a process to verify the origin of the received data. Solutions to problems from the areas of interprocess communication and proprietary services are given.

The main objective of this paper is to present a model of computation which permits logic programs to be executed on a highly-parallel computer architecture. It demonstrates how logic programs may be converted into collections of dataflow graphs in which resolution is viewed as a process of finding matches between certain graph templates and portions of the dataflow graphs. This graph fitting process is carried out by tokens propogating asynchronously through the dataflow graph; thus computation is entirely data-driven, without the need for any centralized control. It is shown that at the implementation level the proposed model is very similar to a general dataflow system and hence a dataflow architecture could easily be extended to support the proposed model.

Autonomous Objects is a new computing and coordination paradigm for distributed systems, based on the concept of intelligent messages that carry their own behavior and that propagate autonomously through the underlying computational network. This is accomplished by running an interpreter of the autonomous objects language in each node, which carries out the tasks prescribed by the program contained in a received message. The tasks could be computational, including the invocation of some node-resident compiled programs, or navigational, which cause the message to be propagated to neighboring nodes. Hence interpretation is incremental in that each node interprets a portion of the received program and passes the rest of it on to one or more of its neighboring nodes. This is repeated until the given problem is solved.

We survey and classify several existing systems that fall into this general category of autonomous objects and present a unifying view of the paradigm by describing the principles of a high-level language and its interpreter, suitable to express the behaviors of complex autonomous objects, called Messengers. We discuss the capabilities and applications of this paradigm by presenting solutions to a wide spectrum of distributed computing problems. This includes inherently open-ended applications, such as interactive simulations, where it is not possible to define and precompile the entire experiment prior to starting its execution, and distributed computations where the underlying network topology is unknown or changes dynamically.

This work has attempted to exploit information sharing to improve the results of Adaptive Simulated Annealing [1] as an optimization algorithm of the high-level synthesis of testable data paths. We have used Messengers [3] as a coordination tool to run several parallel instances of the annealing algorithm on the same design with different probability arrays for the perturbations. When all these instances complete annealing, they exchange information about the design among them which is given by a cost function [2] based on area, speed and testability costs of the digital design. This best design is then used as a starting point and several instances of annealing are run again in an attempt to further improve the design.

The need for extending information management systems to handle the imprecision of information found in the real world has been recognized. Fuzzy set theory together with possibility theory represent a uniform framework for extending the relational database model with these features. However, none of the existing proposals for handling imprecision in the literature has dealt with queries involving a functional evaluation of a set of items, traditionally referred to as aggregation. Two kinds of aggregate operators, namely, scalar aggregates and aggregate functions, exist. Both are important for most real-world applications, and are thus being supported by traditional languages like SQL or QUEL. This paper presents a framework for handling these two types of aggregates in the context of imprecise information. We consider three cases, specifically, aggregates within vague queries on precise data, aggregates within precisely specified queries on possibilistic data, and aggregates within vague queries on imprecise data. These extensions are based on fuzzy set-theoretical concepts such as the extension principle, the sigma-count operation, and the possibilistic expected value. The consistency and completeness of the proposed operations is shown.