SCALAPACK 2.2.2
LAPACK: Linear Algebra PACKage
Loading...
Searching...
No Matches

◆ PB_CargFtoC()

void PB_CargFtoC ( Int  IF,
Int  JF,
Int *  DESCIN,
Int *  IC,
Int *  JC,
Int *  DESCOUT 
)

Definition at line 23 of file PB_CargFtoC.c.

33{
34/*
35* Purpose
36* =======
37*
38* PB_CargFtoC converts a descriptor DESCIN of type BLOCK_CYCLIC_2D
39* or BLOCK_CYCLIC_INB_2D into a descriptor DESCOUT of type
40* BLOCK_CYCLIC_INB_2D.
41*
42* Notes
43* =====
44*
45* A description vector is associated with each 2D block-cyclicly dis-
46* tributed matrix. This vector stores the information required to
47* establish the mapping between a matrix entry and its corresponding
48* process and memory location.
49*
50* In the following comments, the character _ should be read as
51* "of the distributed matrix". Let A be a generic term for any 2D
52* block cyclicly distributed matrix. Its description vector is DESCA:
53*
54* NOTATION STORED IN EXPLANATION
55* ---------------- --------------- -----------------------------------
56* DTYPE_A (global) DESCA( DTYPE1_ ) The descriptor type.
57* CTXT_A (global) DESCA( CTXT1_ ) The BLACS context handle indicating
58* the NPROW x NPCOL BLACS process
59* grid A is distributed over. The
60* context itself is global, but the
61* handle (the integer value) may
62* vary.
63* M_A (global) DESCA( M1_ ) The number of rows in the distri-
64* buted matrix A, M_A >= 0.
65* N_A (global) DESCA( N1_ ) The number of columns in the dis-
66* tributed matrix A, N_A >= 0.
67* MB_A (global) DESCA( MB1_ ) The blocking factor used to distri-
68* bute the rows of A, MB_A > 0.
69* NB_A (global) DESCA( NB1_ ) The blocking factor used to distri-
70* bute the columns of A, NB_A > 0.
71* RSRC_A (global) DESCA( RSRC1_ ) The process row over which the
72* first row of the matrix A is dis-
73* tributed, NPROW > RSRC_A >= 0.
74* CSRC_A (global) DESCA( CSRC1_ ) The process column over which the
75* first column of A is distributed.
76* NPCOL > CSRC_A >= 0.
77* LLD_A (local) DESCA( LLD1_ ) The leading dimension of the local
78* array storing the local blocks of
79* the distributed matrix A,
80* IF( Lc( 1, N_A ) > 0 )
81* LLD_A >= MAX( 1, Lr( 1, M_A ) )
82* ELSE
83* LLD_A >= 1.
84*
85* Let K be the number of rows of a matrix A starting at the global in-
86* dex IA,i.e, A( IA:IA+K-1, : ). Lr( IA, K ) denotes the number of rows
87* that the process of row coordinate MYROW ( 0 <= MYROW < NPROW ) would
88* receive if these K rows were distributed over NPROW processes. If K
89* is the number of columns of a matrix A starting at the global index
90* JA, i.e, A( :, JA:JA+K-1, : ), Lc( JA, K ) denotes the number of co-
91* lumns that the process MYCOL ( 0 <= MYCOL < NPCOL ) would receive if
92* these K columns were distributed over NPCOL processes.
93*
94* The values of Lr() and Lc() may be determined via a call to the func-
95* tion PB_Cnumroc:
96* Lr( IA, K ) = PB_Cnumroc( K, IA, MB_A, MB_A, MYROW, RSRC_A, NPROW )
97* Lc( JA, K ) = PB_Cnumroc( K, JA, NB_A, NB_A, MYCOL, CSRC_A, NPCOL )
98*
99* A description vector is associated with each 2D block-cyclicly dis-
100* tributed matrix. This vector stores the information required to
101* establish the mapping between a matrix entry and its corresponding
102* process and memory location.
103*
104* In the following comments, the character _ should be read as
105* "of the distributed matrix". Let A be a generic term for any 2D
106* block cyclicly distributed matrix. Its description vector is DESC_A:
107*
108* NOTATION STORED IN EXPLANATION
109* ---------------- --------------- ------------------------------------
110* DTYPE_A (global) DESCA[ DTYPE_ ] The descriptor type.
111* CTXT_A (global) DESCA[ CTXT_ ] The BLACS context handle, indicating
112* the NPROW x NPCOL BLACS process grid
113* A is distributed over. The context
114* itself is global, but the handle
115* (the integer value) may vary.
116* M_A (global) DESCA[ M_ ] The number of rows in the distribu-
117* ted matrix A, M_A >= 0.
118* N_A (global) DESCA[ N_ ] The number of columns in the distri-
119* buted matrix A, N_A >= 0.
120* IMB_A (global) DESCA[ IMB_ ] The number of rows of the upper left
121* block of the matrix A, IMB_A > 0.
122* INB_A (global) DESCA[ INB_ ] The number of columns of the upper
123* left block of the matrix A,
124* INB_A > 0.
125* MB_A (global) DESCA[ MB_ ] The blocking factor used to distri-
126* bute the last M_A-IMB_A rows of A,
127* MB_A > 0.
128* NB_A (global) DESCA[ NB_ ] The blocking factor used to distri-
129* bute the last N_A-INB_A columns of
130* A, NB_A > 0.
131* RSRC_A (global) DESCA[ RSRC_ ] The process row over which the first
132* row of the matrix A is distributed,
133* NPROW > RSRC_A >= 0.
134* CSRC_A (global) DESCA[ CSRC_ ] The process column over which the
135* first column of A is distributed.
136* NPCOL > CSRC_A >= 0.
137* LLD_A (local) DESCA[ LLD_ ] The leading dimension of the local
138* array storing the local blocks of
139* the distributed matrix A,
140* IF( Lc( 1, N_A ) > 0 )
141* LLD_A >= MAX( 1, Lr( 1, M_A ) )
142* ELSE
143* LLD_A >= 1.
144*
145* Let K be the number of rows of a matrix A starting at the global in-
146* dex IA,i.e, A( IA:IA+K-1, : ). Lr( IA, K ) denotes the number of rows
147* that the process of row coordinate MYROW ( 0 <= MYROW < NPROW ) would
148* receive if these K rows were distributed over NPROW processes. If K
149* is the number of columns of a matrix A starting at the global index
150* JA, i.e, A( :, JA:JA+K-1, : ), Lc( JA, K ) denotes the number of co-
151* lumns that the process MYCOL ( 0 <= MYCOL < NPCOL ) would receive if
152* these K columns were distributed over NPCOL processes.
153*
154* The values of Lr() and Lc() may be determined via a call to the func-
155* tion PB_Cnumroc:
156* Lr( IA, K ) = PB_Cnumroc( K, IA, IMB_A, MB_A, MYROW, RSRC_A, NPROW )
157* Lc( JA, K ) = PB_Cnumroc( K, JA, INB_A, NB_A, MYCOL, CSRC_A, NPCOL )
158*
159* Arguments
160* =========
161*
162* IF (global input) INTEGER
163* On entry, IF specifies the global row Fortran index of the
164* distributed subarray described by DESCIN. IF must be at least
165* one.
166*
167* JF (global input) INTEGER
168* On entry, JF specifies the global column Fortran index of
169* the distributed subarray described by DESCIN. JF must be at
170* least one.
171*
172* DESCIN (global and local input) INTEGER array
173* On entry, DESCIN is an array of dimension DLEN1_ or DLEN_ as
174* specified by its first entry DESCIN( DTYPE_ ). DESCIN is the
175* source array descriptor of type BLOCK_CYCLIC_2D or of type
176* BLOCK_CYCLIC_2D_INB.
177*
178* IC (global output) INTEGER
179* On exit, IC specifies the global row C index of the distribu-
180* ted subarray described by DESCOUT. IC = IF - 1, i.e IC is at
181* least zero.
182*
183* JC (global output) INTEGER
184* On entry, JC specifies the global column Fortran index of
185* the distributed subarray described by DESCOUT. JC = JF - 1,
186* i.e JC is at least zero.
187*
188* DESCOUT (global and local output) INTEGER array
189* On entry, DESCOUT is an array of dimension DLEN_. DESCOUT is
190* the target array descriptor of type BLOCK_CYCLIC_2D_INB.
191*
192* -- Written on April 1, 1998 by
193* Antoine Petitet, University of Tennessee, Knoxville 37996, USA.
194*
195* ---------------------------------------------------------------------
196*/
197/* ..
198* .. Executable Statements ..
199*
200*/
201 *IC = IF - 1;
202 *JC = JF - 1;
203
204 if ( DESCIN[DTYPE_] == BLOCK_CYCLIC_2D )
205 {
206 DESCOUT[DTYPE_] = BLOCK_CYCLIC_2D_INB;
207 DESCOUT[M_ ] = DESCIN[M1_ ];
208 DESCOUT[N_ ] = DESCIN[N1_ ];
209 DESCOUT[IMB_ ] = DESCIN[MB1_ ];
210 DESCOUT[INB_ ] = DESCIN[NB1_ ];
211 DESCOUT[MB_ ] = DESCIN[MB1_ ];
212 DESCOUT[NB_ ] = DESCIN[NB1_ ];
213 DESCOUT[RSRC_ ] = DESCIN[RSRC1_ ];
214 DESCOUT[CSRC_ ] = DESCIN[CSRC1_ ];
215 DESCOUT[CTXT_ ] = DESCIN[CTXT1_ ];
216 DESCOUT[LLD_ ] = DESCIN[LLD1_ ];
217 }
218 else if ( DESCIN[DTYPE_] == BLOCK_CYCLIC_2D_INB )
219 {
220 DESCOUT[DTYPE_] = BLOCK_CYCLIC_2D_INB;
221 DESCOUT[M_ ] = DESCIN[M_ ];
222 DESCOUT[N_ ] = DESCIN[N_ ];
223 DESCOUT[IMB_ ] = DESCIN[IMB_ ];
224 DESCOUT[INB_ ] = DESCIN[INB_ ];
225 DESCOUT[MB_ ] = DESCIN[MB_ ];
226 DESCOUT[NB_ ] = DESCIN[NB_ ];
227 DESCOUT[RSRC_ ] = DESCIN[RSRC_ ];
228 DESCOUT[CSRC_ ] = DESCIN[CSRC_ ];
229 DESCOUT[CTXT_ ] = DESCIN[CTXT_ ];
230 DESCOUT[LLD_ ] = DESCIN[LLD_ ];
231 }
232 else
233 {
234 DESCOUT[DTYPE_] = DESCIN[0];
235 DESCOUT[CTXT_ ] = DESCIN[1];
236 DESCOUT[M_ ] = 0;
237 DESCOUT[N_ ] = 0;
238 DESCOUT[IMB_ ] = 1;
239 DESCOUT[INB_ ] = 1;
240 DESCOUT[MB_ ] = 1;
241 DESCOUT[NB_ ] = 1;
242 DESCOUT[RSRC_ ] = 0;
243 DESCOUT[CSRC_ ] = 0;
244 DESCOUT[LLD_ ] = 1;
245 }
246/*
247* End of PB_CargFtoC
248*/
249}
CTXT_
#define CTXT_
Definition PBtools.h:38
MB_
#define MB_
Definition PBtools.h:43
RSRC1_
#define RSRC1_
Definition PBtools.h:28
M1_
#define M1_
Definition PBtools.h:24
LLD1_
#define LLD1_
Definition PBtools.h:30
N1_
#define N1_
Definition PBtools.h:25
LLD_
#define LLD_
Definition PBtools.h:47
BLOCK_CYCLIC_2D_INB
#define BLOCK_CYCLIC_2D_INB
Definition PBtools.h:35
MB1_
#define MB1_
Definition PBtools.h:26
RSRC_
#define RSRC_
Definition PBtools.h:45
DTYPE_
#define DTYPE_
Definition PBtools.h:37
M_
#define M_
Definition PBtools.h:39
INB_
#define INB_
Definition PBtools.h:42
NB1_
#define NB1_
Definition PBtools.h:27
CTXT1_
#define CTXT1_
Definition PBtools.h:23
CSRC_
#define CSRC_
Definition PBtools.h:46
IMB_
#define IMB_
Definition PBtools.h:41
CSRC1_
#define CSRC1_
Definition PBtools.h:29
BLOCK_CYCLIC_2D
#define BLOCK_CYCLIC_2D
Definition PBtools.h:20
NB_
#define NB_
Definition PBtools.h:44
N_
#define N_
Definition PBtools.h:40