Abstract

We present a new performance modeling system for message-passing parallel programs that is based around a Performance Evaluating Virtual Parallel Machine (PEVPM). We explain how to develop PEVPM models for message-passing programs using a performance directive language that describes a program’s serial segments of computation and message-passing events. This is a novel bottom-up approach to performance modeling, which aims to accurately model when processing and message-passing occur during program execution. The times at which these events occur are dynamic, because they are affected by network contention and data dependencies, so we use a virtual machine to simulate program execution. This simulation is done by executing models of the PEVPM performance directives rather than executing the code itself, so it is very fast. The simulation is still very accurate because enough information is stored by the PEVPM to dynamically create detailed models of processing and communication events. Another novel feature of our approach is that the communication times are sampled from probability distributions that describe the performance variability exhibited by communication subject to contention. These performance distributions can be empirically measured using a highly accurate message-passing benchmark that we have developed. This approach provides a Monte Carlo analysis that can give very accurate results for the average and the variance (or even the probability distribution) of program execution time. In this paper, we introduce the ideas underpinning the PEVPM technique, describe the syntax of the performance modeling language and the virtual machine that supports it, and present some results, for example, parallel programs to show the power and accuracy of the methodology.

Keywords: Performance modeling; Message-passing; Parallel

Article Outline

1. Introduction

2. Performance modeling of message-passing codes

3. The modeling language

3.1. Machine dependencies

3.2. Sequences of simple statements

3.3. Message-passing calls

3.4. Loop constructs

3.5. Conditional constructs

3.6. Subroutines

4. Automatic performance evaluation

5. Case studies

5.1. Jacobi Iteration

5.2. Bag of Tasks

5.3. Fast Fourier transform

6. Conclusions and further work

Acknowledgements

References

Vitae