4.1 Tema 1: peligro de hacer fuerza
4.4 Discusión de la información e implicaciones para enfermería
It is clear that the scalability of any dynamic load-balancing algorithm which is used in an adaptive mesh solver is a complex issue. Clearly the performance of the dynamic load-balancer depends upon how often the adaptivity has taken place. But
100 200 400 800 1200 2 4 8 16 Time in Seconds Number of Processors Initial ParMetis ParJostle Vidwans et al. Recursive
Figure 5.6: Scalability comparison using a re-balancing tolerance of 5% for Example 1 (where Time = RedTime + SolTime).
100 200 400 800 1200 2 4 8 16 Time in Seconds Number of Processors Initial ParMetis ParJostle Vidwans et al. Recursive
Figure 5.7: Scalability comparison using a re-balancing tolerance of 10% for Example 1 (where Time = RedTime + SolTime).
100 200 400 800 1200 2 4 8 16 Time in Seconds Number of Processors Initial ParMetis ParJostle Vidwans et al. Recursive
Figure 5.8: Scalability comparison using a re-balancing tolerance of 15% for Example 1 (where Time = RedTime + SolTime).
300 600 1200 2400 4000 2 4 8 16 32 Time in Seconds Number of Processors Initial ParMetis ParJostle Vidwans et al. Recursive
Figure 5.9: Scalability comparison using a re-balancing tolerance of 5% for Example 2 (where Time = RedTime + SolTime).
300 600 1200 2400 4000 2 4 8 16 32 Time in Seconds Number of Processors Initial ParMetis ParJostle Vidwans et al. Recursive
Figure 5.10: Scalability comparison using a re-balancing tolerance of 10% for Example 2 (where Time = RedTime + SolTime).
300 600 1200 2400 4000 2 4 8 16 32 Time in Seconds Number of Processors Initial ParMetis ParJostle Vidwans et al. Recursive
Figure 5.11: Scalability comparison using a re-balancing tolerance of 15% for Example 2 (where Time = RedTime + SolTime).
30 60 120 240 2 4 8 16 Time in Seconds Number of Processors Initial ParMetis ParJostle Vidwans et al. Recursive
Figure 5.12: Scalability comparison using a re-balancing tolerance of 15% for Example 1 (where Time = RedTime + 0.2 * SolTime).
600 1200 2400 4800 2 4 8 16 Time in Seconds Number of Processors Initial ParMetis ParJostle Vidwans et al. Recursive
Figure 5.13: Scalability comparison using a re-balancing tolerance of 15% for Example 1 (where Time = RedTime + 5 * SolTime).
3000 6000 12000 24000 2 4 8 16 Time in Seconds Number of Processors Initial ParMetis ParJostle Vidwans et al. Recursive
Figure 5.14: Scalability comparison using a re-balancing tolerance of 15% for Example 1 (where Time = RedTime + 25 * SolTime).
90 180 360 720 2 4 8 16 32 Time in Seconds Number of Processors Initial ParMetis ParJostle Vidwans et al. Recursive
Figure 5.15: Scalability comparison using a re-balancing tolerance of 15% for Example 2 (where Time = RedTime + 0.2 * SolTime).
1200 2400 4800 9600 19200 2 4 8 16 32 Time in Seconds Number of Processors Initial ParMetis ParJostle Vidwans et al. Recursive
Figure 5.16: Scalability comparison using a re-balancing tolerance of 15% for Example 2 (where Time = RedTime + 5 * SolTime).
6000 12000 24000 48000 96000 2 4 8 16 32 Time in Seconds Number of Processors Initial ParMetis ParJostle Vidwans et al. Recursive
Figure 5.17: Scalability comparison using a re-balancing tolerance of 15% for Example 2 (where Time = RedTime + 25 * SolTime).
it also depends upon other parameters. For example if after the adaptation stage, the amount of imbalance remains below a speci ed tolerance no redistribution of data will occur. The other parameter upon which it depends is the number of pro- cessors used. The numerical results shown above suggest that the more processors are used, the more quickly imbalance is generated by the adaptation. Another pa- rameter is the number of levels of re nements. Also, repartitioning consists almost entirely of communication and since the work involved is not evenly distributed, it tends not to scale well.
The more important quantity to consider is the combined performance of the solver and the dynamic load-balancer. In practice one wishes to see the net saving which results in using a solver combined with a dynamic load-balancer. In Figures 5.6 to 5.17 we plot the time (which is a function of RedTime and SolTime) against the number of processors used. In Figures 5.6 to 5.11 the time function is simply the sum of RedTime and SolTime. In Figures 5.12 to 5.17 the time function is equal to RedTime + SolTime, where is a positive constant other than unity. Note that by varying we can analyse the equivalent e ect of other simpler (for which < 1) or more expensive (for which > 1) solvers. (Alternatively, we can view the variation of as representing slower or faster inter-processor communications respectively.)
It is clear from Figure 5.6 that in this case the use of the ParJOSTLE and Vidwans et al. have an adverse a ect and there is a small saving in case one uses the ParMETIS or Recursive algorithm when 16 processors are used. In other cases (see Figures 5.7 to 5.11) it pays o to use the dynamic load-balancing algorithm. As pointed out above, for the larger base mesh it is better to use a relatively larger value of the re-balancing tolerance parameter in those cases where the number of processors are greater than 8 (see Figures 5.9 to 5.11).
We next discuss the relationship between the intensity of the solver and the use of the dynamic load-balancer. From Figures 5.12 and 5.15 it is clear that calling a dynamic load-balancer in the case of a very cheap solver does not pay anything. It in fact increases the cost. However, in the case of an expensive solver it pays o to use a dynamic load-balancer (especially when using a large number of processors). For example if we are having a solver which is 25 times more expensive than the current solver and we are using 16 processors to solve the problem then at least there is a 15% saving in the case of the smaller base mesh and a 48% saving in the
case of the larger base mesh as a result of using a dynamic-load balancing algorithm.
5.8 Conclusions
In this chapter we have demonstrated that good load-balancing results can be ob- tained provided one choses the re-balancing thresholds carefully. As one would expect, we have also shown that the more expensive is the solver the more would be the saving that can be achieved by using a dynamic load-balancer. Moreover, we have demonstrated that the Recursive algorithm is very competitive when con- trasted with other parallel dynamic load-balancing algorithms developed simulta- neously with this work. In some situations it gives the best performance of all four approaches and in all cases the performance is comparable. Clearly the choice of which of the four algorithms is the best to use will depend on the precise nature of the problem being solved and on the exact nature of the parallel architecture.