## Are you sure?

This action might not be possible to undo. Are you sure you want to continue?

Jaeyoung Choi School of Computing Soongsil University 1-1, Sangdo-Dong, Dongjak-Ku Seoul 156-743, KOREA

We present a new fast and scalable matrix multiplication algorithm, called DIMMA Distribution-Independent Matrix Multiplication Algorithm, for block cyclic data distribution on distributed-memory concurrent computers. The algorithm is based on two new ideas; it uses a modi ed pipelined communication scheme to overlap computation and communication e ectively, and exploits the LCM block concept to obtain the maximum performance of the sequential BLAS routine in each processor even when the block size is very small as well as very large. The algorithm is implemented and compared with SUMMA on the Intel Paragon computer.

Abstract

Recent e orts to implement numerical algorithms for dense matrices on distributedmemory concurrent computers are based on a block cyclic data distribution 6 . The distribution can reproduce most data distributions used in linear algebra computations. DGEMM. Tsao and Zhang developed `BiMMeR' 15 for the virtual 2-D torus wrap data layout. Also independently. However. The details of the LCM concept is explained in Section 2. 1. The di erences in these data layouts results in di erent algorithms. 16 . It multiplies the largest possible matrices of A and B for each computation step. Gustavson and Zubair 1 proposed another matrix multiplication algorithm by e ciently overlapping computation with communication on the Intel iPSC 860 and Delta system. which makes it impractical in real applications.2. Q broadcasts for B. which makes the algorithm the most e cient by overlapping computation and communication e ectively. and LCM P. and Huss-Lederman. For details. called DIMMA Distribution-Independent Matrix Multiplication Algorithm for block cyclic data distribution on distributed-memory concurrent computers. DIMMA and SUMMA are implemented and compared on the Intel Paragon computer. The algorithm incorporates SUMMA with two new ideas. In this paper. Dongarra and Walker developed `PUMMA' 7 for block cyclic data decompositions. PBLAS 5 . PUMMA makes it di cult to overlap computation with communication since it always deals with the largest possible matrices for both computation and communication. Two e orts to implement Fox's algorithm on general 2-D grids have been made: Choi. which is a major building block of ScaLAPACK 3 . It consists of only Q . They are based on a P P square processor grid with a block data distribution in which each processor holds a large consecutive block of data. 1 shifts for A. Two classic algorithms are Cannon's algorithm 4 and Fox's algorithm 11 . These two algorithms have been compared on the Intel Touchstone Delta 14 . in each processor. Agrawal. PDGEMM. Q is the least common multiple of P and Q. It uses `a modi ed pipelined communication scheme'.A number of algorithms are currently available for multiplying two matrices A and B to yield the product matrix C = A B on distributed-memory concurrent computers 12. It also exploits `the LCM concept'. Jacobson. see Section 2. so that performance of the routine depends very weakly on the block size of the matrix.2. Q local multiplications. where LCM P. uses the same scheme in implementing the matrix multiplication routine. Van de Geijn and Watts 18 independently developed the same algorithm on the Intel paragon and called it SUMMA. We limit the distribution of data matrices to the block cyclic data distribution. The PUMMA requires a minimum number of communications and computations. we present a new fast and scalable matrix multiplication algorithm. which maintains the maximum performance of the sequential BLAS routine. and it requires large memory space to store them temporarily. in which an M N matrix A consists of mb nb blocks of data. LCM P. even when the block size is very small as well as very large. and the blocks are distributed by wrapping around both row and column directions on an arbitrary P Q processor grid. Introduction .

it is computation intensive. if the block size of A is mb kb . That is. So the number of blocks of matrices 2. and and are scalars. B and C are M K .1. 10 . This paper focuses on the design and implementation of the non-transposed matrix multiplication routine of C A B + C. and are available in optimized form on most computing platforms ranging from workstations up to supercomputers. For performing the matrix multiplication C = A B. Block Cyclic Data Distribution . the performance di erence is approximately 10. K N .2. respectively. But for small matrix of N = 1000 on a 16 16 processor grid. cache. a software library that uses block-partitioned algorithms for performing dense linear algebra computations on vector and shared memory computers.The parallel matrix multiplication requires ON 3 ops and ON 2 communications. A. we assume that A. i. The Level 3 BLAS 9 perform a number of commonly used matrix-matrix operations. while on distributed-memory machines. Thus. e. The most important routine in the Level 3 BLAS is DGEMM for performing matrix-matrix multiplication. 2. 8. XT or XH . there has been much interest in developing versions of the Level 3 BLAS for distributed-memory concurrent computers 5. Design Principles Current advanced architecture computers possess hierarchical memories in which access to data in the upper levels of the memory hierarchy registers. On shared memory machines. The general purpose routine performs the following operation: where opX = X.. For a large matrix. they reduce the number of messages required to get the data from other processors. Level 3 BLAS C opA opB + C 2. And " denotes matrix-matrix multiplication. One technique to exploit the power of such machines more e ciently is to develop algorithms that maximize reuse of data held in the upper levels. B and C are matrices. respectively. This can be done by partitioning the matrix or matrices into blocks and by performing the computation with matrix-matrix operations on the blocks. and or local memory is faster than to data in lower levels shared or o -processor memory. and M N . then that of B and C must be kb nb and mb nb. The distributed routine also requires a condition on the block size to ensure compatibility. The Level 3 BLAS have been successfully used as the building blocks of a number of applications. including LAPACK 2 . but the idea can be easily extended to the transposed multiplication routines of C A BT + C and C A T B + C. block-partitioned algorithms reduce the number of times that data must be fetched from shared memory. the performance di erence between SUMMA and DIMMA may be marginal and negligible.

where a matrix with 12 12 blocks is distributed over a 2 3 grid. the matrix in Figure 1 may be viewed as a 2 2 array of LCM blocks. that is. when an operation is executed on the rst LCM block. the same operation can be done simultaneously on other LCM blocks. which have the same structure and the same data distribution as the rst LCM block. and the number indicates the location in the processor grid all blocks labeled with the same number are stored in the same processor. Then it can be directly applied to the other LCM blocks. represent indices of a row of blocks and of a column of blocks. A. hence. respectively. Figure 1a shows an example of the block cyclic data distribution. The numbered squares represent blocks of elements. and Kg = dK = kb e. B. Blocks belong to the same processor if their relative locations are the same in each LCM block. The slanted numbers. The way in which a matrix is distributed over the processors has a major impact on the load balance and communication characteristics of the concurrent algorithm. where each processor has 6 4 blocks. Ng = dN = nb e.0 1 2 3 4 5 6 7 8 9 10 11 0 1 2 3 4 5 6 7 8 9 10 11 0 3 0 3 0 3 0 3 0 3 0 3 1 4 1 4 1 4 1 4 1 4 1 4 2 5 2 5 2 5 2 5 2 5 2 5 0 3 0 3 0 3 0 3 0 3 0 3 1 4 1 4 1 4 1 4 1 4 1 4 2 5 2 5 2 5 2 5 2 5 2 5 0 3 0 3 0 3 0 3 0 3 0 3 1 4 1 4 1 4 1 4 1 4 1 4 2 5 2 5 2 5 2 5 2 5 2 5 0 3 0 3 0 3 0 3 0 3 0 3 1 4 1 4 1 4 1 4 1 4 1 4 2 5 2 5 2 5 2 5 2 5 2 5 0 3 6 9 1 4 7 10 2 5 8 11 0 2 4 6 8 10 1 3 5 7 9 11 P0 P1 P2 P3 P4 P5 (a) matrix point-of-view (b) processor point-of-view Figure 1: Block cyclic data distribution. in which the order of execution can be intermixed such as matrix multiplication and matrix transposition. . largely determines its performance and scalability. we refer to a square of LCM LCM blocks as an LCM block. The block cyclic distribution provides a simple. and Mg Ng . Each processor has 6 4 blocks. general-purpose way of distributing a block-partitioned matrix on distributedmemory concurrent computers. A parallel algorithm. b It is easier to see the distribution from the processor point-of-view to implement algorithms. A matrix with 12 12 blocks is distributed over a 2 3 processor grid. on the left and on the top of the matrix. And the LCM concept is applied to design software libraries for dense linear algebra computations with algorithmic blocking 17. Figure 1b re ects the distribution from a processor point-of-view. a The shaded and unshaded areas represent di erent grids. may be developed for the rst LCM block. Kg Ng . and C are Mg Kg . respectively. where Mg = dM = mbe. Denoting the least common multiple of P and Q by LCM . 19 . Thus.

1 rowwise. P1 . 3. : along each column of processors. and the time for local computation is 0.0 3 6 9 1 4 7 10 2 5 8 11 0 2 4 6 8 10 1 3 5 7 9 11 0 2 4 6 8 10 1 3 5 7 9 11 0 3 6 9 1 4 7 10 2 5 8 11 A B Figure 2: A snapshot of SUMMA. and the second row of processors. DIMMA . and lightest blocks are broadcast later. and van de Geijn and Watts 18 obtained high e ciency on the Intel Delta and Paragon. SUMMA 3. and P2 broadcasts the rst row of blocks of B B 0.2 seconds as in Figure 3a . broadcasts B 1. Processors multiply the rst column of blocks of A with the rst row of blocks of B. Algorithms SUMMA is basically a sequence of rank-kb updates. 3. and P5 . by exploiting the pipelined communication scheme. A and B are divided into several columns and rows of blocks. the rst column of processors P0 and P3 begins broadcasting the rst column of blocks of A A:. As the snapshot of Figure 2 shows. It is assumed that there are 4 processors. P3 . where broadcasting is implemented as passing a column or row of blocks around the logical ring that forms the row or column. respectively. P4 . In the gure. P0 . each has 2 sets of data to broadcast. the time to send a data set is assumed to be 0.2 seconds. broadcasts A:. The darkest blocks are broadcast rst. In SUMMA. and they use blocking send and non-blocking receive. respectively. Agrawal. the second column of processors. This procedure continues until the last column of blocks of A and the last row of blocks of B. At the same time. We show a simple simulation in Figure 3.1. Then processors multiply the next column of blocks of A and the next row of blocks of B successively. 0 along each row of processors here we use MATLAB notation to simply represent a portion of a matrix.2. After the local multiplication. P1 and P4 . : columnwise.6 seconds. whose block sizes are kb . Then the pipelined broadcasting scheme takes 8. Gustavson and Zubair 1 . the rst row of processors.

and the light gray color signals busy time. It is assumed that blocking send and non-blocking receive are used. After the rst procedure. the rst column . 0 and B 0. If the rst processor broadcasts everything it contains to other processors before the next processor starts to broadcast its data. the new communication scheme saves 4 communication times 8:2 . it is possible to eliminate the unnecessary waiting time. which show when each process is busy or idle. that is. The dark gray color signi es idle time for a given process. which show the communication pattern between the processes. Paragraph is a parallel programming tool that graphically displays the execution of a distributed-memory program. The modi ed communication scheme in Figure 3b takes 7. With this modi ed communication scheme. A careful investigation of the pipelined communication shows there is an extra waiting time between two communication procedures. and utilization Gantt charts. These gures include spacetime diagrams. :. The details of analysis of the algorithms is shown in Section 4. DIMMA is more e cient in communication than SUMMA as shown in these gures. 7:4 = 0:8 = 4 0:2. DIMMA is implemented as follows. broadcasting and multiplying A:. That is.4 seconds. Figures 4 and 5 show a Paragraph visualization 13 of SUMMA and DIMMA on the Intel Paragon computer.Proc 0 Proc 1 Proc 2 Proc 3 0 0 0 0 0 1 2 2 3 3 3 0 0 0 0 1 2 2 3 3 3 1 1 1 1 1 1 2 2 2 2 3 3 4 0 3 7 8 9 1 2 5 6 : time to send a message : time for a local computation Time a SUMMA Proc 0 Proc 1 Proc 2 Proc 3 0 0 0 0 0 0 0 0 0 1 1 2 2 2 2 3 3 3 3 3 3 1 1 1 1 1 1 2 2 2 2 3 6 3 7 8 9 1 2 3 4 5 Time b DIMMA Figure 3: Communication characteristics of SUMMA and DIMMA. respectively.

Figure 4: Paragraph visualization of SUMMA Figure 5: Paragraph visualization of DIMMA .

as shown in Figure 6. For the third and fourth procedures. respectively. broadcasts columnwise B 3. a column of processors broadcasts several MX = dkopt =kb e columns of blocks of A along each row of processors. 9. and P2 sends B 6. if P = 2. 6 along each row of processors. in the Intel Paragon. which corresponds to about 44 M ops on a single node. broadcasts all of their columns of blocks of A along each row of processors. and P5 . The darkest blocks are broadcast rst. Q = 3. kb = 10 and kopt = 20. then kopt = 20 to optimize performance of the sequential BLAS routine. The value of kb should be at least 20 Let kopt be the optimal block size for the computation. 0. DGEMM. and the rst row of processors. A:. . P3 . Then each processor executes its own multiplication. whose distance is LCM blocks in the row direction as shown in Figure 7. 0 and A:. P0 and P3 . P0 and P3 . : and B 9. At the same time. For example. 3 and A:. The multiplication operation is changed from `a sequence = Kg of rank-kb updates' to `a sequence = dKg = MX e of rank-kb MX updates' to maximize the performance. and the same number of thin rows of blocks of B so that each processor multiplies several thin matrices of A and B simultaneously in order to obtain the maximum performance of the machine. : along each column of processors. The basic computation of SUMMA and DIMMA in each processor is a sequence of rankkb updates of the matrix. Instead of broadcasting a single column of A and a single row of B. The vectors of blocks to be multiplied should be conglomerated to form larger matrices to optimize performance if kb is small. and the second row of processors. The basic idea of the LCM concept is to handle simultaneously several thin columns of blocks of A. 0 3 6 9 1 4 7 10 2 5 8 11 0 2 4 6 8 10 1 3 5 7 9 11 0 2 4 6 8 10 1 3 5 7 9 11 0 3 6 9 1 4 7 10 2 5 8 11 A B Figure 6: Snapshot of a simple version of DIMMA. P0 and P3 . 6 that is. The value 6 appears since the LCM of P = 2 and Q = 3 is 6. the second column of processors. whose distance is LCM blocks in the column direction. a row of processors broadcasts the same number of blocks of B along each column of processors. After the rst column of processors. P1 and P4 . The rst column of processors. copies two columns of A:. broadcasts their columns of A. the processors deal with 2 columns of blocks of A and 2 rows of blocks of B at a time MX = dkb =kopt e = 2.of processors. broadcasts A:. P0 and P3 . 6 to TA. P0 . :. broadcasts rowwise A:. the rst column of processors. DIMMA is modi ed with the LCM concept. P4 . P1 .

The product of TA and TB is added to C in each processor. It is assumed that kb = kopt throughout the computation. B 0. If it is assumed that kopt = 20. and the pseudocode of the DIMMA is shown in Figure 8. Then. The value of MX can be determined by the block size. in which kb is smaller and larger than kopt . and divide a row of blocks of B into ve thin rows of blocks. It is possible to divide kb into smaller pieces. are combined. P1 and P2 . it may be di cult to obtain good performance since it is di cult to overlap the communication with the computation. 7 . copies the next two rows of B 1. : that is. : to TB and broadcasts them columnwise. In addition. 6 . P3 . processors divide a column of blocks of A into ve thin columns of blocks.0 3 6 9 1 4 7 10 2 5 8 11 0 2 4 6 8 10 1 3 5 7 9 11 0 2 4 6 8 10 1 3 5 7 9 11 0 3 6 9 1 4 7 10 2 5 8 11 A B Figure 7: A snapshot of DIMMA and broadcasts them along each row of processors. The rst row of processors. The two cases. and the value of MX should be 2 if the block size is 10. available memory space. For example. copies the next two columns of A:. If kb is much larger than the optimal value for example. there are Kg = dK=kbe columns of blocks of A and Kg rows of blocks of B. Then they multiply each thin column of blocks of A with the corresponding thin row of blocks of B successively. At rst. Then all processors multiply TA with TB to produce C. Analysis of Multiplication Algorithms We analyze the elapsed time of SUMMA and DIMMA based on Figure 3. P0 . it is assumed that there are P linearly connected processors. P4 and P5 . in which a column . 7 to TA and broadcasts them again rowwise. and machine characteristics such as processor performance and communication speed. copies two rows of B 0. P1 and P4 . : and B 6. the second column of processors. if kb = 100. : to TB and broadcasts them along each column of processors. 1. Next. for the multiplication CM N CM N + AM K BKN . the value of MX should be 4 if the block size is 5. kb = 100. and the second row of processors. 4. the multiplication routine requires a large amount of memory to send and receive A and B.

The DO loop of L3 is used if kb is smaller than kopt . t1D . 2 tc = Kg tc + tp + 2P . 2 tc = Kg 2tc + tp + P . The innermost DO loop of L4 is used if kb is larger than kopt . the time di erences is 2tc + tp if they are in di erent processors. whose block distance are LCM. The total elapsed time of SUMMA with Kg columns of blocks on an 1-dimensional processor grid. Lm to TA and broadcast it along each row of processors Copy B Lm . is summa t1D = Kg 2tc + tp . and the bracket in L4 represents the L4 -th thin vector. is dimma t1D = Kg tc + tp + P . 1 Copy A:. t1D .C = 0 C :. 1 LX = LCM MX DO L3 = 0. tc + P . 3 tc : summa For DIMMA. 3 tc : dimma . 1 DO L2 = 0. dkb =kopt e . LCM=Q . : + TA TB END DO END DO END DO END DO Figure 8: The pseudocode of DIMMA. 1 DO L4 = 0. The total elapsed time of DIMMA. simultaneously. dKg =LX e . the time di erence between the two pipelined broadcasts is tc + tp if the TAs are broadcast from the same processor. Lm is used to select them correctly. 1tc + P . : = C :. and the time for multiplying TA with TB and adding the product to C is tp . of blocks of A = TA is broadcast along P processors at each step and a row of blocks of B = TB always stays in each processor. the time di erence between successive two pipelined broadcasts of TA is 2tc + tp . : = 0 MX = dkopt =kb e DO L1 = 0. However. where the routine handles MX columns of blocks of A and MX rows of blocks of B . is a data transfer time. Actually tc = + M kb and tp = 2 M N kb . 1 Lm = L1 + L2 Q + L3 LX + L4 : LCM : L3 + 1 LX . It is also assumed that the time for sending a column TA to the next processor is tc . where is a P communication start-up time. : to TB and broadcast it along each column of processors C :. Q . and is a time for multiplication or addition. For SUMMA.

is GCD tcb . Korea. P tcb = Kg . t2D if GCD = P. Meanwhile. t2D if GCD = P dimma = Kg tca + tcb + tp + 2Q . Oak Ridge. kb . Assume again that the time for sending a column TA and a row TB to the next processor are tca and tcb . So. and the time for multiplying TA with TB and adding the product to C is tp . 3tca + P + Q . Implementation and Results We implemented three algorithms. Suwon. which has the pipelined broadcasting scheme and the xed block size. whose distance is GCD. Q tca + Kg .. called them SUMMA0. and the 256 node Intel Paragon at Samsung Advanced Institute of Technology. P=GCD rows of processors. 3tcb = Kg tca + tcb + tp + 2Q . U. The local matrix multiplication in SUMMA0 is the rank-kb update. 3 tca + P . For a column of processors. So. Actually tca = + M kb . only one row of processors has TB to broadcast corresponding to the column of processors. tcb = + N kb . 3 tcb : summa 1 For DIMMA. SUMMA is a revised version of SUMMA0 with the LCM block concept for the optimized performance of DGEMM. P Q t2D = Kg 2tca + 2tcb + tp + Q . kb . and the total extra waiting time is P tcb . each column of processors broadcasts TA until everything is sent. respectively. caused by broadcasting two TB s when they are in di erent processors. the communication time of SUMMA is doubled in order to broadcast TB as well as TA.S. SUMMA0 is the original version of SUMMA. we changed the block size. The extra idle wait. 3tca + PQ + P . Q tca + Kg . and observed how the block size a ects the . where GCD is the greatest common divisor of P and Q. so that the local matrix multiplication is a rank-kapprox update. if GCD = P .On a 2-dimensional P Q processor grid. rows of processors broadcast TB if they have the corresponding TB with the TA. SUMMA and DIMMA. P Q and tp = 2 M N kb . and compared their performance on the 512 node Intel Paragon at the Oak Ridge National Laboratory. However. Then the total extra waiting time to broadcast TB s is Q P=GCD GCD tcb = P Q tcb . have rows of blocks of B to broadcast along with the TA. which currently broadcasts A.A. summa dimma = Kg . PQ tcb otherwise: 3 5. 3tcb otherwise: The time di erence between SUMMA and DIMMA is 2 t2D . where kapprox is computed in the implementation as follows: kapprox = bkopt = kb c kb = bkb = dkb =kopt ec if kopt kb . otherwise: First of all.

that is. At rst SUMMA0 and SUMMA are compared. 20. the processors in the top half have 300 rows of matrices. that is. For N = 8000. When kb = 5. Figures 9 and 10 show the performance of SUMMA and DIMMA on 16 16 and 16 12 processor grids. respectively. Note that on an 8 8 processor grid with 2000 2000 matrices. so that the performance di erence caused by the di erent communication schemes becomes negligible. SUMMA0 becomes ine cient again and it has a di culty in overlapping the communications with the computations. DIMMA always performs better than SUMMA on the 16 16 processor grid. with the xed block size. kb = 50. these algorithms require much more computation. the performance di erence between the two algorithms is about 10. On the 16 12 processor grid. SUMMA . This leads to load imbalance among processors. or 100. 5. the performance di erence is only about 2 3. When kb = 100. With the extreme case of kb = 1. SUMMA with the modi ed blocking scheme performed at least 100 better than SUMMA0. and the processors in the top half require 50 more local computation. But for a large matrix. 50.P Q 88 Matrix Size 2000 2000 88 4000 4000 12 8 4000 4000 Block Size 1 1 5 5 20 20 50 50 100 100 1 1 5 5 20 20 50 50 100 100 1 1 5 5 20 20 50 50 100 100 SUMMA0 1:135 2:488 2:505 2:633 1:444 1:296 2:614 2:801 2:674 2:556 1:842 3:280 3:928 3:536 2:833 SUMMA 2:678 2:730 2:504 2:698 1:945 2:801 2:801 2:801 2:822 2:833 3:660 3:836 3:931 3:887 3:430 DIMMA 2:735 2:735 2:553 2:733 1:948 2:842 2:842 2:842 2:844 2:842 3:731 3:917 4:006 3:897 3:435 Table 1: Dependence of performance on block size Unit: G ops performance of the algorithms. SUMMA outperformed SUMMA0 about 5 10 when A = B = C = 4000 4000 and kb = 50 or 100 on 8 8 and 12 8 processor grids. Now SUMMA and DIMMA are compared. For a small matrix of N = 1000. and 100. These matrix multiplication algorithms require ON 3 ops and ON 2 communications. kb = kopt = 20. the algorithms are computation intensive. If the block size is much larger than the optimal block size. Table 1 shows the performance of A = B = C = 2000 2000 and 4000 4000 on 8 8 and 16 8 processor grids with block sizes kb = 1. the performance of kb = 20 or 100 is much slower than that of other cases.10 enhanced performance. while those in the bottom half have just 200 rows. SUMMA shows 7 .

10 DIMMA SUMMA 8 Gflops 6 4 2 0 0 1000 2000 3000 4000 5000 6000 7000 8000 Matrix Size. . M Figure 9: Performance of SUMMA and DIMMA on a 16 16 processor grid. kopt = kb = 20. M Figure 10: Performance of SUMMA and DIMMA on a 16 12 processor grid.Gflops 12 10 8 6 4 2 0 0 1000 2000 3000 4000 5000 6000 7000 8000 DIMMA SUMMA Matrix Size.

10 DIMMA SUMMA 8 Gflops 6 4 2 0 0 1000 2000 3000 4000 5000 6000 7000 8000 Matrix Size.Gflops 12 10 8 6 4 2 0 0 1000 2000 3000 4000 5000 6000 7000 8000 DIMMA SUMMA Matrix Size. M Figure 12: Predicted Performance of SUMMA and DIMMA on a 16 12 processor grid. M Figure 11: Predicted Performance of SUMMA and DIMMA on a 16 16 processor grid. .

respectively. 3tca + PQ + P . but DIMMA is always better. Conclusions We present a new parallel matrix multiplication algorithm. there would be no improvement in performance. Currently the modi ed blocking scheme in DIMMA uses the rank-kapprox update. when memory usage per node is held constant. 3tcb when GCD 6= P . Those values are observed in practice. However it is possible to modify the DIMMA with the exact rank-kopt update by dividing the virtually connected LCM blocks in each processor. 3. GCD = Q if a column of processors sends all columns of blocks of B instead of a row of processors send all rows of blocks of A as in Figure 8. GCD = 4 6= P . the waiting time is reduced to P + Q . From Eq. Both algorithms show good performance and scalability. for block cyclic data distribution on distributed-memory concurrent computers. and exploits the LCM block concept to obtain the maximum performance of the sequential BLAS routine regardless of the block size. This modi cation is faster if 2 GCD MINP. In Eq. DIMMA always shows the same high performance even when . the DIMMA always reaches 40 M ops per processor. t2D . respectively. it is expected that the SUMMA is faster than DIMMA for the problem if tca = tcb . but the processors send all corresponding blocks of A and B. 6. If P = 16 and Q = 12.performs slightly better than DIMMA for small size of matrices. After the rst column and the rst row of processors send their own A and the corresponding B. such as N = 1000 and 2000. Q = 8 that is. 2. the second column and the second row of processors send their A and B. 2Q . then. 3tcb . called DIMMA. = 0:02218 45 Mbytes sec. For the problem of M = N = K = 2000 and kopt = kb = 20. the idle wait. for the next step. The waiting time is LCM+ Q . 3tca +LCM+ P . We used = 94:75sec. Figures 11 and 12 show the predicted performance of SUMMA and DIMMA corresponding to Figures 9 and 10. If each processor has a local problem size of more than 200 200. Q. respectively. can be reduced by a slight modi cation of the communication scheme. The modi cation complicates the algorithm implementation. 92tcb : summa dimma From the result. The performance per node of SUMMA and DIMMA is shown in Figures 13 and 14. but the SUMMA obtained about 38 M ops per processor. when P = 4. For example. = 22:88nsec 43. We predicted the performance on the Intel Paragon using Eqs 1 and 2. respectively. 3tca + 2P . DIMMA is the most e cient and scalable matrix multiplication algorithm. The communication resembles that of SUMMA. t2D = 100 . 16 12 tcb = 88tca . DIMMA uses the modi ed pipelined broadcasting scheme to overlap computation and communication e ectively. and since the performance of DGEMM is not sensitive to the value of kopt if it is larger than 20.7 M ops per node for the predicted performance. 12 tca + 100 . Kg = K=kb = 100. The following example has another communication characteristic. 3tcb .

300 300.50 Mflops 40 30 20 10 0 0 4 8 12 16 Sqrt of number of nodes Figure 13: Performance per node of SUMMA where memory use per node is held constant. and 500 500 local matrices per node from the bottom. . 200 200. 400 400. The ve curves represent 100 100. 50 Mflops 40 30 20 10 0 0 4 8 12 16 Sqrt of number of nodes Figure 14: Performance per node of DIMMA.

F. Hammarling. Acknowledgement The author appreciates the anonymous reviewers for their helpful comments to improve the quality of the paper The author appreciates Dr. 1990. W. A. Cannon. A. McKenney.S. K. Oak Ridge. Summer 1994. Sorensen. International Journal of Supercomputing Applications.Design Issues and Performance. 2 E. R. D. J.the block size kb is very small as well as very large if the matrices are evenly distributed among processors. C. 3 L. Bai. Henry. 82:99 118. and M. S. S. 6 J. Suwon. Choi. U. and D. ScaLAPACK: A Portable Linear Algebra Library for Distributed Memory Computers . And he appreciates the anonymous reviewers for their helpful comments to improve the quality of the paper. and R. E. CRPC Research into Linear Algebra Software for High Performance Computers. J. Gustavson. D. Z. Petitet. Dongarra. C. University of Tennessee. 4 L. Whaley. J. A High-Performance MatrixMultiplication Algorithm on a Distributed-Memory Parallel Computer Using Overlapped Communication. Choi. P. http: www. J. J. I. Ostrouchov. 7. S. Jack Dongarra at Univ. Pozo.supercomp. C. Montana State University. J. of Tennessee at Knoxville and Oak Ride National Laboratory for providing computing facilities to perform this work. Demmel. References 1 R. 1995. Anderson. Demmel. 1994. Korea. Walker.A. Ph. Walker.D. 1996. And it was supported by the Korean Ministry of Information and Communication under contract 96087-IT1-I2. Sorensen. Blackford. Stanley. In Proceedings of Supercomputing '96. Technical Report CS-95-292. A. D.org sc96 proceedings . IEEE Press. LAPACK: A Portable Linear Algebra Library for High-Performance Computers. C. A. Greenbaum. A Proposal for a Set of Parallel Basic Linear Algebra Subprograms. Thesis. DuCroz. Dongarra. 1969. A Cellular Computer to Implement the Kalman Filter Algorithm. Hammarling. W. J. Walker. Whaley. Dongarra. . This research was performed in part using the Intel Paragon computers both at the Oak Ridge National Laboratory. G. G. J. A. 386:673 681. Agarwal. Dongarra. Bischof. IBM Journal of Research and Development. Cleary. and R. Zubair. Dhillon. 5 J. pages 1 10. J. LAPACK Working Note 100. J. Choi. In Proceedings of Supercomputing '90. Petitet. and at Samsung Advanced Institute of Technology. and D.

1990. Visualizing the Performance of Parallel Programs. In Proceedings of the 1992 Scalable High Performance Computing Conference. 1989.D. September 1991. E. C. IEEE Computer Society Press. and G. 9 J. J. Comparison of Scalable Parallel Multiplication Libraries. CA. Smith. The MIT Press. A Set of Level 3 Basic Linear Algebra Subprograms. Cambridge. SUMMA Scalable Universal Matrix Multiplication Algorithm. Using PLAPACK. Tsao. Parallel Computing.7 J. Karypis. University of Tennessee. and C. 1997. Redwood City. M. Du Croz. IEEE Software. H. W. Skjellum. A. van de Geijn and J. Walker. Algorithmic Redistribution Methods for Block Cyclic Decompositions. S. Ph. Hammarling. 1994. Thesis. 85:29 39. Choi. and A. Baltimore. 15 S. Etheridge. The Multicomputer Toolbox Approach to Concurrent BLAS and LACS. Zhang. Petitet. A. Walker. Concurrency: Practice and Experience. 1992. Still. and D. J. 181:1 17. 17 A. 8:517 535. 16 V. J. A. van de Geijn. The Benjamin Cummings Publishing Company. Technical Report CS-95-286. 11 G. Kumar. The Johns Hopkins University Press. LAPACK Working Note 99. W. J. A. Dongarra. J. S. October 6-8.. Matrix Computations. Matrix Algorithms on a Hypercube I: Matrix Multiplication. Huss-Lederman. Watts. Jacobson. Second Edition. Otto. MS. Introduction to Parallel Computing. V. 1995. and D. Du . Starksville. Van Loan. D. Concurrency: Practice and Experience. 18 R. E. and I. Jacobson. 12 G. University of Tennessee. 6:543 570. W. J. and G. 8 J. Grama. MD. Fox. . Concurrency: Practice and Experience. Gupta. Choi. 13 M. 4:17 31. Golub and C. G. 19 R. H. 1996. M. 1994. T. pages 121 128. S. PB-BLAS: A Set of Parallel Block Basic Linear Algebra Subprograms. 1993. In The Scalable Parallel Libraries Conference. 1994. and A. Dongarra. Falgout. A. 10 R. IEEE Press. Tsao. Huss-Lederman. 14 S. 6:571 594. 1987. J. Matrix Multiplication on the Intel Touchstone Delta. Knoxville. 1996. Heath and J. pages 142 149. PUMMA: Parallel Universal Matrix Multiplication Algorithms on Distributed Memory Concurrent Computers. Dongarra. Hey. ACM Transactions on Mathematical Software. Inc. G. A.

- Section1.4 FFT Algorithmuploaded byGovardhan Reddy.G
- Matrices notesuploaded byps3266_753186479
- a Practical Approach to Linear Algebrauploaded byDeepak Singh
- An Introduction to MATLAB for Geoscientistsuploaded bySergio Pablo Rodríguez
- Formato Plan de Tesisuploaded byPaúl Gonzáles
- Software Optimization for High-Performance Computinguploaded byapi-3714165
- symbosium detailsuploaded bybazeerahamed1232248
- Matrix .pptxuploaded byMonower Hossain
- Matrix Algebra Reviewuploaded byakozy
- pc6_mpiIIuploaded bylinchi
- Bookuploaded byhappy2011
- Generalized Laplace coefficients and Newcomb derivativesuploaded byunima3610
- Reflection-Mirror Through an Arbitrary Planeuploaded byIgor Gjorgjiev
- Chapter 02uploaded bytejswrp
- Project2-1.pdfuploaded byahmad
- Mathematics 2009 Unsolved Paper Outside Delhi.pdfuploaded byroxtr
- Code Optimizationuploaded byPraveenkumar Aepuri
- Aptitude Shortcuts and Mind Tricks for Partnership Problems Type-IIuploaded byssd231
- Statement of Purposeuploaded byAhmedMahir
- 105A_syllabusuploaded byGuanda Fu
- About Meuploaded bycruelhck
- KernelStruct-I1uploaded bysivar22
- 1LabExercise.docediteduploaded byroxette
- Curriculum-2012-CSE.pdfuploaded byRehan Umer
- Undergraduate Prospectus 08uploaded byShairyarShan
- Matlab Basics SENSEuploaded byAnonymous 5xfXLt
- ICCSEAuploaded byCS & IT
- Experiment 1uploaded byAkbar Ali
- Santos Et. Al., 2017uploaded byFernanda Lago
- Diapositivas Matlabuploaded byMarco Antonio Osorio Clemente

- Bisonuploaded byFlor Sosa
- 187382359 Teoria de Juegos JoaquinPerezuploaded byFlor Sosa
- Benjamin C. Pierce - Advanced Topics in Types and Programming Languagesuploaded byFlor Sosa
- Operations Research- By P. Rama Murthy - 2nd Ed - [VelVsher]uploaded byFlor Sosa
- G31 Informe DBuploaded byFlor Sosa
- Wiley.web.Application.architecture.principles.protocols.and.Practices.2nd.edition.may.2009.ISBN.047051860Xuploaded byFlor Sosa
- Programming Language Concepts Ghezzi Carlouploaded byFlor Sosa
- 108_LenguajesyCompiladoresuploaded byFlor Sosa
- 08tn003uploaded byFlor Sosa
- BrazoElectronicouploaded byFlor Sosa
- 10.1.1.116uploaded byFlor Sosa
- Paralelismo en Monoprocesadores - Superescalaresuploaded byFlor Sosa
- Ingenieria de softwareuploaded byFlor Sosa
- VHDL Maxinezuploaded byFlor Sosa
- SCRUMxCMMMI_IEEE-final03uploaded byFlor Sosa

Close Dialog## Are you sure?

This action might not be possible to undo. Are you sure you want to continue?

Loading