scholarly journals Efficient Parallel Programming with Linda

1992 ◽  
Vol 1 (2) ◽  
pp. 177-183 ◽  
Author(s):  
Ashish Deshpande ◽  
Martin Schultz
Keyword(s):  
Parallel Programming ◽  
Programming Language ◽  
Associative Memory ◽  
Shallow Water Equations ◽  
Distributed Memory ◽  
Parallel Machines ◽  
Yale University ◽  
Coordination Language ◽  
High Level ◽  
Memory Architectures

Linda is a coordination language inverted by David Gelernter at Yale University, which when combined with a computation language (like C) yields a high-level parallel programming language for MIMD machines. Linda is based on a virtual shared associative memory containing objects called tuples. Skeptics have long claimed that Linda programs could not be efficient on distributed memory architectures. In this paper, we address this claim by discussing C-Linda's performance in solving a particular scientific computing problem, the shallow water equations, and make comparisons with alternatives available on various shared and distributed memory parallel machines.

scholarly journals Parallel programming technologies on computer complexes

2020 ◽  
Vol 30 (3) ◽  
pp. 28-33 ◽  
Author(s):  
S. A. Pryadko ◽  
A. Yu. Troshin ◽  
V. D. Kozlov ◽  
A. E. Ivanov
Keyword(s):  
Parallel Programming ◽  
Shared Memory ◽  
Programming Language ◽  
Operating Systems ◽  
Distributed Memory ◽  
Programming Models ◽  
Writing Programs ◽  
Advantages And Disadvantages ◽  
C Programming Language ◽  
C Programming

The article describes various options for speeding up calculations on computer systems. These features are closely related to the architecture of these complexes. The objective of this paper is to provide necessary information when selecting the capability for the speeding process of solving the computation problem. The main features implemented using the following models are described: programming in systems with shared memory, programming in systems with distributed memory, and programming on graphics accelerators (video cards). The basic concept, principles, advantages, and disadvantages of each of the considered programming models are described. All standards for writing programs described in the article can be used both on Linux and Windows operating systems. The required libraries are available and compatible with the C/C++ programming language. The article concludes with recommendations on the use of a particular technology, depending on the type of task to be solved.

scholarly journals Workload Decomposition Strategies for Shared Memory Parallel Systems with OpenMP

2001 ◽  
Vol 9 (2-3) ◽  
pp. 109-122 ◽  
Author(s):  
Beniamino Di Martino ◽  
Sergio Briguglio ◽  
Gregorio Vlad ◽  
Giuliana Fogaccia
Keyword(s):  
Programming Languages ◽  
Parallel Programming ◽  
Shared Memory ◽  
Memory Systems ◽  
Particle In Cell ◽  
Decomposition Strategies ◽  
Programming Effort ◽  
High Level ◽  
Memory Architectures

A crucial issue in parallel programming (both for distributed and shared memory architectures) is work decomposition. Work decomposition task can be accomplished without large programming effort with use of high-level parallel programming languages, such as OpenMP. Anyway particular care must still be payed on achieving performance goals. In this paper we introduce and compare two decomposition strategies, in the framework of shared memory systems, as applied to a case study particle in cell application. A number of different implementations of them, based on the OpenMP language, are discussed with regard to time efficiency, memory occupancy, and program restructuring effort.

Implementing the evaluation transformer model of reduction on parallel machines

1991 ◽  
Vol 1 (3) ◽  
pp. 329-366 ◽  
Author(s):  
G. L. Burn
Keyword(s):  
Distributed Memory ◽  
Parallel Machines ◽  
Functional Languages ◽  
Essential Difference ◽  
Lazy Evaluation ◽  
New Type ◽  
Non Local ◽  
Definition Of ◽  
Transformer Model ◽  
Memory Architectures

AbstractThe evaluation transformer model of reduction generalizes lazy evaluation in two ways: it can start the evaluation of expressions before their first use, and it can evaluate expressions further than weak head normal form. Moreover, the amount of evaluation required of an argument to a function may depend on the amount of evaluation required of the function application. It is a suitable candidate model for implementing lazy functional languages on parallel machines.In this paper we explore the implementation of lazy functional languages on parallel machines, both shared and distributed memory architectures, using the evaluation transformer model of reduction. We will see that the same code can be produced for both styles of architecture, and the definition of the instruction set is virtually the same for each style. The essential difference is that a distributed memory architecture has one extra node type for non-local pointers, and instructions which involve the value of such nodes need their definitions extended to cover this new type of node.To make our presentation accessible, we base our description on a variant of the well-known G-machine, an abstract machine for executing lazy functional programs.

LLC: A PARALLEL SKELETAL LANGUAGE

2003 ◽  
Vol 13 (03) ◽  
pp. 437-448 ◽  
Author(s):  
ANTONIO J. DORTA ◽  
JESÚS A. GONZÁLEZ ◽  
CASIANO RODRÍGUEZ ◽  
FRANCISCO DE SANDE
Keyword(s):  
Theoretical Model ◽  
Parallel Programming ◽  
Distributed Memory ◽  
Parallel Architectures ◽  
Parallel Applications ◽  
Prototype Implementation ◽  
Memory Architectures

The skeletal approach to the development of parallel applications has been revealed to be one of the most successful and has been widely explored in the recent years. The goal of this approach is to develop a methodology of parallel programming based on a restricted set of parallel constructs. This paper presents llc, a parallel skeletal language, the theoretical model that gives support to the language and a prototype implementation for its compiler. The language is based on directives, uses a C-like syntax and gives support to the most widely used skeletal constructs. llCoMP is a source to source compiler for the language built on top of MPI. We evaluate the performance of our prototype compiler using four different parallel architectures and three algorithms. We present the results obtained in both shared and distributed memory architectures. Our model guarantees the portability of the language to any platform and its simplicity greatly eases its implementation.

Sign in / Sign up

Export Citation Format

Share Document