Distributed processes: a concurrent programming concept

@article{Hansen1978DistributedPA,
  title={Distributed processes: a concurrent programming concept},
  author={Per Brinch Hansen},
  journal={Commun. ACM},
  year={1978},
  volume={21},
  pages={934-941}
}
  • P. B. Hansen
  • Published 1 November 1978
  • Computer Science
  • Commun. ACM
A language concept for concurrent processes without common variables is introduced. These processes communicate and synchronize by means of procedure calls and guarded regions. This concept is proposed for real-time applications controlled by microcomputer networks with distributed storage. The paper gives several examples of distributed processes and shows that they include procedures, coroutines, classes, monitors, processes, semaphores, buffers, path expressions, and input/output as special… 

Limitations of synchronous communication with static process structure in languages for distributed computing

TLDR
This paper examines one possible choice: synchronous communication primitives in combination with modules that encompass a fixed number of processes (such as Ada tasks or UNIX processes) that is poorly suited for applications such as distributed programs in which concurrency is important.

Structuring distributed programs with control fault detection

  • M. Tsukamoto
  • Computer Science
    Operating Systems Engineering
  • 1980
TLDR
A language concept, guarding processes, is introduced as a method of structuring concurrent programs in distributed computing systems without a common memory based on two types of path expression.

Concurrent communication and synchronization mechanisms

TLDR
This paper deals with many of the proposed communication and synchronization primitives and compares them from the perspective of their implementability and treats four basic criteria: the length of synchronization, process termination, deadlock and protocol complexity.

Processes, Tasks, and Monitors: A Comparative Study of Concurrent Programming Primitives

TLDR
Three notations for concurrent programming are compared, namely CSP, Ada, and monitors, and "lower-level" communication, synchronization, and nondeterminism in CSP and Ada are compared and "higher- level" module interface properties of Ada tasks and monitors are examined.

LYNX: A dynamic distributed programming lan-guage

TLDR
A control-flow mechanism similar to coroutines simplifies the ordering of entry procedures in a new language for multi-computer systems programming.

Communication Port: A Language Concept for Concurrent Programming

  • T. MaoR. Yeh
  • Computer Science
    IEEE Transactions on Software Engineering
  • 1980
TLDR
Communication port is an encapsulation of two language properties: "communication non-determinism" and "communication disconnect time" that provides a tool for progranmers to write well-structured, modular, and efficient concurrent programs.

Algebraic Specification Of A Communication Scheduler

TLDR
A number of different communication mechanisms, such as synchronous and asynchronous message passing, broadcasts and remote procedure calls, are modelled and, as an illustration of how global properties can be analysed, the problem of deadlock detection is considered.

Synchronizing Resources

TLDR
A new proposal for synchronization and communication in parallel programs is presented, called synchronization resources, which provides a single notation for parallel programming with or without shared variables and is suited for either shared or distributed memory architectures.

Synchronizing shared objects

  • M. Riveill
  • Computer Science
    Distributed Syst. Eng.
  • 1995
TLDR
This paper presents the integration of a concurrency control mechanism in class-based languages and addresses language and system issues: canonical examples of synchronized objects are provided and an implementation of the mechanism is outlined.
...

References

SHOWING 1-10 OF 12 REFERENCES

Communicating sequential processes

This paper suggests that input and output are basic primitives of programming and that parallel composition of communicating sequential processes is a fundamental program structuring method. When

The programming language Concurrent Pascal

  • P. B. Hansen
  • Computer Science
    IEEE Transactions on Software Engineering
  • 1975
TLDR
The main contribution of Concurrent Pascal is to extend the monitor concept with an explicit hierarchy of access rights to shared data structures that can be stated in the program text and checked by a compiler.

Specification and Implementation of Mutual Exclusion

TLDR
The method eliminates the need for auxiliary variables and establishes the correctness of a whole class of solutions to the same problem, derived directly from the specifications using a language construct called guarded regions.

Monitors: an operating system structuring concept

This paper develops Brinch-Hansen's concept of a monitor as a method of structuring an operating system. It introduces a form of synchronization, describes a possible method of implementation in

The specification of process synchronization by path expressions

TLDR
It is shown that the method's ability to express synchronization rules is equivalent to that of P and V operations, and a means of automatically translating path expressions to existing primitive synchronization operations is given.

Modula: A language for modular multiprogramming

  • N. Wirth
  • Computer Science
    Softw. Pract. Exp.
  • 1977
TLDR
Modula is a language intended primarily for programming dedicated computer systems, including process control systems on smaller machines, which is largely based on Pascal, but in addition to conventional block structure it introduces a so‐called module structure.

Guarded commands, nondeterminacy and formal derivation of programs

So-called “guarded commands” are introduced as a building block for alternative and repetitive constructs that allow nondeterministic program components for which at least the activity evoked, but

The Architecture of Concurrent Programs

Operating System Principles

Modula: A programming language for modular multiprogramming

  • Software—Practice and Experience
  • 1977