OpenMP, the popular parallel programming standard for high performance computing, is about to come out with a new version incorporating a number of enhancements, the most significant one being support for HPC accelerators. Version 4.0 will include the functionality that was implemented in OpenACC, the accelerator API that splintered off from the OpenMP work, as well as offer additional support beyond that. The new standard is expected to become the the law of the land sometime in early 2013.

In high performance computing, OpenMP serves as the de facto parallel programming framework for shared memory environments — that is, code that shares a coherent memory space within a server node. Combined with MPI, which supports distributed parallelism across many nodes, the two standards provide the software foundation for most HPC applications.

Since the advent of multicore CPUs, and more recently attached accelerators like GPUs, parallelism at the node level has skyrocketed. While OpenMP has supported multicore processors for most of its 15-year history, support for accelerators is just now being folded in.

Some would say a little late. GPU computing has been around for six years, thanks mostly to the efforts of NVIDIA, which has spearheaded this new programming paradigm. In fact, the GPU maker’s early and mostly unchallenged entrance into HPC acceleration led to the emergence of a number of other parallel programming frameworks, including NVIDIA’s own CUDA software toolset, OpenCL, and more recently, OpenACC.

OpenACC is somewhat of a historical accident. Although the OpenMP accelerator work began a few years ago, at that time NVIDIA had the only credible products on the market, namely its Tesla GPU offerings. Customers of those products wanted a directives-based API for current development work that offered a higher level framework than either CUDA or OpenCL, and had at least some promise of hardware independence. At the time, it looked like that until Intel brought its Xeon Phi coprocessor to market there would be no OpenMP accelerator standard. So NVIDIA, along with Cray, and compiler-makers CAPS enterprise and The Portland Group Inc (PGI), developed OpenACC based on some of the initial OpenMP effort.

As a result of this common history, both OpenMP and OpenACC offer a directives based approach to parallel programming, and in the case of developing codes for accelerators, share many of the same capabilities. Intel senior scientist and OpenMP evangelist Tim Mattson says the emerging OpenMP accelerator standard is more or less a superset of the OpenACC API. According to him, porting an OpenACC code to OpenMP will be relatively easy. “Moving from OpenACC to the OpenMP directives as defined in the current Technical Report, is trivial,” says Mattson.

The Technical Report he refers to is the document released by the OpenMP Architecture Review Board (ARB) three weeks ago, the idea being to gather user and vendor feedback before incorporating the new directives into OpenMP 4.0. Assuming all goes as planned the final version of the accelerator directives will be slid into OpenMP 4.0 by the first quarter of 2013, first as a release candidate, and soon thereafter as an official standard. The new version will also have a number of other enhancements including thread affinity (enables users to define where to execute OpenMP threads) initial support for Fortran 2003, SIMD support (to vectorize serial and parallelized loops), user-defined reductions, and sequentially consistent atomics.

The Technical Report was a product of the ARB working group on accelerators, which included all four OpenACC backers. So it’s a given that GPUs will be well-supported in the OpenMP going forward. But since the working group also included x86 vendors Intel and AMD, DSP provider Texas Instruments, as well as hybrid computer-maker Convey, there is likely to be something in the new standard for everyone. The goal is to allow developers to write target-independent applications that can take advantage of the latest GPUs from NVIDIA and AMD, Intel’s Xeon Phi, FPGAs, and even the TI DSP chips. The directives are also designed to allow for future types of accelerators.

The trick is to design the compiler directives abstractly enough to hide the hardware dependencies for a diverse group of architectures, but not so ethereal so that it becomes impossible for compilers to generate efficient, performant code from them. Assuming the compiler implementations from Intel, PGI, CAPS, and others live up to that ideal, the developer community will likely gravitate toward the new OpenMP standard.

For the time being though, it’s business as usual for the OpenACC backers. A draft of version 2.0 was made public for comment at the recent Supercomputing Conference (SC12). In concert, both PGI and CAPS announced OpenACC compiler support for the latest accelerators — Intel’s Xeon Phi coprocessor, NVIDIA’s K20/K20X GPUs, AMD APUs and GPUs, and the ARM-based CARMA platform. For the near-term, at least, both OpenACC and OpenMP accelerator support looks like it will move forward in tandem.

How long that lasts is not clear. But given the propensity of both developers and software toolmakers to support monolithic standards, at some point the two frameworks should merge. “It’s now in our camp of OpenMP to bring it back together as one happy family,” says Mattson.