No abstract

In this paper we describe how to apply powerful performance analysis techniques to understand the behavior of multilevel parallel applications. We use the Paraver/OMPItrace performance analysis system for our study. This system consists of two major components: The OMPItrace dynamic instrumentation mechanism, which allows the tracing of processes and threads and the Paraver graphical user interface for inspection and analyses of the generated traces. We apply the system to conduct a detailed comparative study of a benchmark code implemented in five different programming paradigms applicable for shared memory computer architectures.

Abstract

Abstract. Performance analysis tools are an important component of the parallel program development and tuning cycle. To obtain the raw performance data, an instrumented application is run with probes that take measures of specific events or performance indicators. Tracing parallel programs can easily lead to huge trace files of hundreds of Megabytes. Several problems arise in this context: The storage requirement of the high number of traces from executions under slightly changed conditions; visualization packages have difficulties in showing large traces efficiently leading to slow response time; large trace files often contain huge amounts of redundant information. In this paper we propose and evaluate a dynamic scalable tracing mechanism for OpenMP based parallel applications. Our results show: With scaled tracing the size of the trace files becomes significantly reduced. The scaled traces contain only the non-iterative data. The scaled trace reveals important performance information faster to the performance analyst and identifies the application structure.

requirement for trace files. We show that the agent can obtain such an understanding automatically at runtime without programmer intervention or support. The remainder of the paper is structured as follows: In section 2 we describe scalability problems of tracing mechanisms. Section 3 shows the implementation of the trace-scaling agent. Section 4 describes some applications and results of scaled tracing. Section 5 contains further disussion of our approach. In section 6 we conclude the paper.Tracing and performance analysis tools are an important component in the development of high performance applications. Tracing paral'el prqgrams with current tracing tools. however. easily leads to large trace files with hundreds of lUegabytes. The s~orage. visualization, and analysis of such trace files is often difficult.We propose a trace-scaling agent for tracing p~ral'el applications. which learns the application behaVior in runtime and achieves a small. easy to handle trade. The agent dynamically identifies the amount of inforbtation needed to capture the application behavior. This knowledge acquired at runtime allows recording o~ly the non-iterative trace iriformation, which drastical'y rf!duces the size of the tracefile. Scalability of tracing mechanisms Problems associated to large tracesThe perfonnance analysis of parallel programs easily leads to a large number of trace files, since often several executions of the instrumented application are carried out in order to observe the application behavior under slightly changed conditions. Another reason why several traces are needed is to study how the application scales. All these traces for the different configurations of the application and the environment (number of processors, algorithmic changes, hardware counters, ...) require storage space.Visualization packages have difficulties in showing such large traces effectively. Large traces make the navigation (zooming, forward/backward animation) through them very slow and require the machine where the visualization package is run to have a large physical memory. Othern'ise, the response time of the tool increases significantly, strongly affecting the motivation of the programmer to carry out the perfonnance analysis.The high amount of redundant trace infonnation in large trace files hides the relevant details of the application behavior. When visualizing such large traces, zooming down to identify the application structure becomes an inefficient task for the program analyst. Often, the analyst needs to have a certain understanding of the application in order to carry out an efficient perfonnance analysis.