Clayton Ferner

Pattern programming approach for teaching parallel and distributed computing

In this paper, we describe an approach for teaching parallel and distributed computing at the undergraduate level using computational patterns. The goal is to promote higher-level structured design for parallel programming and make parallel programming easier and more scalable. A pattern programming framework has been developed to create a distributed application that avoids the need to write code in low level message--passing APIs such as MPI. Several patterns have been implemented including workpool, pipeline, synchronous and iterative all-to-all, and stencil. We have redesigned a regular senior undergraduate parallel programming course to begin with a pattern strategy using our framework and provide a detailed syllabus around patterns.

Revisiting communication code generation algorithms for message-passing systems

In this paper, we investigate algorithms for generating communication code to run on distributed-memory systems. We modify algorithms from previously published work and prove that the algorithms produce correct code. We then extend these algorithms to incorporate the mapping of virtual to physical processors and prove the correctness of this extension. This technique can reduce the number of interprocessor messages. In the examples that we show, the total number of messages was reduced from O(N 2) to O(P 2), where N is the input size and P is the number of physical processors. The reason that it is important to revisit communication code generation and to introduce a formal specification of the incorporation of mapping in the communication code generation is so that we can make use of the many scheduling heuristics proposed in the literature. We need a generalized mapping function so that we can apply different mapping and scheduling heuristics proposed in the literature for each input program, therefore improving the average performance.

A geographically-distributed, assignment-structured undergraduate grid computing course

Grid computing is now mature enough and important enough to be studied as a full course at the undergraduate level for upper-level computer science majors. We have developed such a course, including a set of lecture slides, assignments, and assignment handouts specifically targeted for this audience. The sequence of assignments is a key part of the course. Some of the assignments are modifications of pre-existing work and others are completely new. We describe the key decisions we made about the course organization and content and describe the assignments. An important feature of the course is that it was geographically distributed with copies of the grid software installed at three campuses. Those campuses plus three others were receiving sites and included students and faculty associated with nine universities.

Hyperbanyan networks: a new class of networks for distributed-memory multiprocessors

A new class of connection topologies for distributed-memory multiprocessors, hyperbanyan networks, is introduced. A hyperbanyan is a combination of the topological designs of a banyan and the hypertree networks. Since the hypertree combines the advantages of the binary tree and the hypercube, a hyperbanyan has the features of a binary tree, a hypercube, and a banyan. The hyperbanyans have a fixed degree of five, and the diameter of an (n stage*2/sup n-1/ nodes/stage) hyperbanyan is 2(n-1). A routing algorithm which is close to optimal is presented.<<ETX>>

JXPL: an XML-based scripting language for workflow execution in a grid environment

JXPL is a new functional scripting language that uses XML syntax. JXPL is intended to be a workflow language that easily interacts with web and grid services. There are built in web and grid clients that can communicate with a variety of services. This facilitates the creation of workflow editors and other applications designed for grid environments and leaves application developers free to concentrate on the implementation of the user interface. In this paper, we give our motivation for JXPL and describe JXPL so that others may use the language. To aid our discussion, we introduce the grammar for JXPL using the extended Backus Naur form (EBNF). We also include examples and detail predefined functions. We conclude with current and future work.

Experiences in teaching a geographically distributed undergraduate grid computing course

This paper describes the experiences of teaching a new undergraduate grid computing course to students across the State of North Carolina in Fall 2004. This course is specifically focused at the undergraduate level and has a large number of geographically distributed participating sites. New materials have been developed for undergraduate students. We have developed a coherent set of grid computing programming assignments. All the materials developed are available on-line. This course also had internationally known guest speakers to provide state-of-the art presentations. Apart from developing grid computing materials, a number of issues arose in using the grid computing software and coordinating the activities, which are described here.

The Paraguin compiler - message-passing code generation using SUIF [Stanford University Intermediate Format]

Introduces the Paraguin project at the University of North Carolina at Wilmington. The goal of the project is to build an open-source message-passing parallelizing compiler for distributed-memory computer systems. We discuss the progress we have made in developing this compiler as well as mention the parts that have not yet been developed. It is our intent that, by providing an open-source compiler, we will stimulate research in automatic message-passing parallelism and encourage collaboration. We demonstrate a technique to improve the performance of a message-passing program by overlapping communication with computation. Although the original concept was introduced previously by S.P. Amarasinghe and M.S. Lam (1993), the algorithm was not developed nor shown to provide any benefit. Our preliminary results indicate that the technique significantly improves the performance. We were able to reduce the running time of our test program by 4-65%.

Toward Using Higher-Level Abstractions to Teach Parallel Computing

We have developed two new approaches to teaching parallel computing to undergraduates using higher level tools that lead to ease of programming, good software design, and scalable programs. The first approach uses a new software environment that creates a higher level of abstraction for parallel and distributed programming based upon a pattern programming approach. The second approach uses compiler directives to describe how a program should be parallelized. We have studied whether using the above tools better helps the students grasp the concepts of parallel computing across the two campuses of the University of North Carolina Wilmington and the University of North Carolina Charlotte using a televideo network. We also taught MPI and OpenMP in the traditional fashion with which we could ask the students to compare and contrast the approaches. An external evaluator conducted three surveys during the semester and analyzed the data. In this paper, we discuss the techniques we used, the assignments we gave the students, and the results of what we learned.

Automatic choice of scheduling heuristics for parallel/distributed computing

Task mapping and scheduling are two very difficult problems that must be addressed when a sequential program is transformed into a parallel program. Since these problems are NP-hard, compiler writers have opted to concentrate their efforts on optimizations that produce immediate gains in performance. As a result, current parallelizing compilers either use very simple methods to deal with task scheduling or they simply ignore it altogether. Unfortunately, the programmer does not have this luxury. The burden of repartitioning or rescheduling, should the compiler produce inefficient parallel code, lies entirely with the programmer. We were able to create an algorithm (called a metaheuristic), which automatically chooses a scheduling heuristic for each input program. The metaheuristic produces better schedules in general than the heuristics upon which it is based. This technique was tested on a suite of real scientific programs written in SISAL and simulated on four different network configurations. Averaged over all of the test cases, the metaheuristic out-performed all eight underlying scheduling algorithmss beating the best one by 2%, 12%, 13%, and 3% on the four separate network configurations. It is able to do this, not always by picking the best heuristic, but rather by avoiding the heuristics when they would produce very poor schedules. For example, while the metaheuristic only picked the best algorithm about 50% of the time for the 100 Gbps Ethernet, its worst decision was only 49% away from optimal. In contrast, the best of the eight scheduling algorithms was optimal 30% of the time, but its worst decision was 844% away from optimal.

Toward a Graphical User Interface for Grid Services

The goal of the UNCW Grid project is to produce a user-friendly graphical environment for assembling and executing Grid applications. In this paper, we provide examples of the work done for this ongoing project. In particular we demonstrate a ¿drag-and-drop¿ approach to assembling complex Grid applications from individual Grid services. We also show how our graphical environment interacts with existing services to install and execute user applications on remote machines.