Conference Paper

Using generative design patterns to generate parallel code for a distributed memory environment

University of Waterloo, Ватерлоо, Ontario, Canada
DOI: 10.1145/781498.781532 Conference: Proceedings of the ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, PPOPP 2003, June 11-13, 2003, San Diego, CA, USA
Source: DBLP


A design pattern is a mechanism for encapsulating the knowledge of experienced designers into a re-usable artifact. Parallel design patterns reflect commonly occurring parallel communication and synchronization structures. Our tools, CO2P3S (Correct Object-Oriented Pattern-based Parallel Programming System) and MetaCO2P3S, use . A programmer selects the parallel design patterns that are appropriate for an application, and then adapts the patterns for that specific application by selecting from a small set of code-configuration options. CO2P3S then generates a custom framework for the application that includes all of the structural code necessary for the application to run in parallel. The programmer is only required to write simple code that launches the application and to fill in some application-specific sequential hook routines. We use generative design patterns to take an application specification (parallel design patterns + sequential user code) and use it to generate parallel application code that achieves good performance in shared memory and distributed memory environments. Although our implementations are for Java, the approach we describe is tool and language independent. This paper describes generalizing CO2P3S to generate distributed-memory parallel solutions.

Download full-text


Available from: Duane Szafron, Feb 10, 2014
  • Source
    • "WaveFront Pattern (WFP) [38] is a pattern that supports the computation of dependent elements. The pattern is used to generate frameworks automatically using CO 2 P 3 S parallel programming system [39]. A generated WaveFront Pattern framework was considered in this experiment. "
    [Show abstract] [Hide abstract]
    ABSTRACT: An application framework provides reusable design and implementation for a family of software systems. At the application engineering stage, application developers extend framework assets to build their particular framework instantiations. Typically, framework software assets are tested before being used. However, achieving complete coverage of a system under test is impossible or at least impractical. Therefore, framework software assets can have undiscovered errors that appear in some instantiations. During the application engineering stage, it is important to identify the framework use cases that are used in the instantiation but not covered during the framework testing stage. In this paper, a testing model that considers retesting framework assets during the application engineering stage is proposed. In addition, a test-case-reusing technique is introduced to identify uncovered framework use cases and cover them by reusing the test cases already built during the framework domain engineering stage. Empirical studies are reported to show the adequacy of the proposed framework test-case-reusing technique in terms of reducing testing time and effort, and a supporting tool that automates the proposed test-case-reusing technique is developed and introduced.
    Full-text · Article · May 2008
  • Source
    • "The graphical modeling languages used in these tools are elaborated aiming the user necessities , providing mechanisms for description of the desired system, but in many cases (such as in [13] and [17]) a formal definition of the language semantics is not presented. "
    [Show abstract] [Hide abstract]
    ABSTRACT: During the development of a parallel application, besides being able to analyze performance aspects, it is highly desirable to be able to assure functional properties as early as possible. Assuring functional properties about a model of the parallel applicationcan lead to important savings since it reduces the time spent in application development and debugging. In this direction, model-checking and automatic code generation can be used as complementary tools during the development, making possible to analyze the system behavior and allowing the fast generation of corresponding code. In this paper we propose the use of Object-Based Graph Grammars (OBGG) for the specification of parallel applications. OBGG is a formal, visual language suited for the description of concurrent systems based on asynchronous message passing. Models described using OBGG can be verified through model checking. Following this approach, a translation from OBGG models to C code using MPI (Message Passing Interface), which is suited for clusters, is presented. To illustrate the contribution, a sample parallel application is modelled in OBGG; functional properties of the model are proven by model-checking; the C/MPI corresponding model is presented and performance results of the translated model are discussed and compared with an analogous C/MPI application built by hand.
    Full-text · Article · Jul 2007 · Electronic Notes in Theoretical Computer Science
  • Source
    • "Aspect Oriented Programming (AOP) [8] provides a capability to modularize concerns that are crosscutting in nature and concurrency is one such crosscutting concern that can be addressed using AOP. Most of the current work in applying AOP to parallel computing has been primarily with Java using AspectJ [6][11][14] and there are not many efforts applying AOP to parallel computing using C/C++. But most of the parallel applications are developed using either Fortran or C/C++ and Java is yet to be accepted as a language for high performance computing mainly due to performance considerations and floating point capabilities. "
    [Show abstract] [Hide abstract]
    ABSTRACT: Developing and debugging parallel programs particularly for distributed memory architectures is still a difficult task. The most popular approach to developing parallel programs for distributed memory architectures requires adding explicit message passing calls into existing sequential programs for data distribution, coordination, and communication. This approach creates separate source tree for sequential code and parallel code as well as further branches based on the specific set of message passing primitives used (point-to-point communication vs. one-sided communication). Aspect oriented programming provides an option to separate programming concerns and weave code into applications instead of directly modifying the original program. This paper described an effort to use Aspect Oriented Programming (specifically AspectC++), components and patterns for data distribution and message passing to develop parallel programs without making any changes to existing sequential program. This technique is used to generate a suite of parallel matrix multiplication algorithms as well as several simple parallel algorithms without making any changes to the sequential code. Performance results obtained indicate that the desired functionality is achieved without compromising performance.
    Preview · Conference Paper · Jan 2007
Show more