您现在的位置:首页 > >

On the automatic parallelization of sparse and irregular Fortran programs

发布时间:

On the Automatic Parallelization of Sparse and Irregular Fortran Programs ?
Yuan Lin and David Padua
Department of Computer Science, University of Illinois at Urbana-Champaign

fyuanlin,paduag@uiuc.edu

Abstract. Automatic parallelization is usually believed to be less e ec-

tive at exploiting implicit parallelism in sparse/irregular programs than in their dense/regular counterparts. However, not much is really known because there have been few research reports on this topic. In this work, we have studied the possibility of using an automatic parallelizing compiler to detect the parallelism in sparse/irregular programs. The study with a collection of sparse/irregular programs led us to some common loop patterns. Based on these patterns three new techniques were derived that produced good speedups when manually applied to our benchmark codes. More importantly, these parallelization methods can be implemented in a parallelizing compiler and can be applied automatically.

1 Introduction
Sparse computations are implementations of linear algebra algorithms that store and operate on the nonzero array elements only. These algorithms are usually complex, use sophisticated data structures, and have irregular memory reference patterns. Automatic parallelization is usually believed to be less e ective at exploiting implicit parallelism in sparse codes than in their dense counterparts. However, little is known because there have been few research reports on the applicability of automatic parallelism detection techniques on sparse/irregular programs. In the work reported in this paper, we studied a collection of sparse programs written in Fortran 77. We found that, despite their irregular memory reference pattern, many loops in the sparse/irregular codes we studied are parallel. We have derived several new transformation techniques that can be applied automatically by a compiler to parallelize these loops. Manually applying these techniques to our collection of irregular programs resulted in good speedups. This strengthens our belief that automatic parallelizing techniques can work on sparse/irregular programs as well as they do on dense codes.
?

This work is supported in part by Army contract DABT63-95-C-0097; Army contract N66001-97-C-8532; NSF contract MIP-9619351; and a Partnership Award from IBM. This work is not necessarily representative of the positions or policies of the Army or Government.

Table 1. Benchmark Codes
# of Seq Exec Benchmark Description Origin lines Time (s) 1 Cholesky Sparse cholesky factorization HPF-2 1284 323.50 2 Euler A multimaterial, multidiscipline HPF-2 1990 972.14 3D hydrodynamics code 3 Gccg Computational uid dynamics Univ of Vienna 407 374.27 4 Lanczos Eigenvalues of symmetric matrices Univ of Malaga 269 389.25 5 SpLU Sparse LU factorization HPF-2 363 1958 6 SparAdd Addition of two sparse matrices 9] 67 2.40 7 ProdMV Product of a sparse matrix by 9] 28 1.28 a column vector 8 ProdVM Product of a row vector by 9] 31 1.07 a sparse matrix 9 SparMul Product of two sparse matrices 9] 64 3.32 10 SolSys Solution of system U T DUx = b 9] 43 4.51 11 ProdUB Product of matrices U ?T and B 9] 49 3.72

Our hope is that the techniques developed based on our limited benchmark collection also will be e ective at handling most situations in an extended benchmark collection. In fact, for sparse computation, we intend to follow the approach we took for dense computation in the Polaris project 2]. The Polaris project started with a hand analysis of a program collection, the Perfect Benchmark suite. The techniques derived from the Perfect Benchmark suite proved to be quite e ective with an extended collection of programs, including SPEC and Grand Challenge programs contributed by NCSA. As in our early Polaris study, our current work focuses on loop-level parallelism in shared memory programs. We believe this is an important rst step in understanding di culties in automatic parallelization of sparse/irregular programs. For programs that can be separated into a symbolic section and a numeric section, we focus on (but do not limit ourselves to) the numeric section. Distinguishing the two sections helps us to develop transformation techniques that are key to obtaining good speedups. This paper is organized as follows. Section 2 describes the benchmark programs we collected for this project. The important loop patterns we found are studied in Sect. 3. Section 4 discusses some newly identi ed transformation techniques, the e ectiveness of which is evaluated in Sect. 5. Section 6 compares our work with that of others. And, Section 7 presents our conclusions.

2 The Benchmark Suite
Table 1 lists all the codes in our sparse/irregular benchmark suite 1]. We chose them for the same reason programs were chosen for the collection of HPF-2 motivating applications: \they include parallel idioms important to full-scale

Table 2. Loop Patterns
Indirectly Accessed Array Others RightO set Sparse Consecutively Premature Array Benchmark hand Histogram and and Written Exit Loop w. PrivatSide Reduction Length Private Array Reduction ization II p p p 1 Cholesky p 2 Euler p 3 Gccg p 4 Lanczos p p p p 5 SpLU p p 6 SparAdd p 7 ProdMV p 8 ProdVM p p 9 SparMul p p 10 SolSys p 11 ProdUB

`sparse/irregular' applications" 5]. The programs in our suite are small. This enabled us to complete the hand analysis in a reasonable time. We plan to expand this collection to include larger programs. The expanded collection will be used to evaluate the parallelizing techniques once they are implemented in the Polaris parallelizing compiler.

3 Loop Patterns
3.1 Overview
Sparse/irregular programs are usually considered di cult for automatic parallelization because they use indirectly accessed arrays and the subscript values are often unknown until run-time. However, in order to better understand this problem, we studied how indirectly accessed arrays are used in our benchmark collection. Our most surprising nding is that e cient methods can be used to automatically analyze and parallelize loops with indirectly accessed arrays. We also found some important loops in our benchmarks that require the use of new techniques to parallelize. These loops do not contain indirectly accessed arrays, but do occur in sparse/irregular programs. Table 2 summarizes the seven most important loop patterns we found in our benchmarks. A `p' means this pattern appears in the program. The patterns in columns three through six involve indirectly accessed arrays. In this paper, we call the array that appears in the subscript of another array the subscript array and the indirectly accessed array the host array.

3.2 Loop Patterns for Indirectly Accessed Arrays Right-hand Side. In this pattern, the indirectly accessed arrays appear only
on the right-hand side of assignment statements. These arrays are read-only in the enclosing loop. Thus, this loop pattern does not cause any di culty in the automatic detection of parallelism. The pattern, illustrated in Fig. 1, appears in Gccg, Lanczos, ProdMV and SolSys.
do nc = nintci, nintcf direc2(nc) = bp(nc)*direc1(nc) - bs(nc)*direc1(lcc(nc,1)) - bw(nc)*direc1(lcc(nc,4)) - bl(nc)*direc1(lcc(nc,5)) end do

Fig. 1. An Example of the Right-hand Side Pattern

is a reduction operation, and expression does not contain any references to array a(). Array a() is accessed via index array x(). Because two elements of x() could have the same value, loop-carried dependence may exist. Histogram reductions are also called irregular reductions 5].
op
real a(m) do i = 1, n a(x(i)) = a(x(i)) op expression end do

Histogram Reduction. An example of this pattern is shown in Fig. 2, where

Fig. 2. An Example of the Histogram Reduction Loop
Histogram reductions are pervasive in sparse/irregular codes. There are several reasons for this. First, some typical sparse matrix computations, such as the vector/matrix multiplication in the following example, have the form of histogram reduction:
do i = 1, n do k = rowbegin(i), rowend(i) c(ja(k)) = c(ja(k)) + b(i) * an(i) end do end do

Second, a large collection of irregular problems, which can be categorized as general molecular dynamics, accumulate values using histogram reduction. Four programs in the HPF-2 motivation applications(i. e. , MolDyn, NBFC, Binz and DSMC) have histogram reductions at their computation core 5]. The third reason is that the computation of structure arrays, like the index arrays used to access sparse matrix and the interaction list in molecular dynamics, often contains histogram reductions. An obvious example is the calculation of the number of nonzero elements for each row in a sparse matrix stored in column-wise form. In Sect. 4.2, we will discuss in detail the techniques that are useful to parallelize a histogram reduction loop.

O set and Length. In this pattern, subscript arrays are used to store o set pointers or length of segments. The host array is accessed contiguously within each segment. Figure 3 shows the basic pattern. Array offset() points to the starting position of each segment. The size of each segment is given in array length(). Figure 3(a) and (b) are two common forms of using the o set and length arrays.
offset(1) offset(2) offset(3) offset(4) offset(n) offset(n+1)

Host Array length(1) length(2) length(3) length(4) length(n)

do 100 i = 1, n do 200 j = 1, length(i) data(offset(i)+j-1) = .. end do end do (a)

do 100 i = 1, n do 200 j = offset(i), offset(i+1)-1 data(j) = .. end do end do (b)

Fig. 3. Examples of the O

set and Length Subscript Array

A typical example of this pattern appears in sparse matrix codes using the Compressed Column Storage(CCS) or the Compressed Row Storage(CRS) format and traversing the matrix by row or column. The CCS/CRS format was adopted by the Harwell-Boeing Matrix Collection 6] and has become very popular. We also found this pattern in the Perfect Benchmark codes DYFESM and TRFD. There are variants of CCS/CRS that re ect the structures of some speci c sparse matrices. However, the basic loop patterns to access arrays represented in these variants are similar to those in Fig. 3. This loop pattern is somewhat regular. In languages, such as Fortran 77, where the array is the basic data type and the loop is the main iterative con-

struct, storing and accessing related data elements contiguously in an array is the natural way to program. Furthermore, this pattern has good spatial cache locality. Thus, the presence of this access pattern in sparse/irregular codes is not surprising.

Sparse and Private. In this loop pattern, array elements are accessed in a
working place which can be privatized. A typical example of this pattern appears in the scatter and gather operation, as shown in the matrix addition code in Fig. 4, where the working place array x() is used to hold the intermediate result.
do i = 1, n /* scatter */ do ip = ic(i), ic(i+1) x(jc(ip)) = 0 end do do ip = ia(i), ia(i+1) x(ja(ip)) = an(ip) end do do ip = ib(i), ib(i+1) x(jb(ip)) = x(jb(ip)) end do /* gather */ do ip = ic(i), ic(i+1) c(ip) = x(jc(ip)) end do end do

totally irregular manner. However, in this pattern, the array is also used as a

1

1

1 + bn(ip)

1

8 1 i n; fjc(j ) j ic(i) j ic(i + 1) ? 1g = fja(j ) j ia(i) j ia(i + 1) ? 1g fjb(j ) j ib(i) j ib(i + 1) ? 1g

Fig. 4. An Example of the Sparse and Private Pattern - Sparse Matrix Addition

Summary. Of the four loop patterns, Right-Hand Side is trivial to handle; Histogram Reduction can be recognized automatically 10], although its e cient parallelization is not as easy as it rst appears; and O set and Length and Sparse and Private can be managed by the run-time method presented in Section 4.3.
Thus, we believe that a parallelizing compiler enhanced with the techniques described in this paper should be able to automatically analyze most loops containing indirectly accessed arrays in our benchmark codes.

3.3 Other Loop Patterns
The loop patterns described in this subsection do not involve indirectly accessed arrays. However, they appear in our benchmark codes and require new parallelization techniques.

Consecutively Written Array. In this pattern, array elements are written one after another in consecutive locations. However, there is no closed form expression of the array index because the value of the index is changed conditionally. This pattern is illustrated in Fig. 5.
do i = 1, n while (...) if (...) then S1: a(j) = ... S2: j = j+1 end if end do end do ( a() is write only in this pattern )

Fig. 5. An Example of the Consecutively Written Array
Current data dependence tests fail to disprove the dependence in this pattern because the index value in each iteration is determined at run-time.

Premature Exit Loop with Reduction Operations. A premature exit loop is a loop containing a goto or break statement that directs the program ow out

of the loop before all iterations have been executed. Speculative execution, which is a possible parallelization method for this type of loop, may execute beyond the iteration where the loop exit occurs and cause side-e ects. These overshot iterations should be recovered in order to produce the correct result. The need for rollback makes the parallelization complicated and sometimes impossible. However, if the only operation within the premature exit loop is a reduction, as illustrated in Fig. 6, then a simple speculative parallelization transformation is possible. The basic idea is to block schedule the loop, let each processor get its own partial result and throw away the unneeded part in the cross-processor reduction phase.

Array Privatization of Type II. Array privatization is one of the most
important parallelization techniques. It eliminates data dependences between di erent occurrences of a temporary variable or an array element across di erent

a = initvalue do i = lower, upper if (cond(i)) break a = reduct(a,i) end do

Fig. 6. An Example of the Premature Exit Loop with Reduction Operations
iterations 8] 13]. Blume et al. 2] measured the e ectiveness of privatization on the Perfect Benchmark suite. Figure 7 shows a typical access pattern for a privatizable array.

do i = 1, m t(i) = const end do LOOP_2: do i = 1, n do j = 1, m t(j) = 0 enddo .. = t(k) enddo do i = 1, n k = 0 .... while (...) ... = t(...) op express .... k = k+1 t(k) = ... .... end while .... do j = 1, k t(j) = const end do end do

S1:

S2:

1 k m

S3:

Fig. 7. Array Privatization of Type I

Fig. 8. Array Privatization of Type II

Generally, a variable or an array can be privatized if it is de ned before it is used in each loop iteration 13] 8]. This traditionally has been the only kind of data item privatized by existing compliers. However, in our benchmark codes, we found another kind of privatizable array, as shown in Fig. 8, which we will refer to as type II. We call the more traditional privatizable array type I. In this example, array t() is used as a temporary array. In each iteration of LOOP 2, the elements of t(), which are modi ed in S2, are always reset to const before leaving the iteration. Because the value of t() is always the same

upon entering each iteration, a private copy for each iteration with the same initial value const can be used. Thus, t() is a privatizable array. It is not surprising that people write code in this way, rather than initializing t() to `const' at the beginning of each iteration. The reason is twofold. First, the size of t() may be very large while the number of elements modi ed in each iteration is relatively small, thereby creating a high cost to initialize all elements of t() in each iteration. Second, when the range of t() that will be referenced in each iteration is unknown until the array is actually being written, such as the value of k in the example, it is di cult to write initialization statements prior to the references. In this case `resetting' rather than `initializing' is more straightforward and unnecessary computations can be avoided. Like the pattern of consecutively written array, privatizable array of type II re ects the dynamic nature of sparse/irregular programs. We found this access pattern in CHOLESKY and SpLU.

4 New Transformation Techniques
This section describes three transformation techniques that we found important to parallelize sparse/irregular programs1. For two reasons, we want to recognize the consecutively written array. { First, most consecutively written accesses can be statically detected. A parallelizing compiler should be able to parallelize the enclosing loop if there are no other dependences. { The knowledge that all the array elements within a section are written is important for array data ow analysis in some cases, such as the array privatization test in the following example. The array a() can be privatized if the compiler knows that a(1..k-1) is de ned before entering loop j in each iteration of loop i.
do i = 1, n k = 1 while (..) do a(k) = .. k = k+1 end while do j = 1, k-1 .. = a(j) end do end do
1

4.1 Parallelizing Loops Containing Consecutively Written Array

We do not cover the techniques for the patterns of Right-hand Side and of Premature Exit Loop with Reduction Operation. The former is trivial to handle and the latter can be parallelized by using the associative transformation 11].

To recognize a consecutively written array, we rst use the following heuristic method to nd a candidate array: 1. the array is write-only in the loop, 2. the array is always written at positions speci ed by a same induction variable, and 3. all operations on the induction variable are increments of 1, or all are decrements of 1. Then, we work on the control ow graph of the loop. We call all assignment statements of the candidate array (like S1 in Fig. 5) black nodes, and all assignments to the induction variable (like S2) grey nodes. The remaining nodes are called white nodes. The candidate array is a consecutively written array if and only if on each path between two grey nodes there is at least one black node. We can do the checking in the following way. For each grey node, we do a depth- rst search from it. The boundary of this search is black nodes. If any other grey node is found before the search nishes, then the array is not a consecutively written array and the search aborts. If the search nishes for all grey nodes, then we nd a consecutively written array. Because the working control ow graph is usually rather simple, the recognition phase is fast and can be integrated into the pass for induction variables processing in a parallelizing compiler. the elements of a consecutively written array are written in one iteration depend on the previous iteration, there is a loop-carried true dependence. We use a technique called array splitting and merging to parallelize this loop. Array splitting and merging has three phases. First, a private copy of the consecutively written array is allocated on each processor. Then, all processors work on their private copies from position 1 in parallel. After the computation, each processor knows the length of its private copy of the array; hence, the starting position in the original array for each processor can be easily calculated. Finally, the private copies are copied back (merged) to the original array. Figure 9 illustrates the idea when two processors are used.
Private Copy for Processor 1 - PA1() 31 45 62 78 .. .. 12 43

Transformation - Array Splitting and Merging. Because positions where

Original Array A()

31 45 62 78 ..

.. 12 43 54 44 23 ..

89 23 18

Private Copy for Processor 2 - PA2()

54 44 23 ..

89 23 18

Fig. 9. An Example of Array Splitting and Merging

4.2 Histogram Reduction
In this section, we discuss four techniques that can be used to parallelize histogram reduction loops: critical section, data a liated loops, array expansion, and reduction table. section, using a lock/unlock pair. The operations on di erent arrays can be executed in parallel. However, this method does not exploit the parallelism within reductions. Without fast hardware support for synchronization, critical section in many cases is not a good alternative to sequential reduction. all the iterations and checks whether the data referenced in the current iteration belongs to it. If it does, the processor executes the operation; otherwise, it skips the operation. The advantage of this approach is its potential for good cache locality when block distribution is used. The disadvantage is that this method becomes too complicated when there are several indirectly accessed arrays in the loop. Also, the overhead could be high if each iteration is relatively short.

Critical Section. We can put the accesses to shared variables in a critical

Data A liated Loops. This method shares the same idea as the owner computes rule. It partitions data instead of loop iterations. Each processor traverses

Array Expansion. In this method, each processor allocates a private copy of the whole reduction array. The parallelized loop has three phases. All the private copies are initialized to the reduction identity in the rst phase. In the second phase, each processor executes the reduction operation in its own private copy in parallel. There is no inter-processor communication in this phase. The last phase does cross-processor reduction. The following example illustrates the three phases.
real a(1:m) real pa(1:m,1:num_of_threads) // phase 1 parallel do i = 1, num_of_threads do j = 1, m pa(j,i) = reduction_identity end do end do // phase 2 parallel do i = 1, n pa(i, thread_id) = pa(i, thread_id) op expression end do

// phase 3 parallel do i = 1, m do j = 1, num_of_threads a(i) = a(i) op pa(i,j) end do end do

The method works well when almost all array elements will be updated by each processor. The biggest disadvantage of this approach, however, is having to keep multiple copies of the whole array. This not only increases the memory pressure, but also introduces high overhead. When each processor touches only a small portion of the array, working on the whole array in the rst and the last phase may hinder speedup. size is small. The private copy is used as a table. The number of entries is xed. Each entry in the table has two elds: index and value. The value of an entry is accessed by using a fast hash function of the index. Thus, this can be thought of as a hash table. We call this table the reduction table because the value of an entry is updated by some reduction operation. Figure 10 illustrates how reduction table is used. Processor 1 executes iterations 1 through 4, and Processor 2 executes 5 through 8.
do i=1, n a(k(i)) = a(k(i)) + b(i) end do
index 1 2 i k(i) 1 3 2 5 3 3 4 7 5 8 6 8 7 3 8 8 3 4 5 x hash(x) 3 4 5 5 7 3 8 2 7 3 5 0 0 b(4) b(1)+b(3) b(2) value 1 2 3 4 5 3 8 index 0 b(5)+b(6) +b(8) 0 b(7) 0 value

Reduction Table. This method also uses private memory, but the required

Reduction Table of Processor 1

Reduction Table of Processor 2

Fig. 10. An example of using reduction table
In the reduction table approach, all entries in the reduction tables are initialized to the reduction identity before entering the parallel loop. Then, each processor works on its own reduction table in parallel. Each array element is mapped to a table entry by using a hash function on the array subscript. When a reduction is to be performed, the table is looked up to nd an entry that contains the same array index or, if no such entry exists, an empty entry. If the entry is available, then reduction operation is performed on the old value in the entry with the new value. If the entry is not avaialbe, which means the table is full, the operation is performed directly on the shared array within a critical

section. After the parallel section, all entries whose values do not equal reduction identity are ushed out to the global array in critical sections. This method is a hybrid of the critical section method and the array expansion method. Like the critical section method, it ensures the atomic operation on global shared variables; and, like the expansion method, it takes advantage of reduction operation. The reduction table method does not have to keep private copies of the whole reduction array. The number of table entries can be much smaller than the number of elements in the reduction array. Only those elements that are updated in the loop are kept. This method trades hash table calculations with memory operations. It may be particularly bene cial when used with a simple, fast hash function.

4.3 Loop-pattern-aware run-time dependence test

When static analysis is too complex or the subscript arrays are functions of the input data, a run-time method becomes necessary for parallelization. Some runtime tests, as proposed in 12], use shadow arrays that have the same size as the data arrays. They check and mark every read/write operation on the array elements. This kind of run-time test would introduce high overhead on modern machines where memory access is signi cantly slower than computation. One solution is to use hardware support 14]. However in some cases, e cient software methods are available if the information of loop patterns can be used. Our run-time test is based on the loop patterns we discussed above and is applied to loops with indirectly accessed arrays. Of the four patterns, right-hand side and histogram reduction can always be handled statically. We, therefore, focus on the last two cases. Our run-time test can be thought of as run-time pattern matching. It relies on the compiler to detect the static syntactic pattern and uses the run-time test to verify variable constraints. In the case of the o set and length pattern, a run-time test would be used to check whether two array segments overlap. Thus, only the rst and last positions need to be stored, and the size of the shadow array is greatly reduced. In the case of the sparse and private pattern, the marking and analysis phases can be simpli ed because we only check the validation of privatization for these totally irregular arrays. For type I privatization, we mark the shadow array when a write occurs. The test immediately fails once we nd a shadow that is not marked when a read occurs. For type II privatization, the shadow is marked when an array element is read or written and is cleared when the element is set to a constant. If there are still some marked elements in the shadow at the end of the inspector phase, then the test fails. In the experiment on CHOLESKY, we found that our simpli ed run-time test has a run-time overhead of 20% of the parallel execution time on eight processors as compared to 120% overhead of the general run-time test. Because the new run-time test is based on the loop pattern, we call it the loop-pattern-aware run-time test. The trade-o is its conservativeness. While the general run-time test 12] can exploit almost all classes of parallelism (even partially parallelizable loop), ours may report dependence where there actually

9 8 7 6
speedup

7
Manual Polairs with H-R

6 5
speedup

Manual Polaris with H-R Polaris without H-R

Polaris without H-R

5 4 3 2 1 0 Cholesky Euler SpLU GCCG LANCZOS

4 3 2 1 0

SparAdd ProdMV ProdVM SparMul SolSys

ProdUB

(a)

(b)

Fig. 11. Speedups of Benchmark Codes
is none. However, for the codes in our benchmark suite, the loop-pattern-aware run-time test su ces.

5 Experimental Results
Preliminary experimental results are discussed in this section. We compare the speedups obtained by manually applying the new techniques with those of the current version of Polaris, with and without histogram reduction2 . The programs were executed in real-time mode on an SGI PowerChallenge with eight 195 MHz R10000 processors. Figure 11(a) shows the speedups of benchmark codes for the rst ve programs. Parallelizing Gccg and Lanczos requires no new techniques, and our current version of Polaris does quite well on these two codes. For Cholesky, Euler and SpLU, manual transformation led to good speedups. In Cholesky and SpLU, there are several innermost loops that perform very simple histogram reductions. The overhead of array expansion transformation reduction hinders the performance. However, this transformation works well on Euler, which has large granularity in its loopbodies. Speedups of the sparse matrix algebra kernels in our benchmark collection are shown in Fig. 11(b). ProvVM and ProdUB achieve speedup because of the parallel histogram reduction transformation. ProvMV is simple and Polaris handles it well. SparAdd and SparMul require the loop pattern aware run-time test and array privatization of type II. These new techniques produce speedups of
2

SGI's parallelizing compiler, PFA, produced results very similar to Polaris without histogram reduction. We, therefore, do not include its data here. The parallelization technique for histogram reduction loops currently implemented in Polaris is the array expansion method.

Table 3. Techniques Applied to Each Code
Code Techniques 1 Cholesky Associative Transformation, Loop-pattern-aware Run-time Test 2 Euler Histogram Reduction(Array Expansion) 3 Gccg trivial 4 Lanczos trivial 5 SpLU Array Splitting and Merging, Loop-pattern-aware Run-time Test 6 SparAdd Loop-pattern-aware Run-time Test 7 ProdMV trivial 8 ProdVM Histogram Reduction(Array Expansion) 9 SparMul Loop-pattern-aware Run-time Test 10 SolSys Histogram Reduction(Reduction Table) 11 ProdUB Histogram Reduction(Array Expansion)

around 6. SolSys has a DOALL loop, which Polaris recognized as a histogram reduction loop thereby causing the slow down. The techniques manually applied to each code are summarized in Table 3.

6 Related Work
To our knowledge, there are very few papers in the literature that directly address the problem of automatically detecting parallelism in sequential sparse/irregular programs. The closest work we are aware of is that of Christoph Ke ler 3]. Ke ler is investigating the generalization of his program comprehension technique to sparse matrix codes. His approach is based on pattern matching and therefore depends on the storage scheme and algorithm used by the program. By contrast, we study the loop pattern to nd the common ingredients of di erent algorithms and storage formats. Our approach is more general and even applicable to some `homemade' codes that do not follow standard algorithms. Another approach is followed by Bik and Wijsho 4]. Their solution is to generate sparse matrix programs from dense matrix programs by using their sparse compiler. Kotlyar, Pingali, and Stodghill proposed another interesting solution based on their `data-centric-compilation' concept 7]. Although both methods can be used to produce parallel sparse programs, they can not handle existing sequential sparse codes and their applicability to programs beyond matrix computation kernels is unclear.

7 Conclusion and Future Work
In this paper, we have studied the possibility of using automatic compilers to detect the parallelism of sparse/irregular programs. The experiments with our benchmarks led us to extract some common loop patterns, which can be used to

apply transformations. Three new techniques have been derived. Manual transformation using these techniques generates good speedups. More importantly, these parallelization methods can be applied automatically. Loop-pattern-aware run-time test is used to handle the case of o set and length and sparse and private in this paper. However, we nd that in some cases these patterns can be detected statically by analysis of the subscript arrays. We are currently developing techniques for this type of analysis.

References
1. Rafael Asenjo, Eladio Gutierrez, Yuan Lin, David Padua, Bill Pottenger, and Emilio Zapata. On the Automatic Parallelization of Sparse and Irregular Fortran Codes. Technical Report 1512, Univ. of Illinois at Urbana-Champaign, CSRD, Dec 1996 2. William Blume, Ramon Doallo, Rudolf Eigenmann, John Grout, Jay Hoe inger, Thomas Lawrence, Jaejin Lee, David Padua, Yunheung Paek, Bill Pottenger, Lawrence Rauchwerger, and Peng Tu. Parallel Programming with Polaris. IEEE Computer, 29(12):78{82, December 1996. 3. Christoph W. Ke ler, Applicability of Program Comprehension to Sparse Matrix Computations, In PROC of 3rd EUROPAR, Passau, German, August, 1997 4. Aart J. C. Bik and Harry A. G. Wijsho , Automatic Data Structure Selection and Transformation for sparse Matrix Computations. IEEE Trans. on Parallel and Distributed Systems, Volume 7, pages 109{126, Feb. 1996 5. Ian Foster, Rob Schreiber, and Paul Havlak. HPF-2 Scope of Activities and Motivating Applications. Technical Report CRPC-TR94492, Rice University, November, 1994 6. Harwell-Boeing Sparse Matrix Collection (Release I), Matrix Market, 7. Vladimir Kotlyar, Keshav Pingali, and Paul Stodghill. Compiling Parallel Code for Sparse Matrix Applications. In Supercomputing, November 1997 8. Zhiyuan Li, Array privatization of parallel execution of loops, In Proc. of ICS'92, pages 313-322, 1992 9. Sergio Pissanetzky, Sparse Matrix Technology, Academic Press, 1984, ISBN 0-12557580-7 10. Bill Pottenger and Rudolf Eigenmann. Idiom Recognition in the Polaris Parallelizing Compiler. Proceedings of the 9th ACM International Conference on Supercomputing, Barcelona, Spain, pages 444{448, July 1995 11. Bill Pottenger, Theory, techniques, and experiments in solving recurrences in computer programs. PhD Thesis. University of Illinois at Urbana-Champaign, IL, 1997 12. Lawrence Rauchwerger, Run-time parallelization: a framework for parallel computation. PhD Thesis. University of Illinois at Urbana-Champaign, IL, 1995 13. Peng Tu and David Padua. Automatic Array Privatization. In Proc. Sixth Workshop on Languages and Compilers for Parallel Computing, Portland, OR. Lecture Notes in Computer Science, volume 768, pages 500{521, August 12-14, 1993. 14. Ye Zhang, Lawrence Rauchwerger, and Josep Torrellas. Hardware for Speculative Run-Time Parallelization in Distributed Shared-Memory Multiprocessors. In Proc. of the 4th International Symposium on Hight-Performance Computer Architecture, 1998
http://http://math.nist.gov/MatrixMarket /collections/hb.html



热文推荐
猜你喜欢
友情链接: 幼儿教育 小学教案 初中教案 高中教案 职业教育 成人教育