Multicore Parallel Computing with OpenMP

Transcription

1 Multicore Parallel Computing with OpenMP Tan Chee Chiang (SVU/Academic Computing, Computer Centre) 1. OpenMP Programming The death of OpenMP was anticipated when cluster systems rapidly replaced large shared memory (SMP) multiprocessor systems, and MPI (Message Passing Interface) programming took over OpenMP programming for parallel computation. However, with the emergence of the multicore processor, OpenMP programming is making a revival among HPC users. OpenMP programming is a compiler directives based method of implementing parallel programs for SMP systems. OpenMP is a set of compiler directives and callable runtime library routines that extend Fortran, C and C++ to express shared memory parallelism. As OpenMP programming enables incremental ways of converting existing codes to parallel codes, eg allowing one DO loop (for Fortran program) to be parallelised at a time, it is probably one of the easiest ways to achieve parallelism within a reasonably short time. 2. NAS Parallel Benchmarks The OpenMP codes used in this multicore performance assessment were taken from the NAS (Numerical Aerodynamic Simulation) Parallel Benchmarks package developed at NASA Ames Research Centre. These benchmarks consist of three simulated application and five parallel kernels benchmarks. The benchmarks mimic the computation and data movement characteristics of large scale computational fluid dynamics (CFD) applications, one of the major HPC applications at NUS. For this study, one of the parallel kernel benchmarks, the IS or integer sort kernel that is written in C, was not used. The other benchmarks are written in Fortran. The three simulated application benchmarks were BT (Block tridiagonal solver), SP (Pentadiagonal solver) and LU (Block lower and upper triangular solver). The four kernel benchmarks used were FT (3-D FFT PDE), MG (Multigrid), CG (Conjugate gradient) and EP (Embarassingly parallel). Detailed description of the benchmarks can be found at

2 Performance Study The objective of this study was to find out how well the OpenMP codes could exploit the capability of the latest multicore system. The first part of the study looked into the effect of problem size and the second part examined the performance of different codes. The compiler used was the Intel Fortran compiler ifort and the key compiler options used were -O2, -openmp, -i-static, -I/opt/intel/fce/current/include and - L/opt/intel/fce/current/lib. Do check out the following article if you wish to know how OpenMP was coded in each of the benchmarks: Effect of Problem Size The BT simulated application benchmark was used in this test. The benchmark was executed in three sizes, Class A being the smallest and Class C being the largest. A larger size, Class D, was not considered in the test. NAS BT Class A NAS BT Class B NAS BT Class C

3 Effect of Problem Size Speedup No. of core Class A Class B Class C The above results show that the problem size has just minimal impact on the speedup when larger numbers of cores were used. However, it is important to note that due to time constraints, the memory sizes we managed to test (up to 690MB) were relatively small compared to the memory available on the test system (16GB total). To assess the effectiveness of a multicore system running large memory applications, further tests are needed. If you have any large memory OpenMP application, we will be happy to work with you in porting the application to these systems. 2.2 Performance of Different OpenMP Codes NAS BT Class A NAS SP Class A

4 NAS LU Class A NAS FT Class A NAS MG Class A NAS CG Class A NAS EP Class A

5 Speedup Comparison Speedup BT SP LU FT MG CG No. of Core EP As expected, different codes/algorithms produced different levels of speedup during the parallel execution. In general, you will get more speedup if a larger portion of your computation can be done in parallel. As the multicore system is also a shared memory system, the memory access pattern and intensity also affect the speedup. One key observation was that the OpenMP codes used in this study did not scale as well on the multicore systems, compared to their performance on a single-core multiprocessor system (as shown in this referenced article Comparing the SP benchmark performance below for example, the scaling is obviously better on the single-core SMP system. For this benchmark on the quad-core CPU system, the speedup scaling is reasonable up to the four threads execution. Memory bottleneck could be the cause of the relatively lower scalability on the multicore system. SP Benchmark Multiple single-core CPUs system (195MHz) 2 x Quad-core CPUs system (3GHz) Single thread elapse time 2 threads elapse time (speedup) 4 threads elapse time (speedup) 8 threads elapse time (speedup) secs secs (1.9) secs (3.5) secs (7.0) secs secs (1.8) secs (2.8) secs (3.1)

6 3. Conclusion Even though some OpenMP codes may not scale very well on the multicore system, the ease of OpenMP programming will definitely make it an attractive option for HPC. Highly parallel codes such as the one represented by the EP benchmark are expected to do well. With the multicore nodes in a cluster, users will also have another option to explore multi-tier parallel computing, where the message passing type of parallel processing can be done between nodes and the multi-thread type of parallel processing can be done within nodes.