14942325
Using Object-Oriented Techniques for Realizing Parallel Architectural Skeletons
The concept of design patterns has recently emerged as a new paradigm in the context of object-oriented design methodology. Similar ideas are being explored in other areas of computing. In the parallel computing domain, design patterns describe recurring parallel computing problems and their solution strategies. Starting with the late 1980’s, several pattern-based systems have been built for facilitating parallel application development. However, most of these systems use patterns in ad hoc manners, thus lacking a generic or standard model for using and intermixing different patterns. This substantially hampers the usability of such systems. Lack of flexibility and extensibility are some of the other major concerns associated with most of these systems. In this paper, we propose a generic (i.e., pattern- and application-independent) model for realizing and using parallel design patterns. The term architectural skeleton is used to represent the application independent, re-usable set of attributes associated with a pattern. The model can provide most of the functionalities of low level message passing libraries, such as PVM or MPI, plus the benefits of the patterns. This results in tremendous flexibility to the user. It turns out that the model is an ideal candidate for object-oriented style of design and implementation. It is currently implemented as a C++ template-library without requiring any language extension. The generic model, together with the object-oriented and library-based approach, facilitates extensibility.
5517060
Structuring Distributed Algorithms in a Workstation Environment: The FrameWorks Approach
62714434
Experience with parallel programming using code templates
For almost a decade we have been working at developing and using template-based models for parallel computing. Template-based models separate the speci cation of the parallel structuring aspects from the application code that is to be parallelized. A user provides the application code and speci es the parallel structure of the application using high-level icons, called templates. The parallel programming system then generates the code necessary for parallelizing the application. The goal here is to provide a mechanism for quick and reliable development of coarse-grain parallel applications that employ frequently occurring parallel structures. Our initial template-based system, FrameWorks, was positively received but had a number of shortcomings. The Enterprise parallel programming environment evolved out of this work. Now, after several years of experience with the system, its shortcomings are becoming evident. Controlled experiments have been conducted to assess the usability of our system in comparison with other systems. This paper outlines our experiences in developing and using these systems. A list of desirable characteristics of template-based models is given. FrameWorks and Enterprise systems are discussed in the context of these characteristics and the results of our usability experiments. Many of our observations are relevant to other parallel programming systems, even though they may be based on di erent assumptions. Although template-base models have the potential for simplifying the complexities of parallel programming, they have yet to realize these expectations for high-performance applications.
46262817
Extensible Parallel Architectural Skeletons
Complexity of parallel application development has been one of the major obstacles towards the mainstream adoption of parallel programming. In order to hide some of these complexities, researchers have been actively investigating the pattern-based approaches to parallel programming. As reusable components, patterns are intended to ease the design and development phases of parallel applications. Parallel Architectural Skeleton (PAS) is one such pattern-based parallel programming model which describes the architectural aspects of parallel patterns. Like many other pattern-based parallel programming models and tools, the benefits of PAS were offset by the difficulties in extending PAS. EPAS is an extension of PAS that addresses this issue. Using EPAS, a skeleton designer can design new skeletons and add them to the skeleton repository (i.e., extensibility). EPAS also makes the PAS model more flexible by defining composition of skeletons. In this paper, we describe the model of EPAS and also discuss some of the recent usability and performance studies. The studies demonstrate that EPAS is a practical and usable parallel programming model and tool.
42975476
An Integrated Performance Analysis Tool for SPMD Data-Parallel Programs
Abstract A new generation of data parallel languages have been proposed whereby a user specifies how data structures are to be distributed amongst the processor nodes of a distributed-memory machine. Based on this information, the compiler then generates code for the parallel application. Although this approach significantly simplifies the development of the initial version of a parallel application, selection of good data distributions leading to efficient computations is often quite difficult. Therefore, performance debuggers are needed to yield insights into the data distribution effects. On the other hand, most of the existing approaches to performance debugging are very general and thus do not provide the user feedback in terms of the high level programming model or the source code of the parallel application. In this paper, we describe a novel approach to performance debugging of data parallel programs. The design and implementation of a visual performance debugger is described that is specifically targeted to meet the performance debugging requirements of a data-parallel programming model based on user-specified data distributions. The performance debugger is part of an integrated programming environment, called EPPP, which also supports a data parallel compiler and a parallel architecture simulator. Thus development and performance debugging of an application may be done either on the real hardware or by using the simulator. The code for EPPP can be obtained free of cost (contact web address, http://www.crim.ca/apar).
28610861
A User Level, Reliable, and Reconfigurable Transport Layer Protocol
It is well known that TCP is not suitable for a number of environments such as wireless, satellite, and long-fat-pipe networks. At the same time, there is no other single transport protocol that would outperform TCP in all situations. In this paper, we explore an alternative transport layer protocol that is more suitable for today’s mobile as well as other non-conventional network environments. The result is a user-level, reconfigurable, TCP-friendly (asymptotically converges to fairness as in the case of LIMD (Linear Increase Multiplicative Decrease) algorithms) transport layer protocol, called RRTP (Reliable and Reconfigurable Transport Protocol), which runs atop of UDP. We evaluate our protocol using the standard network simulation tool (ns2). Several representative network configurations are used to benchmark the performance of our protocol against TCP in terms of network throughput and congestion loss rate. It is observed that under normal operating conditions, our protocol has a performance advantage of 30% to 700% over TCP in lossy, wireless environments as well as high bandwidth, high latency networks.
9328622
Dynamic Query-Based Debugging
Program errors are hard to find because of the cause-effect gap between the time when an error occurs and the time when the error becomes apparent to the programmer. Although debugging techniques such as conditional and data breakpoints help to find error causes in simple cases, they fail to effectively bridge the cause-effect gap in many situations. Dynamic query-based debuggers offer programmers an effective tool that provides instant error alert by continuously checking inter-object relationships while the debugged program is running. To speed up dynamic query evaluation, our debugger (implemented in portable Java) uses a combination of program instrumentation, load-time code generation, query optimization, and incremental reevaluation. Experiments and a query cost model show that selection queries are efficient in most cases, while more costly join queries are practical when query evaluations are infrequent or query domains are small.
6105186
Query-based debugging of object-oriented programs
Object relationships in modem software systems are becoming increasingly numerous and complex. Programmers who try to find violations of such relationships need new tools that allow them to explore objects in a large system more efficiently. Many existing debuggers present only a low-level, one-object-at-a-time view of objects and their relationships. We propose a new solution to overcome these problems: query-based debugging. The implementation of the query-based debugger described here offers programmers an effective query tool that allows efficient searching of large object spaces and quick verification of complex relationships. Even for programs that have large numbers of objects, the debugger achieves interactive response times for common queries by using a combination of fast searching primitives, query optimization, and incremental result delivery.
13609251
Creating an adaptive network of hubs using Schelling's model
Adjusting the overlay network topology in a peer-to-peer network to satisfy performance criteria.
15601419
A Peer-to-Peer Reference Architecture
Peer-to-peer (P2P) applications are extremely popular on the Internet because they allow users to share information in a decentralized manner. Internet users use file-sharing applications (e.g., BitTorrent, KaZaA) to share and exchange files and collaboration applications (e.g., Jabber, Groove) to exchange chat messages and work on shared documents. A reference architecture for a domain provides an architecture template which can be used as a starting point for designing the software architecture of a system in that domain. Despite the popularity of P2P applications there is no reference architecture for the P2P domain. This paper presents a reference architecture for the P2P domain. The reference architecture has been designed to satisfy the concerns that a P2P application needs to address. The reference architecture takes a service-centric view of the P2P domain. The reference architecture can be used to describe the structure of existing P2P applications and middlewares. The paper validates the reference architecture by describing the structure of some of the existing P2P applications and middlewares using the reference architecture
42861498
Decentralized compression and predistribution via randomized gossiping