You are here
A Signpost on the Road to Exascale: UBC Researchers Use WestGrid to Explore Exascale Computing
Exascale computing is the next great challenge in supercomputing. Major industrial countries are competing to see who will be the first to build a supercomputer capable of executing an exaflop (one Billion Gigaflops per second), which is estimated to require 100 Million processing cores. Currently no such machines exist and one significant challenge is developing software to scale to take advantage of such immense amount of power.
Recently, two University of British Columbia (UBC) researchers Humaira Kamal and Alan Wagner, with help from WestGrid support staff Roman Baranowski and Brent Gawryluik, were able to execute programs with over 100 Million processes on 6,480 processor cores at WestGrid’s computing facility at UBC.
"This is an exciting milestone; no one before has demonstrated programs with exascale number of MPI processes and these tests show that basic MPI middleware can scale to massively parallel programming," said Wagner. "Access to WestGrid's computing resources was essential. You never know whether a system will scale until you test it, and we could not have achieved the 100 million milestone without access to a cluster with thousands of cores like that available from WestGrid."
As part of her PhD work, Kamal has developed a novel extension to MPICH2, which is an award-winning software from the Argonne National Laboratory in the US that is widely used to develop high performance computing applications. MPICH2 is one of most widely used middleware supporting the MPI standard, the de-facto library for building scalable parallel software. Kamal's middleware, called Fine-Grain MPI or simply FG-MPI, is integrated into the MPICH2 runtime to allow for hundreds and thousands of MPI processes inside a single Operating System (OS) level process. These are full-fledged MPI processes, each with their own state that communicate in the same way whether it is between processes in the same OS-process or between processes on separate compute nodes. FG-MPI decouples MPI from the hardware and it is no longer necessary to have thousands of cores to execute programs with thousands of MPI processes.
In December 2012, Kamal and Wagner started testing the extent to which they were able to scale up FG-MPI to see whether they could achieve 100 Million MPI processes. They did this in several stages before attempting the final runs using all available machines. There are over 540 newer machines in WestGrid where each machine has two dual-socket with 6 processing cores per socket, a total of 6,480 processing cores. The machines are Intel Xeon X5650, 64 bit machines, with 24 GB of memory interconnected by a InfiniBand network. Kamal and Wagner executed several programs on 6,480 cores with one OS-process for each core and 16,000 MPI processes within each OS-process using FG-MPI, resulting in total 16,000 times 6,480 equal to 103,680,000 MPI processes.
Several programs were executed to test the middleware. This included the well-known MPI CPI (Pi calculation) program and programs to test MPI collectives, broadcast (one message to everyone), reduce (one process collecting the result from all the others), and a barrier synchronization. The calculation of Pi required less than 10 seconds and the barrier operation required only 0.2 seconds to complete on all 103 Million processes.
Since there are no exascale machines, by enabling concurrency inside each OS-process, the researchers were able to approximate the execution of massively parallel programs. In FG-MPI, it is not necessary to re-compile the program, the same program can used whether it is in one OS process on one machine, several processes on one multicore or a cluster of multicore machines, or on a large supercomputer like WestGrid. Kamal and Wagner have shown with FG-MPI that many of the core library calls in MPI and in particular MPICH2 scale to 100 million processes and FG-MPI provides a path for testing and evaluating MPI middleware as larger machines become available by shifting concurrency within an OS-process to parallelism on the cores of the machine, inching our way towards exascale.
Although simple algorithms were executed to demonstrate the capability of this approach to scaling MPI to exascale, it sets the stage for investigating the scalability of MPI middleware and MPI programs to execute on larger machines.
“It is intriguing to also think about the types of programs that could benefit from having so many independent processes,” said Wagner. “A lot of simulation software, such as those used in chemical and biological computation, simulate the real world at the molecular or cellular level where scaling models up to 100 Million processes may advance research.”