Model Of Concurrent Computation Research Articles

The algebra of stream processing functions

Data flow networks are a model of concurrent computation. They consist of a collection of concurrent asynchronous processes which communicate by sending data over FIFO channels. In this paper we study the algebraic structure of the data flow networks and base their semantics on stream processing functions. Our algebraic theory is based on the calculus of flownomials. With an additive (or cantorian) interpretation the calculus gives a unified presentation of the classical algebraic models for control structures, that is, regular algebra and iteration theories. The kernel of the calculus is an equational axiomatization called basic network algebra (BNA) for flow graphs modulo graph isomorphism. We show that the algebra of stream processing functions called SPF (used for deterministic networks) and the algebra of sets of stream processing functions called P SPF (used for nondeterministic networks) are BNA algebras. Actually they give a multiplicative (or cartesian) interpretation of the calculus of flownomials. As a byproduct this shows that both semantic models are compositional. This means the semantics of a network may be described in terms of the semantics of its components. (As it is well known this is not true for the input–output relational semantics of nondeterministic networks.) We also identify additional axioms satisfied by the branching constants in these two algebraic theories. For the deterministic case we study in addition the coarser equivalence relation on networks given by the input–output behavior and provide a correct and complete axiomatization.

Variations on mobile processes

The paper investigates a concurrent computation model, chi calculus, in which communications resemble cut eliminations for classical proofs. Two bisimilarities, local bisimilarity and barbed bisimilarity, on chi processes are studied and are shown to be congruence relations. The former equivalence turns out to be strictly stronger than the latter. It is shown that chi calculus is capable of modeling sequential computation in that it captures the operational semantics of call-by-name lambda calculus. A translation from pi calculus to chi calculus is given, demonstrating that, practically speaking, pi is a sublanguage of chi. A higher-order version of chi calculus is proposed and examined. It combines the communication mechanism of chi calculus and the recursion mechanism of full lambda calculus, and therefore extends both.

Flame extinction limits in CH 2F 2/air mixtures

To optimize the efficiency and safety of mixtures of nonozone-depleting refrigerant replacements, precise measurements of the lean flammability limits of pure refrigerants and the critical flammability ratio of their mixtures are crucial. Current test methods that model the accidental ignition of a volume of premixed fuel and air provide ambiguous results when measuring the limiting behavior of weakly flammable refrigerants. An alternative approach using the extrapolation of the global extinction stretch rates to zero as measured in a premixed counterflow burner has been tested. In this work the approach, accuracy, and precision of the technique as it applies to CH 2F 2 (difluoromethane, R-32) are presented. Comparisons are made to the behavior of CH 4 in the same burner and to published data on the lean limiting equivalence ratio, Φ 0. The lean flammability limit of CH 2F 2 in dry air is found to be Φ 0 = 0.78 ± 0.04. Concurrent computational modeling of the combustion of a one-dimensional, unstrained flame of CH 2F 2 in air, individually and in mixtures with CH 4, has been performed. Initial estimates of the laminar flame speed for CH 2F 2/air mixtures from stoichiometric to lean are reported and interpreted in light of the experimental results.

Pi+-Calculus: A Calculus for Concurrent Processes with Constraints

The Pi-calculus is a formal model of concurrent computation based on the notion of naming. It has an important role to play in the search for more abstract theories of concurrent and communicating systems. In this paper we augment the Pi-calculus with a constraint store and add the notion of constraint agent to the standard Pi-calculus concept of agent. We call this extension the Pi+-calculus. We also extend the notion of barbed bisimulation to define behavioral equivalence for the Pi+-calculus and use it to characterize some equivalent behaviors derived from constraint agents. The paper discusses examples of the extended calculus showing the transparent interaction of constraints and communicating processes.

An object oriented model for concurrent systems

It appears that extensibility and reusability of concurrent applications is far from trivial. Often the inheritance anomalies problems will arise. Basing on the composition-filters object model which is proposed by Aksit, we introduce the Generic Synchronization Policy (GSP) in the inheritance mechanism, produce a new kind of concurrent object-oriented computational model. After analyzing, we show that this new model can tackle the suffering from the inheritance anomalies.

Decidability of model checking for infinite-state concurrent systems

We study the decidability of the model checking problem for linear and branching time logics, and two models of concurrent computation, namely Petri nets and Basic Parallel Processes.

A trusted subject architecture for multilevel secure object-oriented databases

We address security in object-oriented database systems for multilevel secure environments. Such an environment consists of users cleared to various security levels, accessing information labeled with varying classifications. Our purpose is three-fold. First, we show how security can be naturally incorporated into the object model of computing so as to form a foundation for building multilevel secure object-oriented database management systems. Next, we show how such an abstract security model can be realized under a cost-effective, viable, and popular security architecture. Finally, we give security arguments based on trusted subjects and a formal proof to demonstrate the confidentiality of our architecture and approach. A notable feature of our solution is the support for secure synchronous write-up operations. This is useful when low level users want to send information to higher level users. In the object-oriented context, this is naturally modeled and efficiently accomplished through write-up messages sent by low level subjects. However, such write-up messages can pose confidentiality leaks (through timing and signaling channels) if the timing of the receipt and processing of the messages is observable to lower level senders. Such covert channels are a formidable obstacle in building high-assurance secure systems. Further, solutions to problems such as these have been known to involve various tradeoffs between confidentiality, integrity, and performance. We present a concurrent computation model that closes such channels while preserving the conflicting goals of confidentiality, integrity, and performance. Finally, we give a confidentiality proof for a trusted subject architecture and implementation and demonstrate that the trusted subject (process) cannot leak information in violation of multilevel security.

A formal semantics for DAI language NUML

Traditional AI systems are brittle in the sense that they fail miserably when presented with problems even slightly outside of their limited range of expertise. A powerful, extensible strategy of Distributed Artificial Intelligence (DAI) for overcoming such bounds is to put the system in a society of systems. So the ability to coordinate group activities of individuals and to communicate between each other is necessary for a language describing DAI systems. Agent-oriented language NUML is such a language. It is a specific kind of object-oriented language. To give formal semantics to NUML, there is the problem to formalise object-oriented programming paradigm which is still open. The theory of higher-order π-calculus is a concurrent computation model with sufficient capability, which provides us a mathematical tool to do the formalization. This paper tries to use higher-order π-calculus to formalise NUML.

Asynchronous communication model based on linear logic

Abstract We propose a new framework called ACL for concurrent computation based on linear logic. ACL is a kind of linear logic programming framework, where its operational semantics is described in terms of proof construction in linear logic. We also give a model-theoretic semantics based on phase semantics , a model of linear logic. Our framework well captures concurrent computation based on asynchronous communication. It will, therefore, provide us with a new insight into other models of asynchronous concurrent computation from a logical point of view. We also expect ACL to become a formal framework for analysis, synthesis and transformation of concurrent programs by the use of techniques for traditional logic programming. ACL's attractive features for concurrent programming paradigms are also discussed.

“Use-once” variables and linear objects

Programming languages should have 'use-once' variables in addition to the usual 'multiple-use' variables. 'Use-once' variables are bound to linear ( unshared, unaliased, or singly-referenced ) objects. Linear objects are cheap to access and manage, because they require no synchronization or tracing garbage collection. Linear objects can elegantly and efficiently solve otherwise difficult problems of functional/mostly-functional systems---e.g., in-place updating and the efficient initialization of functional objects. Use-once variables are ideal for directly manipulating resources which are inherently linear such as freelists and 'engine ticks' in reflective languages.A 'use-once' variable must be dynamically referenced exactly once within its scope. Unreferenced use-once variables must be explicitly killed, and multiply-referenced use-once variables must be explicitly copied; this duplication and deletion is subject to the constraint that some linear datatypes do not support duplication and deletion methods. Use-once variables are bound only to linear objects, which may reference other linear or non-linear objects. Non-linear objects can reference other non-linear objects, but can reference a linear object only in a way that ensures mutual exclusion.Although implementations have long had implicit use-once variables and linear objects, most languages do not provide the programmer any help for their utilization. For example, use-once variables allow for the safe/controlled use of reified language implementation objects like single-use continuations.Linear objects and use-once variables map elegantly into dataflow models of concurrent computation, and the graphical representations of dataflow models make an appealing visual linear programming language .

Virtual Shared Memory: Algorithms and Complexity

We consider the Block PRAM model of Aggarwal et al. ( in "Proceedings, First Annual ACM Symposium on Parallel Algorithms and Architectures, 1989," pp. 11-21). For a Block PRAM model with n /log n processors and communication latency l = O (log n ), we show that prefix sums can be performed in time O ( l log n /log l ), but list ranking requires time Ω( l log n ); these bounds are tight. These results justify an intuitive observation of Gazit et al. ( in "Proceedings, 1987 Princeton Workshop on Algorithm, Architecture and Technology Issues for Models of Concurrent Computation," pp. 139-156) that algorithm designers should, when possible, replace the list ranking procedure with the prefix sums procedure. We demonstrate the value of this technique in choosing between two optimal PRAM algorithms for finding the connected components of dense graphs. We also give theoretical improvements for integer sorting and many other algorithms based on prefix sums, and suggest a relationship between the issue of graph density for the connected components problem and alternative approaches to integer sorting.

On the power of bounded concurrency I

We investigate the descriptive succinctness of three fundamental notions for modeling concurrency: nondeterminism and pure parallelism, the two facets of alternation, and bounded cooperative concurrency , whereby a system configuration consists of a bounded number of cooperating states. Our results are couched in the general framework of finite-state automata, but hold for appropriate versions of most concurrent models of computation, such as Petri nets, statecharts or finite-state versions of concurrent programming languages. We exhibit exhaustive sets of upper and lower bounds on the relative succinctness of these features over Σ * and Σ ω , establishing that: For example, we prove exponential upper and lower bounds on the simulation of deterministic concurrent automata by AFAs, and triple-exponential bounds on the simulation of alternating concurrent automata by DFAs.

On the power of bounded concurrency II

This is the second in a series of papers on the inherent power of bounded cooperative concurrency, whereby an automaton can be in some bounded number of states that cooperate in accepting the input. In this paper, we consider pushdown automata. We are interested in differences in power of expression and in exponential (or higher) discrepancies in succinctness between variants of pda's that incorporate nondeterminism (E), pure parallelism (A), and bounded cooperative concurrency (C). Technically, the results are proved for cooperating push-down automata with cooperating states, but they hold for appropriate versions of most concurrent models of computation. We exhibit exhaustive sets of upper and lower bounds on the relative succinctness of these features for three classes of languages: deterministic context-free, regular, and finite. For example, we show that C represents exponential savings in succinctness in all cases except when both E and A are present (i.e., except for alternating automata), and that E and A represent unlimited savings in succinctness in all cases.

Towards a theory of parallel algorithms on concrete data structures

Building on Kahn and Plotkin's theory of concrete data structures and sequential functions, Berry and Curien defined an intensional model of sequential algorithms between concrete data structures. In this paper we report on an attempt to develop a similar intensional model of concurrent computation. We present a notion of parallel algorithm between concrete data structures, together with suitable application and currying operations. We define an intensional strictness ordering on parallel algorithms, with respect to which application is well behaved (at first-order types). We define the input—output function computed by a parallel algorithm, and we show that every parallel algorithm computes a continuous function. Thus, a parallel algorithm may be viewed as a continuous function together with a parallel computation strategy. In contrast, a Berry—Curien sequential algorithm may be viewed as a sequential function together with a sequential computation strategy. The intensional strictness ordering on parallel algorithms corresponds to the pointwise ordering on the functions they compute, in the same sense that the set-inclusion ordering used by Berry and Curien on sequential algorithms corresponds to the stable ordering on the functions they compute. We believe that the ideas and results presented here constitute a first step towards a fuller understanding of the intensional semantics of parallelism, even though the model presented here is not yet general enough to provide a satisfactory account of higher-order algorithms, and lacks a notion of composition for algorithms. We present some ideas for overcoming these deficiencies and some directions for further research.

Visualizing actor programs using predicate transition nets

The actor model of concurrent computation unifies the functional and object-oriented programming language paradigms. The model provides a flexible basis for concurrent programming. It supports local state, dynamic creation and configuration, and inherent parallelism. Because of the fluidity of actors, specifying and debugging actor systems is often considered difficult. We believe visual programming techniques are of fundamental importance in addressing powerful concurrent systems of this nature. Not surprisingly, a number of methods to visualize actor programs have been proposed. We give an outline of visualization techniques and their relation to actors. We then discuss one such proposal, namely the use of Predicate Transition nets, to visualize actor programs.

The J-Machine: A fine-grain parallel computer

Most modern computers, whether parallel or sequential, are coarse grained. They are composed of physically large nodes with tens of megabytes of memory. Only a small fraction of the silicon area in the machine is devoted to computation. By increasing the ratio of computation area to memory area, fine-grain computers offer the potential of improving cost/performance by several orders of magnitude. To efficiently operate at such a fine grain, however, a machine must provide mechanisms that permit rapid access to global data and fast interaction between nodes. The MIT J-Machine is a fine-grain concurrent computer that provides low-overhead mechanisms for parallel computing. Prototype J-Machines have been operational since July 1991. The J-Machine communication mechanism permits a node to send a message to any other node in the machine in < 2 μs. On message arrival, a task is created and dispatched in < 1 μs. A translation mechanism supports a global virtual address space. These mechanisms efficiently support most proposed models of concurrent computation and allow parallelism to be exploited at a grain size of 10 operations. The hardware is an ensemble of up to 65,536 nodes each containing a 36-bit processor, 4K 36-bit words of on-chip memory, 256K words of DRAM and a router. The nodes are connected by a high-speed three-dimensional mesh network.

Review of Actors: A Model of Concurrent Computation in Distributed Systems

Gul A. Agha's Actors: A Model of Concurrent Computation in Distributed Systems (The MIT Press, Cambridge, Mass., 1987, 144 pages, $25.00, ISBN 0-262-01092-5) is part of the MIT Press Series in Artificial Intelligence. This volume is edited by Patrick Winston, Michael Brady, and Daniel Bobrow.

A logical theory of concurrent objects

A new theory of concurrent objects is presented. The theory has the important advantage of being based directly on a logic called rewriting logic in which concurrent object-oriented computation exactly corresponds to logical deduction. This deduction is performed by concurrent rewriting modulo structural axioms of associativity, commutativity and identity that capture abstractly the essential aspects of communication in a distributed object-oriented configuration made up of concurrent objects and messages. Thanks to this axiomatization, it becomes possible to study the behavior of concurrent objects by formal methods in a logic intrinsic to their computation. The relationship with Actors and with other models of concurrent computation is also discussed. A direct fruit of this theory is a new language, called Maude, to program concurrent object-oriented modules in an entirely declarative way using rewriting logic; modules written in this language are used to illustrate the main ideas with examples. Maude contains OBJ3 as a functional sublanguage and provides a simple and semantically rigorous integration of functional programming and concurrent object-oriented programming.

Concurrent object-oriented programming

Three significant trends have underscored the central role of concurrency in computing. First, there is increased use of interacting processes by individual users, for example, application programs running on X windows. Second, workstation networks have become a cost-effective mechanism for resource sharing and distributed problem solving. For example, loosely coupled problems, such as finding all the factors of large prime numbers, have been solved by utilizing ideal cycles on networks of hundreds of workstations. A loosely coupled problem is one which can be easily partitioned into many smaller subproblems so that interactions between the subproblems is quite limited. Finally, multiprocessor technology has advanced to the point of providing supercomputing power at a fraction of the traditional cost. At the same time, software engineering considerations such as the need for data abstraction to promote program modularity underlie the rapid acceptance of object-oriented programming methodology. By separating the specification of what is done (the abstraction) from how it is done (the implementation), the concept of objects provides modularity necessary for programming in the large. It turns out that concurrency is a natural consequence of the concept of objects. In fact Simula, the first object-oriented language, simulated a simple form of concurrency using coroutines on conventional architectures. Current development of concurrent object-oriented programming (COOP) is providing a solid software foundation for concurrent computing on multiprocessors, Future generation computing systems are likely to be based on the foundations being developed by this emerging software technology. The goal of this article is to discuss the foundations and methodology of COOP. Concurrency refers to the potentially parallel execution of parts of a computation. In a concurrent computation, the components of a program may be executed sequentially, or they may be executed in parallel. Concurrency provides us with the flexibility to interleave the execution of components of a program on a single processor, or to distribute it among several processors. Concurrency abstracts away some of the details in an execution, allowing us to concentrate on conceptual issues without having to be concerned with a particular order of execution which may result from the quirks of a given system. Objects can be defined as entities which encapsulate data and operations into a single computational unit. Object models differ in how the internal behavior of objects is specified. Further, models of concurrent computation based on objects must specify how the objects interact, and different design concerns have led to different models of communication between objects. Object-oriented programming builds on the concepts of objects by supporting patterns of reuse and classification, for example, through the use of inheritance which allows all instances of a particular class to share the same method. In the following section, we outline some common patterns of concurrent problem solving. These patterns can be easily expressed in terms of the rich variety of structures provided by COOP. In particular, we discuss the actor model as a framework for concurrent systems 1 and some concepts which are useful in building actor systems. We will then describe some other models of objects and their relation to the actor model along with novel techniques for supporting reusability and modularity in concurrent object-oriented programming. The last section briefly outlines some major on-going projects in COOP. It is important to note that the actor languages give special emphasis to developing flexible program structures which simplify reasoning about programs. By reasoning we do not narrowly restrict ourselves to the problem of program verification—an important program of research whose direct practical utility has yet to be established. Rather our interest is in the ability to understand the properties of software because of clarity in the structure of the code. Such an understanding may be gained by reasoning either informally or formally about programs. The ease with which we can carry out such reasoning is aided by two factors: by modularity in code which is the result of the ability to separate design concerns, and by the ability to abstract program structures which occur repeatedly. In particular, because of their flexible structure, actor languages are particularly well-suited to rapid prototyping applications.

Concurrent transition systems

Concurrent transition systems (CTS's), are ordinary nondeterministic transition systems that have been equipped with additional concurrency information. This concurrency information is specified in terms of a binary residual operation on transitions, which describes how certain pairs of transitions “commute.” The defining axioms for a CTS generate a rich algebraic theory, which we develop in detail. Each CTS C freely generates a complete CTS or computational category C ∗, whose arrows are equivalence classes of finite computation sequences, modulo a congruence induced by the residual operation. The notion “computation tree” for ordinary transition systems generalizes to computation diagram for CTS's, leading to the convenient definition of computations of a CTS as the ideals of its computation diagram. A pleasant property of this definition is that the notion of a maximal ideal in certain circumstances can serve as a replacement for the more troublesome notion of a fair computation sequence To illustrate the utility of CTS's, we use them to define and investigate a dataflow-like model of concurrent computation. The model consists of machines, which generalize the sequential machines of classical automata theory, and various operations (parallel product, input and output relabeling, and feedback) on machines that correspond to ways of combining machines into networks. Using our definition of computations as ideals, we define a natural notion of observable equivalence of machines, and show that it is the largest congruence, respecting parallel product and feedback, that does not relate two machines with distinct input/output relations. In an attempt to obtain information about the algebra of observable equivalence classes, we investigate a series of abstractions of the machine model, show that these abstractions respect the feedback operation, and characterize the homomorphic image of this operation in each case. A byproduct of our analysis is a structural characterization of a large class of processes with functional input/output behavior, and a proof that the feedback operation on such processes obeys Kahn's fixed-point principle.