SCALAPACK 2.2.2
LAPACK: Linear Algebra PACKage
All Classes Files Functions Variables Typedefs Macros
PB_CVMinit.c
Go to the documentation of this file.
1/* ---------------------------------------------------------------------
2*
3* -- PBLAS auxiliary routine (version 2.0) --
4* University of Tennessee, Knoxville, Oak Ridge National Laboratory,
5* and University of California, Berkeley.
6* April 1, 1998
7*
8* ---------------------------------------------------------------------
9*/
10/*
11* Include files
12*/
13#include "../pblas.h"
14#include "../PBpblas.h"
15#include "../PBtools.h"
16#include "../PBblacs.h"
17#include "../PBblas.h"
18
19#ifdef __STDC__
20void PB_CVMinit( PB_VM_T * VM, Int OFFD, Int M, Int N, Int IMB1, Int INB1,
21 Int MB, Int NB, Int MRROW, Int MRCOL, Int NPROW,
22 Int NPCOL, Int LCMB )
23#else
24void PB_CVMinit( VM, OFFD, M, N, IMB1, INB1, MB, NB, MRROW, MRCOL, NPROW,
25 NPCOL, LCMB )
26/*
27* .. Scalar Arguments ..
28*/
29 Int IMB1, INB1, LCMB, M, MB, MRCOL, MRROW, N, NB, NPCOL,
30 NPROW, OFFD;
31/*
32* .. Array Arguments ..
33*/
34 PB_VM_T * VM;
35#endif
36{
37/*
38* Purpose
39* =======
40*
41* PB_CVMinit initializes a virtual matrix with the information of an m
42* by n local array owned by the process of relative coordinates
43* ( MRROW, MRCOL ).
44*
45* Arguments
46* =========
47*
48* VM (local output) pointer to a PB_VM_T structure
49* On entry, VM is a pointer to a structure of type PB_VM_T.
50* On exit, VM points to the initialized structure containing
51* the virtual matrix information (see pblas.h).
52*
53* OFFD (global input) INTEGER
54* On entry, OFFD specifies the off-diagonal of the underlying
55* matrix of interest as follows:
56* OFFD = 0 specifies the main diagonal,
57* OFFD > 0 specifies lower subdiagonals, and
58* OFFD < 0 specifies upper superdiagonals.
59*
60* M (local input) INTEGER
61* On entry, M specifies the local number of rows of the under-
62* lying matrix owned by the process of relative coordinates
63* ( MRROW, MRCOL ). M must be at least zero.
64*
65* N (local input) INTEGER
66* On entry, N specifies the local number of columns of the un-
67* derlying matrix owned by the process of relative coordinates
68* ( MRROW, MRCOL ). N must be at least zero.
69*
70* IMB1 (global input) INTEGER
71* On input, IMB1 specifies the global true size of the first
72* block of rows of the underlying global submatrix. IMB1 must
73* be at least MIN( 1, M ).
74*
75* INB1 (global input) INTEGER
76* On input, INB1 specifies the global true size of the first
77* block of columns of the underlying global submatrix. INB1
78* must be at least MIN( 1, N ).
79*
80* MB (global input) INTEGER
81* On entry, MB specifies the blocking factor used to partition
82* the rows of the matrix. MB must be at least one.
83*
84* NB (global input) INTEGER
85* On entry, NB specifies the blocking factor used to partition
86* the the columns of the matrix. NB must be at least one.
87*
88* MRROW (local input) INTEGER
89* On entry, MRROW specifies the relative row coordinate of the
90* process that possesses these M rows. MRROW must be least zero
91* and strictly less than NPROW.
92*
93* MRCOL (local input) INTEGER
94* On entry, MRCOL specifies the relative column coordinate of
95* the process that possesses these N columns. MRCOL must be
96* least zero and strictly less than NPCOL.
97*
98* NPROW (global input) INTEGER
99* On entry, NPROW specifies the total number of process rows
100* over which the matrix is distributed. NPROW must be at least
101* one.
102*
103* NPCOL (global input) INTEGER
104* On entry, NPCOL specifies the total number of process col-
105* umns over which the matrix is distributed. NPCOL must be at
106* least one.
107*
108* LCMB (global input) INTEGER
109* On entry, LCMB specifies the least common multiple of
110* NPROW * MB and NPCOL * NB.
111*
112* -- Written on April 1, 1998 by
113* Antoine Petitet, University of Tennessee, Knoxville 37996, USA.
114*
115* ---------------------------------------------------------------------
116*/
117/*
118* .. Local Scalars ..
119*/
120 Int tmp1;
121/* ..
122* .. Executable Statements ..
123*
124*/
125/*
126* Initialize the fields of the VM structure
127*/
128 VM->offd = OFFD;
129 VM->lcmt00 = OFFD;
130 VM->mp = M; VM->imb1 = IMB1; VM->mb = MB; VM->upp = MB - 1;
131 VM->prow = MRROW; VM->nprow = NPROW;
132 VM->nq = N; VM->inb1 = INB1; VM->nb = NB; VM->low = 1 - NB;
133 VM->pcol = MRCOL; VM->npcol = NPCOL;
134 VM->lcmb = LCMB;
135
136 if( ( M <= 0 ) || ( N <= 0 ) )
137 {
138/*
139* If the local virtual array is empty, then simplify the remaining of the
140* initialization.
141*/
142 VM->imbloc = 0; VM->lmbloc = 0; VM->mblks = 0;
143 VM->iupp = ( MRROW ? MB - 1 : ( IMB1 > 0 ? IMB1 - 1 : 0 ) );
144 VM->inbloc = 0; VM->lnbloc = 0; VM->nblks = 0;
145 VM->ilow = ( MRCOL ? 1 - NB : ( INB1 > 0 ? 1 - INB1 : 0 ) );
146 VM->lcmt00 += ( VM->low - VM->ilow + MRCOL * NB ) -
147 ( VM->iupp - VM->upp + MRROW * MB );
148 return;
149 }
150
151 if( MRROW )
152 {
153/*
154* I am not in the first relative process row. Use the first local row block
155* size MB to initialize the VM structure.
156*/
157 VM->lcmt00 -= IMB1 - MB + MRROW * MB;
158 VM->imbloc = MIN( M, MB );
159 VM->mblks = ( M - 1 ) / MB + 1;
160 VM->iupp = MB - 1;
161 VM->lmbloc = M - ( M / MB ) * MB;
162 if( !( VM->lmbloc ) ) VM->lmbloc = MB;
163
164 if( MRCOL )
165 {
166/*
167* I am not in the first relative process column. Use the first local column
168* block size NB to initialize the VM structure.
169*/
170 VM->inbloc = MIN( N, NB );
171 VM->ilow = 1 - NB;
172 VM->lcmt00 += INB1 - NB + MRCOL * NB;
173 VM->nblks = ( N - 1 ) / NB + 1;
174 VM->lnbloc = N - ( N / NB ) * NB;
175 if( !( VM->lnbloc ) ) VM->lnbloc = NB;
176 }
177 else
178 {
179/*
180* I am in the first relative process column. Use the first column block size
181* INB1 to initialize the VM structure.
182*/
183 VM->inbloc = INB1;
184 VM->ilow = 1 - INB1;
185 tmp1 = N - INB1;
186 if( tmp1 )
187 {
188/*
189* There is more than one column block. Compute the number of local column
190* blocks and the size of the last one.
191*/
192 VM->nblks = ( tmp1 - 1 ) / NB + 2;
193 VM->lnbloc = tmp1 - ( tmp1 / NB ) * NB;
194 if( !( VM->lnbloc ) ) VM->lnbloc = NB;
195 }
196 else
197 {
198/*
199* There is only one column block.
200*/
201 VM->nblks = 1;
202 VM->lnbloc = INB1;
203 }
204 }
205 }
206 else
207 {
208/*
209* I am in the first relative process row. Use the first row block size IMB1 to
210* initialize the VM structure.
211*/
212 VM->imbloc = IMB1;
213 VM->iupp = IMB1 - 1;
214 tmp1 = M - IMB1;
215 if( tmp1 )
216 {
217/*
218* There is more than one row block. Compute the number of local row blocks and
219* the size of the last one.
220*/
221 VM->mblks = ( tmp1 - 1 ) / MB + 2;
222 VM->lmbloc = tmp1 - ( tmp1 / MB ) * MB;
223 if( !( VM->lmbloc ) ) VM->lmbloc = MB;
224 }
225 else
226 {
227/*
228* There is only one row block.
229*/
230 VM->mblks = 1;
231 VM->lmbloc = IMB1;
232 }
233 if( MRCOL )
234 {
235/*
236* I am not in the first relative process column. Use the first local column
237* block size NB to initialize the VM structure.
238*/
239 VM->inbloc = MIN( N, NB );
240 VM->ilow = 1 - NB;
241 VM->lcmt00 += INB1 - NB + MRCOL * NB;
242 VM->nblks = ( N - 1 ) / NB + 1;
243 VM->lnbloc = N - ( N / NB ) * NB;
244 if( !( VM->lnbloc ) ) VM->lnbloc = NB;
245 }
246 else
247 {
248/*
249* I am in the first relative process column. Use the first column block size
250* INB1 to initialize the VM structure.
251*/
252 VM->inbloc = INB1;
253 VM->ilow = 1 - INB1;
254 tmp1 = N - INB1;
255 if( tmp1 )
256 {
257/*
258* There is more than one column block. Compute the number of local column
259* blocks and the size of the last one.
260*/
261 VM->nblks = ( tmp1 - 1 ) / NB + 2;
262 VM->lnbloc = tmp1 - ( tmp1 / NB ) * NB;
263 if( !( VM->lnbloc ) ) VM->lnbloc = NB;
264 }
265 else
266 {
267/*
268* There is only one column block.
269*/
270 VM->nblks = 1;
271 VM->lnbloc = INB1;
272 }
273 }
274 }
275/*
276* End of PB_CVMinit
277*/
278}
#define Int
Definition Bconfig.h:22
void PB_CVMinit()
#define MIN(a_, b_)
Definition PBtools.h:76
Int lcmb
Definition pblas.h:463
Int lnbloc
Definition pblas.h:456
Int low
Definition pblas.h:459
Int iupp
Definition pblas.h:447
Int npcol
Definition pblas.h:461
Int nprow
Definition pblas.h:450
Int lcmt00
Definition pblas.h:439
Int pcol
Definition pblas.h:460
Int inbloc
Definition pblas.h:454
Int ilow
Definition pblas.h:458
Int offd
Definition pblas.h:438
Int inb1
Definition pblas.h:453
Int nblks
Definition pblas.h:457
Int mp
Definition pblas.h:441
Int prow
Definition pblas.h:449
Int imbloc
Definition pblas.h:443
Int nq
Definition pblas.h:452
Int lmbloc
Definition pblas.h:445
Int nb
Definition pblas.h:455
Int imb1
Definition pblas.h:442
Int mblks
Definition pblas.h:446
Int mb
Definition pblas.h:444
Int upp
Definition pblas.h:448