Ease(ID:3593/eas001)

Semitically validated Linda Occam hybrid 


General purpose parallel programming language, combining the process constructs of CSP (via OCCAM) and the distributed data structures of Linda. Semiotically validated Linda implementation (Ericsson Zenith is a painter and poet as well as programmer)

Steven Ericsson Zenith, Yale, 1990, ENS Paris 1992

"The name? Well, Ease is a puzzle solution. The question and answer are mutually recursive.
Q. An Abstract System in ease.
A. Ease (Abstract (A) System (S) in ease (e)s = eASe)"

Possibly written as a Definitionist work (Definitionism is a general theory of signs (semiotics)) and possibly also drawing on experience writing Occam

Places
Related languages
Linda => Ease   Implementation
Occam => Ease   Influence

References:
  • Ericsson Zenith, Steven "Programming with Ease: the semiotic definition of the language" Yale Research Report 809, July 1990 view details Abstract: This document proposes a new language for parallel computation and related (distributed) data structures. The language provides a type associative storage model which can be efficiently implemented on a range of machine memory architectures.

    Ease is a general purpose, high level, imperative programming language designed to enable the simple expression of concurrent algorithms on parallel machines. Parallel machine in this context refers not only to general purpose parallel machines but also to specialised (perhaps massively parallel) super computers, embedded systems and real timecontrol systems.

    A program is described as a collection of processes which execute concurrently, constructing and interacting via strictly typed distributed data structures called "contexts".

    Ease is novel in the following regard: a "context" provides a priority oriented and strictly typed intermediary in which distributed data structures are constructed and by which processes may interact. Ease provides simple and symmetric binding operators which allow complex data structures to be constructed and exchanged efficiently. Ease provides constructions for both cooperative and subordinate concurrency.

    Ease is a development and synthesis of several concepts that exist in the domain of parallel processing. The principal synthesis in Ease is between the process constructor concepts of CSP and the ideas of distributed data structures found in the tuple space concepts of Linda.

    Unlike the generalised Tuple Space of Linda, Ease contexts are strictly typed and perform no matching at runtime.

    Ease is designed to exploit opportunities for efficiency on a range of machine architectures, whilst remaining architecture independent.

    The main requirements when designing Ease were that it should be an expressive, well defined language, efficient to implement and applicable to a wide range of applications in general purpose computing and embedded systems, and be suited as a target formalism for automatic generation.
  • Zenith, S.E. "Programming with Ease: Semiotic Definition of the Language", Yale U TR-809, Jul 1990. view details
  • Ericsson Zenith, Steven "Programming with Ease" Centre de Recherche en Informatique, Ecole Nationale Superieure des Mines de Paris, Sept. 20 1991 view details
  • Ericsson Zenith, Steven "A Rationale for Programming with Ease" pp147-156 view details ftp
          in Banâtre, J.P. and D. Le Métayer, (eds) Research Directions in High-Level Parallel Programming Languages, June 17-19 1991 LNCS 574, Springer Verlag, Berlin 1992 view details
  • Ericsson Zenith, Steven "The Axiomatic Characterization of Ease" In Greg Wilson, editor, Linda-Like Systems and Their Implementation , pages 143-152. Technical Report 91-13 Edinburgh Parallel Computing Centre, 1991 . view details
          in Banâtre, J.P. and D. Le Métayer, (eds) Research Directions in High-Level Parallel Programming Languages, June 17-19 1991 LNCS 574, Springer Verlag, Berlin 1992 view details
  • Ericsson Zenith, Steven., Process Interaction Models, Universite Pierre et Marie Curie Ph.D. thesis. Ecole Nationale Superieure des Mines de Paris, July 1992 view details
          in Banâtre, J.P. and D. Le Métayer, (eds) Research Directions in High-Level Parallel Programming Languages, June 17-19 1991 LNCS 574, Springer Verlag, Berlin 1992 view details
  • Ericsson Zenith, Steven "Ease: the model and its implementation" p87 view details Abstract: The Ease programming model was first suggested in [Zen90] as a new model for process interaction and is completely described in [Zen92].

    The rationale for the model argues that generalized message passing, as epitomized by the CSP [Hoa85] model, is unsuitable as an programming model since it preoccupies the programmer with issues of data distribution. However, CSP provides an important mathematical tool for reasoning about program behavior and CSP is used as the formal basis for the new model.

    Ease programs are described as collections of processes which execute concurrently, constructing and interacting via strictly typed shared data structures.

    Ease allows the simple and explicit expression of locality and proximity by the construction of uniform logically shared data structures called contexts. In essence this provides a mechanism that frees the programmer of data distribution preoccupations and the need for the contrived associative construction of distributed data structures found in other models.

    Contexts are acted upon by four simple and symmetric operations; read, write, put, and get. Contexts possess important behavioral characteristics; singletons are subscriptable data items, streams yield the least recently assigned value present, bags yield one of the present values assigned to it, and resource combinations provide a guaranteed call/reply semantics. These characteristics can be efficiently implemented on a range of machine architectures; and are especially useful on the hybrid shared/distributed memory architectures becoming available on high performance computing machines.

    Contexts are described as CSP subordinate processes and this allows the actions upon them and their characteristic behavior to be specified formally. Further the formal specification is extended to describe the implementation of these logically shared data structures on distributed memory machines.

    The Context Model encapsulates a mechanism that allows an implementation to exchange data by reference. This is of particular advantage in the manipulation of non-trivial data structures and reduces data exchange and memory space costs in shared memory, distributed virtual shared memory, and other distributed memory architectures.

    The Ease process model is well defined with interleaving semantics and no side effects. There are two parallel constructions: a cooperation is a construction that terminates when all the processes in the construction terminate providing a barrier synchronization, a subordination terminates immediately allowing the created parallel processes to continue independently.
          in [ACM SIGPLAN] SIGPLAN Notices 28(01) January 1993 Workshop on languages, compilers and run-time environments for distributed memory 1993 multiprocessors view details
  • Skillicorn, David B. and Talia, Domenico "Models and languages for parallel computation" pp123-169 view details Extract: Ease
    A model that extends Linda by including ideas from Occam is the language Ease. Ease programs have multiple tuple spaces, which are called contexts and may be visible to only some threads. Because those threads that access a particular context are known, contexts take on some of the properties of Occam-like channels. Threads read and write data to contexts as if they were Linda tuple spaces, with associative matching for reads and inputs. However, they can also use a second set of primitives that move data to a context and relinquish ownership of the data, or retrieve data from a context and remove them from the context. Such operations can use pass-by-reference since they guarantee that the data will be referenced by only one thread at a time. Ease has many of the same properties as Linda, but makes it easier to build implementations with guaranteed performance. Ease also helps with decomposition by allowing process structuring in the style of Occam.
          in [ACM] ACM Computing Surveys (CSUR) 30(2) June 1998 view details
    Resources