Incorporating input/output operations in LINDA

1996

Orca is an object-based distributed shared memory system that is designed for writing portable and efficient parallel programs. Orca hides the communication substrate from the programmer by providing an abstract communication model based on shared objects. Mutual exclusion and condition synchronization are cleanly integrated in the model. Orca has been implemented using a layered system, consisting of a compiler, a runtime system, and a virtual machine (Panda). To implement shared objects efficiently on a distributed-memory machine, the Orca compiler generates regular expressions describing how shared objects are accessed. The runtime system uses this information together with runtime statistics to decide which objects to replicate and where to store nonreplicated objects. The Orca system has been implemented on a range of platforms (including Solaris, Amoeba, Parix, and the CM-5). Measurements of several benchmarks and applications across four platforms show that the new Orca system achieves portability with good performance. In addition, the measurements show that performance of the new system is as good as the previous implementation that was specialized for Amoeba.

2002

structure called a monitor synchronizes access to shared data in shared-memory architectures, whereas °This work wa._ partially supported by National Science rent prograrnming mechanisnts of the tirrw (monitor:_. F,,uudatiou Krant ('CR-9121875. r_wssage-passing, and rernote oi)orations) a.s to make tThis w,,rk wa._ _upported by the Applied Mathematical S,:i-it a fo_lrt, h model, lt differs from the other menials in ,'m'_._ _ubpr,,Kr;tu_,,f the ()trice of E_ergy Ftesearch, II ..q.

2001

ABSTRACT Coordination systems, in particular Linda, have established themselves as important tools for developing applications for open systems such as the Internet. This paper shows how to tackle a forgotten, yet crucial problem in open coordination systems: memory management. As with any system which intends to be of wide use, coordination systems have to address the problems of memory exhaustion since memory is a finite resource.

ACM Transactions on Computer Systems, 1986

Linda is a parallel programming language that differs from other parallel languages in its simplicity and in its support for distributed data structures. The S/Net is a multicomputer, designed and built at AT&T Bell Laboratories, that is based on a fast, word-parallel bus interconnect. We describe the Linda-supporting communication kernel we have implemented on the S/Net. The implementation suggests that Linda's unusual shared-memory-like communication primitives can be made to run well in the absence of physically shared memory; the simplicity of the language and of our implementation's logical structure suggest that similar Linda implementations might readily be constructed on related architectures. We outline the language, and programming methodologies based on distributed data structures; we then describe the implementation, and the performance both of the Linda primitives themselves and of a simple S/Net-Linda matrix-multiplication program designed to exercise them.

Citeseer

Communicating Process Architectures

Abstract. This paper describes the implementation of an extended version of Linda in Java. The extensions have been made with a view to increasing the efficiency of the underlying communication mechanisms and the flexibility ...

Electronic Notes in Theoretical …, 2002

Linda is a coordination language, originally presented as a set of inter-agent communication primitives which can virtually be added to any programming language. In this paper, we analyse the use of Linda to specify the interactive behaviour of software components. We first introduce a process algebra for Linda and we define a notion of process compatibility that ensures the safe composition of components. In particular, we prove that compatibility implies successful computation. We also argue that Linda features some advantages with respect to similar proposals in the context of dynamic compatibility checking. In this perspective, we propose an alternative definition of compatibility that takes into account the state of a global store, which gives some relevant information about the current execution of the system.

Concurrency and Computation: Practice and Experience, 2004

This paper surveys a number of the implementations of Linda that are available in Java. It provides some discussion of their strengths and weaknesses, and presents the results from benchmarking experiments using a network of commodity workstations. Some extensions to the original Linda programming model are also presented and discussed, together with examples of their application to parallel processing problems.

Computer, 2000

2014

The goal of the workshop and this report is to identify common themes and standardize concepts for locality-preserving abstractions for exascale programming models. Current software tools are built on the premise that computing is the most expensive component, we are rapidly moving to an era that computing is cheap and massively parallel while data movement dominates energy and performance costs. In order to respond to exascale systems (the next generation of high performance computing systems), the scientific computing community needs to refactor their applications to align with the emerging data-centric paradigm. Our applications must be evolved to express information about data locality. Unfortunately current programming environments offer few ways to do so. They ignore the incurred cost of communication and simply rely on the hardware cache coherency to virtualize data movement. With the increasing importance of task-level parallelism on future systems, task models have to support constructs that express data locality and affinity. At the system level, communication libraries implicitly assume all the processing elements are equidistant to each other. In order to take advantage of emerging technologies, application developers need a set of programming abstractions to describe data locality for the new computing ecosystem. The new programming paradigm should be more data centric and allow to describe how to decompose and how to layout data in the memory. Fortunately, there are many emerging concepts such as constructs for tiling, data layout, array views, task and thread affinity, and topology aware communication libraries for managing data locality. There is an opportunity to identify commonalities in strategy to enable us to combine the best of these concepts to develop a comprehensive approach to expressing and managing data locality on exascale programming systems. These programming model abstractions can expose crucial information about data locality to the compiler and runtime system to enable performance-portable code. The research question is to identify the right level of abstraction, which includes techniques that range from template libraries all the way to completely new languages to achieve this goal.