Bill Appelbe

Incremental dependence analysis for interactive parallelization

Incrementally updating dependence information during interactive parallelization is a difficult proposition. We have developed a tool (PAT) that maintains dependence information during incremental transformations to a Fortran program, including loop parallelization, code <italic>replication, alignment</italic> and <italic>shifting</italic>, as well as <italic>insertion</italic> and <italic>deletion</italic> of code including parallel primitives. Our analysis is based on a variation on the standard approach to dependence graph generation, with program wide and local information separated in a <italic>sequential</italic> and a <italic>parallel</italic> dependence graph.

Optimizing Parallel Programs Using Affinity Regions

Afinity regions ensure that a shared processor scheduling, mapping iterations to processors, is used in consecutive parallel loop nests. Using affinity regions can significantly improve locality of reference and hence the performance. This paper discusses the use and effectiveness of affinity regions.

Developing multitasking applications programs

The current state-of-the-art tools for developing numerical/scientific multitasking applications programs are examined. An integrated toolkit is proposed that is necessary before reliable multitasking applications can be effectively developed. A prototype of the proposed toolkit is being developed on the basis of a static-analysis tool that has been developed by the authors.<<ETX>>

Real-time interrupt handling in Ada

The Ada† programming language defines the semantics of interrupt handling as part of the tasking mechanism, making it possible to construct implementation‐independent interrupt handlers. However, for the Ada mechanism to be effective, an implementation must provide support not specified by the Ada standard, such as for initializing hardware interrupting devices, handling unexpected interrupts and optimizing for real‐time performance constraints. This paper analyses some of the constraints that efficient interrupt support places on an implementation. It develops a model for the interaction between interrupt hardware and Ada tasks and describes optimizations for Ada interrupt handlers. Implementation issues, including task priorities and task termination for interrupt handlers, are discussed in detail.

Software Tools for High-Performance Computiing: Survey and Recommendations

Applications programming for high-performance computing is notoriously difficult. Al-though parallel programming is intrinsically complex, the principal reason why high-performance computing is difficult is the lack of effective software tools. We believe that the lack of tools in turn is largely due to market forces rather than our inability to design and build such tools. Unfortunately, the poor availability and utilization of parallel tools hurt the entire supercomputing industry and the U.S. high performance computing initiative which is focused on applications. A disproportionate amount of resources is being spent on faster hardware and architectures, while tools are being neglected. This article introduces a taxonomy of tools, analyzes the major factors that contribute to this situation, and suggests ways that the imbalance could be redressed and the likely evolution of tools.

Interactive conversion of sequential to multitasking FORTRAN

Fully automated compilation of sequential Fortran to efficient multitasking code is impractical; tools need to be developed to aid users in interactively converting sequential to multitasking Fortran. This paper reports on experience using an interactive Parallelizing Assistant Tool (PAT) to convert sequential Fortran applications (ranging from short benchmarks to large application programs) to Cray microtasking Fortran, and discusses the advantages and limitations of interactive parallelization. We also introduce a taxonomy of task parallelization.

PAT: a retargetable parallelizing tool for Fortran

A description is given of PAT (Parallelization Assistant Tool), a retargetable tool that converts sequential Fortran to Parallel Fortran for IBM, CRAY, and Sequent multiprocessors. It runs on a range of Unix workstations, using X windows to display source code, program analysis, and transformations. PAT is intended to help programmers convert their program from sequential to parallel code, while simultaneously educating them in exploiting and understanding applications-level and architectural parallelism. The authors report on experiences with PAT, limitations of its approach, future development, and the use of PATs analysis for other tools.<<ETX>>

PATCH—a new algorithm for rapid incremental dependence analysis

Dependence analysis is critical to tools for parallel programming such as compilers, parallelizers, and performance analyzers. Conventional algorithms and data structures for dependence analysis are complex and time consuming, requiring multiple passes. In addition, these algorithms cannot easily be adapted to incrementally recompute dependence after program modifications. In this paper we present a new approach to dependence analysis which computes dependence in linear time (no backtracking) with a low space overhead. The algorithm handles arbitrary, unstructured control flow and calls to subprograms whose dependence have not been analyzed, and can be extended to allow very rapid incremental dependence recomputation. The algorithms are currently being implemented in PAT, a portable parallelization tool.

Beyond objects: a response

In a recent article [5], Shaw puts forth the argument that a process control paradigm for structuring software is more natural, and hence most appropriate for process control applications. However, we believe that there are other considerations, such as scalability and maintainability, that need to be addressed when choosing a design paradigm. Our experience, and a re-examination of Shaws models, suggests that object modeling is more appropriate for large scale process control applications.

PAT: interactive conversion of sequential to parallel Fortran

Software development for the next generation of high-performance computers is faced with a challenge-how to exploit applications parallelism without rewriting and redesigning current sequential programs and algorithms from scratch. A prototype tool for interactive parallelization of Fortran, called PAT, is described. The current versions of Pat support Fortran 77, together with Cray micro- and macrotasking, IBM Parallel Fortran, and Sequent Parallel Fortran constructs for parallelism. Pat is implemented using the C language and has been ported to a range of Unix systems, using X-windows for their graphics interface. The internal representation and I/O of multitasking primitives have been carefully designed and implemented to be easily ported to different multitasking dialects.<<ETX>>