|
|
| |
| # lines: |
453 | | # code: |
453 | | # comment: | 0 | |
# blank: | 0 |
| # Variables: | 45 |
| # Callers: | 1 |
| # Callings: | 4 |
| # Words: | 229 |
| # Keywords: | 115 |
|
|
|
|
|
..
.. Array Arguments ..
..
Purpose
=======
PZGEBD2 reduces a complex general M-by-N distributed matrix
sub( A ) = A(IA:IA+M-1,JA:JA+N-1) to upper or lower bidiagonal
form B by an unitary transformation: Q' * sub( A ) * P = B.
If M >= N, B is upper bidiagonal; if M < N, B is lower bidiagonal.
Notes
=====
Each global data object is described by an associated description
vector. This vector stores the information required to establish
the mapping between an object element and its corresponding process
and memory location.
Let A be a generic term for any 2D block cyclicly distributed array.
Such a global array has an associated description vector DESCA.
In the following comments, the character _ should be read as
"of the global array".
NOTATION STORED IN EXPLANATION
--------------- -------------- --------------------------------------
DTYPE_A(global) DESCA( DTYPE_ )The descriptor type. In this case,
DTYPE_A = 1.
CTXT_A (global) DESCA( CTXT_ ) The BLACS context handle, indicating
the BLACS process grid A is distribu-
ted over. The context itself is glo-
bal, but the handle (the integer
value) may vary.
M_A (global) DESCA( M_ ) The number of rows in the global
array A.
N_A (global) DESCA( N_ ) The number of columns in the global
array A.
MB_A (global) DESCA( MB_ ) The blocking factor used to distribute
the rows of the array.
NB_A (global) DESCA( NB_ ) The blocking factor used to distribute
the columns of the array.
RSRC_A (global) DESCA( RSRC_ ) The process row over which the first
row of the array A is distributed.
CSRC_A (global) DESCA( CSRC_ ) The process column over which the
first column of the array A is
distributed.
LLD_A (local) DESCA( LLD_ ) The leading dimension of the local
array. LLD_A >= MAX(1,LOCr(M_A)).
Let K be the number of rows or columns of a distributed matrix,
and assume that its process grid has dimension p x q.
LOCr( K ) denotes the number of elements of K that a process
would receive if K were distributed over the p processes of its
process column.
Similarly, LOCc( K ) denotes the number of elements of K that a
process would receive if K were distributed over the q processes of
its process row.
The values of LOCr() and LOCc() may be determined via a call to the
ScaLAPACK tool function, NUMROC:
LOCr( M ) = NUMROC( M, MB_A, MYROW, RSRC_A, NPROW ),
LOCc( N ) = NUMROC( N, NB_A, MYCOL, CSRC_A, NPCOL ).
An upper bound for these quantities may be computed by:
LOCr( M ) <= ceil( ceil(M/MB_A)/NPROW )*MB_A
LOCc( N ) <= ceil( ceil(N/NB_A)/NPCOL )*NB_A
Arguments
=========
M (global input) INTEGER
The number of rows to be operated on, i.e. the number of rows
of the distributed submatrix sub( A ). M >= 0.
N (global input) INTEGER
The number of columns to be operated on, i.e. the number of
columns of the distributed submatrix sub( A ). N >= 0.
A (local input/local output) COMPLEX*16 pointer into the
local memory to an array of dimension (LLD_A,LOCc(JA+N-1)).
On entry, this array contains the local pieces of the
general distributed matrix sub( A ). On exit, if M >= N,
the diagonal and the first superdiagonal of sub( A ) are
overwritten with the upper bidiagonal matrix B; the elements
below the diagonal, with the array TAUQ, represent the
unitary matrix Q as a product of elementary reflectors, and
the elements above the first superdiagonal, with the array
TAUP, represent the orthogonal matrix P as a product of
elementary reflectors. If M < N, the diagonal and the first
subdiagonal are overwritten with the lower bidiagonal
matrix B; the elements below the first subdiagonal, with the
array TAUQ, represent the unitary matrix Q as a product of
elementary reflectors, and the elements above the diagonal,
with the array TAUP, represent the orthogonal matrix P as a
product of elementary reflectors. See Further Details.
IA (global input) INTEGER
The row index in the global array A indicating the first
row of sub( A ).
JA (global input) INTEGER
The column index in the global array A indicating the
first column of sub( A ).
DESCA (global and local input) INTEGER array of dimension DLEN_.
The array descriptor for the distributed matrix A.
D (local output) DOUBLE PRECISION array, dimension
LOCc(JA+MIN(M,N)-1) if M >= N; LOCr(IA+MIN(M,N)-1) otherwise.
The distributed diagonal elements of the bidiagonal matrix
B: D(i) = A(i,i). D is tied to the distributed matrix A.
E (local output) DOUBLE PRECISION array, dimension
LOCr(IA+MIN(M,N)-1) if M >= N; LOCc(JA+MIN(M,N)-2) otherwise.
The distributed off-diagonal elements of the bidiagonal
distributed matrix B:
if m >= n, E(i) = A(i,i+1) for i = 1,2,...,n-1;
if m < n, E(i) = A(i+1,i) for i = 1,2,...,m-1.
E is tied to the distributed matrix A.
TAUQ (local output) COMPLEX*16 array dimension
LOCc(JA+MIN(M,N)-1). The scalar factors of the elementary
reflectors which represent the unitary matrix Q. TAUQ is
tied to the distributed matrix A. See Further Details.
TAUP (local output) COMPLEX*16 array, dimension
LOCr(IA+MIN(M,N)-1). The scalar factors of the elementary
reflectors which represent the unitary matrix P. TAUP is
tied to the distributed matrix A. See Further Details.
WORK (local workspace/local output) COMPLEX*16 array,
dimension (LWORK)
On exit, WORK(1) returns the minimal and optimal LWORK.
LWORK (local or global input) INTEGER
The dimension of the array WORK.
LWORK is local input and must be at least
LWORK >= MAX( MpA0, NqA0 )
where NB = MB_A = NB_A, IROFFA = MOD( IA-1, NB )
IAROW = INDXG2P( IA, NB, MYROW, RSRC_A, NPROW ),
IACOL = INDXG2P( JA, NB, MYCOL, CSRC_A, NPCOL ),
MpA0 = NUMROC( M+IROFFA, NB, MYROW, IAROW, NPROW ),
NqA0 = NUMROC( N+IROFFA, NB, MYCOL, IACOL, NPCOL ).
INDXG2P and NUMROC are ScaLAPACK tool functions;
MYROW, MYCOL, NPROW and NPCOL can be determined by calling
the subroutine BLACS_GRIDINFO.
If LWORK = -1, then LWORK is global input and a workspace
query is assumed; the routine only calculates the minimum
and optimal size for all work arrays. Each of these
values is returned in the first entry of the corresponding
work array, and no error message is issued by PXERBLA.
INFO (local output) INTEGER
= 0: successful exit
< 0: If the i-th argument is an array and the j-entry had
an illegal value, then INFO = -(i*100+j), if the i-th
argument is a scalar and had an illegal value, then
INFO = -i.
Further Details
===============
The matrices Q and P are represented as products of elementary
reflectors:
If m >= n,
Q = H(1) H(2) . . . H(n) and P = G(1) G(2) . . . G(n-1)
Each H(i) and G(i) has the form:
H(i) = I - tauq * v * v' and G(i) = I - taup * u * u'
where tauq and taup are complex scalars, and v and u are complex
vectors;
v(1:i-1) = 0, v(i) = 1, and v(i+1:m) is stored on exit in
A(ia+i:ia+m-1,ja+i-1);
u(1:i) = 0, u(i+1) = 1, and u(i+2:n) is stored on exit in
A(ia+i-1,ja+i+1:ja+n-1);
tauq is stored in TAUQ(ja+i-1) and taup in TAUP(ia+i-1).
If m < n,
Q = H(1) H(2) . . . H(m-1) and P = G(1) G(2) . . . G(m)
Each H(i) and G(i) has the form:
H(i) = I - tauq * v * v' and G(i) = I - taup * u * u'
where tauq and taup are complex scalars, and v and u are complex
vectors;
v(1:i) = 0, v(i+1) = 1, and v(i+2:m) is stored on exit in
A(ia+i+1:ia+m-1,ja+i-1);
u(1:i-1) = 0, u(i) = 1, and u(i+1:n) is stored on exit in
A(ia+i-1,ja+i:ja+n-1);
tauq is stored in TAUQ(ja+i-1) and taup in TAUP(ia+i-1).
The contents of sub( A ) on exit are illustrated by the following
examples:
m = 6 and n = 5 (m > n): m = 5 and n = 6 (m < n):
( d e u1 u1 u1 ) ( d u1 u1 u1 u1 u1 )
( v1 d e u2 u2 ) ( e d u2 u2 u2 u2 )
( v1 v2 d e u3 ) ( v1 e d u3 u3 u3 )
( v1 v2 v3 d e ) ( v1 v2 e d u4 u4 )
( v1 v2 v3 v4 d ) ( v1 v2 v3 e d u5 )
( v1 v2 v3 v4 v5 )
where d and e denote diagonal and off-diagonal elements of B, vi
denotes an element of the vector defining H(i), and ui an element of
the vector defining G(i).
Alignment requirements
======================
The distributed submatrix sub( A ) must verify some alignment proper-
ties, namely the following expressions should be true:
( MB_A.EQ.NB_A .AND. IROFFA.EQ.ICOFFA )
=====================================================================
.. Parameters ..
|
|
|
|
001 SUBROUTINE PZGEBD2( M , N , A , IA , JA , DESCA , D , E , TAUQ , TAUP ,
002 $WORK , LWORK , INFO )
003
004 * -- ScaLAPACK auxiliary routine(version 1.7) --
005 * University of Tennessee , Knoxville , Oak Ridge National Laboratory ,
006 * and University of California , Berkeley.
007 * May 1 , 1997
008
009 * .. Scalar Arguments ..
010 INTEGER IA , INFO , JA , LWORK , M , N
011 INTEGER BLOCK_CYCLIC_2D , CSRC_ , CTXT_ , DLEN_ , DTYPE_ ,
012 $LLD_ , MB_ , M_ , NB_ , N_ , RSRC_
013 PARAMETER( BLOCK_CYCLIC_2D = 1 , DLEN_ = 9 , DTYPE_ = 1 ,
014 $CTXT_ = 2 , M_ = 3 , N_ = 4 , MB_ = 5 , NB_ = 6 ,
015 $RSRC_ = 7 , CSRC_ = 8 , LLD_ = 9 )
016 COMPLEX*16 ONE , ZERO
017 PARAMETER( ONE =( 1.0D + 0 , 0.0D + 0 ) ,
018 $ZERO =( 0.0D + 0 , 0.0D + 0 ) )
019 * ..
020 * .. Local Scalars ..
021 LOGICAL LQUERY
022 INTEGER I , IACOL , IAROW , ICOFFA , ICTXT , II , IROFFA , J ,
023 $JJ , K , LWMIN , MPA0 , MYCOL , MYROW , NPCOL , NPROW ,
024 $NQA0
025 COMPLEX*16 ALPHA
026 * ..
027 * .. Local Arrays ..
028 INTEGER DESCD( DLEN_ ) , DESCE( DLEN_ )
029 * ..
030 * .. External Subroutines ..
031 EXTERNAL BLACS_ABORT , BLACS_GRIDINFO , CHK1MAT , DESCSET ,
032 $DGEBR2D , DGEBS2D , INFOG2L , PXERBLA ,
033 $PDELSET , PZELSET , PZLACGV , PZLARF ,
034 $PZLARFC , PZLARFG , ZGEBR2D , ZGEBS2D ,
035 $ZLARFG
036 * ..
037 * .. External Functions ..
038 INTEGER INDXG2P , NUMROC
039 EXTERNAL INDXG2P , NUMROC
040 * ..
041 * .. Intrinsic Functions ..
042 INTRINSIC DBLE , DCMPLX , MAX , MIN , MOD
043 * ..
044 * .. Executable Statements ..
045
046 * Test the input parameters
047
048 ICTXT = DESCA( CTXT_ )
049 CALL BLACS_GRIDINFO( ICTXT , NPROW , NPCOL , MYROW , MYCOL )
050
051 * Test the input parameters
052
053 INFO = 0
054 IF( NPROW.EQ. - 1 ) THEN
054  
055 INFO = - (600 + CTXT_)
056 ELSE
056
057 CALL CHK1MAT( M , 1 , N , 2 , IA , JA , DESCA , 6 , INFO )
058 IF( INFO.EQ.0 ) THEN
058
059 IROFFA = MOD( IA - 1 , DESCA( MB_ ) )
060 ICOFFA = MOD( JA - 1 , DESCA( NB_ ) )
061 IAROW = INDXG2P( IA , DESCA( MB_ ) , MYROW , DESCA( RSRC_ ) ,
062 $ NPROW )
063 IACOL = INDXG2P( JA , DESCA( NB_ ) , MYCOL , DESCA( CSRC_ ) ,
064 $ NPCOL )
065 MPA0 = NUMROC( M + IROFFA , DESCA( MB_ ) , MYROW , IAROW , NPROW )
066 NQA0 = NUMROC( N + ICOFFA , DESCA( NB_ ) , MYCOL , IACOL , NPCOL )
067 LWMIN = MAX( MPA0 , NQA0 )
068
069 WORK( 1 ) = DCMPLX( DBLE( LWMIN ) )
070 LQUERY =( LWORK.EQ. - 1 )
071 IF( IROFFA.NE.ICOFFA ) THEN
071
072 INFO = - 5
073 ELSE IF( DESCA( MB_ ).NE.DESCA( NB_ ) ) THEN
073
074 INFO = - (600 + NB_)
075 ELSE IF( LWORK.LT.LWMIN .AND. .NOT.LQUERY ) THEN
075
076 INFO = - 12
077 END IF
078 END IF
079 END IF
080
081 IF( INFO.LT.0 ) THEN
081
082 CALL PXERBLA( ICTXT , 'PZGEBD2' , - INFO )
083 CALL BLACS_ABORT( ICTXT , 1 )
084 RETURN
085 ELSE IF( LQUERY ) THEN
085
086 RETURN
087 END IF
088
089 CALL INFOG2L( IA , JA , DESCA , NPROW , NPCOL , MYROW , MYCOL , II , JJ ,
090 $IAROW , IACOL )
091
092 IF( M.EQ.1 .AND. N.EQ.1 ) THEN
092
093 IF( MYCOL.EQ.IACOL ) THEN
093
094 IF( MYROW.EQ.IAROW ) THEN
094
095 I = II + (JJ - 1)*DESCA( LLD_ )
096 CALL ZLARFG( 1 , A( I ) , A( I ) , 1 , TAUQ( JJ ) )
097 D( JJ ) = DBLE( A( I ) )
098 CALL DGEBS2D( ICTXT , 'Columnwise' , ' ' , 1 , 1 , D( JJ ) ,
099 $ 1 )
100 CALL ZGEBS2D( ICTXT , 'Columnwise' , ' ' , 1 , 1 , TAUQ( JJ ) ,
101 $ 1 )
102 ELSE
102
103 CALL DGEBR2D( ICTXT , 'Columnwise' , ' ' , 1 , 1 , D( JJ ) ,
104 $ 1 , IAROW , IACOL )
105 CALL ZGEBR2D( ICTXT , 'Columnwise' , ' ' , 1 , 1 , TAUQ( JJ ) ,
106 $ 1 , IAROW , IACOL )
107 END IF
108 END IF
109 IF( MYROW.EQ.IAROW )
109
110 $ TAUP( II ) = ZERO
111 RETURN
112 END IF
113
114 ALPHA = ZERO
115
116 IF( M.GE.N ) THEN
117
118 * Reduce to upper bidiagonal form
119
119
120 CALL DESCSET( DESCD , 1 , JA + MIN(M , N) - 1 , 1 , DESCA( NB_ ) , MYROW ,
121 $ DESCA( CSRC_ ) , DESCA( CTXT_ ) , 1 )
122 CALL DESCSET( DESCE , IA + MIN(M , N) - 1 , 1 , DESCA( MB_ ) , 1 ,
123 $ DESCA( RSRC_ ) , MYCOL , DESCA( CTXT_ ) ,
124 $ DESCA( LLD_ ) )
125 DO 10 K = 1 , N
125
126 I = IA + K - 1
127 J = JA + K - 1
128
129 * Generate elementary reflector H(j) to annihilate
130 * A(ia + i : ia + m - 1 , j)
131
132 CALL PZLARFG ( M - K + 1 , ALPHA , I , J , A , MIN( I + 1 , M + IA - 1 ) ,
133 $ J , DESCA , 1 , TAUQ )
134 CALL PDELSET( D , 1 , J , DESCD , DBLE( ALPHA ) )
135 CALL PZELSET( A , I , J , DESCA , ONE )
136
137 * Apply H(i) to A(i : ia + m - 1 , i + 1 : ja + n - 1) from the left
138
139 CALL PZLARFC ( 'Left' , M - K + 1 , N - K , A , I , J , DESCA , 1 , TAUQ ,
140 $ A , I , J + 1 , DESCA , WORK )
141 CALL PZELSET( A , I , J , DESCA , DCMPLX( DBLE( ALPHA ) ) )
142
143 IF( K.LT.N ) THEN
144
145 * Generate elementary reflector G(i) to annihilate
146 * A(i , ja + j + 1 : ja + n - 1)
147
147
148 CALL PZLACGV ( N - K , A , I , J + 1 , DESCA , DESCA( M_ ) )
149 CALL PZLARFG ( N - K , ALPHA , I , J + 1 , A , I ,
150 $ MIN( J + 2 , JA + N - 1 ) , DESCA , DESCA( M_ ) ,
151 $ TAUP )
152 CALL PDELSET( E , I , 1 , DESCE , DBLE( ALPHA ) )
153 CALL PZELSET( A , I , J + 1 , DESCA , ONE )
154
155 * Apply G(i) to A(i + 1 : ia + m - 1 , i + 1 : ja + n - 1) from the right
156
157 CALL PZLARF ( 'Right' , M - K , N - K , A , I , J + 1 , DESCA ,
158 $ DESCA( M_ ) , TAUP , A , I + 1 , J + 1 , DESCA ,
159 $ WORK )
160 CALL PZELSET( A , I , J + 1 , DESCA , DCMPLX( DBLE( ALPHA ) ) )
161 CALL PZLACGV ( N - K , A , I , J + 1 , DESCA , DESCA( M_ ) )
162 ELSE
162
163 CALL PZELSET( TAUP , I , 1 , DESCE , ZERO )
164 END IF
165 10 CONTINUE
166
166
167 ELSE
168
169 * Reduce to lower bidiagonal form
170
170
171 CALL DESCSET( DESCD , IA + MIN(M , N) - 1 , 1 , DESCA( MB_ ) , 1 ,
172 $ DESCA( RSRC_ ) , MYCOL , DESCA( CTXT_ ) ,
173 $ DESCA( LLD_ ) )
174 CALL DESCSET( DESCE , 1 , JA + MIN(M , N) - 1 , 1 , DESCA( NB_ ) , MYROW ,
175 $ DESCA( CSRC_ ) , DESCA( CTXT_ ) , 1 )
176 DO 20 K = 1 , M
176
177 I = IA + K - 1
178 J = JA + K - 1
179
180 * Generate elementary reflector G(i) to annihilate
181 * A(i , ja + j : ja + n - 1)
182
183 CALL PZLACGV ( N - K + 1 , A , I , J , DESCA , DESCA( M_ ) )
184 CALL PZLARFG ( N - K + 1 , ALPHA , I , J , A , I ,
185 $ MIN( J + 1 , JA + N - 1 ) , DESCA , DESCA( M_ ) , TAUP )
186 CALL PDELSET( D , I , 1 , DESCD , DBLE( ALPHA ) )
187 CALL PZELSET( A , I , J , DESCA , ONE )
188
189 * Apply G(i) to A(i : ia + m - 1 , j : ja + n - 1) from the right
190
191 CALL PZLARF ( 'Right' , M - K , N - K + 1 , A , I , J , DESCA ,
192 $ DESCA( M_ ) , TAUP , A , MIN( I + 1 , IA + M - 1 ) , J ,
193 $ DESCA , WORK )
194 CALL PZELSET( A , I , J , DESCA , DCMPLX( DBLE( ALPHA ) ) )
195 CALL PZLACGV ( N - K + 1 , A , I , J , DESCA , DESCA( M_ ) )
196
197 IF( K.LT.M ) THEN
198
199 * Generate elementary reflector H(i) to annihilate
200 * A(i + 2 : ia + m - 1 , j)
201
201
202 CALL PZLARFG ( M - K , ALPHA , I + 1 , J , A ,
203 $ MIN( I + 2 , IA + M - 1 ) , J , DESCA , 1 , TAUQ )
204 CALL PDELSET( E , 1 , J , DESCE , DBLE( ALPHA ) )
205 CALL PZELSET( A , I + 1 , J , DESCA , ONE )
206
207 * Apply H(i) to A(i + 1 : ia + m - 1 , j + 1 : ja + n - 1) from the left
208
209 CALL PZLARFC ( 'Left' , M - K , N - K , A , I + 1 , J , DESCA , 1 ,
210 $ TAUQ , A , I + 1 , J + 1 , DESCA , WORK )
211 CALL PZELSET( A , I + 1 , J , DESCA , DCMPLX( DBLE( ALPHA ) ) )
212 ELSE
212
213 CALL PZELSET( TAUQ , 1 , J , DESCE , ZERO )
214 END IF
215 20 CONTINUE
215
216 END IF
217
218 WORK( 1 ) = DCMPLX( DBLE( LWMIN ) )
219
220 RETURN
221
222 * End of PZGEBD2
223
224 END39
23
|
|
Variables in Routine PZGEBD2()
| Summary Report |
| Data Type | Quantity | Size(byte) |
| COMPLEX*16 | 3 | ? |
| INTEGER | 38 | 152 |
| LOGICAL | 1 | 1 |
| REAL | 3 | 12 |
| TOTAL | 45 | 165 |
List of Variables
COMPLEX*16
INTEGER
| BLOCK_CYCLIC_2D | CSRC_ | CTXT_ | DESCD( DLEN_ ) | DESCE( DLEN_ ) |
| DLEN_ | DTYPE_ | I | IA | IACOL |
| IAROW | ICOFFA | ICTXT | II | INDXG2P |
| INFO | IROFFA | J | JA | JJ |
| K | LLD_ | LWMIN | LWORK | M |
| M_ | MB_ | MPA0 | MYCOL | MYROW |
| N | N_ | NB_ | NPCOL | NPROW |
| NQA0 | NUMROC | RSRC_ | | |
LOGICAL
REAL
Variables Dependence Graph
Put the mouse over a right hand side variable to display the corresponding line of the dependence | | - | | - | - | | ALPHA | <--- | ZEROALPHA = ZERO |
| D | <--- | ID( JJ ) = DBLE( A( I ) ) |
| I | <--- | IAI = IA + K - 1{2I = IA + K - 1}, III = II+(JJ-1)*DESCA( LLD_ ), JJI = II+(JJ-1)*DESCA( LLD_ ), KI = IA + K - 1{2I = IA + K - 1}, LLD_I = II+(JJ-1)*DESCA( LLD_ ) |
| IACOL | <--- | INDXG2PIACOL = INDXG2P( JA, DESCA( NB_ ), MYCOL, DESCA( CSRC_ ),, JAIACOL = INDXG2P( JA, DESCA( NB_ ), MYCOL, DESCA( CSRC_ ),, CSRC_IACOL = INDXG2P( JA, DESCA( NB_ ), MYCOL, DESCA( CSRC_ ),, MYCOLIACOL = INDXG2P( JA, DESCA( NB_ ), MYCOL, DESCA( CSRC_ ),, NB_IACOL = INDXG2P( JA, DESCA( NB_ ), MYCOL, DESCA( CSRC_ ),, NPCOLIACOL = INDXG2P( JA, DESCA( NB_ ), MYCOL, DESCA( CSRC_ ), |
| IAROW | <--- | IAIAROW = INDXG2P( IA, DESCA( MB_ ), MYROW, DESCA( RSRC_ ),, INDXG2PIAROW = INDXG2P( IA, DESCA( MB_ ), MYROW, DESCA( RSRC_ ),, MB_IAROW = INDXG2P( IA, DESCA( MB_ ), MYROW, DESCA( RSRC_ ),, MYROWIAROW = INDXG2P( IA, DESCA( MB_ ), MYROW, DESCA( RSRC_ ),, NPROWIAROW = INDXG2P( IA, DESCA( MB_ ), MYROW, DESCA( RSRC_ ),, RSRC_IAROW = INDXG2P( IA, DESCA( MB_ ), MYROW, DESCA( RSRC_ ), |
| ICOFFA | <--- | JAICOFFA = MOD( JA-1, DESCA( NB_ ) ), NB_ICOFFA = MOD( JA-1, DESCA( NB_ ) ) |
| ICTXT | <--- | CTXT_ICTXT = DESCA( CTXT_ ) |
| INFO | <--- | NB_INFO = -(600+NB_), CTXT_INFO = -(600+CTXT_) |
| IROFFA | <--- | IAIROFFA = MOD( IA-1, DESCA( MB_ ) ), MB_IROFFA = MOD( IA-1, DESCA( MB_ ) ) |
| J | <--- | JAJ = JA + K - 1{2J = JA + K - 1}, KJ = JA + K - 1{2J = JA + K - 1} |
| K | <--- | MDO 20 K = 1, M, NDO 10 K = 1, N |
| LWMIN | <--- | MPA0LWMIN = MAX( MPA0, NQA0 ), NQA0LWMIN = MAX( MPA0, NQA0 ) |
| MPA0 | <--- | IAROWMPA0 = NUMROC( M+IROFFA, DESCA( MB_ ), MYROW, IAROW, NPROW ), IROFFAMPA0 = NUMROC( M+IROFFA, DESCA( MB_ ), MYROW, IAROW, NPROW ), MMPA0 = NUMROC( M+IROFFA, DESCA( MB_ ), MYROW, IAROW, NPROW ), MB_MPA0 = NUMROC( M+IROFFA, DESCA( MB_ ), MYROW, IAROW, NPROW ), MYROWMPA0 = NUMROC( M+IROFFA, DESCA( MB_ ), MYROW, IAROW, NPROW ), NPROWMPA0 = NUMROC( M+IROFFA, DESCA( MB_ ), MYROW, IAROW, NPROW ), NUMROCMPA0 = NUMROC( M+IROFFA, DESCA( MB_ ), MYROW, IAROW, NPROW ) |
| NQA0 | <--- | IACOLNQA0 = NUMROC( N+ICOFFA, DESCA( NB_ ), MYCOL, IACOL, NPCOL ), ICOFFANQA0 = NUMROC( N+ICOFFA, DESCA( NB_ ), MYCOL, IACOL, NPCOL ), MYCOLNQA0 = NUMROC( N+ICOFFA, DESCA( NB_ ), MYCOL, IACOL, NPCOL ), NNQA0 = NUMROC( N+ICOFFA, DESCA( NB_ ), MYCOL, IACOL, NPCOL ), NB_NQA0 = NUMROC( N+ICOFFA, DESCA( NB_ ), MYCOL, IACOL, NPCOL ), NPCOLNQA0 = NUMROC( N+ICOFFA, DESCA( NB_ ), MYCOL, IACOL, NPCOL ), NUMROCNQA0 = NUMROC( N+ICOFFA, DESCA( NB_ ), MYCOL, IACOL, NPCOL ) |
| WORK | <--- | LWMINWORK( 1 ) = DCMPLX( DBLE( LWMIN ) ){2WORK( 1 ) = DCMPLX( DBLE( LWMIN ) )} |
|
|
Analysis elements of the routine PZGEBD2()
Put the mouse over each element to display detailed matching information
 Assigned variables |
| | | ALPHA , BLOCK_CYCLIC_2D , CSRC_ , CTXT_ , DLEN_ , DTYPE_ , I , IACOL , IAROW , ICOFFA , ICTXT , II , INFO , IROFFA , J , JJ , K , LLD_ , LQUERY , LWMIN , M_ , MB_ , MPA0 , N_ , NB_ , NQA0 , ONE , RSRC_ , WORK , ZERO |
|
| Active variables |
| | | A , ALPHA , BLOCK_CYCLIC_2D , CSRC_ , CTXT_ , D , DESCA , DESCD , DESCE , DLEN_ , DTYPE_ , E , I , IA , IACOL , IAROW , ICOFFA , ICTXT , II , INDXG2P , INFO , IROFFA , J , JA , JJ , K , LLD_ , LQUERY , LWMIN , LWORK , M , M_ , MB_ , MPA0 , MYCOL , MYROW , N , N_ , NB_ , NPCOL , NPROW , NQA0 , NUMROC , ONE , RSRC_ , TAUP , TAUQ , WORK , ZERO |
|
| Accessed arrays [ array name : associated index ] |
| |  A | : I , I , i,ja+j:ja+n-1 , i,ja+j+1:ja+n-1 , i:ia+m-1,i+1:ja+n-1 , i:ia+m-1,j:ja+n-1 , i+1:ia+m-1,i+1:ja+n-1 , i+1:ia+m-1,j+1:ja+n-1 , i+2:ia+m-1,j , ia+i:ia+m-1,j |
| | D | : JJ , JJ , JJ |
| | DESCA | : CSRC_ , CSRC_ , CSRC_ , CTXT_ , CTXT_ , CTXT_ , CTXT_ , CTXT_ , LLD_ , LLD_ , LLD_ , M_ , M_ , M_ , M_ , M_ , M_ , M_ , M_ , MB_ , MB_ , MB_ , MB_ , MB_ , MB_ , NB_ , NB_ , NB_ , NB_ , NB_ , NB_ , RSRC_ , RSRC_ , RSRC_ |
| | DESCD | : DLEN_ |
| | DESCE | : DLEN_ |
| | NUMROC | : M+IROFFA, DESCA( MB_ ), MYROW, IAROW, NPROW , N+ICOFFA, DESCA( NB_ ), MYCOL, IACOL, NPCOL |
| | TAUP | : II |
| | TAUQ | : JJ , JJ , JJ |
| | WORK | : 1 , 1 |
|
| Conditional statements [ statement : associated predicate ] |
| | do | : ( 10 K = 1 , N ) , ( 20 K = 1 , M ) |
| | if | : ( NPROW.EQ. - 1 ) , ( INFO.EQ.0 ) , ( IROFFA.NE.ICOFFA ) , ( (DESCA( MB_ ).NE.DESCA( NB_ ) ) ) , ( LWORK.LT.LWMIN .AND. .NOT.LQUERY ) , ( INFO.LT.0 ) , ( LQUERY ) , ( M.EQ.1 .AND. N.EQ.1 ) , ( MYCOL.EQ.IACOL ) , ( MYROW.EQ.IAROW ) , ( MYROW.EQ.IAROW ) , ( M.GE.N ) , ( K.LT.N ) , ( K.LT.M ) |
|
| List of variables |
ALPHA
BLOCK_CYCLIC_2D
CSRC_
CTXT_
D
DESCD( DLEN_ )
DESCE( DLEN_ )
| DLEN_
DTYPE_
I
IA
IACOL
IAROW
ICOFFA
ICTXT
| II
INDXG2P
INFO
IROFFA
J
JA
JJ
K
| LLD_
LQUERY
LWMIN
LWORK
M
M_
MB_
MPA0
| MYCOL
MYROW
N
N_
NB_
NPCOL
NPROW
NQA0
| NUMROC
ONE
RSRC_
TAUP
WORK
ZERO | | close
| |
ALPHA
BLOCK_CYCLIC_2D
CSRC_
CTXT_
D
DESCD( DLEN_ )
DESCE( DLEN_ )
DLEN_
DTYPE_
I
IA
IACOL
IAROW
ICOFFA
ICTXT
II
INDXG2P
INFO
IROFFA
J
JA
JJ
K
LLD_
LQUERY
LWMIN
LWORK
M
M_
MB_
MPA0
MYCOL
MYROW
N
N_
NB_
NPCOL
NPROW
NQA0
NUMROC
ONE
RSRC_
TAUP
WORK
ZERO
534#533#512#531
| |
