Compilers for HPF

At the SC'96 HPF BOF in November 1996, it appeared that 17 computer hardware vendors offered HPF on their machines. An excellent list of commercially available compilers can be had from Michael Hennecke at Karlsruhe. Another site was established in 1996 to track HPF implementations [155]. This section describes the history and current status of some of these compilers.

IBM's XL High Performance Fortran compiler for AIX 4.1 became generally available on April 19, 1996, after beta-testing at a large number of institutions, including Cornell. XL HPF accepts most of F90 and a substantial part of HPF, including some of the HPF_LIBRARY. It runs over MPI and comes with a debugger, a profiler, and a trace visualizer. A description of some early research compiler techniques that were incorporated into the product can be found in Gupta et al. [84,85], and Suganuma et al. [174].

After a long beta-test of their compiler at the San Diego Supercomputer Center, the Portland Group announced pghpf , their HPF compiler [134,167] on November 11, 1994. Targets at that time were Intel (both Paragon and iPSC/860), Meiko, SGI, SPARC-Cray, and clusters of SGI and/or SPARCs. (They did the node compiler for Meiko and Paragon.) As of 1995, they supported the IBM SP2 as well (Fortran 77 + MPI). In November 1995, Cray announced that they would be supplying pghpf as their HPF offering. That Cray would use pghpf was confirmed in March 1996 by Cray Research Inc, after the merger with SGI. The pghpf compiler is popular with CM Fortran programmers, because it accepts most of CM Fortran syntax. As of Feburary 1995, the PGI compiler supported only BLOCK distributions, but in multiple dimensions, and a rather complete EXTRINSIC interface was planned. As of June 1995, the SP2 version was running successfully on top of MPI-F at the Cornell Theory Center. By that time it supported CYCLIC as well as block, a large portion of F90 syntax and intrinsics, and a number of HPF intrinsics as well (including GRADE_DOWN). The EXTRINSIC interface was weak (no HPF_LOCAL routines) until version 2.1 came out in June 1996, at which time the HPF_LOCAL extrinsic kind was added. Release 2 of pghpf includes some support for INDEPENDENT DO loops. Future plans include HPF2's ON and REDUCE constructs.

Digital was arguably the leader in ``true'' HPF compilers, beating IBM to the HPF market. DEC had a compiler out for Beta test in late 1994 for the Alpha platform. DEC Fortran 90 was a ``full HPF'', in the sense that it was based on Fortran 90. In fact, ``The Digital Fortran Family of High Performance Developement Tools'' not only contains HPF but also ``DEC Fortran 90'' which runs on the 64-bit Alpha AXP OSF/1-based system. In 1994, this package included the HPF subset (bundled) plus EXTRINSIC [12/20/94]. It consisted of DEC Fortran 90 v1.3 and the Digital Paralllel Software Environment v1.0 (which is similar to IBM's Parallel Environment). As of 1996 1996 Digital was planning to put out a new version in January 1997 which will conform to the October 20, 1996 draft of HPF 2.0 language spec. DEC F90 V1.3 supports the full ANSI/IOS F90 standard. As of late 1995, DEC Fortran 90 did not parallelize any DO loops; only FORALL statements were parallelized. The GRADE_UP routines run on one node serially, but that may have been fixed by now (December 1996). A discussion of the HPF language as well as Digital's implementation of HPF can be found in a paper by Harris et al. [88,144]. Some performance results can be found in Sørevik [146]. The March 1997 release was to support mapping (ALIGN, DISTRIBUTE) of pointer variables. Certainly one novel feature of the DEC compiler is that it allows HPF code to be called from serial (i.e. C code) as well as from an (HPF_SERIAL) procedure.

In May, 1995, NAG announced their intention to produce, in partnership with ACE, an F90 compiler complete with FORALL and ``every HPF language feature and intrinsic''. ACE is a compiler-technology company that has something called the CoSy framework that lets compiler pieces be put into it. One of these was (in July 1996) the HPF Fortran 90 frontend from the Vienna HPF+ project. As of July 1996, the ACE/NAG F90 compiler was available, replacing the older NAG F90-to-C translator. Upon request, at no extra cost, the CoSy HPF compiler would be combined with the F90 compiler (SPARC and SOLARIS platform). This would continue for another year, to find out what the demand for HPF is; if there is no demand, it would be dropped. As of January 1996 the blurbs for the NAG/ACE compiler mentioned that the NAGWare F90 Compiler accepts HPF extensions. As of May 1996, CoSy's HPF compiler was called EXPERT HPF [155], and translated HPF to PowerPC or Sparc code. It could also emit standard C. SofTech announced in 1995 that it would have an HPF compiler for a number of platforms, including the PowerPC. But then it appeared instead that SofTech was licensed to sell its own versions of DEC's HPF/F90 compiler.

TransTech and CDAC also announced HPF compiler efforts.

NEC's HPF compiler for the Cenju-3 is a research compiler ('95). Yoshiki Seo is the HPF environment specialist, and attended some HPFF meetings. HPF programming for the Cenju-3 is now (as of 1996) supported by the Annai programming environment [56,142] from CSCS in Switzerland. The Anni Parallelization Support Tool is a source to source translator from HPF to C plus calls to a runtime communications library, with MPI underneath.

Hitachi's SR2201 is scalable from 12 to 1024 processors based on the Mach 3.0 microkernel. Its programming environment includes HPF according to a September 1, 1995 announcment from Hitachi.

APR's xHPF pre-compiler [121] gives you most of what you need. Version 2.0, the January 1995 release, supported multidimensional decompositions as well as a form of EXTRINSIC. Version 2.1 in Jan. 96 contained bug fixes and new documentation. Unfortunately, xHPF lacks much support for F90, and its HPF_LIBRARY support is weak. All intrinsics are translated into F77 and then compiled. Their big edge is being able to produce relatively fast parallel programs from grundgy F77 code, due to their powerful (non-HPF compliant) PAR DO ON... directive. A good overview of APR's own directives can be found in [63]. Although these directives are not standard and dangerous to use, the can make xHPF generate reasonably efficient parallel code.

Thinking Machines announced an HPF compiler in early 1996 (for SPARCS running Solaris), with a beta test planned for September 1996. However, with their acquisition by Sun, these plans became unclear, although they had been planning a full HPF in 1997. PRISM would be the programming environment, and the TMC compiler would accept both CMF and HPF. The HPF library is based on the old, and very popular, CMSSL, and was to be called TM/HPF. GlobalWorks, already a product, would support TM/HPF. Thinking Machines was also planning to market a CMF2HPF tool.

The other shoe dropped when SUN announced (in November 1997) their parallel environment for their cluster machines. HPC 2.0 from Sun includes HPF, Prism, MPI, and CMSSL.

Lahey has an HPF syntax checker (January 1995).

Pacific Sierra announced at SC'94 a VAST preprocessor for HPF. At SC'95 they said their HPF compiler was generally available. The VAST-HPF compiler initially generates F77 code with message passing calls, which is passed to the machine's native compiler for final compilation and linking. We evaluated this compiler at Cornell during the Fall of 1996, and found that it did a reasonably good job on its example codes, but failed on our standard test case. Also it really prefers that the number of processors should be specified at compile time, a limitation. However, Digital is promoting VAST-HPF to its Fortran 90 customers as a way of generating HPF code. NA Software, a leading European vendor for HPF, has an HPF-to-F90 plus message passing code mapper , sort of a basic offering as of January 1995. In February 1996 they announced ``HPF Mapper Version 1.1" with better efficiency, more functionality, and new platforms: IBM SP2, T800 with a PC host, and PC Linux clusters. A brief writeup from the U. of Edinborough explained how the Mapper was used with their HPF compiler as of July 1997. They take F90 input (but have an F77-to-F90 translator called Loft90). As of 1996, they are the compiler of choice for the Esprit-funded PHAROS project. As of early 1977, Version 2.0 of High Performance Fortran Plus was the name of their product, and it runs on both MPI and PVM. ADAPTOR from GMD [38,39] is a for-free compiler that can be run on anything from a PC compatible to an IBM SP2. Some say it is amazingly good, considering ts cost. It claims to support the HPF subset, or something close to it, and optimizes for cache and communications. It generates Fortran 77 or Fortran 90 message passing programs.

Vienna Fortran and Fortran D were described earlier as being vehicles for research into HPF compilation techniques; of course, both are also compilers in their own right. The Vienna Fortran Compilation System , carries out language definition via compiler implementation. Like Fortran D, it is moving in the direction of accepting ``true HPF'' (plus extensions). PARADIGM at the U. of Illinois (Banerjee et al. [17,96,172]) accepts Fortran programs with HPF directives. Like the D System, this is a research compiler. Unlike standard HPF compilers, it will insert HPF directives into your program, and it supports both task and data parallelism (what they refer to as functional parallelism). Like xhpf and pghpf, it accepts either F77 or HPF and then generates an explicit message passing code. What's nice about the Paradigm effort is that it is a framework into which separate tools can be placed: Parafrase-2 Program analysis and dependence pass; automatic data distributer; irregular pattern analyzer; task graph synthesizer; irregular pattern runtime support and the like. Moreover, they invoke Mathematica to do the integer programming required for subscript analysis! Some recent work with Paradigm has added support for irregular computation [120].

Other research HPF compilers include Carnegie Mellon CS department's Fx [173]. This compiler also integrates both task and data parallelism, and has been implemented for quite a wide variety of machines. Jaspal Subhlok heads up this compiler project. Fx was used as the basis for task parallelism in HPF 2.0.

A prototype HPF compiler called hpfc exists at the Centre de Recherche en Informatique at the Ecole de Mines de Paris [58], which generates PVM3 code.

Another compiler, available by anonymous ftp, is John Merlin's ``shpf'' (Subset High Performance Fortran compilation system). It translates HPF into serial Fortran which calls a run-time communications library which then calls MPI. Documentation for the compiler can be found at http://www.ccg.ecs.soton.ac.uk/shpf/shpf.html . However, this compiler (as of July 1996) did not parallelize DO loops or even FORALL's, only array expressions and assignments. However, there does exist a kelp-shpf, which is a multigrid library for use with shpf.