As the cost of high performance computing hardware continues drops, more users in a variety of application domains are being tempted to take advantage of the cheaper flops. But most people have come to realize that software has become the limiting factor to HPC adoption. Developing or porting an application to run in a parallel computing environment can be a daunting task.

The Star-P solution from Interactive Supercomputing Corporation (ISC) is intended to help close this software gap. It is designed to enable parallelization and interactive execution of desktop-developed technical applications on high performance hardware. Unlike some of the other software frameworks recently highlighted in HPCwire — namely ASPEED's ACCELLERANT and Intel's Cluster OpenMP — Star-P works at the level of the desktop tool, such as MATLAB, rather than within a conventional high-level language, such as C or Fortran.

The product is aimed at two types of users: (1) For cluster owners users who are looking for an easier programming model, and (2) Desktop users that have applications that have expanded beyond the power of their workstations.

Star-P is designed in the client/server model. The client, which runs on the PC or workstation, intercepts commands from the desktop tool and projects the necessary parallelism onto the server, which runs on the target HPC system. Currently Star-P supports MATLAB, on the application side, and SGI Altix and Opteron-based clusters on the target side.

In the broadest sense, Star-P can be characterized as a high performance computing framework for the end user, rather than the programmer. This represents a different plan of attack on the “HPC software crisis” than most other solutions. While OpenMP and ACCELERANT allow you to instrument C or Fortran code to exploit parallelism, Star-P will allow you to work within the constructs of a domain-friendly desktop environment.

Ilya Mirman, ISC's Vice President of Marketing, says that for every domain expert (the actual scientist or researcher doing the modeling on the desktop), you often need three or four people executing a project to actually code up the algorithm, scale it, test it with real data, and then run it on a parallel system.

“You have these domain experts that know everything about the physical things they want to model, but they don't want to have to learn how to write a parallel application,” says Mirman. “That's a huge impediment to the adoption of parallel computing. Three quarters of the time they actually prototype the application with a desktop tool, like MATLAB. Then the applications are almost exclusively written in C, Fortran and some flavor of MPI. Suddenly you need a roomful of programmers to do that. So our proposition is to skip the middleman — prototype to production inside this familiar tool.”

With this approach, MATLAB with its familiar, high-level interface, becomes a browser onto an HPC platform. In this interactive environment, the end user can do a lot more iterations on the algorithms — not because they've sped up the execution. It runs the same on the HPC target as it would for any C or Fortran code parallelized with MPI. In fact, Star-P uses message passing to do thread communication on the server, but this is transparent to the user.

“We use compiled libraries on the backend, optimized for parallel systems,” explains Mirman. “We don't make processors magically faster, we just don't force people to write C, Fortran and MPI code to extract that performance. What were seeing is people parallelizing applications with Star-P in minutes or hours what would have taken weeks or months to have written in C and some sort of a message passing paradigm””

ISC's solution takes advantage of the two main types of parallelism: task parallelism (coarse-grained or embarrassingly parallel) and data parallelism. For the latter type, the end user just has to identify the global data they want to distribute. For task parallelism, the user determines which functions operate on data independently, so they can be invoked concurrently.

To implement task parallelism, Star-P uses a function called ppeval, which is very similar to MATLAB's feval evaluate function. You pass ppeval a function name and an argument list. When executed, the specified function is automatically distributed over the target's processors using the input arguments. The ppeval may be viewed as an unrolled FOR loop.

“Task parallelism is relatively easy,” says Mirman. The real magic is in the global array syntax — *p.”

The global array syntax enables users to define a matrix that may be distributed over hundreds or even thousands of processors. You just have to tag the dimensions of the matrix with the *p construct. The parallel operations associated with the matrix automatically distribute over the number of processors that are specified when Star-P is invoked.

Star-P was also designed as an extensible, open platform. According to Mirman, this is even more fundamental than Star-P's global array syntax. User communities tend to develop software that live for many years — decades even. And typically, users don't want to modify these codes. For example, some nuclear codes that were written in the 1970's are still being used today. Users can plug in these existing libraries on the backend of Star-P to run on the HPC target. This enables MATLAB users to invoke any C or Fortran code, regardless of whether they're parallelized or not. Mirman says some national labs have used this feature to plug in custom solvers.

“Really a lot of the time it's the glue,” said Mirman. “People have great libraries, but then the interoperability can limit the solution.”

One of the early users of this ISC's technology is Bryan Wong, a researcher in the Department of Chemistry at MIT. He's using Star-P with his MATLAB application to capture the thermodynamic properties of gases at high temperatures. The results of this work may be applied to practical applications in climate prediction and pollution control.

But on his PC, Wong's application took around 12 hours to complete. And because of memory limitations, he could only run the model with relatively low temperature.

“It was taking too long,” said Wong. “And to get to the higher temperatures, I would need to manipulate a lot of data at once. PCs have at most around four gigabytes of memory, so I needed something with much more memory.”

By using Star-P's global array syntax he was able to parallelize the compute-intensive thermodynamic calculations with a 20K by 20K matrix and take advantage of a 16-processor 80 GB SGI Altix 350 server at MIT. With the increases memory and computing power, Wong was able to run the model with the desired high temperature parameters.

Wong says without Star-P, he would have had to convert the code to Fortran and learn to use MPI to parallelize it. He estimates it might have taken up to a year to do this.

Expanding Horizons

When you look at desktop software, out of the thousands of software vendors out there, only a handful offer parallelized solutions, — MSC.Software, Fluent, LSTC, and Abaqus, for example. And although it's possible for many applications to scale out, most ISVs don't have the resources to parallelize their code. But since ISC built client hooks into Star-P, the company sees this as a way to integrate with a large number of applications.

“There's a whole bunch of application vendors that want to develop parallel software, but don't have parallel programming expertise. People are exploring Star-P as possible solution to get parallelism into their apps.”

Beyond that, the company is also looking to expand both its application and target platforms. Today Star-P supports MATLAB, on the application side, and SGI Altix and Opteron-based systems on the target side. According to Mirman, that's about to change. He says we can expect to see support for additional desktop application tools and parallel computing platforms in the second half of this year.

According to him, we can expect to see “64-bit commodity processor support” in their offering within the next few months. Since they've already announced Opteron support, one can assume this means they'll soon be targeting Intel Xeon-based clusters. Mirman says their strategy is to have both a volume solution, but also work with interested vendors to create a more customized offering — as they did with SGI and their Altix platform.

On the desktop tool side, Python, Maple and Mathematica would seem to be some reasonable choices, although Mirman offered no specific commitments for support.

ISC's exclusive distribution arrangement with SGI expires at the end of June. Starting in July, Mirman says they will be announcing some new partners. Combined with more desktop tool and target server support, the company is optimistic about expanding its user base and, in the process, helping to narrow the HPC software gap.

“I know it sounds corny, but the people at the company really view that we are changing the world,” says Mirman. “It's an important need we're filling, in an industry that is very important to society. That's a big motivator.”