|
 RSS Feed
Last week's SC07 show in Reno, NV was a great time to connect with friends, customers, partners, and other folks interested in developing parallel applications for high performance computers.
ISC's Virtual Tour
In addition to our booth, we participated in several interesting sessions, such as the ClearSpeed User Forum, HPC Challenge, Cray's booth, Parallel MATLAB® session, and others. In case you missed something of interest, we've created a Virtual Tour of our SC07 activities. Here, you will findthe various presentations, product demonstrations, news announcements, customer videos, and awards.
P.S.: here's Ronnie setting up the booth, Aquil demonstrating an image processing app, and me with Austin Powers (told me later he prefers Python over other Very High Level Languages).
  
Article has 0 comments. Click To Read/Write Comments
This week at the SC07 conference, we won the HPC Challenge. Judged by a committee led by Jack Dongarra (University of Tennessee, and Oak Ridge National Lab) and Jeremy Kepner (MIT Lincoln Lab), the goal of the competition is to focus the HPC community’s attention on developing a broad set of HPC hardware and HPC software capabilities that are necessary to productively use HPC systems.
Our entry this year was done in the Python language, extended to a parallel environment with Star-P. We won in the category of "Most Productivity" - based 50% on performance, and 50% on code elegance, clarity, and size.
Python is a high-level, dynamically typed, multi-paradigm (procedural, objectoriented and functional) interpreted language created by Guido Van Russom. Natively, Python does not have data types and containers such as matrices and lacks linear algebra. and signal processing functions. Instead, these are added to the language through Python extension modules. Currently, the de facto Python module for numerical computing is NumPy authored by Travis Oliphant and others.
The Star-P package in Python is an extension module that can be imported just like any of the modules in the Python standard library. The syntax and semantics in Star-P Python closely model those in NumPy.
The basic premise of the model is to maintain compatibility in syntax with serial codes written using the NumPy module. In most cases, the user must not be burdened with having to think “in parallel”, keep track of distributions or worry about which portions of the code runs in serial and which in parallel. This allows users with a large existing serial application to port it to run in parallel with the least amount of effort.
The tests were run at a high performance cluster at the San Diego Supercomputing Center. The cluster consists of 32 nodes, where each node contains one quad-core Intel Xeon 5140 processor and 8 GB of memory, for a total of 128 cores and 256 GB of memory. The interconnect is IP over Infiniband.
Here are the scaling results for 3 of benchmarks. The full submission and presentation can be found here.
Article has 1 comments. Click To Read/Write Comments
Greetings from the SC07 Conference in Reno, NV! The show kicks off later today, and is shaping up to be pretty exciting.
One thing we are psyched about is our collaboration with Cray, where we are working together to enable Star-P to run on Cray's XT4 supercomputers. (Cray announced this earlier this morning.) The cool thing here is that it enables a whole new way to run applications on a Cray system, and makes Cray an extension of the scientist's desktop. Imagine coding an algorithm in a desktop tool such as Python, MATLAB®, R, and others, and then running the code - with potentially enormous data sets - on a Cray system, without coding a line of C++, Fortran, and MPI.
We got some work ahead of us to deliver this to early adopters in Q1 of 2008, but already have some pieces of Star-P's port to Cray working. One thing that makes it a pretty reasonable effort is that it's built on standard x86-64 chipset, running Linux.
Initial Porting Results
As a proof of concept, we tweaked a couple things in Star-P and compiled it for the Cray, and ran a couple toy problems on (perhaps the world's smallest) Cray supercomputer :) - a 32-core XT4. The neat thing here is that it worked, and scaled nicely. For this test, we took 64 matrices of 3 different sizes (1000 x 1000, 1500 x 1500, and 2000 x 2000), and found the 2 most correlated vectors in each matrix, all done from Python (one of the very high-level languages Star-P supports).
We ran each problem on 1, 2, 4, 8, 16, and 32 processors of the XT4 system. Looks like pretty good scaling for a 1st run. The timing curve for the smallest problem (1000 x 1000 matrix size) starts to lean over slightly at 32 processors, likely due to the communication overhead associated with distributing the relatively small data set across 32 cores.
Article has 1 comments. Click To Read/Write Comments
|