We compare two systems for program comprehension that are targeted towards support of automatic parallelization: the PAP recognizer currently included into the Vienna Fortran Compilation System, and the PARAMAT pattern recognizer developed at Saarbrucken University. We illuminate the main differences, the advantages and disadvantages of each approach, and show how both approaches may be integrated to combine the generality of one approach with the speed of the other one.

This paper describes a knowledge-based system for automatic parallelization of a wide class of sequential numeric codes operating on vectors and dense matrices, and for execution on distributed memory message-passing multiprocessors. Its main feature is a fast and powerful pattern recognition tool that locally identifies frequently-occurring computations and programming concepts in the source code. This tool works also for dusty deck codes that have been `encrypted' by former machine-specific code transformations. Successful pattern recognition guides sophisticated code transformations including local algorithm replacement such that the parallelized code need not emerge from the sequential program structure by just parallelizing the loops. It allows access to an expert's knowledge on useful parallel algorithms, available machine-specific library routines, and powerful program transformations, The partially restored program semantics also supports local array alignment, distribution and redistribution, and allows for faster and more exact prediction of the performance of the parallelized target code than is usually possible.

Techniques for automatic program recognition, at the algorithmic level, could be of high interest for the area of Program Parallelization, because the selection of suitable parallelization strategies is driven by algorithmic features of the code. In this paper a technique for the specification and automatic recognition of algorithmic concepts is presented. Its flexibility and expressivity power to specify the hierarchy, the constraints and the relationships among concepts allow it to deal with recognition of algorithmic concepts within optimized code, irregular computations, and in presence of code sharing, delocalization, implementation variations and other problems related to program recognition in the context of the imperative languages typically used for scientific computation. 1. Introduction The problem of assigning concepts to code does not seem to be automatically solvable in its general form [2], because the concepts oriented to human domains are inherently ambiguous, and th...

This report presents a novel family of linear-time algorithms for loop analysis based on the CR# (CR-sharp) algebra, which is a new nontrivial extension of the Chains of Recurrences (CR) algebra. Conventional compiler methods apply induction variable substitution and array recovery translations to construct closed forms for induction variables and pointers prior to dependence testing and loop optimization. In this report we take a radically different approach to symbolic analysis by turning the problem up-sidedown. We convert closed forms to recurrences and compute recurrence relations for (non)linear induction variables and conditionally updated variables and pointers. The recurrence forms are used to solve a larger class of loop analysis problems such as nonlinear array dependence testing without requiring a-priori code translations.

Automatic program comprehension is particularly useful e.g. from specific sparse matrix storage formats used in the code. In this paper we describe SPARAMAT, a system for speculative automatic program comprehension suitable for sparse matrix codes, and its implementation.

In this paper a formalism for the specification of algorithmic concepts recognition is presented. It is coupled to an automated hierarchical concept parsing recognition technique. It allows for a successful handling of the languages and the kind of codes, algorithms and optimizations connected to scientific and high performance computing. Its flexibility and expressivity power for the specification of the hierarchy, the constraints and the relationships among concepts is exemplified through a case study. 1 Introduction The problem of assigning concepts to code does not seem to be automatically solvable in its general form [2], because the concepts oriented to human domains are inherently ambiguous, and their recognition heavily relies on a priori knowledge on the particular domain. Nevertheless, if the recognition is limited to the algorithmic level, the task seems to be manageable. The winning strategy [16, 8] is to structure the recognition process as an increasingly abstraction pro...

Automatic program comprehension techniques have been shown to improve automatic parallelization of dense matrix computations. The recognition of concepts in the code enables aggressive automatic program transformations up to local algorithm replacement, and supports automatic data layout and performance prediction. We show how this approach can be generalized to sparse matrix codes. Program comprehension will be particularly useful in this case, since it should allow to abstract e.g. from specific storage formats used in the code. Unfortunately, space-efficient data structures for sparse matrices typically yield programs in which not all data dependencies can be determined at compile time. We propose a speculative program comprehension and parallelization method suitable for sparse matrix codes. Only where static analysis does not supply sufficient information, a parallelized run time test must check whether a code fragment speculatively recognized at compile time as a sparse matrix computation really implements this type of computation. The placement of run-time tests is supported by a static data flow analysis framework.

As recent studies show, state-of-the-art parallelizing compilers produce no noticeable speedup for 9 out of 12 PERFECT benchmark codes, while the speedup that was reached by manually applying certain automatable techniques ranges from 10 to 50. In this paper we introduce the Global Value Propagation algorithm that unifies several of these techniques. Global propagation is performed using program abstraction called Value Flow Graph (VFG). VFG is an acyclic graph in which vertices and arcs are parametrically specified using F-relations. The distinctive features of our propagation algorithm are: (1) It propagates not only values carried by scalar variables, but also values carried by individual array elements. (2) We do not have to transform a program in order to use propagation results in program analysis. In this paper we focus on use of the VFG and global value propagation in array dataflow analysis. F-relations are used to represent values produced by uninterpreted function symbols th...

As recent studies show, state-of-the-art parallelizing compilers produce no noticeable speedup for 9 out of 12 PERFECT benchmark codes, while the speedup that was reached by manually applying certain automatable constraint propagation techniques ranges from 10 to 50 times. In this paper we show how a subset of these much-desired techniques can be automated. We describe an algorithm that is a combination of exact array dataflow dependence analysis and on-demand global value propagation. Propagating values to the references that make the dependence problem non-affine, the algorithm in many cases can affinize the dependence problem. Affine dependence problems result in exact dependence information and therefore lead to new opportunities in propagation. We also present three algorithms for global value propagation and discuss their merits and applications. The propagation is performed on the acyclic parametrized value flow graph of the program represented by F-relations (also in...

The recognition of program constructs that are frequently used by software developers is a powerful mechanism for optimizing and parallelizing compilers to improve the performance of the object code. The development of techniques for automatic recognition of computational kernels such as inductions, reductions and array recurrences has been an intensive research area in the scope of compiler technology during the 90’s. This article presents a new compiler framework that, unlike previous techniques that focus on specific and isolated kernels, recognizes a comprehensive collection of computational kernels that appear frequently in full-scale real applications. The XARK compiler operates on top of the Gated Single Assignment (GSA) form of a high-level intermediate representation (IR) of the source code. Recognition is carried out through a demand-driven analysis of this high-level IR at two different levels. First, the dependences between the statements that compose the strongly connected components (SCCs) of the data-dependence graph of the GSA form are analyzed. As a result of this intra-SCC analysis, the computational kernels corresponding to the execution of the statements of the SCCs are recognized. Second, the dependences between statements of different SCCs are examined in order to recognize more complex kernels that result from combining simpler kernels in the same code. Overall, the XARK compiler builds a hierarchical