UnEncrypted

Meta-epidemic model

but this is due to an intrinsic assumption of the model, that disregards essentially vital dynamics. We will not address this issue any further and concentrate instead on more relevant outcomes.

The original system (2) can settle only to an equilibrium in which the disease is eradicated, and the susceptibles are partitioned among the two patches, or a coexistence equilibrium in which all subpopulations thrive in both enviroments. Further, evidently from what just mentioned, the disease cannot invade the whole environment totally a ecting the population, i.e. wiping out all the susceptibles.

By breaking the path from patch 2 into patch 1, the population cannot coexist with the disease in both environments, as it does when communications are allowed. Instead, it

would settle to equilibrium (3), i.e. no infected remain in patch 1, where in fact the whole

E

population is depleted, but rather the disease remains endemic in patch 2. This occurs if condition (17) holds. But when either the total population N or the disease incidence β decrease suitably, or instead the recovery rate η increases, then the disease gets eradicated also in patch 2 and all the healthy population migrates into patch 2 and remains there, at

equilibrium (1). The fact that patch 1 gets completely depleted is not surprising, as here

E

migrations back into it are forbidden and only outward migrations are allowed.

As a comparison, in these very same conditions, note that when communications are allowed in both directions, the population distributes according to the proportions M3 and M0 respectively in patch 1 and 2. The conditions for which the disease is eradicated are also modified, compare (14) and (18).

When infected are too weak to migrate, there cannot again be a coexistence equilibrium. In this case either the disease is eradicated from the environment, at equilibrium E(1), or it remains endemic solely in patch 2, the system settling at equilibrium E(3), or only in patch 1, with the system attaining equilibrium E(4). In both these last two cases, susceptibles are present in both patches. The discriminating parameter appears to be ρ. When the disease disappears from the whole ecosystem, at equilibrium E(1), the susceptibles distribute among the two environments according respectively to the proportions M3 and M0 for patch 1 and 2 as for (2) when also infected can migrate. In case infected are segregated to their own environment, therefore, it might becomes easier to fight the disease in each patch, since the system’s outcome among the two equilibria is regulated by the parameter ρ. Instead, it is necessary to violate both feasibility conditions (19) and (20) in order to have disease eradication in the whole environment.

Thus, breaking communications in one direction or forbidding infected to migrate, are both possible means of disease eradication, either everywhere or just in one selected patch.

References

[1] J.C. Frauenthal, Mathematical Modeling in Epidemiology, Springer Verlag, 1980.

Proceedings of the 12th International Conference on Computational and Mathematical Methods in Science and Engineering, CMMSE 2012 July, 2-5, 2012.

Tracing the Power and Energy Consumption of the QR Factorization on Multicore Processors

Mar´ıa Barreda1, Sandra Catal´an1, Manuel F. Dolz1, Rafael Mayo1 and

Enrique S. Quintana-Ort´ı1

1 Dpto. Ingenier´ıa y Ciencia de Computadores, Univ. Jaime I, 12.071–Castell´on (Spain)

emails: mvaya@guest.uji.es, al106631@uji.es, dolzm@icc.uji.es, mayo@icc.uji.es, quintana@icc.uji.es

Abstract

In this paper we analyze the interaction between computational performance, power dissipation and energy consumption of several high-performance implementations of the QR factorization, a crucial matrix operation for the solution of linear systems of equations and linear least squares problems. Our experimental results on a multiprocessor platform equipped with recent multicore technology from AMD show the interaction between these three factors.

Key words: Power, energy, QR factorization, high performance, multicore processors.

1Introduction

For many decades, a considerable e ort has been spent in the optimization of dense linear algebra routines (as well as underlying numerical kernels like the BLAS) from the point of view of computational performance, for an ample range of target computer architectures, from vector processors, to superscalar/VLIW architectures and, in recent years, hardware accelerators (e.g., graphics processors, FPGAs, DSPs, etc.). All this labor has produced a number of high quality libraries which, nowadays, are widely utilized by scientific and engineering applications. Examples of these libraries include LAPACK and libflame for desktop servers [2, 20], and distributed-memory (message-passing) versions as ScaLAPACK and PLAPACK for clusters of computers [7, 19]. The stock of numerical packages is still growing, together with the evolution of hardware architectures, and ongoing developments comprise PLASMA, MAGMA or libflame+SuperMatrix [15, 14, 11].

Tracing Power and Energy of the QR Factorization on Multicore Processors

On the other hand, power (dissipation) is currently recognized as a crucial factor that will exert strong influence on the design of future computer systems, from basic components (processors, memory, NIC, etc.), to large-scale HPC facilities and data processing centers [8, 9, 10]. However, the evaluation and tuning of the power and/or energy consumption of the linear algebra codes in the above-mentioned libraries are still in their beginnings, in spite of the considerable benefits that, in general, energy-aware software can yield [1].

In [5], we performed an initial study of the (computational) performance and powerenergy balance for several high-performance implementations of two common matrix operations for the solution of linear systems, the LU factorization and the Cholesky decomposition [12], on a multicore platform. In this paper we extend this study to cover a third matrix decomposition, the QR factorization, key for the solution of (overdetermined) linear systems and linear-least squares problems [12]. Our evaluation of the traditional blocked “slab-based” implementations of this matrix operation in the LAPACK and MKL libraries, as well as an implementation of the incremental QR factorization [13] reveal the trade-o of the factors in the performance-power-energy triangle.

The rest of the paper is structured as follows. In Section 2 we revisit the two blocked algorithms for the QR factorization. In Section 3 we evaluate the performance, power dissipation and energy consumption of these algorithms on 12 cores of a recent AMD-based multiprocessor. Finally, in Section 4 we o er some concluding remarks.

2The QR Factorization

The QR factorization decomposes a matrix A Rm×n into the product A = QR where Q Rm×m is orthogonal and R Rm×n is upper triangular. For simplicity, hereafter we will assume that the matrix is square (i.e., m = n). In the following, we will also consider that A is partitioned into blocks of size b × b, denote the (i, j) block in this partitioning as Aij , and assume that n is an integer multiple of the block size b, i.e., there exists an integer s such that n = s · b.

We next review two right-looking blocked algorithms, for the traditional (slab-based) QR factorization and the incremental QR factorization, which represent the state-of-the- art to attain high performance in the solution of linear systems and linear least-squares problems on current multicore processors [16].

2.1The traditional algorithm for the QR factorization

The traditional QR factorization of a matrix A Rn×n proceeds in panels of b columns (or slabs), as illustrated by Algorithm 1. In practice, the factor R overwrites the upper triangular part of A while the orthogonal matrix is not built but implicitly stored as a collection of Householder vectors using the annihilated entries in the strictly lower triangle of A and an auxiliary vector of order n. Besides, the algorithm requires 4n3/3 floating-point

Barreda et al.

arithmetic operations (flops). Provided n b and b is chosen to be in the range [128, ..., 512], the bulk of the computations in this algorithm is in the application of orthogonal transforms to the trailing submatrix Ak:s,j . A large fraction of these computations can be cast in terms of matrix-matrix products and, therefore, notable performance and a considerable level of concurrency can be expected from tuned implementations of this operation for multicore platforms.

Algorithm 1 Right-looking blocked algorithm for the QR factorization.

3:for j = k + 1, k + 2, . . . , s do

5:end for

6:end for

2.2The incremental QR factorization

The incremental QR factorization, initially proposed to solve the updating problem and/or as an out-of-core algorithm, has attracted considerable attention in recent years due to its high degree of concurrency [4, 6, 17]. Algorithm 2 presents a blocked procedure to compute the incremental QR factorization of a matrix A. By carefully exploiting the special structure of the blocks involved in the procedures for the “2 × 1” QR factorization and the “2 × 1” application of orthogonal transforms, the practical cost of this algorithm is reduced to 4n3/3 flops; see [13] for details. Under the same conditions as above (i.e., n b and b and b [128, ..., 512]), high performance can be expected from an implementation of this algorithm that employs highly optimized version of the four numerical kernels that are involved.

3Experimental Results

The following experiments were obtained using IEEE double-precision arithmetic on a platform with four AMD Opteron 6172 processors, operating at 2.1 GHz, and 256 GB of RAM. The implementation of BLAS was that provided in Intel MKL (v10.3.9). Performance traces were obtained using Extrae (v2.2.0) and Paraver (v4.1.0); power traces were obtained using our own software module compatible with Paraver and a microcontroller-based internal powermeter that measures the power dissipated internally by the main board with a sampling frequency of 25 Hz [3]. The problem size was set to n=10,240 and one single processor (12 cores) were employed in the evaluation. Similar results were found for other problem dimensions and number of processors/cores.

Tracing Power and Energy of the QR Factorization on Multicore Processors

Algorithm 2 Right-looking blocked algorithm for the incremental QR factorization.

10:end for

11:end for

12:end for

Three implementations were evaluated for the QR factorization:

•LAPACK: The legacy codes for this factorization from http://www.netlib.org (routine dgeqrf), with parallelism exploited within the invocations to Intel (multi-threaded) MKL BLAS. This routine mimics the numerical procedure in Algorithm 1. The block size was b=128 as for the problem dimensions (n), architecture and BLAS employed in our experiments, this value was close to the optimal.

•MKL: The code from the Intel library for the QR factorization. While, in principle, this routine also responds to the procedure in Algorithm 1, it contains important features (e.g., look-ahead) to optimize performance. Unfortunately, the source code is not available.

•SMPSs: C codes for the incremental QR factorization, linked to the sequential MKL BLAS, with task-level parallelism extracted by the SMPSs runtime system [4]. In the experiments, we set b=256 and the inner block size to 64.

Figure 1 displays the invocations of kernels and the associated power consumption obtained for the execution of the LAPACK routine dgeqrf, which computes the QR factorization following procedure sketched in Algorithm 1. From top to bottom, the first two plots correspond to the trace of the complete factorization (kernels and power, respectively), while next two zoom into the first two iterations of the routine (third and fourth plots, for kernels and power respectively). These results illustrate that, on this platform, the LAPACK routine linked to the multi-threaded implementation of BLAS from Intel MKL interleaves

Barreda et al.

Kernels

Power

Kernels

Figure 1: Trace of LAPACK dgeqrf. From top to bottom: kernels and power for the complete factorization; kernels and power for the first two iterations of loop k (see Algorithm 1).

sequential and concurrent phases, with the former ones corresponding to the QR factorization of the “current” slab and the parallel ones to the application of orthogonal transforms. From the power consumption perspective, the interlaced sequential and concurrent activity leads to periods of low and high power, respectively, which vary between 266.9 and 376.6 Watts.

Figure 2 evaluates the implementation of the multi-threaded implementation of routine dgetrf for the QR factorization in MKL. In this case, we sample the hardware counters for the L2 cache misses and the MFLOPS (millions of flops per second) (PAPI L2 DCM and PAPI FP INS respectively). These plots show that the MKL routine attains a high utilization of the architectures cores, except for the initial and final stages of the factorization, due to the lack of concurrency at this points. Also, during the execution, there appear some performance drops (captured by the yellow areas in the middle of the MFLOPS plot) which

Tracing Power and Energy of the QR Factorization on Multicore Processors

L2 misses

Legend

MFLOPS

Legend

Power

Figure 2: Trace of MKL dgeqrf. From top to bottom: L2 cache misses rate, MFLOPS, and power.

may correspond to an unexpectedly high L2 cache miss rate (see the first plot). It is very likely that the MKL routine applies some sort of of look-ahead [18] to overlap the factorization of the “current” panel with the application of orthogonal transforms from previous factorizations to the panels to its right. We can expect that this explains the lack of periods of serial execution and, therefore, the flat pattern of the power line, which now has a minimum at 326.6 Watts and a maximum at 366.0 Watts.

Figure 3 reports the kernel execution and power dissipation of the SMPSs task-parallel C implementation of the incremental QR factorization; see Algorithm 2. The kernel for the 2 × 1 application of orthogonal transforms dominates the theoretical cost and, as the figure clearly exposes, the execution time of the implementation. There are little synchronization points, due to the higher concurrency of this particular algorithm, which is leveraged by SMPSs to maintain all cores/threads executing tasks (kernels) most of the time, and accounts for the flat profile of the power line for this routine.

Barreda et al.

Kernels

Figure 3: Trace of the C implementation of the QR factorization parallelized with SMPSs. From top to bottom: Kernels and power.

Finally, Table 1 compares the three implementations for the QR factorization from the viewpoint of Time (T , in seconds); GFLOPS (billions of flops per second); minimum, average and maximum power (Pmin, Pavg and Pmax, respectively, all in Watts); and total energy (Etot, in Joules).

4Conclusions

We have analyzed the execution of three di erent, high-quality implementations of numerical procedures for the QR factorization on a multicore platform. The LAPACK code linked

Table 1: Performance, power and energy of the di erent implementations for the QR factorization.

Tracing Power and Energy of the QR Factorization on Multicore Processors

with a multi-threaded implementation of BLAS clearly obtains the worst results, from the point of view of both execution time and energy consumption. Indeed, the higher energy consumption of this case is a direct consequence of the longer execution time since on average, the power dissipated by this implementation is inferior to those of the MKL and SMPSs alternatives. Compared with the MKL code, the SMPSs variant yields longer execution time (39.02%) and energy consumption (35.66%) in spite of its slightly inferior average power dissipation (0.97%).

These results demonstrate the direct relation between execution time and energy for compute-intensive dense linear algebra codes. A consequence is that, as a general principle, for this kind of numerical algorithms, one direct manner of optimizing energy consumption is to tune the routine for maximum computational performance.

Acknowledgments

This research was supported by project TIN2011-23283 of the Ministerio de Econom´ıa y Competitividad and FEDER.

References

[1]Susanne Albers. Energy-e cient algorithms. Commun. ACM, 53:86–96, May 2010.

[2]E. Anderson, Z. Bai, J. Demmel, J. E. Dongarra, J. DuCroz, A. Greenbaum, S. Hammarling, A. E. McKenney, S. Ostrouchov, and D. Sorensen. LAPACK Users’ Guide. SIAM, Philadelphia, 1992.

[3]R. Badia, J. Labarta, M. Barreda, M. F. Dolz, R. Mayo, E. S. Quintana-Ort´ı, and

R.Reyes. Tools for power and energy analysis of parallel scientific applications. In The 41st International Conference on Parallel Processing – ICPP, 2012. Submitted.

[4]R. M. Badia, J. R. Herrero, J. Labarta, J. M. P´erez, E. S. Quintana-Ort´ı, and

G.Quintana-Ort´ı. Parallelizing dense and banded linear algebra libraries using SMPSs.

Concurrency and Computation: Practice and Experience, 21(18):2438–2456, 2009.

[5]M. Barreda, M. F. Dolz, R. Mayo, E. S. Quintana-Ort´ı, and R. Reyes. Binding performance and power of dense linear algebra operations. In Proceedings of the 10th IEEE International Symposium on Parallel and Distributed Processing with Applications – ISPA, 2012. To appear.

[6]Alfredo Buttari, Julien Langou, Jakub Kurzak, and Jack Dongarra. A class of parallel tiled linear algebra algorithms for multicore architectures. Parallel Comput., 35(1):38– 53, 2009.

Barreda et al.

[7]J. Choi, J. J. Dongarra, R. Pozo, and D. W. Walker. Scalapack: A scalable linear algebra library for distributed memory concurrent computers. In Proceedings of the Fourth Symposium on the Frontiers of Massively Parallel Computation, pages 120–127. IEEE Comput. Soc. Press, 1992.

[8]J. Dongarra et al. The international ExaScale software project roadmap. Int. J. of High Performance Computing & Applications, 25(1), 2011.

[9]M. Duranton et al. The HiPEAC vision, 2010. Available from http://www.hipeac.net/roadmap.

[10]Wu-chun Feng, Xizhou Feng, and Rong Ge. Green supercomputing comes of age. IT Professional, 10(1):17 –23, jan.-feb. 2008.

[11]FLAME project home page. http://www.cs.utexas.edu/users/flame/.

[12]Gene H. Golub and Charles F. Van Loan. Matrix Computations. The Johns Hopkins University Press, Baltimore, 3rd edition, 1996.

[13]Brian C. Gunter and Robert A. van de Geijn. Parallel out-of-core computation and updating the QR factorization. ACM Transactions on Mathematical Software, 31(1):60– 78, March 2005.

[14]MAGMA project home page. http://icl.cs.utk.edu/magma/.

[15]PLASMA project home page. http://icl.cs.utk.edu/plasma/.

[16]G. Quintana-Ort´ı, E.S. Quintana-Ort´ı, R.A. van de Geijn, F.G. Van Zee, and E. Chan. Programming matrix algorithms-by-blocks for thread-level parallelism. ACM Trans. Math. Softw., 36(3):14:1–14:26, 2009.

[17]Gregorio Quintana-Ort´ı, Enrique S. Quintana-Ort´ı, Robert van de Geijn, Field Van Zee, and Ernie Chan. Programming matrix algorithms-by-blocks for thread-level parallelism. ACM Transactions on Mathematical Software, 36(3):14:1–14:26, 2009.

[18]Peter Strazdins. A comparison of lookahead and algorithmic blocking techniques for parallel matrix factorization. Technical Report TR-CS-98-07, Department of Computer Science, The Australian National University, Canberra 0200 ACT, Australia, 1998.

[19]Robert A. van de Geijn. Using PLAPACK: Parallel Linear Algebra Package. The MIT Press, 1997.

[20]F. G. Van Zee. libflame. the complete reference, 2008. In preparation. http://www. cs.utexas.edu/users/flame.