|The Leading Source for Global News and Information Covering the Ecosystem of High Productivity Computing / April 27, 2007|
There is classic conflict in database processing. More and more data is being generated, while users want to process that data in smaller and smaller timeframes. Fortunately, these two colliding demands have a possible solution -- parallel hardware. But getting the software to exploit that hardware has been a struggle.
Several years ago, Pervasive Software realized that their own database technology was not going to scale into the 21st century. And as their customers took on commercial high performance computing applications, they too would be searching for ways to deal with the data deluge. According to Pervasive CTO Mike Hoskins, the industry is now at a fork in the road for how high performance computing is going to proceed. Although the last 20 years has seen the rise of cluster and grid architectures, Hoskins believes the advent of multicore technology will now favor scaled-up SMP architectures for many types of HPC applications.
"This is just the beginning of a revolution that I think will forever change not just how high performance scientific computing is done, but how any kind of high performance computing is done," says Hoskins. "Significantly, since these SMP machines use a single address space, we can enjoy the other revolution that is going on, which is the software revolution. This has been largely absent in the HPC world where they're still wrestling with Stone Age technologies like MPI and other brittle technologies that try to organize coherence across non-uniform memory and heterogeneous clusters."
Hoskins says what software developers really want is familiar programming languages, like Java, and a global address space. He thinks that over the next five years there's going to be a movement away from loosely coupled grid and cluster platforms and toward SMPs. Hoskins speculates that scaled out cluster systems will only be used for the largest types of problems that can be parallelized relatively easily. For everyday high performance computing, he says, people will use multicore SMP platforms.
To meet the demands of multicore-based data processing, Pervasive came up with DataRush, a Java framework for data- and compute-intensive applications -- what Hoskins calls "hyper-parallel" applications. The framework was conceived six years ago at a company called Data Junction, where Hoskins was the president. Data Junction was acquired in 2003 by Pervasive, where DataRush technology was further developed and refined.
The DataRush framework is based on a dataflow or directed graph model. Workloads that must process large datasets and can be represented as a dataflow graph, for example, data mining, searching/surveillance, and analytics, are good candidates for the technology. This includes applications like financial data auditing, genomic data analysis and logistics data processing.
The framework provides a high-level XML scripting interface for the programmer to specify how their data is to be processed. The DataRush SDK library provides a set of components, which includes standard data management operations like Sort, Join and Merge; prebuilt operators like And, Not, and Compare; and readers/writers for I/O. Users can extend the framework with custom components. Behind the scenes, the DataRush parallel processing engine performs all the necessary low-level concurrency by managing threads and global memory accesses.
From the developer's point of view, everything is done with standard vanilla Java; no special interpreters or Java Virtual Machines (JVMs) are required. The technology exploits the fact that JVMs are inherently thread-aware and are implemented on all commercial multicore platforms. Thus, once the application is developed in the framework, parallelization on the hardware becomes automatic. An interesting side-effect of JVM independence is that even if Pervasive is overly optimistic about the rise of SMP systems, Terracotta's cluster JVM could be used by DataRush to parallelize applications in a more loosely coupled environment.
Today, many dataflow-type applications are being implemented using either a cluster/MPI model or in a global address space environment using conventional languages, but without a framework to hide the concurrency primitives. Hoskins says these approaches lead to a lot of hard-to-maintain code that is expensive to develop and won't scale well when more highly parallelized hardware become available.
"A lot of the supercomputing industry is stuck in a bit of a time warp," says Hoskins. "I started with mainframes and assembly programming. In those days machines were expensive and humans were cheap. Now, it's turned around completely. The constant focus on machine performance really misses the boat."
In general, Java has not been considered for HPC workloads because JVMs have been deemed performance-challenged. But Hoskins bet that JVMs would become more efficient and that the hardware would inevitably become faster to compensate for some of the JVM sluggishness. And he was right. But more importantly, Hoskins believed that "design-time performance" (programmer productivity) would become the driving concern for application development. And for this, he says, the Java environment gives you a permanent advantage over any other language.
"And besides," Hoskins says, "if you're a true believer in parallelism, it isn't the last ounce of performance that you can get out of your serially threaded C algorithm that's important, it's how you can divide and conquer the problem and take advantage of the hardware geniuses that are throwing cores at you left and right."
Pervasive used the DataRush framework to develop a commercial product, the Pervasive Data Profiler, an analytics tool used to audit data quality in massive data sets. Early users of the product are in the financial services and health care markets. Once the Data Profiler became a product, the company realized DataRush could be more than just an internal development tool. In 2006, the company released DataRush as a beta product, freely downloadable from their website. Hoskins evangelizes DataRush on the product's own website at http://www.pervasivedatarush.com/.
Pervasive is working closely with beta customers to help them get started using the framework. One potential user is a company in the health care field that has developed an analytics tool to process payer transactions and find instances where the insurance company may have paid too much. Not surprisingly, the insurance company that tried out the tool liked it a great deal. But the insurance company now wants the tool to go through the last two years of payer transactions, consisting of hundreds of millions of health care claims spread across hundreds of thousands of patients. The time required to sift through such a dataset is on the order of eight weeks. By helping to parallelize the analytics application with DataRush, they hope to reduce the compute time to something more practical.
Hoskins thinks that the financial services market is another area where DataRush is a good fit. A large number of the developers in that vertical already use Java, and Pervasive hopes to capture some of the applications that are inevitably looking to tap into multicore platforms. One possible customer is attempting to validate financial transactions recorded in a very large dataset -- ten millions records, each of which has 1500 fields. They want to apply business rules on multiple fields of that data.
Although the DataRush framework is already fairly mature (currently at version 3), the product in its first standalone release is still in beta. Pervasive is currently gathering early adopters, sample applications and benchmark libraries. When the framework does become generally available, the company plans to make academic licenses free. For commercial customers, all testing and development use is free, and the DataRush engine will be licensed for any deployed applications (pricing and licensing structure to be determined). In addition, the SDK library components and sample applications will be open source.
Besides getting end-user developers interested in the DataRush product, the company would also like to work through channel partners to inject the technology into the ecosystem. Pervasive has initiated talks with Intel, AMD, HP, Sun and IBM to start to establish complimentary relationships with the chip and SMP hardware vendors. They're also intending to work with ISVs to get the DataRush engine embedded in other software products.
By betting against clusters, Hoskins admits that they're making somewhat of a gamble with their approach. But he thinks the impact of the multicore phenomenon will be ten times bigger than what most people think.
"Sometimes you're lucky in life and catch the trends right and I think we did," says Hoskins.