Performance comparison for OpenMP, PThreads and MPI Hot Plate

Ilya Raykhel
CS 684
Hot plate OpenMP, PThreads and MPI performance comparison.
Introduction.
There are multiple ways to implement a parallel solution to the same problem of calculating a stable
temperature state on a "Hot Plate" system. The "Hot Plate" is a matrix, elements of which are
temperature values. Some of these values are fixed, while others try to reach a stable state based on
the laws of thermodynamics. The problem is to calculate a stable state for the whole system, when no
temperature values change anymore. The solution is apparent in case of a single-threaded execution,
but there are multiple ways to do it in multiprocessor environment. Comparison of three of these
approaches, the OpenMP implementation, the PThreads implementation, and the MPI implementation, is
presented in this paper.
Approach.
OpenMP implementation of Hot plate is based on shared memory usage and OpenMP library of C
compiler directives, which takes care of thread spawning and thread-to-processor allocation. Advantage
of this approach is less memory usage and less direct inter-thread communication. Disadvantage of
using OpenMP is a communication barrier and synchronization -- since the main requirement of the
problem is that the entire system must reach a stable state, a check on the whole hot plate is required
every nth iteration. This means that threads have to be synchronized and joined, which significantly
increases the time it takes for the program to execute.
PThreads follows the OpenMP approach and has same advantages and disadvantages. In essence, it is
OpenMP on a lower level.
MPI, or Message Passing Interface, is a fully-distributed system that runs on multiple processors and
uses direct inter-process communication via bus messages. No memory is shared among the processes,
and all information has to be explicitly exchanged. This approach eliminates synchronization
requirement, but introduces a need to send blocks of memory that could have been shared by using
OpenMP.
Experimental setup.
Two implementations were made to match in as many details as possible to minimize the discrepancies
due to algorithmic inconsistencies. That included using the same serial optimizations with the same
parameters, such as the whole hot plate state was checked every 10th iteration regardless of
implementation, although of course different approaches had to be used for that check: thread joining
in OpenMP/PThreads and MPI reduce in MPI. This also included resetting fixed temperature values on
every iterating instead of checking for them.
All programs were run on Marylou0 SGI symmetric multiprocessing BYU supercomputer using 1, 2, 4, 8
and 16 processors. All programs were compiled using cc compiler with optimization level of 3.
Since there is no "standard" or "known best" algorithm for the hot plate, absolute speedup metric is
hard to define for performance measurements; instead wall clock time and relative speedup will be
used.
Results.

It is clear that MPI implementation shows a rather better performance than OpenMP or PThreads. MPI
also seems to scale significantly better, with almost linear time/processors correspondence. Speedup is
not superlinear because horizontal scale is logarithmic.
Conclusion.
The experiment clearly demonstrated that MPI implementation of hot plate performs much faster than
OpenMP or PThreads. Apparently, thread spawning/joining overhead adversely affects overall
performance, while MPI's reduce and interprocess communication proceeds much faster. One thing to
note is that since number of processors used (16) is negligible compared to overall problem size
(768x768), amount of direct interprocess communication is not high compared to the time spent on

computing temperature values. So, MPI's performance is expected to get less scalable with more than
16 processors, ultimately resulting in no speedup due to Amdahl's Law.