Actual source code: fdmpiaij.c
petsc-3.11.4 2019-09-28
1: #include <../src/mat/impls/sell/mpi/mpisell.h>
2: #include <../src/mat/impls/aij/mpi/mpiaij.h>
3: #include <../src/mat/impls/baij/mpi/mpibaij.h>
4: #include <petsc/private/isimpl.h>
6: PetscErrorCode MatFDColoringApply_BAIJ(Mat J,MatFDColoring coloring,Vec x1,void *sctx)
7: {
8: PetscErrorCode (*f)(void*,Vec,Vec,void*)=(PetscErrorCode (*)(void*,Vec,Vec,void*))coloring->f;
9: PetscErrorCode ierr;
10: PetscInt k,cstart,cend,l,row,col,nz,spidx,i,j;
11: PetscScalar dx=0.0,*w3_array,*dy_i,*dy=coloring->dy;
12: PetscScalar *vscale_array;
13: const PetscScalar *xx;
14: PetscReal epsilon=coloring->error_rel,umin=coloring->umin,unorm;
15: Vec w1=coloring->w1,w2=coloring->w2,w3,vscale=coloring->vscale;
16: void *fctx=coloring->fctx;
17: PetscInt ctype=coloring->ctype,nxloc,nrows_k;
18: PetscScalar *valaddr;
19: MatEntry *Jentry=coloring->matentry;
20: MatEntry2 *Jentry2=coloring->matentry2;
21: const PetscInt ncolors=coloring->ncolors,*ncolumns=coloring->ncolumns,*nrows=coloring->nrows;
22: PetscInt bs=J->rmap->bs;
25: /* (1) Set w1 = F(x1) */
26: if (!coloring->fset) {
27: PetscLogEventBegin(MAT_FDColoringFunction,coloring,0,0,0);
28: (*f)(sctx,x1,w1,fctx);
29: PetscLogEventEnd(MAT_FDColoringFunction,coloring,0,0,0);
30: } else {
31: coloring->fset = PETSC_FALSE;
32: }
34: /* (2) Compute vscale = 1./dx - the local scale factors, including ghost points */
35: VecGetLocalSize(x1,&nxloc);
36: if (coloring->htype[0] == 'w') {
37: /* vscale = dx is a constant scalar */
38: VecNorm(x1,NORM_2,&unorm);
39: dx = 1.0/(PetscSqrtReal(1.0 + unorm)*epsilon);
40: } else {
41: VecGetArrayRead(x1,&xx);
42: VecGetArray(vscale,&vscale_array);
43: for (col=0; col<nxloc; col++) {
44: dx = xx[col];
45: if (PetscAbsScalar(dx) < umin) {
46: if (PetscRealPart(dx) >= 0.0) dx = umin;
47: else if (PetscRealPart(dx) < 0.0 ) dx = -umin;
48: }
49: dx *= epsilon;
50: vscale_array[col] = 1.0/dx;
51: }
52: VecRestoreArrayRead(x1,&xx);
53: VecRestoreArray(vscale,&vscale_array);
54: }
55: if (ctype == IS_COLORING_GLOBAL && coloring->htype[0] == 'd') {
56: VecGhostUpdateBegin(vscale,INSERT_VALUES,SCATTER_FORWARD);
57: VecGhostUpdateEnd(vscale,INSERT_VALUES,SCATTER_FORWARD);
58: }
60: /* (3) Loop over each color */
61: if (!coloring->w3) {
62: VecDuplicate(x1,&coloring->w3);
63: PetscLogObjectParent((PetscObject)coloring,(PetscObject)coloring->w3);
64: }
65: w3 = coloring->w3;
67: VecGetOwnershipRange(x1,&cstart,&cend); /* used by ghosted vscale */
68: if (vscale) {
69: VecGetArray(vscale,&vscale_array);
70: }
71: nz = 0;
72: for (k=0; k<ncolors; k++) {
73: coloring->currentcolor = k;
75: /*
76: (3-1) Loop over each column associated with color
77: adding the perturbation to the vector w3 = x1 + dx.
78: */
79: VecCopy(x1,w3);
80: dy_i = dy;
81: for (i=0; i<bs; i++) { /* Loop over a block of columns */
82: VecGetArray(w3,&w3_array);
83: if (ctype == IS_COLORING_GLOBAL) w3_array -= cstart; /* shift pointer so global index can be used */
84: if (coloring->htype[0] == 'w') {
85: for (l=0; l<ncolumns[k]; l++) {
86: col = i + bs*coloring->columns[k][l]; /* local column (in global index!) of the matrix we are probing for */
87: w3_array[col] += 1.0/dx;
88: if (i) w3_array[col-1] -= 1.0/dx; /* resume original w3[col-1] */
89: }
90: } else { /* htype == 'ds' */
91: vscale_array -= cstart; /* shift pointer so global index can be used */
92: for (l=0; l<ncolumns[k]; l++) {
93: col = i + bs*coloring->columns[k][l]; /* local column (in global index!) of the matrix we are probing for */
94: w3_array[col] += 1.0/vscale_array[col];
95: if (i) w3_array[col-1] -= 1.0/vscale_array[col-1]; /* resume original w3[col-1] */
96: }
97: vscale_array += cstart;
98: }
99: if (ctype == IS_COLORING_GLOBAL) w3_array += cstart;
100: VecRestoreArray(w3,&w3_array);
102: /*
103: (3-2) Evaluate function at w3 = x1 + dx (here dx is a vector of perturbations)
104: w2 = F(x1 + dx) - F(x1)
105: */
106: PetscLogEventBegin(MAT_FDColoringFunction,0,0,0,0);
107: VecPlaceArray(w2,dy_i); /* place w2 to the array dy_i */
108: (*f)(sctx,w3,w2,fctx);
109: PetscLogEventEnd(MAT_FDColoringFunction,0,0,0,0);
110: VecAXPY(w2,-1.0,w1);
111: VecResetArray(w2);
112: dy_i += nxloc; /* points to dy+i*nxloc */
113: }
115: /*
116: (3-3) Loop over rows of vector, putting results into Jacobian matrix
117: */
118: nrows_k = nrows[k];
119: if (coloring->htype[0] == 'w') {
120: for (l=0; l<nrows_k; l++) {
121: row = bs*Jentry2[nz].row; /* local row index */
122: valaddr = Jentry2[nz++].valaddr;
123: spidx = 0;
124: dy_i = dy;
125: for (i=0; i<bs; i++) { /* column of the block */
126: for (j=0; j<bs; j++) { /* row of the block */
127: valaddr[spidx++] = dy_i[row+j]*dx;
128: }
129: dy_i += nxloc; /* points to dy+i*nxloc */
130: }
131: }
132: } else { /* htype == 'ds' */
133: for (l=0; l<nrows_k; l++) {
134: row = bs*Jentry[nz].row; /* local row index */
135: col = bs*Jentry[nz].col; /* local column index */
136: valaddr = Jentry[nz++].valaddr;
137: spidx = 0;
138: dy_i = dy;
139: for (i=0; i<bs; i++) { /* column of the block */
140: for (j=0; j<bs; j++) { /* row of the block */
141: valaddr[spidx++] = dy_i[row+j]*vscale_array[col+i];
142: }
143: dy_i += nxloc; /* points to dy+i*nxloc */
144: }
145: }
146: }
147: }
148: MatAssemblyBegin(J,MAT_FINAL_ASSEMBLY);
149: MatAssemblyEnd(J,MAT_FINAL_ASSEMBLY);
150: if (vscale) {
151: VecRestoreArray(vscale,&vscale_array);
152: }
154: coloring->currentcolor = -1;
155: return(0);
156: }
158: /* this is declared PETSC_EXTERN because it is used by MatFDColoringUseDM() which is in the DM library */
159: PetscErrorCode MatFDColoringApply_AIJ(Mat J,MatFDColoring coloring,Vec x1,void *sctx)
160: {
161: PetscErrorCode (*f)(void*,Vec,Vec,void*) = (PetscErrorCode (*)(void*,Vec,Vec,void*))coloring->f;
162: PetscErrorCode ierr;
163: PetscInt k,cstart,cend,l,row,col,nz;
164: PetscScalar dx=0.0,*y,*w3_array;
165: const PetscScalar *xx;
166: PetscScalar *vscale_array;
167: PetscReal epsilon=coloring->error_rel,umin=coloring->umin,unorm;
168: Vec w1=coloring->w1,w2=coloring->w2,w3,vscale=coloring->vscale;
169: void *fctx=coloring->fctx;
170: ISColoringType ctype=coloring->ctype;
171: PetscInt nxloc,nrows_k;
172: MatEntry *Jentry=coloring->matentry;
173: MatEntry2 *Jentry2=coloring->matentry2;
174: const PetscInt ncolors=coloring->ncolors,*ncolumns=coloring->ncolumns,*nrows=coloring->nrows;
177: if ((ctype == IS_COLORING_LOCAL) && (J->ops->fdcoloringapply == MatFDColoringApply_AIJ)) SETERRQ(PetscObjectComm((PetscObject)J),PETSC_ERR_SUP,"Must call MatColoringUseDM() with IS_COLORING_LOCAL");
178: /* (1) Set w1 = F(x1) */
179: if (!coloring->fset) {
180: PetscLogEventBegin(MAT_FDColoringFunction,0,0,0,0);
181: (*f)(sctx,x1,w1,fctx);
182: PetscLogEventEnd(MAT_FDColoringFunction,0,0,0,0);
183: } else {
184: coloring->fset = PETSC_FALSE;
185: }
187: /* (2) Compute vscale = 1./dx - the local scale factors, including ghost points */
188: if (coloring->htype[0] == 'w') {
189: /* vscale = 1./dx is a constant scalar */
190: VecNorm(x1,NORM_2,&unorm);
191: dx = 1.0/(PetscSqrtReal(1.0 + unorm)*epsilon);
192: } else {
193: VecGetLocalSize(x1,&nxloc);
194: VecGetArrayRead(x1,&xx);
195: VecGetArray(vscale,&vscale_array);
196: for (col=0; col<nxloc; col++) {
197: dx = xx[col];
198: if (PetscAbsScalar(dx) < umin) {
199: if (PetscRealPart(dx) >= 0.0) dx = umin;
200: else if (PetscRealPart(dx) < 0.0 ) dx = -umin;
201: }
202: dx *= epsilon;
203: vscale_array[col] = 1.0/dx;
204: }
205: VecRestoreArrayRead(x1,&xx);
206: VecRestoreArray(vscale,&vscale_array);
207: }
208: if (ctype == IS_COLORING_GLOBAL && coloring->htype[0] == 'd') {
209: VecGhostUpdateBegin(vscale,INSERT_VALUES,SCATTER_FORWARD);
210: VecGhostUpdateEnd(vscale,INSERT_VALUES,SCATTER_FORWARD);
211: }
213: /* (3) Loop over each color */
214: if (!coloring->w3) {
215: VecDuplicate(x1,&coloring->w3);
216: PetscLogObjectParent((PetscObject)coloring,(PetscObject)coloring->w3);
217: }
218: w3 = coloring->w3;
220: VecGetOwnershipRange(x1,&cstart,&cend); /* used by ghosted vscale */
221: if (vscale) {
222: VecGetArray(vscale,&vscale_array);
223: }
224: nz = 0;
226: if (coloring->bcols > 1) { /* use blocked insertion of Jentry */
227: PetscInt i,m=J->rmap->n,nbcols,bcols=coloring->bcols;
228: PetscScalar *dy=coloring->dy,*dy_k;
230: nbcols = 0;
231: for (k=0; k<ncolors; k+=bcols) {
233: /*
234: (3-1) Loop over each column associated with color
235: adding the perturbation to the vector w3 = x1 + dx.
236: */
238: dy_k = dy;
239: if (k + bcols > ncolors) bcols = ncolors - k;
240: for (i=0; i<bcols; i++) {
241: coloring->currentcolor = k+i;
243: VecCopy(x1,w3);
244: VecGetArray(w3,&w3_array);
245: if (ctype == IS_COLORING_GLOBAL) w3_array -= cstart; /* shift pointer so global index can be used */
246: if (coloring->htype[0] == 'w') {
247: for (l=0; l<ncolumns[k+i]; l++) {
248: col = coloring->columns[k+i][l]; /* local column (in global index!) of the matrix we are probing for */
249: w3_array[col] += 1.0/dx;
250: }
251: } else { /* htype == 'ds' */
252: vscale_array -= cstart; /* shift pointer so global index can be used */
253: for (l=0; l<ncolumns[k+i]; l++) {
254: col = coloring->columns[k+i][l]; /* local column (in global index!) of the matrix we are probing for */
255: w3_array[col] += 1.0/vscale_array[col];
256: }
257: vscale_array += cstart;
258: }
259: if (ctype == IS_COLORING_GLOBAL) w3_array += cstart;
260: VecRestoreArray(w3,&w3_array);
262: /*
263: (3-2) Evaluate function at w3 = x1 + dx (here dx is a vector of perturbations)
264: w2 = F(x1 + dx) - F(x1)
265: */
266: PetscLogEventBegin(MAT_FDColoringFunction,0,0,0,0);
267: VecPlaceArray(w2,dy_k); /* place w2 to the array dy_i */
268: (*f)(sctx,w3,w2,fctx);
269: PetscLogEventEnd(MAT_FDColoringFunction,0,0,0,0);
270: VecAXPY(w2,-1.0,w1);
271: VecResetArray(w2);
272: dy_k += m; /* points to dy+i*nxloc */
273: }
275: /*
276: (3-3) Loop over block rows of vector, putting results into Jacobian matrix
277: */
278: nrows_k = nrows[nbcols++];
279: VecGetArray(w2,&y);
281: if (coloring->htype[0] == 'w') {
282: for (l=0; l<nrows_k; l++) {
283: row = Jentry2[nz].row; /* local row index */
284: *(Jentry2[nz++].valaddr) = dy[row]*dx;
285: }
286: } else { /* htype == 'ds' */
287: for (l=0; l<nrows_k; l++) {
288: row = Jentry[nz].row; /* local row index */
289: *(Jentry[nz].valaddr) = dy[row]*vscale_array[Jentry[nz].col];
290: nz++;
291: }
292: }
293: VecRestoreArray(w2,&y);
294: }
295: } else { /* bcols == 1 */
296: for (k=0; k<ncolors; k++) {
297: coloring->currentcolor = k;
299: /*
300: (3-1) Loop over each column associated with color
301: adding the perturbation to the vector w3 = x1 + dx.
302: */
303: VecCopy(x1,w3);
304: VecGetArray(w3,&w3_array);
305: if (ctype == IS_COLORING_GLOBAL) w3_array -= cstart; /* shift pointer so global index can be used */
306: if (coloring->htype[0] == 'w') {
307: for (l=0; l<ncolumns[k]; l++) {
308: col = coloring->columns[k][l]; /* local column (in global index!) of the matrix we are probing for */
309: w3_array[col] += 1.0/dx;
310: }
311: } else { /* htype == 'ds' */
312: vscale_array -= cstart; /* shift pointer so global index can be used */
313: for (l=0; l<ncolumns[k]; l++) {
314: col = coloring->columns[k][l]; /* local column (in global index!) of the matrix we are probing for */
315: w3_array[col] += 1.0/vscale_array[col];
316: }
317: vscale_array += cstart;
318: }
319: if (ctype == IS_COLORING_GLOBAL) w3_array += cstart;
320: VecRestoreArray(w3,&w3_array);
322: /*
323: (3-2) Evaluate function at w3 = x1 + dx (here dx is a vector of perturbations)
324: w2 = F(x1 + dx) - F(x1)
325: */
326: PetscLogEventBegin(MAT_FDColoringFunction,0,0,0,0);
327: (*f)(sctx,w3,w2,fctx);
328: PetscLogEventEnd(MAT_FDColoringFunction,0,0,0,0);
329: VecAXPY(w2,-1.0,w1);
331: /*
332: (3-3) Loop over rows of vector, putting results into Jacobian matrix
333: */
334: nrows_k = nrows[k];
335: VecGetArray(w2,&y);
336: if (coloring->htype[0] == 'w') {
337: for (l=0; l<nrows_k; l++) {
338: row = Jentry2[nz].row; /* local row index */
339: *(Jentry2[nz++].valaddr) = y[row]*dx;
340: }
341: } else { /* htype == 'ds' */
342: for (l=0; l<nrows_k; l++) {
343: row = Jentry[nz].row; /* local row index */
344: *(Jentry[nz].valaddr) = y[row]*vscale_array[Jentry[nz].col];
345: nz++;
346: }
347: }
348: VecRestoreArray(w2,&y);
349: }
350: }
352: MatAssemblyBegin(J,MAT_FINAL_ASSEMBLY);
353: MatAssemblyEnd(J,MAT_FINAL_ASSEMBLY);
354: if (vscale) {
355: VecRestoreArray(vscale,&vscale_array);
356: }
357: coloring->currentcolor = -1;
358: return(0);
359: }
361: PetscErrorCode MatFDColoringSetUp_MPIXAIJ(Mat mat,ISColoring iscoloring,MatFDColoring c)
362: {
363: PetscErrorCode ierr;
364: PetscMPIInt size,*ncolsonproc,*disp,nn;
365: PetscInt i,n,nrows,nrows_i,j,k,m,ncols,col,*rowhit,cstart,cend,colb;
366: const PetscInt *is,*A_ci,*A_cj,*B_ci,*B_cj,*row=NULL,*ltog=NULL;
367: PetscInt nis=iscoloring->n,nctot,*cols;
368: IS *isa;
369: ISLocalToGlobalMapping map=mat->cmap->mapping;
370: PetscInt ctype=c->ctype,*spidxA,*spidxB,nz,bs,bs2,spidx;
371: Mat A,B;
372: PetscScalar *A_val,*B_val,**valaddrhit;
373: MatEntry *Jentry;
374: MatEntry2 *Jentry2;
375: PetscBool isBAIJ,isSELL;
376: PetscInt bcols=c->bcols;
377: #if defined(PETSC_USE_CTABLE)
378: PetscTable colmap=NULL;
379: #else
380: PetscInt *colmap=NULL; /* local col number of off-diag col */
381: #endif
384: if (ctype == IS_COLORING_LOCAL) {
385: if (!map) SETERRQ(PetscObjectComm((PetscObject)mat),PETSC_ERR_ARG_INCOMP,"When using ghosted differencing matrix must have local to global mapping provided with MatSetLocalToGlobalMapping");
386: ISLocalToGlobalMappingGetIndices(map,<og);
387: }
389: MatGetBlockSize(mat,&bs);
390: PetscObjectTypeCompare((PetscObject)mat,MATMPIBAIJ,&isBAIJ);
391: PetscObjectTypeCompare((PetscObject)mat,MATMPISELL,&isSELL);
392: if (isBAIJ) {
393: Mat_MPIBAIJ *baij=(Mat_MPIBAIJ*)mat->data;
394: Mat_SeqBAIJ *spA,*spB;
395: A = baij->A; spA = (Mat_SeqBAIJ*)A->data; A_val = spA->a;
396: B = baij->B; spB = (Mat_SeqBAIJ*)B->data; B_val = spB->a;
397: nz = spA->nz + spB->nz; /* total nonzero entries of mat */
398: if (!baij->colmap) {
399: MatCreateColmap_MPIBAIJ_Private(mat);
400: }
401: colmap = baij->colmap;
402: MatGetColumnIJ_SeqBAIJ_Color(A,0,PETSC_FALSE,PETSC_FALSE,&ncols,&A_ci,&A_cj,&spidxA,NULL);
403: MatGetColumnIJ_SeqBAIJ_Color(B,0,PETSC_FALSE,PETSC_FALSE,&ncols,&B_ci,&B_cj,&spidxB,NULL);
405: if (ctype == IS_COLORING_GLOBAL && c->htype[0] == 'd') { /* create vscale for storing dx */
406: PetscInt *garray;
407: PetscMalloc1(B->cmap->n,&garray);
408: for (i=0; i<baij->B->cmap->n/bs; i++) {
409: for (j=0; j<bs; j++) {
410: garray[i*bs+j] = bs*baij->garray[i]+j;
411: }
412: }
413: VecCreateGhost(PetscObjectComm((PetscObject)mat),mat->cmap->n,PETSC_DETERMINE,B->cmap->n,garray,&c->vscale);
414: PetscFree(garray);
415: }
416: } else if (isSELL) {
417: Mat_MPISELL *sell=(Mat_MPISELL*)mat->data;
418: Mat_SeqSELL *spA,*spB;
419: A = sell->A; spA = (Mat_SeqSELL*)A->data; A_val = spA->val;
420: B = sell->B; spB = (Mat_SeqSELL*)B->data; B_val = spB->val;
421: nz = spA->nz + spB->nz; /* total nonzero entries of mat */
422: if (!sell->colmap) {
423: /* Allow access to data structures of local part of matrix
424: - creates aij->colmap which maps global column number to local number in part B */
425: MatCreateColmap_MPISELL_Private(mat);
426: }
427: colmap = sell->colmap;
428: MatGetColumnIJ_SeqSELL_Color(A,0,PETSC_FALSE,PETSC_FALSE,&ncols,&A_ci,&A_cj,&spidxA,NULL);
429: MatGetColumnIJ_SeqSELL_Color(B,0,PETSC_FALSE,PETSC_FALSE,&ncols,&B_ci,&B_cj,&spidxB,NULL);
431: bs = 1; /* only bs=1 is supported for non MPIBAIJ matrix */
433: if (ctype == IS_COLORING_GLOBAL && c->htype[0] == 'd') { /* create vscale for storing dx */
434: VecCreateGhost(PetscObjectComm((PetscObject)mat),mat->cmap->n,PETSC_DETERMINE,B->cmap->n,sell->garray,&c->vscale);
435: }
436: } else {
437: Mat_MPIAIJ *aij=(Mat_MPIAIJ*)mat->data;
438: Mat_SeqAIJ *spA,*spB;
439: A = aij->A; spA = (Mat_SeqAIJ*)A->data; A_val = spA->a;
440: B = aij->B; spB = (Mat_SeqAIJ*)B->data; B_val = spB->a;
441: nz = spA->nz + spB->nz; /* total nonzero entries of mat */
442: if (!aij->colmap) {
443: /* Allow access to data structures of local part of matrix
444: - creates aij->colmap which maps global column number to local number in part B */
445: MatCreateColmap_MPIAIJ_Private(mat);
446: }
447: colmap = aij->colmap;
448: MatGetColumnIJ_SeqAIJ_Color(A,0,PETSC_FALSE,PETSC_FALSE,&ncols,&A_ci,&A_cj,&spidxA,NULL);
449: MatGetColumnIJ_SeqAIJ_Color(B,0,PETSC_FALSE,PETSC_FALSE,&ncols,&B_ci,&B_cj,&spidxB,NULL);
451: bs = 1; /* only bs=1 is supported for non MPIBAIJ matrix */
453: if (ctype == IS_COLORING_GLOBAL && c->htype[0] == 'd') { /* create vscale for storing dx */
454: VecCreateGhost(PetscObjectComm((PetscObject)mat),mat->cmap->n,PETSC_DETERMINE,B->cmap->n,aij->garray,&c->vscale);
455: }
456: }
458: m = mat->rmap->n/bs;
459: cstart = mat->cmap->rstart/bs;
460: cend = mat->cmap->rend/bs;
462: PetscMalloc1(nis,&c->ncolumns);
463: PetscMalloc1(nis,&c->columns);
464: PetscCalloc1(nis,&c->nrows);
465: PetscLogObjectMemory((PetscObject)c,3*nis*sizeof(PetscInt));
467: if (c->htype[0] == 'd') {
468: PetscMalloc1(nz,&Jentry);
469: PetscLogObjectMemory((PetscObject)c,nz*sizeof(MatEntry));
470: c->matentry = Jentry;
471: } else if (c->htype[0] == 'w') {
472: PetscMalloc1(nz,&Jentry2);
473: PetscLogObjectMemory((PetscObject)c,nz*sizeof(MatEntry2));
474: c->matentry2 = Jentry2;
475: } else SETERRQ(PetscObjectComm((PetscObject)mat),PETSC_ERR_SUP,"htype is not supported");
477: PetscMalloc2(m+1,&rowhit,m+1,&valaddrhit);
478: nz = 0;
479: ISColoringGetIS(iscoloring,PETSC_IGNORE,&isa);
480: for (i=0; i<nis; i++) { /* for each local color */
481: ISGetLocalSize(isa[i],&n);
482: ISGetIndices(isa[i],&is);
484: c->ncolumns[i] = n; /* local number of columns of this color on this process */
485: if (n) {
486: PetscMalloc1(n,&c->columns[i]);
487: PetscLogObjectMemory((PetscObject)c,n*sizeof(PetscInt));
488: PetscMemcpy(c->columns[i],is,n*sizeof(PetscInt));
489: } else {
490: c->columns[i] = 0;
491: }
493: if (ctype == IS_COLORING_GLOBAL) {
494: /* Determine nctot, the total (parallel) number of columns of this color */
495: MPI_Comm_size(PetscObjectComm((PetscObject)mat),&size);
496: PetscMalloc2(size,&ncolsonproc,size,&disp);
498: /* ncolsonproc[j]: local ncolumns on proc[j] of this color */
499: PetscMPIIntCast(n,&nn);
500: MPI_Allgather(&nn,1,MPI_INT,ncolsonproc,1,MPI_INT,PetscObjectComm((PetscObject)mat));
501: nctot = 0; for (j=0; j<size; j++) nctot += ncolsonproc[j];
502: if (!nctot) {
503: PetscInfo(mat,"Coloring of matrix has some unneeded colors with no corresponding rows\n");
504: }
506: disp[0] = 0;
507: for (j=1; j<size; j++) {
508: disp[j] = disp[j-1] + ncolsonproc[j-1];
509: }
511: /* Get cols, the complete list of columns for this color on each process */
512: PetscMalloc1(nctot+1,&cols);
513: MPI_Allgatherv((void*)is,n,MPIU_INT,cols,ncolsonproc,disp,MPIU_INT,PetscObjectComm((PetscObject)mat));
514: PetscFree2(ncolsonproc,disp);
515: } else if (ctype == IS_COLORING_LOCAL) {
516: /* Determine local number of columns of this color on this process, including ghost points */
517: nctot = n;
518: PetscMalloc1(nctot+1,&cols);
519: PetscMemcpy(cols,is,n*sizeof(PetscInt));
520: } else SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SUP,"Not provided for this MatFDColoring type");
522: /* Mark all rows affect by these columns */
523: PetscMemzero(rowhit,m*sizeof(PetscInt));
524: bs2 = bs*bs;
525: nrows_i = 0;
526: for (j=0; j<nctot; j++) { /* loop over columns*/
527: if (ctype == IS_COLORING_LOCAL) {
528: col = ltog[cols[j]];
529: } else {
530: col = cols[j];
531: }
532: if (col >= cstart && col < cend) { /* column is in A, diagonal block of mat */
533: row = A_cj + A_ci[col-cstart];
534: nrows = A_ci[col-cstart+1] - A_ci[col-cstart];
535: nrows_i += nrows;
536: /* loop over columns of A marking them in rowhit */
537: for (k=0; k<nrows; k++) {
538: /* set valaddrhit for part A */
539: spidx = bs2*spidxA[A_ci[col-cstart] + k];
540: valaddrhit[*row] = &A_val[spidx];
541: rowhit[*row++] = col - cstart + 1; /* local column index */
542: }
543: } else { /* column is in B, off-diagonal block of mat */
544: #if defined(PETSC_USE_CTABLE)
545: PetscTableFind(colmap,col+1,&colb);
546: colb--;
547: #else
548: colb = colmap[col] - 1; /* local column index */
549: #endif
550: if (colb == -1) {
551: nrows = 0;
552: } else {
553: colb = colb/bs;
554: row = B_cj + B_ci[colb];
555: nrows = B_ci[colb+1] - B_ci[colb];
556: }
557: nrows_i += nrows;
558: /* loop over columns of B marking them in rowhit */
559: for (k=0; k<nrows; k++) {
560: /* set valaddrhit for part B */
561: spidx = bs2*spidxB[B_ci[colb] + k];
562: valaddrhit[*row] = &B_val[spidx];
563: rowhit[*row++] = colb + 1 + cend - cstart; /* local column index */
564: }
565: }
566: }
567: c->nrows[i] = nrows_i;
569: if (c->htype[0] == 'd') {
570: for (j=0; j<m; j++) {
571: if (rowhit[j]) {
572: Jentry[nz].row = j; /* local row index */
573: Jentry[nz].col = rowhit[j] - 1; /* local column index */
574: Jentry[nz].valaddr = valaddrhit[j]; /* address of mat value for this entry */
575: nz++;
576: }
577: }
578: } else { /* c->htype == 'wp' */
579: for (j=0; j<m; j++) {
580: if (rowhit[j]) {
581: Jentry2[nz].row = j; /* local row index */
582: Jentry2[nz].valaddr = valaddrhit[j]; /* address of mat value for this entry */
583: nz++;
584: }
585: }
586: }
587: PetscFree(cols);
588: }
590: if (bcols > 1) { /* reorder Jentry for faster MatFDColoringApply() */
591: MatFDColoringSetUpBlocked_AIJ_Private(mat,c,nz);
592: }
594: if (isBAIJ) {
595: MatRestoreColumnIJ_SeqBAIJ_Color(A,0,PETSC_FALSE,PETSC_FALSE,&ncols,&A_ci,&A_cj,&spidxA,NULL);
596: MatRestoreColumnIJ_SeqBAIJ_Color(B,0,PETSC_FALSE,PETSC_FALSE,&ncols,&B_ci,&B_cj,&spidxB,NULL);
597: PetscMalloc1(bs*mat->rmap->n,&c->dy);
598: } else if (isSELL) {
599: MatRestoreColumnIJ_SeqSELL_Color(A,0,PETSC_FALSE,PETSC_FALSE,&ncols,&A_ci,&A_cj,&spidxA,NULL);
600: MatRestoreColumnIJ_SeqSELL_Color(B,0,PETSC_FALSE,PETSC_FALSE,&ncols,&B_ci,&B_cj,&spidxB,NULL);
601: }else {
602: MatRestoreColumnIJ_SeqAIJ_Color(A,0,PETSC_FALSE,PETSC_FALSE,&ncols,&A_ci,&A_cj,&spidxA,NULL);
603: MatRestoreColumnIJ_SeqAIJ_Color(B,0,PETSC_FALSE,PETSC_FALSE,&ncols,&B_ci,&B_cj,&spidxB,NULL);
604: }
606: ISColoringRestoreIS(iscoloring,&isa);
607: PetscFree2(rowhit,valaddrhit);
609: if (ctype == IS_COLORING_LOCAL) {
610: ISLocalToGlobalMappingRestoreIndices(map,<og);
611: }
612: PetscInfo3(c,"ncolors %D, brows %D and bcols %D are used.\n",c->ncolors,c->brows,c->bcols);
613: return(0);
614: }
616: PetscErrorCode MatFDColoringCreate_MPIXAIJ(Mat mat,ISColoring iscoloring,MatFDColoring c)
617: {
619: PetscInt bs,nis=iscoloring->n,m=mat->rmap->n;
620: PetscBool isBAIJ,isSELL;
623: /* set default brows and bcols for speedup inserting the dense matrix into sparse Jacobian;
624: bcols is chosen s.t. dy-array takes 50% of memory space as mat */
625: MatGetBlockSize(mat,&bs);
626: PetscObjectTypeCompare((PetscObject)mat,MATMPIBAIJ,&isBAIJ);
627: PetscObjectTypeCompare((PetscObject)mat,MATMPISELL,&isSELL);
628: if (isBAIJ || m == 0) {
629: c->brows = m;
630: c->bcols = 1;
631: } else if (isSELL) {
632: /* bcols is chosen s.t. dy-array takes 50% of local memory space as mat */
633: Mat_MPISELL *sell=(Mat_MPISELL*)mat->data;
634: Mat_SeqSELL *spA,*spB;
635: Mat A,B;
636: PetscInt nz,brows,bcols;
637: PetscReal mem;
639: bs = 1; /* only bs=1 is supported for MPISELL matrix */
641: A = sell->A; spA = (Mat_SeqSELL*)A->data;
642: B = sell->B; spB = (Mat_SeqSELL*)B->data;
643: nz = spA->nz + spB->nz; /* total local nonzero entries of mat */
644: mem = nz*(sizeof(PetscScalar) + sizeof(PetscInt)) + 3*m*sizeof(PetscInt);
645: bcols = (PetscInt)(0.5*mem /(m*sizeof(PetscScalar)));
646: brows = 1000/bcols;
647: if (bcols > nis) bcols = nis;
648: if (brows == 0 || brows > m) brows = m;
649: c->brows = brows;
650: c->bcols = bcols;
651: } else { /* mpiaij matrix */
652: /* bcols is chosen s.t. dy-array takes 50% of local memory space as mat */
653: Mat_MPIAIJ *aij=(Mat_MPIAIJ*)mat->data;
654: Mat_SeqAIJ *spA,*spB;
655: Mat A,B;
656: PetscInt nz,brows,bcols;
657: PetscReal mem;
659: bs = 1; /* only bs=1 is supported for MPIAIJ matrix */
661: A = aij->A; spA = (Mat_SeqAIJ*)A->data;
662: B = aij->B; spB = (Mat_SeqAIJ*)B->data;
663: nz = spA->nz + spB->nz; /* total local nonzero entries of mat */
664: mem = nz*(sizeof(PetscScalar) + sizeof(PetscInt)) + 3*m*sizeof(PetscInt);
665: bcols = (PetscInt)(0.5*mem /(m*sizeof(PetscScalar)));
666: brows = 1000/bcols;
667: if (bcols > nis) bcols = nis;
668: if (brows == 0 || brows > m) brows = m;
669: c->brows = brows;
670: c->bcols = bcols;
671: }
673: c->M = mat->rmap->N/bs; /* set the global rows and columns and local rows */
674: c->N = mat->cmap->N/bs;
675: c->m = mat->rmap->n/bs;
676: c->rstart = mat->rmap->rstart/bs;
677: c->ncolors = nis;
678: return(0);
679: }