4.4 Some experiments
Based on this example program, a few experiments are presented in this section to give an impression of the performance of Calypso programs. These experiments were executed on four Pentium 90 machines, interconnected by a standard 10 Mbps Ethernet. The number of routinesnwas chosen so thatng=1s while
gis varied between1ms and100ms. All numbers are averaged over50executions.
Figure 4.1 shows the impact of granularity on the execution time without additional traffic (a = 0), Figure 4.2 fora = 1, and Figure 4.3 fora = 5. Calypso behaves as expected: for low to moderate traffic, it scales as long as the granularity is not too small. The higher the granularity, the lower are the inherent overheads, but the lower are also the benefits of load balancing. For a single worker, the total execution time is longer than1sowing to the additional traffic (depending ona) and the inherent overheads of Calypso (administrating the routine table, etc.).
0 200 400 600 800 1000 1200 1400 1600
1 5 10 50 100
Granularity g (ms)
Time (ms)
1 worker 2 workers 3 workers 4 workers
Figure 4.1: Average runtime of a single parallel step with varying granularitygand number of work-ersm, other parametersa=0,v=0,ng=1s.
Figure 4.4 shows the impact of imbalance in the routines on the total execution time. Even for severely imbalanced parallel steps, Calypso’s load balancing mechanisms manage to hide that imbalance and achieve rather uniform total execution times. The effects of load balancing only start to degrade slightly at 100ms granularity. The results are similar for other values of a andm. Hence, imbalance can be neglected as a parameter in practical experiments.
0 500 1000 1500 2000 2500 3000 3500 4000 4500
1 5 10 50 100
Granularity g (ms)
Time (ms)
1 worker 2 workers 3 workers 4 workers
Figure 4.2: Average runtime of a single parallel step with varying granularitygand number of work-ersm, other parametersa=1,v=0,ng=1s.
0 2000 4000 6000 8000 10000 12000 14000 16000 18000 20000
1 5 10 50 100
Granularity g (ms)
Time (ms)
1 worker 2 workers 3 workers 4 workers
Figure 4.3: Average runtime of a single parallel step with varying granularitygand number of work-ersm, other parametersa=5,v=0,ng=1s.
4.4. SOME EXPERIMENTS
0 500 1000 1500 2000 2500 3000 3500 4000 4500
1 5 10 50 100
Granularity g (ms)
Time (ms)
v=0% v=50% v=100% v=150% v=200%
Figure 4.4: Average runtime of a single parallel step with varying granularitygand imbalancev(in percent), other parametersa=1,m=4workers,ng=1s.
It is today very difficult to write mathematical books. If one is not concerned with the finer points of theorems, explanations, proofs, and conclusions, it will not be a mathematical book; but if one does, it will make for utterly boring reading.::: And even the most detailed explanation has its darkness, none less than laconic brevity.
– Johannes Kepler, Astronomia Nova, 1609
Chapter 5
Analysis of Eager Scheduling
In this chapter, the runtime distribution of a parallel step with eager scheduling as execution regime is ana-lyzed. Worker machines can be of different speeds and possibly experience faults; the routines of a parallel step are modeled with two different assumptions, leading to two differently complex ways of analyzing the problem.
5.1 Introduction
In order to reason about or even guarantee the responsiveness of a Calypso program, it is necessary to know the responsiveness of its parallel and sequential steps. For sequential steps, this is a well researched problem:
estimating runtimes of programs (see for example [50, 234, 275]). A parallel step is a generalization of a single sequential program since it consists of many concurrently executing sequential program parts.
In general, computing the runtime distribution of even a sequential program is an undecidable problem, since it generalizes the halting problem. It is hence necessary to limit the scope of this problem to make it tractable. The choice of assumptions about the program behavior results in different levels of complexity in the analysis, and also determines the level of realism of a model. Given sufficiently realistic assumptions, such an analysis allows probabilistic guarantees about the execution times of a parallel step and, ultimately, an entire Calypso program. In this chapter, an analysis of the response time distribution of a parallel step when eager scheduling is used is presented; two different assumptions about the behavior of individual routines are considered.
In an environment with fixed resources (e.g., only one available processor) and a fixed program that has a deadline, there is little that can be done beyond executing the given program and hoping that it will finish before its deadline. It is, however, quite evident that the amount of available resources has a considerable impact on the runtime distribution of a program. If it is possible to compute the runtime distribution as a function of the available resources, and if the execution environment of the parallel program is capable of adapting to a varying number of resources, a resource management system can use this information to make informed decisions how much resources to dedicate to a given program. Work on resource management systems abounds, a candidate for cooperation with a Calypso program is the Just-in-Time resource manager described in [24].
Conversely, a program that is capable to tune its resource requirements to the given resource situation can meet deadlines, possibly by sacrificing quality or precision, where a fixed program would have failed—
CHANGet al. [49] describes such a tunability extension for Calypso. However, for a program to correctly judge the results of tuning its execution, an analysis of the effects of the alternatives with regard to their runtime distribution is again needed. This necessitates a fast and simple computation of the runtime distribution; a goal which is in conflict with an also desirable generality of assumptions. This problem of generality is discussed in more detail in Section 5.4.
In the remainder of this chapter, an overview of related work is given in Section 5.2. Suitable assumptions about the runtime behavior of parallel routines in a detailed model of eager scheduling are discussed in Sec-tion 5.3, and the analysis of eager scheduling’s runtime distribuSec-tion is presented in SecSec-tion 5.4. In SecSec-tion 5.5, a few examples of runtime distributions as derived by this analysis are shown. Finally, some conclusions are presented in Section 5.6 and possible extensions are considered in Section 5.7.