Routine PZMAX1() Documented By Universal Report

Routine: PZMAX1()

# lines:	358
# code:	358
# comment:	0
# blank:	0
# Variables:	44
# Callers:	1
# Callings:	0
# Words:	175
# Keywords:	110

..
     .. Array Arguments ..
     ..
  Purpose
  =======
  PZMAX1 computes the global index of the maximum element in absolute
  value of a distributed vector sub( X ). The global index is returned
  in INDX and the value is returned in AMAX,
  where sub( X ) denotes X(IX:IX+N-1,JX) if INCX = 1,
                         X(IX,JX:JX+N-1) if INCX = M_X.
  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
  Because vectors may be viewed as a subclass of matrices, a
  distributed vector is considered to be a distributed matrix.
  When the result of a vector-oriented PBLAS call is a scalar, it will
  be made available only within the scope which owns the vector(s)
  being operated on.  Let X be a generic term for the input vector(s).
  Then, the processes which receive the answer will be (note that if
  an operation involves more than one vector, the processes which re-
  ceive the result will be the union of the following calculation for
  each vector):
  If N = 1, M_X = 1 and INCX = 1, then one can't determine if a process
  row or process column owns the vector operand, therefore only the
  process of coordinate {RSRC_X, CSRC_X} receives the result;
  If INCX = M_X, then sub( X ) is a vector distributed over a process
  row. Each process part of this row receives the result;
  If INCX = 1, then sub( X ) is a vector distributed over a process
  column. Each process part of this column receives the result;
  Based on PZAMAX from Level 1 PBLAS. The change is to use the
  'genuine' absolute value.
  The serial version was contributed to LAPACK by Nick Higham for use
  with ZLACON.
  Arguments
  =========
  N       (global input) pointer to INTEGER
          The number of components of the distributed vector sub( X ).
          N >= 0.
  AMAX    (global output) pointer to DOUBLE PRECISION
          The absolute value of the largest entry of the distributed
          vector sub( X ) only in the scope of sub( X ).
  INDX    (global output) pointer to INTEGER
          The global index of the element of the distributed vector
          sub( X ) whose real part has maximum absolute value.
  X       (local input) COMPLEX*16 array containing the local
          pieces of a distributed matrix of dimension of at least
              ( (JX-1)*M_X + IX + ( N - 1 )*abs( INCX ) )
          This array contains the entries of the distributed vector
          sub( X ).
  IX      (global input) INTEGER
          The row index in the global array X indicating the first
          row of sub( X ).
  JX      (global input) INTEGER
          The column index in the global array X indicating the
          first column of sub( X ).
  DESCX   (global and local input) INTEGER array of dimension DLEN_.
          The array descriptor for the distributed matrix X.
  INCX    (global input) INTEGER
          The global increment for the elements of X. Only two values
          of INCX are supported in this version, namely 1 and M_X.
          INCX must not be zero.
  =====================================================================
     .. Parameters ..

Display dynamic version

FontSize: - +

001        SUBROUTINE PZMAX1( N , AMAX , INDX , X , IX , JX , DESCX , INCX )
002  
003  *     -- ScaLAPACK auxiliary routine(version 1.7) --
004  *     University of Tennessee , Knoxville , Oak Ridge National Laboratory ,
005  *     and University of California , Berkeley.
006  *     May 1 , 1997
007  
008  *     .. Scalar Arguments ..
009        INTEGER INDX , INCX , IX , JX , N
010        COMPLEX*16 AMAX
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 ZERO
017        PARAMETER( ZERO =( 0.0D + 0 , 0.0D + 0 ) )
018  *     ..
019  *     .. Local Scalars ..
020        CHARACTER CBTOP , CCTOP , RBTOP , RCTOP
021        INTEGER ICOFF , ICTXT , IDUMM , IIX , IROFF , IXCOL , IXROW ,
022       $JJX , LCINDX , LDX , MAXPOS , MYCOL , MYROW , NP ,
023       $NPCOL , NPROW , NQ
024  *     ..
025  *     .. Local Arrays ..
026        COMPLEX*16 WORK( 2 )
027  *     ..
028  *     .. External Subroutines ..
029        EXTERNAL BLACS_GRIDINFO , IGEBR2D , IGEBS2D , INFOG2L ,
030       $PB_TOPGET , PZTREECOMB , ZCOMBAMAX1 , ZGAMX2D
031  *     ..
032  *     .. External Functions ..
033        LOGICAL LSAME
034        INTEGER IZMAX1 , INDXL2G , NUMROC
035        EXTERNAL IZMAX1 , INDXL2G , NUMROC
036  *     ..
037  *     .. Intrinsic Functions ..
038        INTRINSIC ABS , DBLE , DCMPLX , MOD , NINT
039  *     ..
040  *     .. Executable Statements ..
041  
042  *     Get grid parameters
043  
044        ICTXT = DESCX( CTXT_ )
045        CALL BLACS_GRIDINFO( ICTXT , NPROW , NPCOL , MYROW , MYCOL )
046  
047  *     Quick return if possible.
048  
049        INDX = 0
050        AMAX = ZERO
051        IF( N.LE.0 )
051               
052       $    RETURN
053  
054  *         Retrieve local information for vector X.
055  
056            LDX = DESCX( LLD_ )
057            CALL INFOG2L( IX , JX , DESCX , NPROW , NPCOL , MYROW , MYCOL , IIX , JJX ,
058       $    IXROW , IXCOL )
059  
060            IF( INCX.EQ.1 .AND. DESCX( M_ ).EQ.1 .AND. N.EQ.1 ) THEN
060                   
061                INDX = JX
062                AMAX = X( IIX + (JJX - 1)*LDX )
063                RETURN
064            END IF
065  
066  *         Find the maximum value and its index
067  
068            IF( INCX.EQ.DESCX( M_ ) ) THEN
069  
069                   
070                IF( MYROW.EQ.IXROW ) THEN
071  
071                       
072                    ICOFF = MOD( JX - 1 , DESCX( NB_ ) )
073                    NQ = NUMROC( N + ICOFF , DESCX( NB_ ) , MYCOL , IXCOL , NPCOL )
074                    IF( MYCOL.EQ.IXCOL )
074                           
075       $                NQ = NQ - ICOFF
076  
077                        CALL PB_TOPGET( ICTXT , 'Broadcast' , 'Rowwise' , RBTOP )
078  
079                        IF( LSAME( RBTOP , ' ' ) ) THEN
080  
080                               
081                            IF( NQ.GT.0 ) THEN
081                                   
082                                LCINDX = JJX - 1 + IZMAX1( NQ , X( IIX + (JJX - 1)*LDX ) , LDX )
083                                WORK( 1 ) = X( IIX + (LCINDX - 1)*LDX )
084                                WORK( 2 ) = DCMPLX( DBLE( INDXL2G( LCINDX ,
085       $                        DESCX( NB_ ) , MYCOL , DESCX( CSRC_ ) , NPCOL ) ) )
086                            ELSE
086                                   
087                                WORK( 1 ) = ZERO
088                                WORK( 2 ) = ZERO
089                            END IF
090  
091                            CALL PZTREECOMB( ICTXT , 'Row' , 2 , WORK , - 1 , MYCOL ,
092       $                    ZCOMBAMAX1 )
093  
094                            AMAX = WORK( 1 )
095                            IF( AMAX.EQ.ZERO ) THEN
095                                   
096                                INDX = JX
097                            ELSE
097                                   
098                                INDX = NINT( DBLE( WORK( 2 ) ) )
099                            END IF
100  
101                        ELSE
102  
102                               
103                            CALL PB_TOPGET( ICTXT , 'Combine' , 'Rowwise' , RCTOP )
104  
105                            IF( NQ.GT.0 ) THEN
105                                   
106                                LCINDX = JJX - 1 + IZMAX1( NQ , X( IIX + (JJX - 1)*LDX ) , LDX )
107                                AMAX = X( IIX + (LCINDX - 1)*LDX )
108                            ELSE
108                                   
109                                AMAX = ZERO
110                            END IF
111  
112  *                         Find the maximum value
113  
114                            CALL ZGAMX2D( ICTXT , 'Rowwise' , RCTOP , 1 , 1 , AMAX , 1 ,
115       $                    IDUMM , MAXPOS , 1 , - 1 , MYROW )
116  
117                            IF( AMAX.NE.ZERO ) THEN
118  
119  *                             Broadcast corresponding global index
120  
120                                   
121                                IF( MYCOL.EQ.MAXPOS ) THEN
121                                       
122                                    INDX = INDXL2G( LCINDX , DESCX( NB_ ) , MYCOL ,
123       $                            DESCX( CSRC_ ) , NPCOL )
124                                    CALL IGEBS2D( ICTXT , 'Rowwise' , RBTOP , 1 , 1 , INDX ,
125       $                            1 )
126                                ELSE
126                                       
127                                    CALL IGEBR2D( ICTXT , 'Rowwise' , RBTOP , 1 , 1 , INDX ,
128       $                            1 , MYROW , MAXPOS )
129                                END IF
130  
131                            ELSE
132  
132                                   
133                                INDX = JX
134  
135                            END IF
136  
137                        END IF
138  
139                    END IF
140  
141                ELSE
142  
142                       
143                    IF( MYCOL.EQ.IXCOL ) THEN
144  
144                           
145                        IROFF = MOD( IX - 1 , DESCX( MB_ ) )
146                        NP = NUMROC( N + IROFF , DESCX( MB_ ) , MYROW , IXROW , NPROW )
147                        IF( MYROW.EQ.IXROW )
147                               
148       $                    NP = NP - IROFF
149  
150                            CALL PB_TOPGET( ICTXT , 'Broadcast' , 'Columnwise' , CBTOP )
151  
152                            IF( LSAME( CBTOP , ' ' ) ) THEN
153  
153                                   
154                                IF( NP.GT.0 ) THEN
154                                       
155                                    LCINDX = IIX - 1 + IZMAX1( NP , X( IIX + (JJX - 1)*LDX ) , 1 )
156                                    WORK( 1 ) = X( LCINDX + (JJX - 1)*LDX )
157                                    WORK( 2 ) = DCMPLX( DBLE( INDXL2G( LCINDX ,
158       $                            DESCX( MB_ ) , MYROW , DESCX( RSRC_ ) , NPROW ) ) )
159                                ELSE
159                                       
160                                    WORK( 1 ) = ZERO
161                                    WORK( 2 ) = ZERO
162                                END IF
163  
164                                CALL PZTREECOMB( ICTXT , 'Column' , 2 , WORK , - 1 , MYCOL ,
165       $                        ZCOMBAMAX1 )
166  
167                                AMAX = WORK( 1 )
168                                IF( AMAX.EQ.ZERO ) THEN
168                                       
169                                    INDX = IX
170                                ELSE
170                                       
171                                    INDX = NINT( DBLE( WORK( 2 ) ) )
172                                END IF
173  
174                            ELSE
175  
175                                   
176                                CALL PB_TOPGET( ICTXT , 'Combine' , 'Columnwise' , CCTOP )
177  
178                                IF( NP.GT.0 ) THEN
178                                       
179                                    LCINDX = IIX - 1 + IZMAX1( NP , X( IIX + (JJX - 1)*LDX ) , 1 )
180                                    AMAX = X( LCINDX + (JJX - 1)*LDX )
181                                ELSE
181                                       
182                                    AMAX = ZERO
183                                END IF
184  
185  *                             Find the maximum value
186  
187                                CALL ZGAMX2D( ICTXT , 'Columnwise' , CCTOP , 1 , 1 , AMAX , 1 ,
188       $                        MAXPOS , IDUMM , 1 , - 1 , MYCOL )
189  
190                                IF( AMAX.NE.ZERO ) THEN
191  
192  *                                 Broadcast corresponding global index
193  
193                                       
194                                    IF( MYROW.EQ.MAXPOS ) THEN
194                                           
195                                        INDX = INDXL2G( LCINDX , DESCX( MB_ ) , MYROW ,
196       $                                DESCX( RSRC_ ) , NPROW )
197                                        CALL IGEBS2D( ICTXT , 'Columnwise' , CBTOP , 1 , 1 ,
198       $                                INDX , 1 )
199                                    ELSE
199                                           
200                                        CALL IGEBR2D( ICTXT , 'Columnwise' , CBTOP , 1 , 1 ,
201       $                                INDX , 1 , MAXPOS , MYCOL )
202                                    END IF
203  
204                                ELSE
205  
205                                       
206                                    INDX = IX
207  
208                                END IF
209  
210                            END IF
211  
212                        END IF
213  
214                    END IF
215  
216                    RETURN
217  
218  *                 End of PZMAX1
219  
220                END
221  2656

Variables in Routine PZMAX1()

Summary Report
Data Type	Quantity	Size(byte)
CHARACTER	4	4
*COMPLEX16**	3	?
INTEGER	36	144
LOGICAL	1	1
TOTAL	44	149

List of Variables

CHARACTER

CBTOP CCTOP RBTOP RCTOP

COMPLEX*16

AMAX WORK( 2 ) ZERO

INTEGER

BLOCK_CYCLIC_2D CSRC_ CTXT_ DLEN_ DTYPE_
ICOFF ICTXT IDUMM IIX INCX
INDX INDXL2G IROFF IX IXCOL
IXROW IZMAX1 JJX JX LCINDX
LDX LLD_ M_ MAXPOS MB_
MYCOL MYROW N N_ NB_
NP NPCOL NPROW NQ NUMROC
RSRC_

LOGICAL

LSAME

Variables Dependence Graph
Put the mouse over a right hand side variable to display the corresponding line of the dependence
-
- -
AMAX <--- IIXAMAX = X( IIX + (LCINDX-1)*LDX ){2AMAX = X( IIX+(JJX-1)*LDX )}, JJXAMAX = X( LCINDX + (JJX-1)*LDX ){2AMAX = X( IIX+(JJX-1)*LDX )}, LCINDXAMAX = X( IIX + (LCINDX-1)*LDX ){2AMAX = X( LCINDX + (JJX-1)*LDX )}, LDXAMAX = X( IIX + (LCINDX-1)*LDX ){2AMAX = X( LCINDX + (JJX-1)*LDX ), 3AMAX = X( IIX+(JJX-1)*LDX )}, WORKAMAX = WORK( 1 ){2AMAX = WORK( 1 )}, ZEROAMAX = ZERO{2AMAX = ZERO, 3AMAX = ZERO}

ICOFF <--- JXICOFF = MOD( JX-1, DESCX( NB_ ) ), NB_ICOFF = MOD( JX-1, DESCX( NB_ ) )

ICTXT <--- CTXT_ICTXT = DESCX( CTXT_ )

INDX <--- INDXL2G{2}, IXINDX = IX{2INDX = IX}, JXINDX = JX{2INDX = JX, 3INDX = JX}, LCINDX{2}, MB_, MYCOL, MYROW, NB_, NPCOL, NPROW, RSRC_, WORKINDX = NINT( DBLE( WORK( 2 ) ) ){2INDX = NINT( DBLE( WORK( 2 ) ) )}, CSRC_

IROFF <--- IXIROFF = MOD( IX-1, DESCX( MB_ ) ), MB_IROFF = MOD( IX-1, DESCX( MB_ ) )

LCINDX <--- IIX{2, 3, 4}, IZMAX1{2, 3, 4}, JJX{2, 3, 4}, LDX{2, 3, 4}, NP{2}, NQ{2}

LDX <--- LLD_LDX = DESCX( LLD_ )

NP <--- IROFF, IXROW, MB_, MYROW, N, NPROW, NUMROC

NQ <--- IXCOL, MYCOL, N, NB_, NPCOL, NUMROC, ICOFF

WORK <--- IIXWORK( 1 ) = X( IIX+(LCINDX-1)*LDX ), INDXL2G{2}, JJXWORK( 1 ) = X( LCINDX + (JJX-1)*LDX ), LCINDXWORK( 1 ) = X( LCINDX + (JJX-1)*LDX ){2, 3WORK( 1 ) = X( IIX+(LCINDX-1)*LDX ), 4}, LDXWORK( 1 ) = X( LCINDX + (JJX-1)*LDX ){2WORK( 1 ) = X( IIX+(LCINDX-1)*LDX )}, MB_, MYCOL, MYROW, NB_, NPCOL, NPROW, RSRC_, ZEROWORK( 1 ) = ZERO{2WORK( 2 ) = ZERO, 3WORK( 1 ) = ZERO, 4WORK( 2 ) = ZERO}, CSRC_

Analysis elements of the routine PZMAX1()
Put the mouse over each element to display detailed matching information

Assigned variables
		AMAX , BLOCK_CYCLIC_2D , CSRC_ , CTXT_ , DLEN_ , DTYPE_ , ICOFF , ICTXT , INDX , IROFF , LCINDX , LDX , LLD_ , M_ , MB_ , N_ , NB_ , NP , NQ , RSRC_ , WORK , ZERO

Active variables
		AMAX , BLOCK_CYCLIC_2D , CBTOP , CCTOP , CSRC_ , CTXT_ , DESCX , DLEN_ , DTYPE_ , ICOFF , ICTXT , IDUMM , IIX , INCX , INDX , INDXL2G , IROFF , IX , IXCOL , IXROW , IZMAX1 , JJX , JX , LCINDX , LDX , LLD_ , LSAME , M_ , MAXPOS , MB_ , MYCOL , MYROW , N , N_ , NB_ , NP , NPCOL , NPROW , NQ , NUMROC , RBTOP , RCTOP , RSRC_ , WORK , X , ZERO

Accessed arrays [ array name : associated index ]
	DESCX	: CSRC_ , CSRC_ , CTXT_ , LLD_ , M_ , M_ , MB_ , MB_ , MB_ , MB_ , NB_ , NB_ , NB_ , NB_ , RSRC_ , RSRC_
	IZMAX1	: NP, X( IIX+(JJX-1)LDX ), 1 , NP, X( IIX+(JJX-1)LDX ), 1 , NQ, X( IIX+(JJX-1)LDX ), LDX , NQ, X( IIX+(JJX-1)LDX ), LDX
	LSAME	: CBTOP, ' ' , RBTOP, ' '
	NUMROC	: N+ICOFF, DESCX( NB_ ), MYCOL, IXCOL, NPCOL , N+IROFF, DESCX( MB_ ), MYROW, IXROW, NPROW
	WORK	: 1 , 1 , 1 , 1 , 1 , 1 , 2 , 2 , 2 , 2 , 2 , 2 , 2
	X	: IIX + (LCINDX-1)LDX , IIX+(JJX-1)LDX , IIX+(JJX-1)LDX , IIX+(JJX-1)LDX , IIX+(JJX-1)LDX , IIX+(JJX-1)LDX , IIX+(LCINDX-1)LDX , LCINDX + (JJX-1)LDX , LCINDX + (JJX-1)*LDX

Conditional statements [ statement : associated predicate ]
	for	: `(` vector X. `)`
	if	: `(` possible. `)` , `(` N.LE.0 `)` , `(` (INCX.EQ.1 .AND. DESCX( M_ ).EQ.1 .AND. N.EQ.1 ) `)` , `(` (INCX.EQ.DESCX( M_ ) ) `)` , `(` MYROW.EQ.IXROW `)` , `(` MYCOL.EQ.IXCOL `)` , `(` (LSAME( RBTOP , ' ' ) ) `)` , `(` NQ.GT.0 `)` , `(` AMAX.EQ.ZERO `)` , `(` NQ.GT.0 `)` , `(` AMAX.NE.ZERO `)` , `(` MYCOL.EQ.MAXPOS `)` , `(` MYCOL.EQ.IXCOL `)` , `(` MYROW.EQ.IXROW `)` , `(` (LSAME( CBTOP , ' ' ) ) `)` , `(` NP.GT.0 `)` , `(` AMAX.EQ.ZERO `)` , `(` NP.GT.0 `)` , `(` AMAX.NE.ZERO `)` , `(` MYROW.EQ.MAXPOS `)`