/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c

Bug Summary

File:	mat/impls/sell/mpi/mpisell.c
Warning:	line 24, column 14 Division by zero

Annotated Source Code

[?] Use j/k keys for keyboard navigation

/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c

→

#include <../src/mat/impls/aij/mpi/mpiaij.h> /*I "petscmat.h" I*/

#include <../src/mat/impls/sell/mpi/mpisell.h> /*I "petscmat.h" I*/

#include <petsc/private/vecimpl.h>

#include <petsc/private/isimpl.h>

#include <petscblaslapack.h>

#include <petscsf.h>

/*MC

MATSELL - MATSELL = "sell" - A matrix type to be used for sparse matrices.

This matrix type is identical to MATSEQSELL when constructed with a single process communicator,

and MATMPISELL otherwise. As a result, for single process communicators,

MatSeqSELLSetPreallocation is supported, and similarly MatMPISELLSetPreallocation is supported

for communicators controlling multiple processes. It is recommended that you call both of

the above preallocation routines for simplicity.

Options Database Keys:

. -mat_type sell - sets the matrix type to "sell" during a call to MatSetFromOptions()

Developer Notes:

Subclasses include MATSELLCUSP, MATSELLCUSPARSE, MATSELLPERM, MATSELLCRL, and also automatically switches over to use inodes when

enough exist.

Level: beginner

.seealso: MatCreateSELL(), MatCreateSeqSELL(), MATSEQSELL, MATMPISELL

M*/

PetscErrorCode MatDiagonalSet_MPISELL(Mat Y,Vec D,InsertMode is)

{

PetscErrorCode ierr;

Mat_MPISELL *sell=(Mat_MPISELL*)Y->data;

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 34; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

if (Y->assembled && Y->rmap->rstart == Y->cmap->rstart && Y->rmap->rend == Y->cmap->rend) {

ierr = MatDiagonalSet(sell->A,D,is);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),36,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

} else {

ierr = MatDiagonalSet_Default(Y,D,is);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),38,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

}

PetscFunctionReturn(0)do { do { ; if (petscstack && petscstack->currentsize
> 0) { petscstack->currentsize--; petscstack->function
[petscstack->currentsize] = 0; petscstack->file[petscstack
->currentsize] = 0; petscstack->line[petscstack->currentsize
] = 0; petscstack->petscroutine[petscstack->currentsize
] = PETSC_FALSE; } if (petscstack) { petscstack->hotdepth =
(((petscstack->hotdepth-1)<(0)) ? (0) : (petscstack->
hotdepth-1)); } ; } while (0); return(0);} while (0);

}

Local utility routine that creates a mapping from the global column

number to the local number in the off-diagonal part of the local

storage of the matrix. When PETSC_USE_CTABLE is used this is scalable at

a slightly higher hash table cost; without it it is not scalable (each processor

has an order N integer array but is fast to acess.

PetscErrorCode MatCreateColmap_MPISELL_Private(Mat mat)

{

Mat_MPISELL *sell=(Mat_MPISELL*)mat->data;

PetscErrorCode ierr;

PetscInt n=sell->B->cmap->n,i;

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 56; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

if (!sell->garray) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_PLIB,"MPISELL Matrix was assembled but is missing garray")return PetscError(((MPI_Comm)0x44000001),57,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,77,PETSC_ERROR_INITIAL,"MPISELL Matrix was assembled but is missing garray"
);

#if defined(PETSC_USE_CTABLE1)

ierr = PetscTableCreate(n,mat->cmap->N+1,&sell->colmap);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),59,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

for (i=0; i<n; i++) {

ierr = PetscTableAdd(sell->colmap,sell->garray[i]+1,i+1,INSERT_VALUES);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),61,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

}

#else

ierr = PetscCalloc1(mat->cmap->N+1,&sell->colmap)PetscMallocA(1,PETSC_TRUE,64,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,(size_t)(mat->cmap->N+1)*sizeof(**(&sell->colmap
)),(&sell->colmap));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),64,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

ierr = PetscLogObjectMemory((PetscObject)mat,(mat->cmap->N+1)*sizeof(PetscInt));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),65,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

for (i=0; i<n; i++) sell->colmap[sell->garray[i]] = i+1;

#endif

}

#define MatSetValues_SeqSELL_A_Private(row,col,value,addv,orow,ocol){ if (col <= lastcol1) low1 = 0; else high1 = nrow1; lastcol1
= col; while (high1-low1 > 5) { t = (low1+high1)/2; if (*
(cp1+8*t) > col) high1 = t; else low1 = t; } for (_i=low1;
_i<high1; _i++) { if (*(cp1+8*_i) > col) break; if (*(
cp1+8*_i) == col) { if (addv == ADD_VALUES) *(vp1+8*_i) += value
; else *(vp1+8*_i) = value; goto a_noinsert; } } if (value ==
0.0 && ignorezeroentries) {low1 = 0; high1 = nrow1;goto
a_noinsert;} if (nonew == 1) {low1 = 0; high1 = nrow1; goto a_noinsert
;} if (nonew == -1) return PetscError(((MPI_Comm)0x44000001),
71,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,63,PETSC_ERROR_INITIAL,"Inserting a new nonzero at global row/column (%D, %D) into matrix"
,orow,ocol); if (nrow1 >= (a->sliidx[row/8 +1]-a->sliidx
[row/8])/8) { Mat_SeqSELL *Ain = (Mat_SeqSELL*)A->data; PetscInt
new_size=Ain->maxallocmat+8,*new_colidx; MatScalar *new_val
; if (nonew == -2) return PetscError(((MPI_Comm)0x44000001),71
,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,63,PETSC_ERROR_INITIAL,"New nonzero at (%D,%D) caused a malloc\nUse MatSetOption(A, MAT_NEW_NONZERO_ALLOCATION_ERR, PETSC_FALSE) to turn off this check"
,row,col); ierr = PetscMallocA(2,PETSC_FALSE,71,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,(size_t)(1*new_size)*sizeof(**(&new_val)),(&new_val)
,(size_t)(1*new_size)*sizeof(**(&new_colidx)),(&new_colidx
));do {if (__builtin_expect(!!(ierr),0)) return PetscError(((
MPI_Comm)0x44000001),71,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0); ierr = PetscMemcpy
(new_val,a->val,a->sliidx[row/8 +1]*sizeof(MatScalar));
do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),71,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0); ierr = PetscMemcpy
(new_colidx,a->colidx,a->sliidx[row/8 +1]*sizeof(PetscInt
));do {if (__builtin_expect(!!(ierr),0)) return PetscError(((
MPI_Comm)0x44000001),71,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0); ierr = PetscMemcpy
(new_val+a->sliidx[row/8 +1]+8,a->val+a->sliidx[row/
8 +1],(a->sliidx[am>>3]-a->sliidx[row/8 +1])*sizeof
(MatScalar));do {if (__builtin_expect(!!(ierr),0)) return PetscError
(((MPI_Comm)0x44000001),71,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0); ierr = PetscMemcpy
(new_colidx+a->sliidx[row/8 +1]+8,a->colidx+a->sliidx
[row/8 +1],(a->sliidx[am>>3]-a->sliidx[row/8 +1])
*sizeof(PetscInt));do {if (__builtin_expect(!!(ierr),0)) return
PetscError(((MPI_Comm)0x44000001),71,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0); for (ii=row/8 +1;ii
<=am>>3;ii++) { a->sliidx[ii] += 8; } cp1 = new_colidx
+a->sliidx[row/8]+(row & 0x07); vp1 = new_val+a->sliidx
[row/8]+(row & 0x07); ierr = MatSeqXSELLFreeSELL(A,&Ain
->val,&Ain->colidx);do {if (__builtin_expect(!!(ierr
),0)) return PetscError(((MPI_Comm)0x44000001),71,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0); Ain->val = (MatScalar
*) new_val; Ain->colidx = new_colidx; Ain->singlemalloc
= PETSC_TRUE; Ain->maxallocmat = new_size; Ain->reallocs
++; if (nrow1>=Ain->maxallocrow) Ain->maxallocrow++;
if (nrow1>=Ain->rlenmax) Ain->rlenmax++; }; for (ii
=nrow1-1; ii>=_i; ii--) { *(cp1+8*(ii+1)) = *(cp1+8*ii); *
(vp1+8*(ii+1)) = *(vp1+8*ii); } *(cp1+8*_i) = col; *(vp1+8*_i
) = value; a->nz++; nrow1++; A->nonzerostate++; a_noinsert
: ; a->rlen[row] = nrow1; } \

{ \

if (col <= lastcol1) low1 = 0; \

else high1 = nrow1; \

lastcol1 = col; \

while (high1-low1 > 5) { \

t = (low1+high1)/2; \

if (*(cp1+8*t) > col) high1 = t; \

else low1 = t; \

} \

for (_i=low1; _i<high1; _i++) { \

if (*(cp1+8*_i) > col) break; \

if (*(cp1+8*_i) == col) { \

if (addv == ADD_VALUES) *(vp1+8*_i) += value; \

else *(vp1+8*_i) = value; \

goto a_noinsert; \

} \

if (value == 0.0 && ignorezeroentries) {low1 = 0; high1 = nrow1;goto a_noinsert;} \

if (nonew == 1) {low1 = 0; high1 = nrow1; goto a_noinsert;} \

if (nonew == -1) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Inserting a new nonzero at global row/column (%D, %D) into matrix", orow, ocol)return PetscError(((MPI_Comm)0x44000001),91,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,63,PETSC_ERROR_INITIAL,"Inserting a new nonzero at global row/column (%D, %D) into matrix"
,orow,ocol); \

MatSeqXSELLReallocateSELL(A,am,1,nrow1,a->sliidx,row/8,row,col,a->colidx,a->val,cp1,vp1,nonew,MatScalar)if (nrow1 >= (a->sliidx[row/8 +1]-a->sliidx[row/8])/
8) { Mat_SeqSELL *Ain = (Mat_SeqSELL*)A->data; PetscInt new_size
=Ain->maxallocmat+8,*new_colidx; MatScalar *new_val; if (nonew
== -2) return PetscError(((MPI_Comm)0x44000001),92,__func__,
"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,63,PETSC_ERROR_INITIAL,"New nonzero at (%D,%D) caused a malloc\nUse MatSetOption(A, MAT_NEW_NONZERO_ALLOCATION_ERR, PETSC_FALSE) to turn off this check"
,row,col); ierr = PetscMallocA(2,PETSC_FALSE,92,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,(size_t)(1*new_size)*sizeof(**(&new_val)),(&new_val)
,(size_t)(1*new_size)*sizeof(**(&new_colidx)),(&new_colidx
));do {if (__builtin_expect(!!(ierr),0)) return PetscError(((
MPI_Comm)0x44000001),92,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0); ierr = PetscMemcpy
(new_val,a->val,a->sliidx[row/8 +1]*sizeof(MatScalar));
do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),92,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0); ierr = PetscMemcpy
(new_colidx,a->colidx,a->sliidx[row/8 +1]*sizeof(PetscInt
));do {if (__builtin_expect(!!(ierr),0)) return PetscError(((
MPI_Comm)0x44000001),92,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0); ierr = PetscMemcpy
(new_val+a->sliidx[row/8 +1]+8,a->val+a->sliidx[row/
8 +1],(a->sliidx[am>>3]-a->sliidx[row/8 +1])*sizeof
(MatScalar));do {if (__builtin_expect(!!(ierr),0)) return PetscError
(((MPI_Comm)0x44000001),92,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0); ierr = PetscMemcpy
(new_colidx+a->sliidx[row/8 +1]+8,a->colidx+a->sliidx
[row/8 +1],(a->sliidx[am>>3]-a->sliidx[row/8 +1])
*sizeof(PetscInt));do {if (__builtin_expect(!!(ierr),0)) return
PetscError(((MPI_Comm)0x44000001),92,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0); for (ii=row/8 +1;ii
<=am>>3;ii++) { a->sliidx[ii] += 8; } cp1 = new_colidx
+a->sliidx[row/8]+(row & 0x07); vp1 = new_val+a->sliidx
[row/8]+(row & 0x07); ierr = MatSeqXSELLFreeSELL(A,&Ain
->val,&Ain->colidx);do {if (__builtin_expect(!!(ierr
),0)) return PetscError(((MPI_Comm)0x44000001),92,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0); Ain->val = (MatScalar
*) new_val; Ain->colidx = new_colidx; Ain->singlemalloc
= PETSC_TRUE; Ain->maxallocmat = new_size; Ain->reallocs
++; if (nrow1>=Ain->maxallocrow) Ain->maxallocrow++;
if (nrow1>=Ain->rlenmax) Ain->rlenmax++; }; \

/* shift up all the later entries in this row */ \

for (ii=nrow1-1; ii>=_i; ii--) { \

*(cp1+8*(ii+1)) = *(cp1+8*ii); \

*(vp1+8*(ii+1)) = *(vp1+8*ii); \

} \

*(cp1+8*_i) = col; \

*(vp1+8*_i) = value; \

100

a->nz++; nrow1++; A->nonzerostate++; \

101

a_noinsert: ; \

102

a->rlen[row] = nrow1; \

103

}

104

105

#define MatSetValues_SeqSELL_B_Private(row,col,value,addv,orow,ocol){ if (col <= lastcol2) low2 = 0; else high2 = nrow2; lastcol2
= col; while (high2-low2 > 5) { t = (low2+high2)/2; if (*
(cp2+8*t) > col) high2 = t; else low2 = t; } for (_i=low2;
_i<high2; _i++) { if (*(cp2+8*_i) > col) break; if (*(
cp2+8*_i) == col) { if (addv == ADD_VALUES) *(vp2+8*_i) += value
; else *(vp2+8*_i) = value; goto b_noinsert; } } if (value ==
0.0 && ignorezeroentries) {low2 = 0; high2 = nrow2; goto
b_noinsert;} if (nonew == 1) {low2 = 0; high2 = nrow2; goto b_noinsert
;} if (nonew == -1) return PetscError(((MPI_Comm)0x44000001),
105,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,63,PETSC_ERROR_INITIAL,"Inserting a new nonzero at global row/column (%D, %D) into matrix"
,orow,ocol); if (nrow2 >= (b->sliidx[row/8 +1]-b->sliidx
[row/8])/8) { Mat_SeqSELL *Ain = (Mat_SeqSELL*)B->data; PetscInt
new_size=Ain->maxallocmat+8,*new_colidx; MatScalar *new_val
; if (nonew == -2) return PetscError(((MPI_Comm)0x44000001),105
,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,63,PETSC_ERROR_INITIAL,"New nonzero at (%D,%D) caused a malloc\nUse MatSetOption(A, MAT_NEW_NONZERO_ALLOCATION_ERR, PETSC_FALSE) to turn off this check"
,row,col); ierr = PetscMallocA(2,PETSC_FALSE,105,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,(size_t)(1*new_size)*sizeof(**(&new_val)),(&new_val)
,(size_t)(1*new_size)*sizeof(**(&new_colidx)),(&new_colidx
));do {if (__builtin_expect(!!(ierr),0)) return PetscError(((
MPI_Comm)0x44000001),105,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0); ierr = PetscMemcpy
(new_val,b->val,b->sliidx[row/8 +1]*sizeof(MatScalar));
do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),105,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0); ierr = PetscMemcpy
(new_colidx,b->colidx,b->sliidx[row/8 +1]*sizeof(PetscInt
));do {if (__builtin_expect(!!(ierr),0)) return PetscError(((
MPI_Comm)0x44000001),105,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0); ierr = PetscMemcpy
(new_val+b->sliidx[row/8 +1]+8,b->val+b->sliidx[row/
8 +1],(b->sliidx[bm>>3]-b->sliidx[row/8 +1])*sizeof
(MatScalar));do {if (__builtin_expect(!!(ierr),0)) return PetscError
(((MPI_Comm)0x44000001),105,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0); ierr = PetscMemcpy
(new_colidx+b->sliidx[row/8 +1]+8,b->colidx+b->sliidx
[row/8 +1],(b->sliidx[bm>>3]-b->sliidx[row/8 +1])
*sizeof(PetscInt));do {if (__builtin_expect(!!(ierr),0)) return
PetscError(((MPI_Comm)0x44000001),105,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0); for (ii=row/8 +1;ii
<=bm>>3;ii++) { b->sliidx[ii] += 8; } cp2 = new_colidx
+b->sliidx[row/8]+(row & 0x07); vp2 = new_val+b->sliidx
[row/8]+(row & 0x07); ierr = MatSeqXSELLFreeSELL(A,&Ain
->val,&Ain->colidx);do {if (__builtin_expect(!!(ierr
),0)) return PetscError(((MPI_Comm)0x44000001),105,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0); Ain->val = (MatScalar
*) new_val; Ain->colidx = new_colidx; Ain->singlemalloc
= PETSC_TRUE; Ain->maxallocmat = new_size; Ain->reallocs
++; if (nrow2>=Ain->maxallocrow) Ain->maxallocrow++;
if (nrow2>=Ain->rlenmax) Ain->rlenmax++; }; for (ii
=nrow2-1; ii>=_i; ii--) { *(cp2+8*(ii+1)) = *(cp2+8*ii); *
(vp2+8*(ii+1)) = *(vp2+8*ii); } *(cp2+8*_i) = col; *(vp2+8*_i
) = value; b->nz++; nrow2++; B->nonzerostate++; b_noinsert
: ; b->rlen[row] = nrow2; } \

106

{ \

107

if (col <= lastcol2) low2 = 0; \

108

else high2 = nrow2; \

109

lastcol2 = col; \

110

while (high2-low2 > 5) { \

111

t = (low2+high2)/2; \

112

if (*(cp2+8*t) > col) high2 = t; \

113

else low2 = t; \

114

} \

115

for (_i=low2; _i<high2; _i++) { \

116

if (*(cp2+8*_i) > col) break; \

117

if (*(cp2+8*_i) == col) { \

118

if (addv == ADD_VALUES) *(vp2+8*_i) += value; \

119

else *(vp2+8*_i) = value; \

120

goto b_noinsert; \

121

} \

122

} \

123

if (value == 0.0 && ignorezeroentries) {low2 = 0; high2 = nrow2; goto b_noinsert;} \

124

if (nonew == 1) {low2 = 0; high2 = nrow2; goto b_noinsert;} \

125

if (nonew == -1) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Inserting a new nonzero at global row/column (%D, %D) into matrix", orow, ocol)return PetscError(((MPI_Comm)0x44000001),125,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,63,PETSC_ERROR_INITIAL,"Inserting a new nonzero at global row/column (%D, %D) into matrix"
,orow,ocol); \

126

MatSeqXSELLReallocateSELL(B,bm,1,nrow2,b->sliidx,row/8,row,col,b->colidx,b->val,cp2,vp2,nonew,MatScalar)if (nrow2 >= (b->sliidx[row/8 +1]-b->sliidx[row/8])/
8) { Mat_SeqSELL *Ain = (Mat_SeqSELL*)B->data; PetscInt new_size
=Ain->maxallocmat+8,*new_colidx; MatScalar *new_val; if (nonew
== -2) return PetscError(((MPI_Comm)0x44000001),126,__func__
,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,63,PETSC_ERROR_INITIAL,"New nonzero at (%D,%D) caused a malloc\nUse MatSetOption(A, MAT_NEW_NONZERO_ALLOCATION_ERR, PETSC_FALSE) to turn off this check"
,row,col); ierr = PetscMallocA(2,PETSC_FALSE,126,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,(size_t)(1*new_size)*sizeof(**(&new_val)),(&new_val)
,(size_t)(1*new_size)*sizeof(**(&new_colidx)),(&new_colidx
));do {if (__builtin_expect(!!(ierr),0)) return PetscError(((
MPI_Comm)0x44000001),126,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0); ierr = PetscMemcpy
(new_val,b->val,b->sliidx[row/8 +1]*sizeof(MatScalar));
do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),126,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0); ierr = PetscMemcpy
(new_colidx,b->colidx,b->sliidx[row/8 +1]*sizeof(PetscInt
));do {if (__builtin_expect(!!(ierr),0)) return PetscError(((
MPI_Comm)0x44000001),126,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0); ierr = PetscMemcpy
(new_val+b->sliidx[row/8 +1]+8,b->val+b->sliidx[row/
8 +1],(b->sliidx[bm>>3]-b->sliidx[row/8 +1])*sizeof
(MatScalar));do {if (__builtin_expect(!!(ierr),0)) return PetscError
(((MPI_Comm)0x44000001),126,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0); ierr = PetscMemcpy
(new_colidx+b->sliidx[row/8 +1]+8,b->colidx+b->sliidx
[row/8 +1],(b->sliidx[bm>>3]-b->sliidx[row/8 +1])
*sizeof(PetscInt));do {if (__builtin_expect(!!(ierr),0)) return
PetscError(((MPI_Comm)0x44000001),126,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0); for (ii=row/8 +1;ii
<=bm>>3;ii++) { b->sliidx[ii] += 8; } cp2 = new_colidx
+b->sliidx[row/8]+(row & 0x07); vp2 = new_val+b->sliidx
[row/8]+(row & 0x07); ierr = MatSeqXSELLFreeSELL(A,&Ain
->val,&Ain->colidx);do {if (__builtin_expect(!!(ierr
),0)) return PetscError(((MPI_Comm)0x44000001),126,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0); Ain->val = (MatScalar
*) new_val; Ain->colidx = new_colidx; Ain->singlemalloc
= PETSC_TRUE; Ain->maxallocmat = new_size; Ain->reallocs
++; if (nrow2>=Ain->maxallocrow) Ain->maxallocrow++;
if (nrow2>=Ain->rlenmax) Ain->rlenmax++; }; \

127

/* shift up all the later entries in this row */ \

128

for (ii=nrow2-1; ii>=_i; ii--) { \

129

*(cp2+8*(ii+1)) = *(cp2+8*ii); \

130

*(vp2+8*(ii+1)) = *(vp2+8*ii); \

131

} \

132

*(cp2+8*_i) = col; \

133

*(vp2+8*_i) = value; \

134

b->nz++; nrow2++; B->nonzerostate++; \

135

b_noinsert: ; \

136

b->rlen[row] = nrow2; \

137

}

138

139

PetscErrorCode MatSetValues_MPISELL(Mat mat,PetscInt m,const PetscInt im[],PetscInt n,const PetscInt in[],const PetscScalar v[],InsertMode addv)

140

{

141

Mat_MPISELL *sell=(Mat_MPISELL*)mat->data;

142

PetscScalar value;

143

PetscErrorCode ierr;

144

PetscInt i,j,rstart=mat->rmap->rstart,rend=mat->rmap->rend,shift1,shift2;

145

PetscInt cstart=mat->cmap->rstart,cend=mat->cmap->rend,row,col;

146

PetscBool roworiented=sell->roworiented;

147

148

/* Some Variables required in the macro */

149

Mat A=sell->A;

150

Mat_SeqSELL *a=(Mat_SeqSELL*)A->data;

151

PetscBool ignorezeroentries=a->ignorezeroentries,found;

152

Mat B=sell->B;

153

Mat_SeqSELL *b=(Mat_SeqSELL*)B->data;

154

PetscInt *cp1,*cp2,ii,_i,nrow1,nrow2,low1,high1,low2,high2,t,lastcol1,lastcol2;

155

MatScalar *vp1,*vp2;

156

157

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 157; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

158

for (i=0; i<m; i++) {

159

if (im[i] < 0) continue;

160

#if defined(PETSC_USE_DEBUG1)

161

if (im[i] >= mat->rmap->N) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Row too large: row %D max %D",im[i],mat->rmap->N-1)return PetscError(((MPI_Comm)0x44000001),161,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,63,PETSC_ERROR_INITIAL,"Row too large: row %D max %D",im[i],
mat->rmap->N-1);

162

#endif

163

if (im[i] >= rstart && im[i] < rend) {

164

row = im[i] - rstart;

165

lastcol1 = -1;

166

shift1 = a->sliidx[row>>3]+(row&0x07); /* starting index of the row */

167

cp1 = a->colidx+shift1;

168

vp1 = a->val+shift1;

169

nrow1 = a->rlen[row];

170

low1 = 0;

171

high1 = nrow1;

172

lastcol2 = -1;

173

shift2 = b->sliidx[row>>3]+(row&0x07); /* starting index of the row */

174

cp2 = b->colidx+shift2;

175

vp2 = b->val+shift2;

176

nrow2 = b->rlen[row];

177

low2 = 0;

178

high2 = nrow2;

179

180

for (j=0; j<n; j++) {

181

if (roworiented) value = v[i*n+j];

182

else value = v[i+j*m];

183

if (ignorezeroentries && value == 0.0 && (addv == ADD_VALUES)) continue;

184

if (in[j] >= cstart && in[j] < cend) {

185

col = in[j] - cstart;

186

MatSetValue_SeqSELL_Private(A,row,col,value,addv,im[i],in[j],cp1,vp1,lastcol1,low1,high1){ Mat_SeqSELL *a=(Mat_SeqSELL*)A->data; found=PETSC_FALSE;
if (col <= lastcol1) low1 = 0; else high1 = a->rlen[row
]; lastcol1 = col; while (high1-low1 > 5) { t = (low1+high1
)/2; if (*(cp1+8*t) > col) high1 = t; else low1 = t; } for
(_i=low1; _i<high1; _i++) { if (*(cp1+8*_i) > col) break
; if (*(cp1+8*_i) == col) { if (addv == ADD_VALUES)*(vp1+8*_i
) += value; else *(vp1+8*_i) = value; found = PETSC_TRUE; break
; } } if (!found) { if (a->nonew == -1) return PetscError(
((MPI_Comm)0x44000001),186,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,63,PETSC_ERROR_INITIAL,"Inserting a new nonzero at global row/column (%D, %D) into matrix"
,im[i],in[j]); if (a->nonew != 1 && !(value == 0.0
&& a->ignorezeroentries) && a->rlen[row
] >= (a->sliidx[row/8+1]-a->sliidx[row/8])/8) { if (
a->maxallocmat < a->sliidx[a->totalslices]+8) { PetscInt
new_size=a->maxallocmat+8,*new_colidx; MatScalar *new_val
; if (a->nonew == -2) return PetscError(((MPI_Comm)0x44000001
),186,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,63,PETSC_ERROR_INITIAL,"New nonzero at (%D,%D) caused a malloc\nUse MatSetOption(A, MAT_NEW_NONZERO_ALLOCATION_ERR, PETSC_FALSE) to turn off this check"
,im[i],in[j]); ierr = PetscMallocA(2,PETSC_FALSE,186,__func__
,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,(size_t)(new_size)*sizeof(**(&new_val)),(&new_val),(
size_t)(new_size)*sizeof(**(&new_colidx)),(&new_colidx
));do {if (__builtin_expect(!!(ierr),0)) return PetscError(((
MPI_Comm)0x44000001),186,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0); ierr = PetscMemcpy
(new_val,a->val,a->sliidx[row/8+1]*sizeof(MatScalar));do
{if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),186,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0); ierr = PetscMemcpy
(new_colidx,a->colidx,a->sliidx[row/8+1]*sizeof(PetscInt
));do {if (__builtin_expect(!!(ierr),0)) return PetscError(((
MPI_Comm)0x44000001),186,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0); ierr = PetscMemcpy
(new_val+a->sliidx[row/8+1]+8,a->val+a->sliidx[row/8
+1],(a->sliidx[a->totalslices]-a->sliidx[row/8+1])*sizeof
(MatScalar));do {if (__builtin_expect(!!(ierr),0)) return PetscError
(((MPI_Comm)0x44000001),186,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0); ierr = PetscMemcpy
(new_colidx+a->sliidx[row/8+1]+8,a->colidx+a->sliidx
[row/8+1],(a->sliidx[a->totalslices]-a->sliidx[row/8
+1])*sizeof(PetscInt));do {if (__builtin_expect(!!(ierr),0)) return
PetscError(((MPI_Comm)0x44000001),186,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0); cp1 = new_colidx+a
->sliidx[row/8]+(row & 0x07); vp1 = new_val+a->sliidx
[row/8]+(row & 0x07); ierr = MatSeqXSELLFreeSELL(A,&a
->val,&a->colidx);do {if (__builtin_expect(!!(ierr)
,0)) return PetscError(((MPI_Comm)0x44000001),186,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0); a->val = (MatScalar
*)new_val; a->colidx = new_colidx; a->singlemalloc = PETSC_TRUE
; a->maxallocmat = new_size; a->reallocs++; } else { ierr
= PetscMemmove(a->val+a->sliidx[row/8+1]+8,a->val+a
->sliidx[row/8+1],(a->sliidx[a->totalslices]-a->sliidx
[row/8+1])*sizeof(MatScalar));do {if (__builtin_expect(!!(ierr
),0)) return PetscError(((MPI_Comm)0x44000001),186,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0); ierr = PetscMemmove
(a->colidx+a->sliidx[row/8+1]+8,a->colidx+a->sliidx
[row/8+1],(a->sliidx[a->totalslices]-a->sliidx[row/8
+1])*sizeof(PetscInt));do {if (__builtin_expect(!!(ierr),0)) return
PetscError(((MPI_Comm)0x44000001),186,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0); } for (ii=row/8+1;
ii<=a->totalslices;ii++) a->sliidx[ii] += 8; if (a->
rlen[row]>=a->maxallocrow) a->maxallocrow++; if (a->
rlen[row]>=a->rlenmax) a->rlenmax++; } for (ii=a->
rlen[row]-1; ii>=_i; ii--) { *(cp1+8*(ii+1)) = *(cp1+8*ii)
; *(vp1+8*(ii+1)) = *(vp1+8*ii); } *(cp1+8*_i) = col; *(vp1+8
*_i) = value; a->nz++; a->rlen[row]++; A->nonzerostate
++; low1 = _i+1; high1++; } }; /* set one value */

187

} else if (in[j] < 0) continue;

188

#if defined(PETSC_USE_DEBUG1)

189

else if (in[j] >= mat->cmap->N) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Column too large: col %D max %D",in[j],mat->cmap->N-1)return PetscError(((MPI_Comm)0x44000001),189,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,63,PETSC_ERROR_INITIAL,"Column too large: col %D max %D",in[
j],mat->cmap->N-1);

190

#endif

191

else {

192

if (mat->was_assembled) {

193

if (!sell->colmap) {

194

ierr = MatCreateColmap_MPISELL_Private(mat);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),194,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

195

}

196

#if defined(PETSC_USE_CTABLE1)

197

ierr = PetscTableFind(sell->colmap,in[j]+1,&col);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),197,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

198

col--;

199

#else

200

col = sell->colmap[in[j]] - 1;

201

#endif

202

if (col < 0 && !((Mat_SeqSELL*)(sell->B->data))->nonew) {

203

ierr = MatDisAssemble_MPISELL(mat);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),203,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

204

col = in[j];

205

/* Reinitialize the variables required by MatSetValues_SeqSELL_B_Private() */

206

B = sell->B;

207

b = (Mat_SeqSELL*)B->data;

208

shift2 = b->sliidx[row>>3]+(row&0x07); /* starting index of the row */

209

cp2 = b->colidx+shift2;

210

vp2 = b->val+shift2;

211

nrow2 = b->rlen[row];

212

low2 = 0;

213

high2 = nrow2;

214

} else if (col < 0) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Inserting a new nonzero at global row/column (%D, %D) into matrix", im[i], in[j])return PetscError(((MPI_Comm)0x44000001),214,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,63,PETSC_ERROR_INITIAL,"Inserting a new nonzero at global row/column (%D, %D) into matrix"
,im[i],in[j]);

215

} else col = in[j];

216

MatSetValue_SeqSELL_Private(B,row,col,value,addv,im[i],in[j],cp2,vp2,lastcol2,low2,high2){ Mat_SeqSELL *a=(Mat_SeqSELL*)B->data; found=PETSC_FALSE;
if (col <= lastcol2) low2 = 0; else high2 = a->rlen[row
]; lastcol2 = col; while (high2-low2 > 5) { t = (low2+high2
)/2; if (*(cp2+8*t) > col) high2 = t; else low2 = t; } for
(_i=low2; _i<high2; _i++) { if (*(cp2+8*_i) > col) break
; if (*(cp2+8*_i) == col) { if (addv == ADD_VALUES)*(vp2+8*_i
) += value; else *(vp2+8*_i) = value; found = PETSC_TRUE; break
; } } if (!found) { if (a->nonew == -1) return PetscError(
((MPI_Comm)0x44000001),216,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,63,PETSC_ERROR_INITIAL,"Inserting a new nonzero at global row/column (%D, %D) into matrix"
,im[i],in[j]); if (a->nonew != 1 && !(value == 0.0
&& a->ignorezeroentries) && a->rlen[row
] >= (a->sliidx[row/8+1]-a->sliidx[row/8])/8) { if (
a->maxallocmat < a->sliidx[a->totalslices]+8) { PetscInt
new_size=a->maxallocmat+8,*new_colidx; MatScalar *new_val
; if (a->nonew == -2) return PetscError(((MPI_Comm)0x44000001
),216,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,63,PETSC_ERROR_INITIAL,"New nonzero at (%D,%D) caused a malloc\nUse MatSetOption(A, MAT_NEW_NONZERO_ALLOCATION_ERR, PETSC_FALSE) to turn off this check"
,im[i],in[j]); ierr = PetscMallocA(2,PETSC_FALSE,216,__func__
,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,(size_t)(new_size)*sizeof(**(&new_val)),(&new_val),(
size_t)(new_size)*sizeof(**(&new_colidx)),(&new_colidx
));do {if (__builtin_expect(!!(ierr),0)) return PetscError(((
MPI_Comm)0x44000001),216,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0); ierr = PetscMemcpy
(new_val,a->val,a->sliidx[row/8+1]*sizeof(MatScalar));do
{if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),216,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0); ierr = PetscMemcpy
(new_colidx,a->colidx,a->sliidx[row/8+1]*sizeof(PetscInt
));do {if (__builtin_expect(!!(ierr),0)) return PetscError(((
MPI_Comm)0x44000001),216,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0); ierr = PetscMemcpy
(new_val+a->sliidx[row/8+1]+8,a->val+a->sliidx[row/8
+1],(a->sliidx[a->totalslices]-a->sliidx[row/8+1])*sizeof
(MatScalar));do {if (__builtin_expect(!!(ierr),0)) return PetscError
(((MPI_Comm)0x44000001),216,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0); ierr = PetscMemcpy
(new_colidx+a->sliidx[row/8+1]+8,a->colidx+a->sliidx
[row/8+1],(a->sliidx[a->totalslices]-a->sliidx[row/8
+1])*sizeof(PetscInt));do {if (__builtin_expect(!!(ierr),0)) return
PetscError(((MPI_Comm)0x44000001),216,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0); cp2 = new_colidx+a
->sliidx[row/8]+(row & 0x07); vp2 = new_val+a->sliidx
[row/8]+(row & 0x07); ierr = MatSeqXSELLFreeSELL(B,&a
->val,&a->colidx);do {if (__builtin_expect(!!(ierr)
,0)) return PetscError(((MPI_Comm)0x44000001),216,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0); a->val = (MatScalar
*)new_val; a->colidx = new_colidx; a->singlemalloc = PETSC_TRUE
; a->maxallocmat = new_size; a->reallocs++; } else { ierr
= PetscMemmove(a->val+a->sliidx[row/8+1]+8,a->val+a
->sliidx[row/8+1],(a->sliidx[a->totalslices]-a->sliidx
[row/8+1])*sizeof(MatScalar));do {if (__builtin_expect(!!(ierr
),0)) return PetscError(((MPI_Comm)0x44000001),216,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0); ierr = PetscMemmove
(a->colidx+a->sliidx[row/8+1]+8,a->colidx+a->sliidx
[row/8+1],(a->sliidx[a->totalslices]-a->sliidx[row/8
+1])*sizeof(PetscInt));do {if (__builtin_expect(!!(ierr),0)) return
PetscError(((MPI_Comm)0x44000001),216,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0); } for (ii=row/8+1;
ii<=a->totalslices;ii++) a->sliidx[ii] += 8; if (a->
rlen[row]>=a->maxallocrow) a->maxallocrow++; if (a->
rlen[row]>=a->rlenmax) a->rlenmax++; } for (ii=a->
rlen[row]-1; ii>=_i; ii--) { *(cp2+8*(ii+1)) = *(cp2+8*ii)
; *(vp2+8*(ii+1)) = *(vp2+8*ii); } *(cp2+8*_i) = col; *(vp2+8
*_i) = value; a->nz++; a->rlen[row]++; B->nonzerostate
++; low2 = _i+1; high2++; } }; /* set one value */

217

}

218

}

219

} else {

220

if (mat->nooffprocentries) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONG,"Setting off process row %D even though MatSetOption(,MAT_NO_OFF_PROC_ENTRIES,PETSC_TRUE) was set",im[i])return PetscError(((MPI_Comm)0x44000001),220,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,62,PETSC_ERROR_INITIAL,"Setting off process row %D even though MatSetOption(,MAT_NO_OFF_PROC_ENTRIES,PETSC_TRUE) was set"
,im[i]);

221

if (!sell->donotstash) {

222

mat->assembled = PETSC_FALSE;

223

if (roworiented) {

224

ierr = MatStashValuesRow_Private(&mat->stash,im[i],n,in,v+i*n,(PetscBool)(ignorezeroentries && (addv == ADD_VALUES)));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),224,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

225

} else {

226

ierr = MatStashValuesCol_Private(&mat->stash,im[i],n,in,v+i,m,(PetscBool)(ignorezeroentries && (addv == ADD_VALUES)));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),226,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

227

}

228

}

229

}

230

}

231

232

}

233

234

PetscErrorCode MatGetValues_MPISELL(Mat mat,PetscInt m,const PetscInt idxm[],PetscInt n,const PetscInt idxn[],PetscScalar v[])

235

{

236

Mat_MPISELL *sell=(Mat_MPISELL*)mat->data;

237

PetscErrorCode ierr;

238

PetscInt i,j,rstart=mat->rmap->rstart,rend=mat->rmap->rend;

239

PetscInt cstart=mat->cmap->rstart,cend=mat->cmap->rend,row,col;

240

241

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 241; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

242

for (i=0; i<m; i++) {

Assuming 'i' is < 'm'

→

←

Loop condition is true. Entering loop body

→

←

Assuming 'i' is < 'm'

→

←

Loop condition is true. Entering loop body

→

243

if (idxm[i] < 0) continue; /* SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Negative row: %D",idxm[i]);*/

←

Assuming the condition is false

Taking false branch

Assuming the condition is false

→

←

Taking false branch

→

244

if (idxm[i] >= mat->rmap->N) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Row too large: row %D max %D",idxm[i],mat->rmap->N-1)return PetscError(((MPI_Comm)0x44000001),244,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,63,PETSC_ERROR_INITIAL,"Row too large: row %D max %D",idxm[i
],mat->rmap->N-1);

Taking false branch

Taking false branch

245

if (idxm[i] >= rstart && idxm[i] < rend) {

Taking true branch

Taking true branch

246

row = idxm[i] - rstart;

247

for (j=0; j<n; j++) {

←

Assuming 'j' is < 'n'

→

←

Loop condition is true. Entering loop body

→

←

Assuming 'j' is >= 'n'

→

←

Loop condition is false. Execution continues on line 242

→

←

Loop condition is true. Entering loop body

→

248

if (idxn[j] < 0) continue; /* SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Negative column: %D",idxn[j]); */

←

Assuming the condition is false

Taking false branch

Taking false branch

249

if (idxn[j] >= mat->cmap->N) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Column too large: col %D max %D",idxn[j],mat->cmap->N-1)return PetscError(((MPI_Comm)0x44000001),249,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,63,PETSC_ERROR_INITIAL,"Column too large: col %D max %D",idxn
[j],mat->cmap->N-1);

Taking false branch

Taking false branch

250

if (idxn[j] >= cstart && idxn[j] < cend) {

251

col = idxn[j] - cstart;

252

ierr = MatGetValues(sell->A,1,&row,1,&col,v+i*n+j);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),252,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

253

} else {

254

if (!sell->colmap) {

←

Assuming the condition is false

Taking false branch

Taking false branch

255

ierr = MatCreateColmap_MPISELL_Private(mat);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),255,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

256

}

257

#if defined(PETSC_USE_CTABLE1)

258

ierr = PetscTableFind(sell->colmap,idxn[j]+1,&col);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),258,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

←

Calling 'PetscTableFind'

→

259

col--;

260

#else

261

col = sell->colmap[idxn[j]] - 1;

262

#endif

263

if ((col < 0) || (sell->garray[col] != idxn[j])) *(v+i*n+j) = 0.0;

264

else {

265

ierr = MatGetValues(sell->B,1,&row,1,&col,v+i*n+j);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),265,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

266

}

267

}

268

}

269

} else SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SUP,"Only local values currently supported")return PetscError(((MPI_Comm)0x44000001),269,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,56,PETSC_ERROR_INITIAL,"Only local values currently supported"
);

270

}

271

272

}

273

274

extern PetscErrorCode MatMultDiagonalBlock_MPISELL(Mat,Vec,Vec);

275

276

PetscErrorCode MatAssemblyBegin_MPISELL(Mat mat,MatAssemblyType mode)

277

{

278

Mat_MPISELL *sell=(Mat_MPISELL*)mat->data;

279

PetscErrorCode ierr;

280

PetscInt nstash,reallocs;

281

282

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 282; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

283

if (sell->donotstash || mat->nooffprocentries) PetscFunctionReturn(0)do { do { ; if (petscstack && petscstack->currentsize
> 0) { petscstack->currentsize--; petscstack->function
[petscstack->currentsize] = 0; petscstack->file[petscstack
->currentsize] = 0; petscstack->line[petscstack->currentsize
] = 0; petscstack->petscroutine[petscstack->currentsize
] = PETSC_FALSE; } if (petscstack) { petscstack->hotdepth =
(((petscstack->hotdepth-1)<(0)) ? (0) : (petscstack->
hotdepth-1)); } ; } while (0); return(0);} while (0);

284

285

ierr = MatStashScatterBegin_Private(mat,&mat->stash,mat->rmap->range);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),285,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

286

ierr = MatStashGetInfo_Private(&mat->stash,&nstash,&reallocs);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),286,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

287

ierr = PetscInfo2(sell->A,"Stash has %D entries, uses %D mallocs.\n",nstash,reallocs)PetscInfo_Private(__func__,sell->A,"Stash has %D entries, uses %D mallocs.\n"
,nstash,reallocs);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),287,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

288

289

}

290

291

PetscErrorCode MatAssemblyEnd_MPISELL(Mat mat,MatAssemblyType mode)

292

{

293

Mat_MPISELL *sell=(Mat_MPISELL*)mat->data;

294

PetscErrorCode ierr;

295

PetscMPIInt n;

296

PetscInt i,flg;

297

PetscInt *row,*col;

298

PetscScalar *val;

299

PetscBool other_disassembled;

300

/* do not use 'b = (Mat_SeqSELL*)sell->B->data' as B can be reset in disassembly */

301

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 301; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

302

if (!sell->donotstash && !mat->nooffprocentries) {

303

while (1) {

304

ierr = MatStashScatterGetMesg_Private(&mat->stash,&n,&row,&col,&val,&flg);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),304,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

305

if (!flg) break;

306

307

for (i=0; i<n; i++) { /* assemble one by one */

308

ierr = MatSetValues_MPISELL(mat,1,row+i,1,col+i,val+i,mat->insertmode);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),308,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

309

}

310

}

311

ierr = MatStashScatterEnd_Private(&mat->stash);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),311,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

312

}

313

ierr = MatAssemblyBegin(sell->A,mode);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),313,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

314

ierr = MatAssemblyEnd(sell->A,mode);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),314,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

315

316

317

determine if any processor has disassembled, if so we must

318

also disassemble ourselfs, in order that we may reassemble.

319

320

321

if nonzero structure of submatrix B cannot change then we know that

322

no processor disassembled thus we can skip this stuff

323

324

if (!((Mat_SeqSELL*)sell->B->data)->nonew) {

325

ierr = MPIU_Allreduce(&mat->was_assembled,&other_disassembled,1,MPIU_BOOL,MPI_PROD,PetscObjectComm((PetscObject)mat))(PetscAllreduceBarrierCheck(PetscObjectComm((PetscObject)mat)
,1,325,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
) || ((petsc_allreduce_ct += PetscMPIParallelComm((PetscObjectComm
((PetscObject)mat))),0) || MPI_Allreduce((&mat->was_assembled
),(&other_disassembled),(1),(MPIU_BOOL),((MPI_Op)(0x58000004
)),(PetscObjectComm((PetscObject)mat)))));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),325,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

326

if (mat->was_assembled && !other_disassembled) {

327

SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SUP,"MatDisAssemble not implemented yet\n")return PetscError(((MPI_Comm)0x44000001),327,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,56,PETSC_ERROR_INITIAL,"MatDisAssemble not implemented yet\n"
);

328

ierr = MatDisAssemble_MPISELL(mat);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),328,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

329

}

330

}

331

if (!mat->was_assembled && mode == MAT_FINAL_ASSEMBLY) {

332

ierr = MatSetUpMultiply_MPISELL(mat);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),332,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

333

}

334

335

ierr = MatSetOption(sell->B,MAT_USE_INODES,PETSC_FALSE);CHKERRQ(ierr);

336

337

ierr = MatAssemblyBegin(sell->B,mode);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),337,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

338

ierr = MatAssemblyEnd(sell->B,mode);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),338,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

339

ierr = PetscFree2(sell->rowvalues,sell->rowindices)PetscFreeA(2,339,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,&(sell->rowvalues),&(sell->rowindices));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),339,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

340

sell->rowvalues = 0;

341

ierr = VecDestroy(&sell->diag);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),341,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

342

343

/* if no new nonzero locations are allowed in matrix then only set the matrix state the first time through */

344

if ((!mat->was_assembled && mode == MAT_FINAL_ASSEMBLY) || !((Mat_SeqSELL*)(sell->A->data))->nonew) {

345

PetscObjectState state = sell->A->nonzerostate + sell->B->nonzerostate;

346

ierr = MPIU_Allreduce(&state,&mat->nonzerostate,1,MPIU_INT64,MPI_SUM,PetscObjectComm((PetscObject)mat))(PetscAllreduceBarrierCheck(PetscObjectComm((PetscObject)mat)
,1,346,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
) || ((petsc_allreduce_ct += PetscMPIParallelComm((PetscObjectComm
((PetscObject)mat))),0) || MPI_Allreduce((&state),(&mat
->nonzerostate),(1),(((MPI_Datatype)0x4c00083a)),((MPI_Op)
(0x58000003)),(PetscObjectComm((PetscObject)mat)))));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),346,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

347

}

348

349

}

350

351

PetscErrorCode MatZeroEntries_MPISELL(Mat A)

352

{

353

Mat_MPISELL *l=(Mat_MPISELL*)A->data;

354

PetscErrorCode ierr;

355

356

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 356; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

357

ierr = MatZeroEntries(l->A);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),357,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

358

ierr = MatZeroEntries(l->B);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),358,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

359

360

}

361

362

PetscErrorCode MatMult_MPISELL(Mat A,Vec xx,Vec yy)

363

{

364

Mat_MPISELL *a=(Mat_MPISELL*)A->data;

365

PetscErrorCode ierr;

366

PetscInt nt;

367

368

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 368; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

369

ierr = VecGetLocalSize(xx,&nt);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),369,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

370

if (nt != A->cmap->n) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_ARG_SIZ,"Incompatible partition of A (%D) and xx (%D)",A->cmap->n,nt)return PetscError(((MPI_Comm)0x44000001),370,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,60,PETSC_ERROR_INITIAL,"Incompatible partition of A (%D) and xx (%D)"
,A->cmap->n,nt);

371

ierr = VecScatterBegin(a->Mvctx,xx,a->lvec,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),371,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

372

ierr = (*a->A->ops->mult)(a->A,xx,yy);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),372,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

373

ierr = VecScatterEnd(a->Mvctx,xx,a->lvec,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),373,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

374

ierr = (*a->B->ops->multadd)(a->B,a->lvec,yy,yy);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),374,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

375

376

}

377

378

PetscErrorCode MatMultDiagonalBlock_MPISELL(Mat A,Vec bb,Vec xx)

379

{

380

Mat_MPISELL *a=(Mat_MPISELL*)A->data;

381

PetscErrorCode ierr;

382

383

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 383; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

384

ierr = MatMultDiagonalBlock(a->A,bb,xx);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),384,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

385

386

}

387

388

PetscErrorCode MatMultAdd_MPISELL(Mat A,Vec xx,Vec yy,Vec zz)

389

{

390

Mat_MPISELL *a=(Mat_MPISELL*)A->data;

391

PetscErrorCode ierr;

392

393

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 393; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

394

ierr = VecScatterBegin(a->Mvctx,xx,a->lvec,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),394,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

395

ierr = (*a->A->ops->multadd)(a->A,xx,yy,zz);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),395,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

396

ierr = VecScatterEnd(a->Mvctx,xx,a->lvec,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),396,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

397

ierr = (*a->B->ops->multadd)(a->B,a->lvec,zz,zz);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),397,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

398

399

}

400

401

PetscErrorCode MatMultTranspose_MPISELL(Mat A,Vec xx,Vec yy)

402

{

403

Mat_MPISELL *a=(Mat_MPISELL*)A->data;

404

PetscErrorCode ierr;

405

406

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 406; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

407

/* do nondiagonal part */

408

ierr = (*a->B->ops->multtranspose)(a->B,xx,a->lvec);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),408,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

409

/* do local part */

410

ierr = (*a->A->ops->multtranspose)(a->A,xx,yy);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),410,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

411

/* add partial results together */

412

ierr = VecScatterBegin(a->Mvctx,a->lvec,yy,ADD_VALUES,SCATTER_REVERSE);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),412,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

413

ierr = VecScatterEnd(a->Mvctx,a->lvec,yy,ADD_VALUES,SCATTER_REVERSE);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),413,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

414

415

}

416

417

PetscErrorCode MatIsTranspose_MPISELL(Mat Amat,Mat Bmat,PetscReal tol,PetscBool *f)

418

{

419

MPI_Comm comm;

420

Mat_MPISELL *Asell=(Mat_MPISELL*)Amat->data,*Bsell;

421

Mat Adia=Asell->A,Bdia,Aoff,Boff,*Aoffs,*Boffs;

422

IS Me,Notme;

423

PetscErrorCode ierr;

424

PetscInt M,N,first,last,*notme,i;

425

PetscMPIInt size;

426

427

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 427; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

428

/* Easy test: symmetric diagonal block */

429

Bsell = (Mat_MPISELL*)Bmat->data; Bdia = Bsell->A;

430

ierr = MatIsTranspose(Adia,Bdia,tol,f);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),430,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

431

if (!*f) PetscFunctionReturn(0)do { do { ; if (petscstack && petscstack->currentsize
> 0) { petscstack->currentsize--; petscstack->function
[petscstack->currentsize] = 0; petscstack->file[petscstack
->currentsize] = 0; petscstack->line[petscstack->currentsize
] = 0; petscstack->petscroutine[petscstack->currentsize
] = PETSC_FALSE; } if (petscstack) { petscstack->hotdepth =
(((petscstack->hotdepth-1)<(0)) ? (0) : (petscstack->
hotdepth-1)); } ; } while (0); return(0);} while (0);

432

ierr = PetscObjectGetComm((PetscObject)Amat,&comm);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),432,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

433

ierr = MPI_Comm_size(comm,&size);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),433,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

434

if (size == 1) PetscFunctionReturn(0)do { do { ; if (petscstack && petscstack->currentsize
> 0) { petscstack->currentsize--; petscstack->function
[petscstack->currentsize] = 0; petscstack->file[petscstack
->currentsize] = 0; petscstack->line[petscstack->currentsize
] = 0; petscstack->petscroutine[petscstack->currentsize
] = PETSC_FALSE; } if (petscstack) { petscstack->hotdepth =
(((petscstack->hotdepth-1)<(0)) ? (0) : (petscstack->
hotdepth-1)); } ; } while (0); return(0);} while (0);

435

436

/* Hard test: off-diagonal block. This takes a MatCreateSubMatrix. */

437

ierr = MatGetSize(Amat,&M,&N);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),437,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

438

ierr = MatGetOwnershipRange(Amat,&first,&last);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),438,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

439

ierr = PetscMalloc1(N-last+first,&notme)PetscMallocA(1,PETSC_FALSE,439,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,(size_t)(N-last+first)*sizeof(**(&notme)),(&notme));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),439,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

440

for (i=0; i<first; i++) notme[i] = i;

441

for (i=last; i<M; i++) notme[i-last+first] = i;

442

ierr = ISCreateGeneral(MPI_COMM_SELF((MPI_Comm)0x44000001),N-last+first,notme,PETSC_COPY_VALUES,&Notme);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),442,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

443

ierr = ISCreateStride(MPI_COMM_SELF((MPI_Comm)0x44000001),last-first,first,1,&Me);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),443,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

444

ierr = MatCreateSubMatrices(Amat,1,&Me,&Notme,MAT_INITIAL_MATRIX,&Aoffs);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),444,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

445

Aoff = Aoffs[0];

446

ierr = MatCreateSubMatrices(Bmat,1,&Notme,&Me,MAT_INITIAL_MATRIX,&Boffs);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),446,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

447

Boff = Boffs[0];

448

ierr = MatIsTranspose(Aoff,Boff,tol,f);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),448,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

449

ierr = MatDestroyMatrices(1,&Aoffs);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),449,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

450

ierr = MatDestroyMatrices(1,&Boffs);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),450,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

451

ierr = ISDestroy(&Me);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),451,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

452

ierr = ISDestroy(&Notme);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),452,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

453

ierr = PetscFree(notme)((*PetscTrFree)((void*)(notme),453,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
) || ((notme) = 0,0));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),453,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

454

455

}

456

457

PetscErrorCode MatMultTransposeAdd_MPISELL(Mat A,Vec xx,Vec yy,Vec zz)

458

{

459

Mat_MPISELL *a=(Mat_MPISELL*)A->data;

460

PetscErrorCode ierr;

461

462

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 462; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

463

/* do nondiagonal part */

464

ierr = (*a->B->ops->multtranspose)(a->B,xx,a->lvec);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),464,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

465

/* do local part */

466

ierr = (*a->A->ops->multtransposeadd)(a->A,xx,yy,zz);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),466,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

467

/* add partial results together */

468

ierr = VecScatterBegin(a->Mvctx,a->lvec,zz,ADD_VALUES,SCATTER_REVERSE);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),468,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

469

ierr = VecScatterEnd(a->Mvctx,a->lvec,zz,ADD_VALUES,SCATTER_REVERSE);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),469,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

470

471

}

472

473

474

This only works correctly for square matrices where the subblock A->A is the

475

diagonal block

476

477

PetscErrorCode MatGetDiagonal_MPISELL(Mat A,Vec v)

478

{

479

PetscErrorCode ierr;

480

Mat_MPISELL *a=(Mat_MPISELL*)A->data;

481

482

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 482; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

483

if (A->rmap->N != A->cmap->N) SETERRQ(PetscObjectComm((PetscObject)A),PETSC_ERR_SUP,"Supports only square matrix where A->A is diag block")return PetscError(PetscObjectComm((PetscObject)A),483,__func__
,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,56,PETSC_ERROR_INITIAL,"Supports only square matrix where A->A is diag block"
);

484

if (A->rmap->rstart != A->cmap->rstart || A->rmap->rend != A->cmap->rend) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_SIZ,"row partition must equal col partition")return PetscError(((MPI_Comm)0x44000001),484,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,60,PETSC_ERROR_INITIAL,"row partition must equal col partition"
);

485

ierr = MatGetDiagonal(a->A,v);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),485,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

486

487

}

488

489

PetscErrorCode MatScale_MPISELL(Mat A,PetscScalar aa)

490

{

491

Mat_MPISELL *a=(Mat_MPISELL*)A->data;

492

PetscErrorCode ierr;

493

494

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 494; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

495

ierr = MatScale(a->A,aa);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),495,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

496

ierr = MatScale(a->B,aa);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),496,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

497

498

}

499

500

PetscErrorCode MatDestroy_MPISELL(Mat mat)

501

{

502

Mat_MPISELL *sell=(Mat_MPISELL*)mat->data;

503

PetscErrorCode ierr;

504

505

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 505; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

506

#if defined(PETSC_USE_LOG1)

507

PetscLogObjectState((PetscObject)mat,"Rows=%D, Cols=%D",mat->rmap->N,mat->cmap->N);

508

#endif

509

ierr = MatStashDestroy_Private(&mat->stash);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),509,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

510

ierr = VecDestroy(&sell->diag);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),510,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

511

ierr = MatDestroy(&sell->A);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),511,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

512

ierr = MatDestroy(&sell->B);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),512,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

513

#if defined(PETSC_USE_CTABLE1)

514

ierr = PetscTableDestroy(&sell->colmap);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),514,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

515

#else

516

ierr = PetscFree(sell->colmap)((*PetscTrFree)((void*)(sell->colmap),516,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
) || ((sell->colmap) = 0,0));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),516,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

517

#endif

518

ierr = PetscFree(sell->garray)((*PetscTrFree)((void*)(sell->garray),518,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
) || ((sell->garray) = 0,0));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),518,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

519

ierr = VecDestroy(&sell->lvec);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),519,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

520

ierr = VecScatterDestroy(&sell->Mvctx);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),520,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

521

ierr = PetscFree2(sell->rowvalues,sell->rowindices)PetscFreeA(2,521,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,&(sell->rowvalues),&(sell->rowindices));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),521,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

522

ierr = PetscFree(sell->ld)((*PetscTrFree)((void*)(sell->ld),522,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
) || ((sell->ld) = 0,0));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),522,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

523

ierr = PetscFree(mat->data)((*PetscTrFree)((void*)(mat->data),523,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
) || ((mat->data) = 0,0));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),523,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

524

525

ierr = PetscObjectChangeTypeName((PetscObject)mat,0);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),525,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

526

ierr = PetscObjectComposeFunction((PetscObject)mat,"MatStoreValues_C",NULL)PetscObjectComposeFunction_Private((PetscObject)mat,"MatStoreValues_C"
,(PetscVoidFunction)(((void*)0)));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),526,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

527

ierr = PetscObjectComposeFunction((PetscObject)mat,"MatRetrieveValues_C",NULL)PetscObjectComposeFunction_Private((PetscObject)mat,"MatRetrieveValues_C"
,(PetscVoidFunction)(((void*)0)));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),527,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

528

ierr = PetscObjectComposeFunction((PetscObject)mat,"MatIsTranspose_C",NULL)PetscObjectComposeFunction_Private((PetscObject)mat,"MatIsTranspose_C"
,(PetscVoidFunction)(((void*)0)));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),528,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

529

ierr = PetscObjectComposeFunction((PetscObject)mat,"MatMPISELLSetPreallocation_C",NULL)PetscObjectComposeFunction_Private((PetscObject)mat,"MatMPISELLSetPreallocation_C"
,(PetscVoidFunction)(((void*)0)));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),529,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

530

ierr = PetscObjectComposeFunction((PetscObject)mat,"MatConvert_mpisell_mpiaij_C",NULL)PetscObjectComposeFunction_Private((PetscObject)mat,"MatConvert_mpisell_mpiaij_C"
,(PetscVoidFunction)(((void*)0)));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),530,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

531

ierr = PetscObjectComposeFunction((PetscObject)mat,"MatDiagonalScaleLocal_C",NULL)PetscObjectComposeFunction_Private((PetscObject)mat,"MatDiagonalScaleLocal_C"
,(PetscVoidFunction)(((void*)0)));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),531,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

532

533

}

534

535

#include <petscdraw.h>

536

PetscErrorCode MatView_MPISELL_ASCIIorDraworSocket(Mat mat,PetscViewer viewer)

537

{

538

Mat_MPISELL *sell=(Mat_MPISELL*)mat->data;

539

PetscErrorCode ierr;

540

PetscMPIInt rank=sell->rank,size=sell->size;

541

PetscBool isdraw,iascii,isbinary;

542

PetscViewer sviewer;

543

PetscViewerFormat format;

544

545

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 545; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

546

ierr = PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERDRAW"draw",&isdraw);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),546,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

547

ierr = PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERASCII"ascii",&iascii);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),547,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

548

ierr = PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERBINARY"binary",&isbinary);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),548,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

549

if (iascii) {

550

ierr = PetscViewerGetFormat(viewer,&format);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),550,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

551

if (format == PETSC_VIEWER_ASCII_INFO_DETAIL) {

552

MatInfo info;

553

PetscBool inodes;

554

555

ierr = MPI_Comm_rank(PetscObjectComm((PetscObject)mat),&rank);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),555,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

556

ierr = MatGetInfo(mat,MAT_LOCAL,&info);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),556,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

557

ierr = MatInodeGetInodeSizes(sell->A,NULL((void*)0),(PetscInt**)&inodes,NULL((void*)0));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),557,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

558

ierr = PetscViewerASCIIPushSynchronized(viewer);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),558,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

559

if (!inodes) {

560

ierr = PetscViewerASCIISynchronizedPrintf(viewer,"[%d] Local rows %D nz %D nz alloced %D mem %D, not using I-node routines\n",

561

rank,mat->rmap->n,(PetscInt)info.nz_used,(PetscInt)info.nz_allocated,(PetscInt)info.memory);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),561,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

562

} else {

563

ierr = PetscViewerASCIISynchronizedPrintf(viewer,"[%d] Local rows %D nz %D nz alloced %D mem %D, using I-node routines\n",

564

rank,mat->rmap->n,(PetscInt)info.nz_used,(PetscInt)info.nz_allocated,(PetscInt)info.memory);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),564,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

565

}

566

ierr = MatGetInfo(sell->A,MAT_LOCAL,&info);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),566,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

567

ierr = PetscViewerASCIISynchronizedPrintf(viewer,"[%d] on-diagonal part: nz %D \n",rank,(PetscInt)info.nz_used);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),567,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

568

ierr = MatGetInfo(sell->B,MAT_LOCAL,&info);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),568,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

569

ierr = PetscViewerASCIISynchronizedPrintf(viewer,"[%d] off-diagonal part: nz %D \n",rank,(PetscInt)info.nz_used);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),569,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

570

ierr = PetscViewerFlush(viewer);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),570,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

571

ierr = PetscViewerASCIIPopSynchronized(viewer);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),571,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

572

ierr = PetscViewerASCIIPrintf(viewer,"Information on VecScatter used in matrix-vector product: \n");CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),572,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

573

ierr = VecScatterView(sell->Mvctx,viewer);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),573,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

574

575

} else if (format == PETSC_VIEWER_ASCII_INFO) {

576

PetscInt inodecount,inodelimit,*inodes;

577

ierr = MatInodeGetInodeSizes(sell->A,&inodecount,&inodes,&inodelimit);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),577,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

578

if (inodes) {

579

ierr = PetscViewerASCIIPrintf(viewer,"using I-node (on process 0) routines: found %D nodes, limit used is %D\n",inodecount,inodelimit);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),579,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

580

} else {

581

ierr = PetscViewerASCIIPrintf(viewer,"not using I-node (on process 0) routines\n");CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),581,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

582

}

583

584

} else if (format == PETSC_VIEWER_ASCII_FACTOR_INFO) {

585

586

}

587

} else if (isbinary) {

588

if (size == 1) {

589

ierr = PetscObjectSetName((PetscObject)sell->A,((PetscObject)mat)->name);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),589,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

590

ierr = MatView(sell->A,viewer);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),590,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

591

} else {

592

/* ierr = MatView_MPISELL_Binary(mat,viewer);CHKERRQ(ierr); */

593

}

594

595

} else if (isdraw) {

596

PetscDraw draw;

597

PetscBool isnull;

598

ierr = PetscViewerDrawGetDraw(viewer,0,&draw);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),598,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

599

ierr = PetscDrawIsNull(draw,&isnull);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),599,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

600

if (isnull) PetscFunctionReturn(0)do { do { ; if (petscstack && petscstack->currentsize
> 0) { petscstack->currentsize--; petscstack->function
[petscstack->currentsize] = 0; petscstack->file[petscstack
->currentsize] = 0; petscstack->line[petscstack->currentsize
] = 0; petscstack->petscroutine[petscstack->currentsize
] = PETSC_FALSE; } if (petscstack) { petscstack->hotdepth =
(((petscstack->hotdepth-1)<(0)) ? (0) : (petscstack->
hotdepth-1)); } ; } while (0); return(0);} while (0);

601

}

602

603

{

604

/* assemble the entire matrix onto first processor. */

605

Mat A;

606

Mat_SeqSELL *Aloc;

607

PetscInt M=mat->rmap->N,N=mat->cmap->N,*acolidx,row,col,i,j;

608

MatScalar *aval;

609

PetscBool isnonzero;

610

611

ierr = MatCreate(PetscObjectComm((PetscObject)mat),&A);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),611,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

612

if (!rank) {

613

ierr = MatSetSizes(A,M,N,M,N);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),613,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

614

} else {

615

ierr = MatSetSizes(A,0,0,M,N);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),615,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

616

}

617

/* This is just a temporary matrix, so explicitly using MATMPISELL is probably best */

618

ierr = MatSetType(A,MATMPISELL"mpisell");CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),618,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

619

ierr = MatMPISELLSetPreallocation(A,0,NULL((void*)0),0,NULL((void*)0));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),619,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

620

ierr = MatSetOption(A,MAT_NEW_NONZERO_LOCATION_ERR,PETSC_FALSE);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),620,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

621

ierr = PetscLogObjectParent((PetscObject)mat,(PetscObject)A);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),621,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

622

623

/* copy over the A part */

624

Aloc = (Mat_SeqSELL*)sell->A->data;

625

acolidx = Aloc->colidx; aval = Aloc->val;

626

for (i=0; i<Aloc->totalslices; i++) { /* loop over slices */

627

for (j=Aloc->sliidx[i]; j<Aloc->sliidx[i+1]; j++) {

628

isnonzero = (PetscBool)((j-Aloc->sliidx[i])/8 < Aloc->rlen[(i<<3)+(j&0x07)]);

629

if (isnonzero) { /* check the mask bit */

630

row = (i<<3)+(j&0x07) + mat->rmap->rstart; /* i<<3 is the starting row of this slice */

631

col = *acolidx + mat->rmap->rstart;

632

ierr = MatSetValues(A,1,&row,1,&col,aval,INSERT_VALUES);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),632,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

633

}

634

aval++; acolidx++;

635

}

636

}

637

638

/* copy over the B part */

639

Aloc = (Mat_SeqSELL*)sell->B->data;

640

acolidx = Aloc->colidx; aval = Aloc->val;

641

for (i=0; i<Aloc->totalslices; i++) {

642

for (j=Aloc->sliidx[i]; j<Aloc->sliidx[i+1]; j++) {

643

isnonzero = (PetscBool)((j-Aloc->sliidx[i])/8 < Aloc->rlen[(i<<3)+(j&0x07)]);

644

if (isnonzero) {

645

row = (i<<3)+(j&0x07) + mat->rmap->rstart;

646

col = sell->garray[*acolidx];

647

ierr = MatSetValues(A,1,&row,1,&col,aval,INSERT_VALUES);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),647,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

648

}

649

aval++; acolidx++;

650

}

651

}

652

653

ierr = MatAssemblyBegin(A,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),653,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

654

ierr = MatAssemblyEnd(A,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),654,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

655

656

Everyone has to call to draw the matrix since the graphics waits are

657

synchronized across all processors that share the PetscDraw object

658

659

ierr = PetscViewerGetSubViewer(viewer,PETSC_COMM_SELF((MPI_Comm)0x44000001),&sviewer);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),659,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

660

if (!rank) {

661

ierr = PetscObjectSetName((PetscObject)((Mat_MPISELL*)(A->data))->A,((PetscObject)mat)->name);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),661,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

662

ierr = MatView_SeqSELL(((Mat_MPISELL*)(A->data))->A,sviewer);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),662,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

663

}

664

ierr = PetscViewerRestoreSubViewer(viewer,PETSC_COMM_SELF((MPI_Comm)0x44000001),&sviewer);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),664,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

665

ierr = PetscViewerFlush(viewer);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),665,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

666

ierr = MatDestroy(&A);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),666,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

667

}

668

669

}

670

671

PetscErrorCode MatView_MPISELL(Mat mat,PetscViewer viewer)

672

{

673

PetscErrorCode ierr;

674

PetscBool iascii,isdraw,issocket,isbinary;

675

676

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 676; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

677

ierr = PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERASCII"ascii",&iascii);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),677,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

678

ierr = PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERDRAW"draw",&isdraw);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),678,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

679

ierr = PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERBINARY"binary",&isbinary);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),679,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

680

ierr = PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERSOCKET"socket",&issocket);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),680,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

681

if (iascii || isdraw || isbinary || issocket) {

682

ierr = MatView_MPISELL_ASCIIorDraworSocket(mat,viewer);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),682,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

683

}

684

685

}

686

687

PetscErrorCode MatGetGhosts_MPISELL(Mat mat,PetscInt *nghosts,const PetscInt *ghosts[])

688

{

689

Mat_MPISELL *sell=(Mat_MPISELL*)mat->data;

690

PetscErrorCode ierr;

691

692

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 692; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

693

ierr = MatGetSize(sell->B,NULL((void*)0),nghosts);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),693,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

694

if (ghosts) *ghosts = sell->garray;

695

696

}

697

698

PetscErrorCode MatGetInfo_MPISELL(Mat matin,MatInfoType flag,MatInfo *info)

699

{

700

Mat_MPISELL *mat=(Mat_MPISELL*)matin->data;

701

Mat A=mat->A,B=mat->B;

702

PetscErrorCode ierr;

703

PetscReal isend[5],irecv[5];

704

705

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 705; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

706

info->block_size = 1.0;

707

ierr = MatGetInfo(A,MAT_LOCAL,info);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),707,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

708

709

isend[0] = info->nz_used; isend[1] = info->nz_allocated; isend[2] = info->nz_unneeded;

710

isend[3] = info->memory; isend[4] = info->mallocs;

711

712

ierr = MatGetInfo(B,MAT_LOCAL,info);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),712,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

713

714

isend[0] += info->nz_used; isend[1] += info->nz_allocated; isend[2] += info->nz_unneeded;

715

isend[3] += info->memory; isend[4] += info->mallocs;

716

if (flag == MAT_LOCAL) {

717

info->nz_used = isend[0];

718

info->nz_allocated = isend[1];

719

info->nz_unneeded = isend[2];

720

info->memory = isend[3];

721

info->mallocs = isend[4];

722

} else if (flag == MAT_GLOBAL_MAX) {

723

ierr = MPIU_Allreduce(isend,irecv,5,MPIU_REAL,MPIU_MAX,PetscObjectComm((PetscObject)matin))(PetscAllreduceBarrierCheck(PetscObjectComm((PetscObject)matin
),5,723,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
) || ((petsc_allreduce_ct += PetscMPIParallelComm((PetscObjectComm
((PetscObject)matin))),0) || MPI_Allreduce((isend),(irecv),(5
),(((MPI_Datatype)0x4c00080b)),((MPI_Op)(0x58000001)),(PetscObjectComm
((PetscObject)matin)))));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),723,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

724

725

info->nz_used = irecv[0];

726

info->nz_allocated = irecv[1];

727

info->nz_unneeded = irecv[2];

728

info->memory = irecv[3];

729

info->mallocs = irecv[4];

730

} else if (flag == MAT_GLOBAL_SUM) {

731

ierr = MPIU_Allreduce(isend,irecv,5,MPIU_REAL,MPIU_SUM,PetscObjectComm((PetscObject)matin))(PetscAllreduceBarrierCheck(PetscObjectComm((PetscObject)matin
),5,731,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
) || ((petsc_allreduce_ct += PetscMPIParallelComm((PetscObjectComm
((PetscObject)matin))),0) || MPI_Allreduce((isend),(irecv),(5
),(((MPI_Datatype)0x4c00080b)),((MPI_Op)(0x58000003)),(PetscObjectComm
((PetscObject)matin)))));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),731,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

732

733

info->nz_used = irecv[0];

734

info->nz_allocated = irecv[1];

735

info->nz_unneeded = irecv[2];

736

info->memory = irecv[3];

737

info->mallocs = irecv[4];

738

}

739

info->fill_ratio_given = 0; /* no parallel LU/ILU/Cholesky */

740

info->fill_ratio_needed = 0;

741

info->factor_mallocs = 0;

742

743

}

744

745

PetscErrorCode MatSetOption_MPISELL(Mat A,MatOption op,PetscBool flg)

746

{

747

Mat_MPISELL *a=(Mat_MPISELL*)A->data;

748

PetscErrorCode ierr;

749

750

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 750; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

751

switch (op) {

752

case MAT_NEW_NONZERO_LOCATIONS:

753

case MAT_NEW_NONZERO_ALLOCATION_ERR:

754

case MAT_UNUSED_NONZERO_LOCATION_ERR:

755

case MAT_KEEP_NONZERO_PATTERN:

756

case MAT_NEW_NONZERO_LOCATION_ERR:

757

case MAT_USE_INODES:

758

case MAT_IGNORE_ZERO_ENTRIES:

759

MatCheckPreallocated(A,1)do { if (__builtin_expect(!!(!(A)->preallocated),0)) return
PetscError(((MPI_Comm)0x44000001),759,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,73,PETSC_ERROR_INITIAL,"Must call MatXXXSetPreallocation() or MatSetUp() on argument %D \"%s\" before %s()"
,(1),"A",__func__); } while (0);

760

ierr = MatSetOption(a->A,op,flg);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),760,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

761

ierr = MatSetOption(a->B,op,flg);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),761,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

762

break;

763

case MAT_ROW_ORIENTED:

764

MatCheckPreallocated(A,1)do { if (__builtin_expect(!!(!(A)->preallocated),0)) return
PetscError(((MPI_Comm)0x44000001),764,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,73,PETSC_ERROR_INITIAL,"Must call MatXXXSetPreallocation() or MatSetUp() on argument %D \"%s\" before %s()"
,(1),"A",__func__); } while (0);

765

a->roworiented = flg;

766

767

ierr = MatSetOption(a->A,op,flg);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),767,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

768

ierr = MatSetOption(a->B,op,flg);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),768,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

769

break;

770

case MAT_NEW_DIAGONALS:

771

ierr = PetscInfo1(A,"Option %s ignored\n",MatOptions[op])PetscInfo_Private(__func__,A,"Option %s ignored\n",MatOptions
[op]);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),771,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

772

break;

773

case MAT_IGNORE_OFF_PROC_ENTRIES:

774

a->donotstash = flg;

775

break;

776

case MAT_SPD:

777

A->spd_set = PETSC_TRUE;

778

A->spd = flg;

779

if (flg) {

780

A->symmetric = PETSC_TRUE;

781

A->structurally_symmetric = PETSC_TRUE;

782

A->symmetric_set = PETSC_TRUE;

783

A->structurally_symmetric_set = PETSC_TRUE;

784

}

785

break;

786

case MAT_SYMMETRIC:

787

MatCheckPreallocated(A,1)do { if (__builtin_expect(!!(!(A)->preallocated),0)) return
PetscError(((MPI_Comm)0x44000001),787,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,73,PETSC_ERROR_INITIAL,"Must call MatXXXSetPreallocation() or MatSetUp() on argument %D \"%s\" before %s()"
,(1),"A",__func__); } while (0);

788

ierr = MatSetOption(a->A,op,flg);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),788,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

789

break;

790

case MAT_STRUCTURALLY_SYMMETRIC:

791

MatCheckPreallocated(A,1)do { if (__builtin_expect(!!(!(A)->preallocated),0)) return
PetscError(((MPI_Comm)0x44000001),791,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,73,PETSC_ERROR_INITIAL,"Must call MatXXXSetPreallocation() or MatSetUp() on argument %D \"%s\" before %s()"
,(1),"A",__func__); } while (0);

792

ierr = MatSetOption(a->A,op,flg);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),792,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

793

break;

794

case MAT_HERMITIAN:

795

MatCheckPreallocated(A,1)do { if (__builtin_expect(!!(!(A)->preallocated),0)) return
PetscError(((MPI_Comm)0x44000001),795,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,73,PETSC_ERROR_INITIAL,"Must call MatXXXSetPreallocation() or MatSetUp() on argument %D \"%s\" before %s()"
,(1),"A",__func__); } while (0);

796

ierr = MatSetOption(a->A,op,flg);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),796,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

797

break;

798

case MAT_SYMMETRY_ETERNAL:

799

MatCheckPreallocated(A,1)do { if (__builtin_expect(!!(!(A)->preallocated),0)) return
PetscError(((MPI_Comm)0x44000001),799,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,73,PETSC_ERROR_INITIAL,"Must call MatXXXSetPreallocation() or MatSetUp() on argument %D \"%s\" before %s()"
,(1),"A",__func__); } while (0);

800

ierr = MatSetOption(a->A,op,flg);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),800,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

801

break;

802

default:

803

SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_SUP,"unknown option %d",op)return PetscError(((MPI_Comm)0x44000001),803,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,56,PETSC_ERROR_INITIAL,"unknown option %d",op);

804

}

805

806

}

807

808

809

PetscErrorCode MatDiagonalScale_MPISELL(Mat mat,Vec ll,Vec rr)

810

{

811

Mat_MPISELL *sell=(Mat_MPISELL*)mat->data;

812

Mat a=sell->A,b=sell->B;

813

PetscErrorCode ierr;

814

PetscInt s1,s2,s3;

815

816

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 816; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

817

ierr = MatGetLocalSize(mat,&s2,&s3);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),817,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

818

if (rr) {

819

ierr = VecGetLocalSize(rr,&s1);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),819,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

820

if (s1!=s3) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_SIZ,"right vector non-conforming local size")return PetscError(((MPI_Comm)0x44000001),820,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,60,PETSC_ERROR_INITIAL,"right vector non-conforming local size"
);

821

/* Overlap communication with computation. */

822

ierr = VecScatterBegin(sell->Mvctx,rr,sell->lvec,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),822,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

823

}

824

if (ll) {

825

ierr = VecGetLocalSize(ll,&s1);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),825,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

826

if (s1!=s2) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_SIZ,"left vector non-conforming local size")return PetscError(((MPI_Comm)0x44000001),826,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,60,PETSC_ERROR_INITIAL,"left vector non-conforming local size"
);

827

ierr = (*b->ops->diagonalscale)(b,ll,0);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),827,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

828

}

829

/* scale the diagonal block */

830

ierr = (*a->ops->diagonalscale)(a,ll,rr);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),830,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

831

832

if (rr) {

833

/* Do a scatter end and then right scale the off-diagonal block */

834

ierr = VecScatterEnd(sell->Mvctx,rr,sell->lvec,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),834,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

835

ierr = (*b->ops->diagonalscale)(b,0,sell->lvec);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),835,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

836

}

837

838

}

839

840

PetscErrorCode MatSetUnfactored_MPISELL(Mat A)

841

{

842

Mat_MPISELL *a=(Mat_MPISELL*)A->data;

843

PetscErrorCode ierr;

844

845

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 845; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

846

ierr = MatSetUnfactored(a->A);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),846,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

847

848

}

849

850

PetscErrorCode MatEqual_MPISELL(Mat A,Mat B,PetscBool *flag)

851

{

852

Mat_MPISELL *matB=(Mat_MPISELL*)B->data,*matA=(Mat_MPISELL*)A->data;

853

Mat a,b,c,d;

854

PetscBool flg;

855

PetscErrorCode ierr;

856

857

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 857; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

858

a = matA->A; b = matA->B;

859

c = matB->A; d = matB->B;

860

861

ierr = MatEqual(a,c,&flg);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),861,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

862

if (flg) {

863

ierr = MatEqual(b,d,&flg);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),863,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

864

}

865

ierr = MPIU_Allreduce(&flg,flag,1,MPIU_BOOL,MPI_LAND,PetscObjectComm((PetscObject)A))(PetscAllreduceBarrierCheck(PetscObjectComm((PetscObject)A),1
,865,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
) || ((petsc_allreduce_ct += PetscMPIParallelComm((PetscObjectComm
((PetscObject)A))),0) || MPI_Allreduce((&flg),(flag),(1),
(MPIU_BOOL),((MPI_Op)(0x58000005)),(PetscObjectComm((PetscObject
)A)))));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),865,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

866

867

}

868

869

PetscErrorCode MatCopy_MPISELL(Mat A,Mat B,MatStructure str)

870

{

871

PetscErrorCode ierr;

872

Mat_MPISELL *a=(Mat_MPISELL*)A->data;

873

Mat_MPISELL *b=(Mat_MPISELL*)B->data;

874

875

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 875; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

876

/* If the two matrices don't have the same copy implementation, they aren't compatible for fast copy. */

877

if ((str != SAME_NONZERO_PATTERN) || (A->ops->copy != B->ops->copy)) {

878

/* because of the column compression in the off-processor part of the matrix a->B,

879

the number of columns in a->B and b->B may be different, hence we cannot call

880

the MatCopy() directly on the two parts. If need be, we can provide a more

881

efficient copy than the MatCopy_Basic() by first uncompressing the a->B matrices

882

then copying the submatrices */

883

ierr = MatCopy_Basic(A,B,str);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),883,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

884

} else {

885

ierr = MatCopy(a->A,b->A,str);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),885,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

886

ierr = MatCopy(a->B,b->B,str);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),886,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

887

}

888

889

}

890

891

PetscErrorCode MatSetUp_MPISELL(Mat A)

892

{

893

PetscErrorCode ierr;

894

895

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 895; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

896

ierr = MatMPISELLSetPreallocation(A,PETSC_DEFAULT-2,0,PETSC_DEFAULT-2,0);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),896,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

897

898

}

899

900

901

extern PetscErrorCode MatConjugate_SeqSELL(Mat);

902

903

PetscErrorCode MatConjugate_MPISELL(Mat mat)

904

{

905

#if defined(PETSC_USE_COMPLEX)

906

PetscErrorCode ierr;

907

Mat_MPISELL *sell=(Mat_MPISELL*)mat->data;

908

909

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 909; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

910

ierr = MatConjugate_SeqSELL(sell->A);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),910,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

911

ierr = MatConjugate_SeqSELL(sell->B);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),911,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

912

#else

913

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 913; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

914

#endif

915

916

}

917

918

PetscErrorCode MatRealPart_MPISELL(Mat A)

919

{

920

Mat_MPISELL *a=(Mat_MPISELL*)A->data;

921

PetscErrorCode ierr;

922

923

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 923; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

924

ierr = MatRealPart(a->A);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),924,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

925

ierr = MatRealPart(a->B);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),925,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

926

927

}

928

929

PetscErrorCode MatImaginaryPart_MPISELL(Mat A)

930

{

931

Mat_MPISELL *a=(Mat_MPISELL*)A->data;

932

PetscErrorCode ierr;

933

934

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 934; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

935

ierr = MatImaginaryPart(a->A);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),935,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

936

ierr = MatImaginaryPart(a->B);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),936,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

937

938

}

939

940

PetscErrorCode MatInvertBlockDiagonal_MPISELL(Mat A,const PetscScalar **values)

941

{

942

Mat_MPISELL *a=(Mat_MPISELL*)A->data;

943

PetscErrorCode ierr;

944

945

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 945; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

946

ierr = MatInvertBlockDiagonal(a->A,values);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),946,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

947

A->factorerrortype = a->A->factorerrortype;

948

949

}

950

951

static PetscErrorCode MatSetRandom_MPISELL(Mat x,PetscRandom rctx)

952

{

953

PetscErrorCode ierr;

954

Mat_MPISELL *sell=(Mat_MPISELL*)x->data;

955

956

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 956; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

957

ierr = MatSetRandom(sell->A,rctx);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),957,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

958

ierr = MatSetRandom(sell->B,rctx);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),958,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

959

ierr = MatAssemblyBegin(x,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),959,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

960

ierr = MatAssemblyEnd(x,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),960,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

961

962

}

963

964

PetscErrorCode MatSetFromOptions_MPISELL(PetscOptionItems *PetscOptionsObject,Mat A)

965

{

966

PetscErrorCode ierr;

967

968

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 968; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

969

ierr = PetscOptionsHead(PetscOptionsObject,"MPISELL options");CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),969,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

970

ierr = PetscOptionsTail()0; {if (PetscOptionsObject->count != 1) do { do { ; if (petscstack
&& petscstack->currentsize > 0) { petscstack->
currentsize--; petscstack->function[petscstack->currentsize
] = 0; petscstack->file[petscstack->currentsize] = 0; petscstack
->line[petscstack->currentsize] = 0; petscstack->petscroutine
[petscstack->currentsize] = PETSC_FALSE; } if (petscstack)
{ petscstack->hotdepth = (((petscstack->hotdepth-1)<
(0)) ? (0) : (petscstack->hotdepth-1)); } ; } while (0); return
(0);} while (0);};CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),970,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

971

972

}

973

974

PetscErrorCode MatShift_MPISELL(Mat Y,PetscScalar a)

975

{

976

PetscErrorCode ierr;

977

Mat_MPISELL *msell=(Mat_MPISELL*)Y->data;

978

Mat_SeqSELL *sell=(Mat_SeqSELL*)msell->A->data;

979

980

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 980; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

981

if (!Y->preallocated) {

982

ierr = MatMPISELLSetPreallocation(Y,1,NULL((void*)0),0,NULL((void*)0));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),982,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

983

} else if (!sell->nz) {

984

PetscInt nonew = sell->nonew;

985

ierr = MatSeqSELLSetPreallocation(msell->A,1,NULL((void*)0));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),985,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

986

sell->nonew = nonew;

987

}

988

ierr = MatShift_Basic(Y,a);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),988,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

989

990

}

991

992

PetscErrorCode MatMissingDiagonal_MPISELL(Mat A,PetscBool *missing,PetscInt *d)

993

{

994

Mat_MPISELL *a=(Mat_MPISELL*)A->data;

995

PetscErrorCode ierr;

996

997

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 997; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

998

if (A->rmap->n != A->cmap->n) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SUP,"Only works for square matrices")return PetscError(((MPI_Comm)0x44000001),998,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,56,PETSC_ERROR_INITIAL,"Only works for square matrices");

999

ierr = MatMissingDiagonal(a->A,missing,d);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),999,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1000

if (d) {

1001

PetscInt rstart;

1002

ierr = MatGetOwnershipRange(A,&rstart,NULL((void*)0));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1002,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1003

*d += rstart;

1004

1005

}

1006

1007

}

1008

1009

PetscErrorCode MatGetDiagonalBlock_MPISELL(Mat A,Mat *a)

1010

{

1011

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 1011; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

1012

*a = ((Mat_MPISELL*)A->data)->A;

1013

1014

}

1015

1016

/* -------------------------------------------------------------------*/

1017

static struct _MatOps MatOps_Values = {MatSetValues_MPISELL,

1018

1019

1020

MatMult_MPISELL,

1021

/* 4*/ MatMultAdd_MPISELL,

1022

MatMultTranspose_MPISELL,

1023

MatMultTransposeAdd_MPISELL,

1024

1025

1026

1027

/*10*/ 0,

1028

1029

1030

MatSOR_MPISELL,

1031

1032

/*15*/ MatGetInfo_MPISELL,

1033

MatEqual_MPISELL,

1034

MatGetDiagonal_MPISELL,

1035

MatDiagonalScale_MPISELL,

1036

1037

/*20*/ MatAssemblyBegin_MPISELL,

1038

MatAssemblyEnd_MPISELL,

1039

MatSetOption_MPISELL,

1040

MatZeroEntries_MPISELL,

1041

/*24*/ 0,

1042

1043

1044

1045

1046

/*29*/ MatSetUp_MPISELL,

1047

1048

1049

MatGetDiagonalBlock_MPISELL,

1050

1051

/*34*/ MatDuplicate_MPISELL,

1052

1053

1054

1055

1056

/*39*/ 0,

1057

1058

1059

MatGetValues_MPISELL,

1060

MatCopy_MPISELL,

1061

/*44*/ 0,

1062

MatScale_MPISELL,

1063

MatShift_MPISELL,

1064

MatDiagonalSet_MPISELL,

1065

1066

/*49*/ MatSetRandom_MPISELL,

1067

1068

1069

1070

1071

/*54*/ MatFDColoringCreate_MPIXAIJ,

1072

1073

MatSetUnfactored_MPISELL,

1074

1075

1076

/*59*/ 0,

1077

MatDestroy_MPISELL,

1078

MatView_MPISELL,

1079

1080

1081

/*64*/ 0,

1082

1083

1084

1085

1086

/*69*/ 0,

1087

1088

1089

1090

1091

1092

/*75*/ MatFDColoringApply_AIJ, /* reuse AIJ function */

1093

MatSetFromOptions_MPISELL,

1094

1095

1096

1097

/*80*/ 0,

1098

1099

1100

/*83*/ 0,

1101

1102

1103

1104

1105

1106

/*89*/ 0,

1107

1108

1109

1110

1111

/*94*/ 0,

1112

1113

1114

1115

1116

/*99*/ 0,

1117

1118

1119

MatConjugate_MPISELL,

1120

1121

/*104*/0,

1122

MatRealPart_MPISELL,

1123

MatImaginaryPart_MPISELL,

1124

1125

1126

/*109*/0,

1127

1128

1129

1130

MatMissingDiagonal_MPISELL,

1131

/*114*/0,

1132

1133

MatGetGhosts_MPISELL,

1134

1135

1136

/*119*/0,

1137

1138

1139

1140

1141

/*124*/0,

1142

1143

MatInvertBlockDiagonal_MPISELL,

1144

1145

1146

/*129*/0,

1147

1148

1149

1150

1151

/*134*/0,

1152

1153

1154

1155

1156

/*139*/0,

1157

1158

1159

MatFDColoringSetUp_MPIXAIJ,

1160

1161

/*144*/0

1162

};

1163

1164

/* ----------------------------------------------------------------------------------------*/

1165

1166

PetscErrorCode MatStoreValues_MPISELL(Mat mat)

1167

{

1168

Mat_MPISELL *sell=(Mat_MPISELL*)mat->data;

1169

PetscErrorCode ierr;

1170

1171

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 1171; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

1172

ierr = MatStoreValues(sell->A);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1172,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1173

ierr = MatStoreValues(sell->B);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1173,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1174

1175

}

1176

1177

PetscErrorCode MatRetrieveValues_MPISELL(Mat mat)

1178

{

1179

Mat_MPISELL *sell=(Mat_MPISELL*)mat->data;

1180

PetscErrorCode ierr;

1181

1182

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 1182; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

1183

ierr = MatRetrieveValues(sell->A);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1183,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1184

ierr = MatRetrieveValues(sell->B);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1184,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1185

1186

}

1187

1188

PetscErrorCode MatMPISELLSetPreallocation_MPISELL(Mat B,PetscInt d_rlenmax,const PetscInt d_rlen[],PetscInt o_rlenmax,const PetscInt o_rlen[])

1189

{

1190

Mat_MPISELL *b;

1191

PetscErrorCode ierr;

1192

1193

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 1193; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

1194

ierr = PetscLayoutSetUp(B->rmap);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1194,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1195

ierr = PetscLayoutSetUp(B->cmap);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1195,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1196

b = (Mat_MPISELL*)B->data;

1197

1198

if (!B->preallocated) {

1199

/* Explicitly create 2 MATSEQSELL matrices. */

1200

ierr = MatCreate(PETSC_COMM_SELF((MPI_Comm)0x44000001),&b->A);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1200,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1201

ierr = MatSetSizes(b->A,B->rmap->n,B->cmap->n,B->rmap->n,B->cmap->n);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1201,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1202

ierr = MatSetBlockSizesFromMats(b->A,B,B);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1202,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1203

ierr = MatSetType(b->A,MATSEQSELL"seqsell");CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1203,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1204

ierr = PetscLogObjectParent((PetscObject)B,(PetscObject)b->A);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1204,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1205

ierr = MatCreate(PETSC_COMM_SELF((MPI_Comm)0x44000001),&b->B);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1205,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1206

ierr = MatSetSizes(b->B,B->rmap->n,B->cmap->N,B->rmap->n,B->cmap->N);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1206,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1207

ierr = MatSetBlockSizesFromMats(b->B,B,B);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1207,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1208

ierr = MatSetType(b->B,MATSEQSELL"seqsell");CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1208,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1209

ierr = PetscLogObjectParent((PetscObject)B,(PetscObject)b->B);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1209,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1210

}

1211

1212

ierr = MatSeqSELLSetPreallocation(b->A,d_rlenmax,d_rlen);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1212,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1213

ierr = MatSeqSELLSetPreallocation(b->B,o_rlenmax,o_rlen);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1213,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1214

B->preallocated = PETSC_TRUE;

1215

B->was_assembled = PETSC_FALSE;

1216

1217

critical for MatAssemblyEnd to work.

1218

MatAssemblyBegin checks it to set up was_assembled

1219

and MatAssemblyEnd checks was_assembled to determine whether to build garray

1220

1221

B->assembled = PETSC_FALSE;

1222

1223

}

1224

1225

PetscErrorCode MatDuplicate_MPISELL(Mat matin,MatDuplicateOption cpvalues,Mat *newmat)

1226

{

1227

Mat mat;

1228

Mat_MPISELL *a,*oldmat=(Mat_MPISELL*)matin->data;

1229

PetscErrorCode ierr;

1230

1231

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 1231; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

1232

*newmat = 0;

1233

ierr = MatCreate(PetscObjectComm((PetscObject)matin),&mat);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1233,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1234

ierr = MatSetSizes(mat,matin->rmap->n,matin->cmap->n,matin->rmap->N,matin->cmap->N);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1234,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1235

ierr = MatSetBlockSizesFromMats(mat,matin,matin);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1235,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1236

ierr = MatSetType(mat,((PetscObject)matin)->type_name);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1236,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1237

a = (Mat_MPISELL*)mat->data;

1238

1239

mat->factortype = matin->factortype;

1240

mat->assembled = PETSC_TRUE;

1241

mat->insertmode = NOT_SET_VALUES;

1242

mat->preallocated = PETSC_TRUE;

1243

1244

a->size = oldmat->size;

1245

a->rank = oldmat->rank;

1246

a->donotstash = oldmat->donotstash;

1247

a->roworiented = oldmat->roworiented;

1248

a->rowindices = 0;

1249

a->rowvalues = 0;

1250

a->getrowactive = PETSC_FALSE;

1251

1252

ierr = PetscLayoutReference(matin->rmap,&mat->rmap);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1252,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1253

ierr = PetscLayoutReference(matin->cmap,&mat->cmap);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1253,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1254

1255

if (oldmat->colmap) {

1256

#if defined(PETSC_USE_CTABLE1)

1257

ierr = PetscTableCreateCopy(oldmat->colmap,&a->colmap);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1257,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1258

#else

1259

ierr = PetscMalloc1(mat->cmap->N,&a->colmap)PetscMallocA(1,PETSC_FALSE,1259,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,(size_t)(mat->cmap->N)*sizeof(**(&a->colmap)),(
&a->colmap));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1259,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1260

ierr = PetscLogObjectMemory((PetscObject)mat,(mat->cmap->N)*sizeof(PetscInt));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1260,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1261

ierr = PetscMemcpy(a->colmap,oldmat->colmap,(mat->cmap->N)*sizeof(PetscInt));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1261,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1262

#endif

1263

} else a->colmap = 0;

1264

if (oldmat->garray) {

1265

PetscInt len;

1266

len = oldmat->B->cmap->n;

1267

ierr = PetscMalloc1(len+1,&a->garray)PetscMallocA(1,PETSC_FALSE,1267,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,(size_t)(len+1)*sizeof(**(&a->garray)),(&a->garray
));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1267,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1268

ierr = PetscLogObjectMemory((PetscObject)mat,len*sizeof(PetscInt));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1268,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1269

if (len) { ierr = PetscMemcpy(a->garray,oldmat->garray,len*sizeof(PetscInt));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1269,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0); }

1270

} else a->garray = 0;

1271

1272

ierr = VecDuplicate(oldmat->lvec,&a->lvec);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1272,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1273

ierr = PetscLogObjectParent((PetscObject)mat,(PetscObject)a->lvec);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1273,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1274

ierr = VecScatterCopy(oldmat->Mvctx,&a->Mvctx);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1274,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1275

ierr = PetscLogObjectParent((PetscObject)mat,(PetscObject)a->Mvctx);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1275,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1276

ierr = MatDuplicate(oldmat->A,cpvalues,&a->A);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1276,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1277

ierr = PetscLogObjectParent((PetscObject)mat,(PetscObject)a->A);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1277,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1278

ierr = MatDuplicate(oldmat->B,cpvalues,&a->B);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1278,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1279

ierr = PetscLogObjectParent((PetscObject)mat,(PetscObject)a->B);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1279,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1280

ierr = PetscFunctionListDuplicate(((PetscObject)matin)->qlist,&((PetscObject)mat)->qlist);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1280,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1281

*newmat = mat;

1282

1283

}

1284

1285

/*@C

1286

MatMPISELLSetPreallocation - Preallocates memory for a sparse parallel matrix in sell format.

1287

For good matrix assembly performance the user should preallocate the matrix storage by

1288

setting the parameters d_nz (or d_nnz) and o_nz (or o_nnz).

1289

1290

Collective on MPI_Comm

1291

1292

Input Parameters:

1293

+ B - the matrix

1294

. d_nz - number of nonzeros per row in DIAGONAL portion of local submatrix

1295

(same value is used for all local rows)

1296

. d_nnz - array containing the number of nonzeros in the various rows of the

1297

DIAGONAL portion of the local submatrix (possibly different for each row)

1298

or NULL (PETSC_NULL_INTEGER in Fortran), if d_nz is used to specify the nonzero structure.

1299

The size of this array is equal to the number of local rows, i.e 'm'.

1300

For matrices that will be factored, you must leave room for (and set)

1301

the diagonal entry even if it is zero.

1302

. o_nz - number of nonzeros per row in the OFF-DIAGONAL portion of local

1303

submatrix (same value is used for all local rows).

1304

- o_nnz - array containing the number of nonzeros in the various rows of the

1305

OFF-DIAGONAL portion of the local submatrix (possibly different for

1306

each row) or NULL (PETSC_NULL_INTEGER in Fortran), if o_nz is used to specify the nonzero

1307

structure. The size of this array is equal to the number

1308

of local rows, i.e 'm'.

1309

1310

If the *_nnz parameter is given then the *_nz parameter is ignored

1311

1312

The stored row and column indices begin with zero.

1313

1314

The parallel matrix is partitioned such that the first m0 rows belong to

1315

process 0, the next m1 rows belong to process 1, the next m2 rows belong

1316

to process 2 etc.. where m0,m1,m2... are the input parameter 'm'.

1317

1318

The DIAGONAL portion of the local submatrix of a processor can be defined

1319

as the submatrix which is obtained by extraction the part corresponding to

1320

the rows r1-r2 and columns c1-c2 of the global matrix, where r1 is the

1321

first row that belongs to the processor, r2 is the last row belonging to

1322

the this processor, and c1-c2 is range of indices of the local part of a

1323

vector suitable for applying the matrix to. This is an mxn matrix. In the

1324

common case of a square matrix, the row and column ranges are the same and

1325

the DIAGONAL part is also square. The remaining portion of the local

1326

submatrix (mxN) constitute the OFF-DIAGONAL portion.

1327

1328

If o_nnz, d_nnz are specified, then o_nz, and d_nz are ignored.

1329

1330

You can call MatGetInfo() to get information on how effective the preallocation was;

1331

for example the fields mallocs,nz_allocated,nz_used,nz_unneeded;

1332

You can also run with the option -info and look for messages with the string

1333

malloc in them to see if additional memory allocation was needed.

1334

1335

Example usage:

1336

1337

Consider the following 8x8 matrix with 34 non-zero values, that is

1338

assembled across 3 processors. Lets assume that proc0 owns 3 rows,

1339

proc1 owns 3 rows, proc2 owns 2 rows. This division can be shown

1340

as follows:

1341

1342

.vb

1343

1 2 0 | 0 3 0 | 0 4

1344

Proc0 0 5 6 | 7 0 0 | 8 0

1345

9 0 10 | 11 0 0 | 12 0

1346

-------------------------------------

1347

13 0 14 | 15 16 17 | 0 0

1348

Proc1 0 18 0 | 19 20 21 | 0 0

1349

0 0 0 | 22 23 0 | 24 0

1350

-------------------------------------

1351

Proc2 25 26 27 | 0 0 28 | 29 0

1352

30 0 0 | 31 32 33 | 0 34

1353

.ve

1354

1355

This can be represented as a collection of submatrices as:

1356

1357

.vb

1358

A B C

1359

D E F

1360

G H I

1361

.ve

1362

1363

Where the submatrices A,B,C are owned by proc0, D,E,F are

1364

owned by proc1, G,H,I are owned by proc2.

1365

1366

The 'm' parameters for proc0,proc1,proc2 are 3,3,2 respectively.

1367

The 'n' parameters for proc0,proc1,proc2 are 3,3,2 respectively.

1368

The 'M','N' parameters are 8,8, and have the same values on all procs.

1369

1370

The DIAGONAL submatrices corresponding to proc0,proc1,proc2 are

1371

submatrices [A], [E], [I] respectively. The OFF-DIAGONAL submatrices

1372

corresponding to proc0,proc1,proc2 are [BC], [DF], [GH] respectively.

1373

Internally, each processor stores the DIAGONAL part, and the OFF-DIAGONAL

1374

part as SeqSELL matrices. for eg: proc1 will store [E] as a SeqSELL

1375

matrix, ans [DF] as another SeqSELL matrix.

1376

1377

When d_nz, o_nz parameters are specified, d_nz storage elements are

1378

allocated for every row of the local diagonal submatrix, and o_nz

1379

storage locations are allocated for every row of the OFF-DIAGONAL submat.

1380

One way to choose d_nz and o_nz is to use the max nonzerors per local

1381

rows for each of the local DIAGONAL, and the OFF-DIAGONAL submatrices.

1382

In this case, the values of d_nz,o_nz are:

1383

.vb

1384

proc0 : dnz = 2, o_nz = 2

1385

proc1 : dnz = 3, o_nz = 2

1386

proc2 : dnz = 1, o_nz = 4

1387

.ve

1388

We are allocating m*(d_nz+o_nz) storage locations for every proc. This

1389

translates to 3*(2+2)=12 for proc0, 3*(3+2)=15 for proc1, 2*(1+4)=10

1390

for proc3. i.e we are using 12+15+10=37 storage locations to store

1391

34 values.

1392

1393

When d_nnz, o_nnz parameters are specified, the storage is specified

1394

for every row, coresponding to both DIAGONAL and OFF-DIAGONAL submatrices.

1395

In the above case the values for d_nnz,o_nnz are:

1396

.vb

1397

proc0: d_nnz = [2,2,2] and o_nnz = [2,2,2]

1398

proc1: d_nnz = [3,3,2] and o_nnz = [2,1,1]

1399

proc2: d_nnz = [1,1] and o_nnz = [4,4]

1400

.ve

1401

Here the space allocated is according to nz (or maximum values in the nnz

1402

if nnz is provided) for DIAGONAL and OFF-DIAGONAL submatrices, i.e (2+2+3+2)*3+(1+4)*2=37

1403

1404

Level: intermediate

1405

1406

.keywords: matrix, sell, sparse, parallel

1407

1408

.seealso: MatCreate(), MatCreateSeqSELL(), MatSetValues(), MatCreatesell(),

1409

MATMPISELL, MatGetInfo(), PetscSplitOwnership()

1410

@*/

1411

PetscErrorCode MatMPISELLSetPreallocation(Mat B,PetscInt d_nz,const PetscInt d_nnz[],PetscInt o_nz,const PetscInt o_nnz[])

1412

{

1413

PetscErrorCode ierr;

1414

1415

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 1415; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

1416

PetscValidHeaderSpecific(B,MAT_CLASSID,1)do { if (!B) return PetscError(((MPI_Comm)0x44000001),1416,__func__
,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,85,PETSC_ERROR_INITIAL,"Null Object: Parameter # %d",1); if (
!PetscCheckPointer(B,PETSC_OBJECT)) return PetscError(((MPI_Comm
)0x44000001),1416,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,64,PETSC_ERROR_INITIAL,"Invalid Pointer to Object: Parameter # %d"
,1); if (((PetscObject)(B))->classid != MAT_CLASSID) { if (
((PetscObject)(B))->classid == -1) return PetscError(((MPI_Comm
)0x44000001),1416,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,64,PETSC_ERROR_INITIAL,"Object already free: Parameter # %d"
,1); else return PetscError(((MPI_Comm)0x44000001),1416,__func__
,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,62,PETSC_ERROR_INITIAL,"Wrong type of object: Parameter # %d"
,1); } } while (0);

1417

PetscValidType(B,1)if (!((PetscObject)B)->type_name) return PetscError(((MPI_Comm
)0x44000001),1417,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,73,PETSC_ERROR_INITIAL,"%s object's type is not set: Argument # %d"
,((PetscObject)B)->class_name,1);;

1418

ierr = PetscTryMethod(B,"MatMPISELLSetPreallocation_C",(Mat,PetscInt,const PetscInt[],PetscInt,const PetscInt[]),(B,d_nz,d_nnz,o_nz,o_nnz))0;{ PetscErrorCode (*f)(Mat,PetscInt,const PetscInt[],PetscInt
,const PetscInt[]), __ierr; __ierr = PetscObjectQueryFunction_Private
(((PetscObject)B),("MatMPISELLSetPreallocation_C"),(PetscVoidFunction
*)(&f));do {if (__builtin_expect(!!(__ierr),0)) return PetscError
(((MPI_Comm)0x44000001),1418,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,__ierr,PETSC_ERROR_REPEAT," ");} while (0); if (f) {__ierr =
(*f)(B,d_nz,d_nnz,o_nz,o_nnz);do {if (__builtin_expect(!!(__ierr
),0)) return PetscError(((MPI_Comm)0x44000001),1418,__func__,
"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,__ierr,PETSC_ERROR_REPEAT," ");} while (0);} };CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1418,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1419

1420

}

1421

1422

/*@C

1423

MatCreateSELL - Creates a sparse parallel matrix in SELL format.

1424

1425

Collective on MPI_Comm

1426

1427

Input Parameters:

1428

+ comm - MPI communicator

1429

. m - number of local rows (or PETSC_DECIDE to have calculated if M is given)

1430

This value should be the same as the local size used in creating the

1431

y vector for the matrix-vector product y = Ax.

1432

. n - This value should be the same as the local size used in creating the

1433

x vector for the matrix-vector product y = Ax. (or PETSC_DECIDE to have

1434

calculated if N is given) For square matrices n is almost always m.

1435

. M - number of global rows (or PETSC_DETERMINE to have calculated if m is given)

1436

. N - number of global columns (or PETSC_DETERMINE to have calculated if n is given)

1437

. d_rlenmax - max number of nonzeros per row in DIAGONAL portion of local submatrix

1438

(same value is used for all local rows)

1439

. d_rlen - array containing the number of nonzeros in the various rows of the

1440

DIAGONAL portion of the local submatrix (possibly different for each row)

1441

or NULL, if d_rlenmax is used to specify the nonzero structure.

1442

The size of this array is equal to the number of local rows, i.e 'm'.

1443

. o_rlenmax - max number of nonzeros per row in the OFF-DIAGONAL portion of local

1444

submatrix (same value is used for all local rows).

1445

- o_rlen - array containing the number of nonzeros in the various rows of the

1446

OFF-DIAGONAL portion of the local submatrix (possibly different for

1447

each row) or NULL, if o_rlenmax is used to specify the nonzero

1448

structure. The size of this array is equal to the number

1449

of local rows, i.e 'm'.

1450

1451

Output Parameter:

1452

. A - the matrix

1453

1454

It is recommended that one use the MatCreate(), MatSetType() and/or MatSetFromOptions(),

1455

MatXXXXSetPreallocation() paradigm instead of this routine directly.

1456

[MatXXXXSetPreallocation() is, for example, MatSeqSELLSetPreallocation]

1457

1458

Notes:

1459

If the *_rlen parameter is given then the *_rlenmax parameter is ignored

1460

1461

m,n,M,N parameters specify the size of the matrix, and its partitioning across

1462

processors, while d_rlenmax,d_rlen,o_rlenmax,o_rlen parameters specify the approximate

1463

storage requirements for this matrix.

1464

1465

If PETSC_DECIDE or PETSC_DETERMINE is used for a particular argument on one

1466

processor than it must be used on all processors that share the object for

1467

that argument.

1468

1469

The user MUST specify either the local or global matrix dimensions

1470

(possibly both).

1471

1472

The parallel matrix is partitioned across processors such that the

1473

first m0 rows belong to process 0, the next m1 rows belong to

1474

process 1, the next m2 rows belong to process 2 etc.. where

1475

m0,m1,m2,.. are the input parameter 'm'. i.e each processor stores

1476

values corresponding to [m x N] submatrix.

1477

1478

The columns are logically partitioned with the n0 columns belonging

1479

to 0th partition, the next n1 columns belonging to the next

1480

partition etc.. where n0,n1,n2... are the input parameter 'n'.

1481

1482

The DIAGONAL portion of the local submatrix on any given processor

1483

is the submatrix corresponding to the rows and columns m,n

1484

corresponding to the given processor. i.e diagonal matrix on

1485

process 0 is [m0 x n0], diagonal matrix on process 1 is [m1 x n1]

1486

etc. The remaining portion of the local submatrix [m x (N-n)]

1487

constitute the OFF-DIAGONAL portion. The example below better

1488

illustrates this concept.

1489

1490

For a square global matrix we define each processor's diagonal portion

1491

to be its local rows and the corresponding columns (a square submatrix);

1492

each processor's off-diagonal portion encompasses the remainder of the

1493

local matrix (a rectangular submatrix).

1494

1495

If o_rlen, d_rlen are specified, then o_rlenmax, and d_rlenmax are ignored.

1496

1497

When calling this routine with a single process communicator, a matrix of

1498

type SEQSELL is returned. If a matrix of type MATMPISELL is desired for this

1499

type of communicator, use the construction mechanism:

1500

MatCreate(...,&A); MatSetType(A,MATMPISELL); MatSetSizes(A, m,n,M,N); MatMPISELLSetPreallocation(A,...);

1501

1502

Options Database Keys:

1503

- -mat_sell_oneindex - Internally use indexing starting at 1

1504

rather than 0. Note that when calling MatSetValues(),

1505

the user still MUST index entries starting at 0!

1506

1507

1508

Example usage:

1509

1510

Consider the following 8x8 matrix with 34 non-zero values, that is

1511

assembled across 3 processors. Lets assume that proc0 owns 3 rows,

1512

proc1 owns 3 rows, proc2 owns 2 rows. This division can be shown

1513

as follows:

1514

1515

.vb

1516

1 2 0 | 0 3 0 | 0 4

1517

Proc0 0 5 6 | 7 0 0 | 8 0

1518

9 0 10 | 11 0 0 | 12 0

1519

-------------------------------------

1520

13 0 14 | 15 16 17 | 0 0

1521

Proc1 0 18 0 | 19 20 21 | 0 0

1522

0 0 0 | 22 23 0 | 24 0

1523

-------------------------------------

1524

Proc2 25 26 27 | 0 0 28 | 29 0

1525

30 0 0 | 31 32 33 | 0 34

1526

.ve

1527

1528

This can be represented as a collection of submatrices as:

1529

1530

.vb

1531

A B C

1532

D E F

1533

G H I

1534

.ve

1535

1536

Where the submatrices A,B,C are owned by proc0, D,E,F are

1537

owned by proc1, G,H,I are owned by proc2.

1538

1539

The 'm' parameters for proc0,proc1,proc2 are 3,3,2 respectively.

1540

The 'n' parameters for proc0,proc1,proc2 are 3,3,2 respectively.

1541

The 'M','N' parameters are 8,8, and have the same values on all procs.

1542

1543

The DIAGONAL submatrices corresponding to proc0,proc1,proc2 are

1544

submatrices [A], [E], [I] respectively. The OFF-DIAGONAL submatrices

1545

corresponding to proc0,proc1,proc2 are [BC], [DF], [GH] respectively.

1546

Internally, each processor stores the DIAGONAL part, and the OFF-DIAGONAL

1547

part as SeqSELL matrices. for eg: proc1 will store [E] as a SeqSELL

1548

matrix, ans [DF] as another SeqSELL matrix.

1549

1550

When d_rlenmax, o_rlenmax parameters are specified, d_rlenmax storage elements are

1551

allocated for every row of the local diagonal submatrix, and o_rlenmax

1552

storage locations are allocated for every row of the OFF-DIAGONAL submat.

1553

One way to choose d_rlenmax and o_rlenmax is to use the max nonzerors per local

1554

rows for each of the local DIAGONAL, and the OFF-DIAGONAL submatrices.

1555

In this case, the values of d_rlenmax,o_rlenmax are:

1556

.vb

1557

proc0 : d_rlenmax = 2, o_rlenmax = 2

1558

proc1 : d_rlenmax = 3, o_rlenmax = 2

1559

proc2 : d_rlenmax = 1, o_rlenmax = 4

1560

.ve

1561

We are allocating m*(d_rlenmax+o_rlenmax) storage locations for every proc. This

1562

translates to 3*(2+2)=12 for proc0, 3*(3+2)=15 for proc1, 2*(1+4)=10

1563

for proc3. i.e we are using 12+15+10=37 storage locations to store

1564

34 values.

1565

1566

When d_rlen, o_rlen parameters are specified, the storage is specified

1567

for every row, coresponding to both DIAGONAL and OFF-DIAGONAL submatrices.

1568

In the above case the values for d_nnz,o_nnz are:

1569

.vb

1570

proc0: d_nnz = [2,2,2] and o_nnz = [2,2,2]

1571

proc1: d_nnz = [3,3,2] and o_nnz = [2,1,1]

1572

proc2: d_nnz = [1,1] and o_nnz = [4,4]

1573

.ve

1574

Here the space allocated is still 37 though there are 34 nonzeros because

1575

the allocation is always done according to rlenmax.

1576

1577

Level: intermediate

1578

1579

.keywords: matrix, sell, sparse, parallel

1580

1581

.seealso: MatCreate(), MatCreateSeqSELL(), MatSetValues(), MatMPISELLSetPreallocation(), MatMPISELLSetPreallocationSELL(),

1582

MATMPISELL, MatCreateMPISELLWithArrays()

1583

@*/

1584

PetscErrorCode MatCreateSELL(MPI_Comm comm,PetscInt m,PetscInt n,PetscInt M,PetscInt N,PetscInt d_rlenmax,const PetscInt d_rlen[],PetscInt o_rlenmax,const PetscInt o_rlen[],Mat *A)

1585

{

1586

PetscErrorCode ierr;

1587

PetscMPIInt size;

1588

1589

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 1589; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

1590

ierr = MatCreate(comm,A);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1590,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1591

ierr = MatSetSizes(*A,m,n,M,N);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1591,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1592

ierr = MPI_Comm_size(comm,&size);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1592,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1593

if (size > 1) {

1594

ierr = MatSetType(*A,MATMPISELL"mpisell");CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1594,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1595

ierr = MatMPISELLSetPreallocation(*A,d_rlenmax,d_rlen,o_rlenmax,o_rlen);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1595,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1596

} else {

1597

ierr = MatSetType(*A,MATSEQSELL"seqsell");CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1597,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1598

ierr = MatSeqSELLSetPreallocation(*A,d_rlenmax,d_rlen);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1598,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1599

}

1600

1601

}

1602

1603

PetscErrorCode MatMPISELLGetSeqSELL(Mat A,Mat *Ad,Mat *Ao,const PetscInt *colmap[])

1604

{

1605

Mat_MPISELL *a=(Mat_MPISELL*)A->data;

1606

PetscBool flg;

1607

PetscErrorCode ierr;

1608

1609

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 1609; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

1610

ierr = PetscObjectTypeCompare((PetscObject)A,MATMPISELL"mpisell",&flg);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1610,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1611

if (!flg) SETERRQ(PetscObjectComm((PetscObject)A),PETSC_ERR_SUP,"This function requires a MATMPISELL matrix as input")return PetscError(PetscObjectComm((PetscObject)A),1611,__func__
,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,56,PETSC_ERROR_INITIAL,"This function requires a MATMPISELL matrix as input"
);

1612

if (Ad) *Ad = a->A;

1613

if (Ao) *Ao = a->B;

1614

if (colmap) *colmap = a->garray;

1615

1616

}

1617

1618

/*@C

1619

MatMPISELLGetLocalMatCondensed - Creates a SeqSELL matrix from an MATMPISELL matrix by taking all its local rows and NON-ZERO columns

1620

1621

Not Collective

1622

1623

Input Parameters:

1624

+ A - the matrix

1625

. scall - either MAT_INITIAL_MATRIX or MAT_REUSE_MATRIX

1626

- row, col - index sets of rows and columns to extract (or NULL)

1627

1628

Output Parameter:

1629

. A_loc - the local sequential matrix generated

1630

1631

Level: developer

1632

1633

.seealso: MatGetOwnershipRange(), MatMPISELLGetLocalMat()

1634

1635

@*/

1636

PetscErrorCode MatMPISELLGetLocalMatCondensed(Mat A,MatReuse scall,IS *row,IS *col,Mat *A_loc)

1637

{

1638

Mat_MPISELL *a=(Mat_MPISELL*)A->data;

1639

PetscErrorCode ierr;

1640

PetscInt i,start,end,ncols,nzA,nzB,*cmap,imark,*idx;

1641

IS isrowa,iscola;

1642

Mat *aloc;

1643

PetscBool match;

1644

1645

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 1645; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

1646

ierr = PetscObjectTypeCompare((PetscObject)A,MATMPISELL"mpisell",&match);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1646,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1647

if (!match) SETERRQ(PetscObjectComm((PetscObject)A), PETSC_ERR_SUP,"Requires MATMPISELL matrix as input")return PetscError(PetscObjectComm((PetscObject)A),1647,__func__
,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,56,PETSC_ERROR_INITIAL,"Requires MATMPISELL matrix as input"
);

1648

ierr = PetscLogEventBegin(MAT_Getlocalmatcondensed,A,0,0,0)(((PetscLogPLB && petsc_stageLog->stageInfo[petsc_stageLog
->curStage].perfInfo.active && petsc_stageLog->
stageInfo[petsc_stageLog->curStage].eventLog->eventInfo
[MAT_Getlocalmatcondensed].active) ? (*PetscLogPLB)((MAT_Getlocalmatcondensed
),0,(PetscObject)(A),(PetscObject)(0),(PetscObject)(0),(PetscObject
)(0)) : 0 ));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1648,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1649

if (!row) {

1650

start = A->rmap->rstart; end = A->rmap->rend;

1651

ierr = ISCreateStride(PETSC_COMM_SELF((MPI_Comm)0x44000001),end-start,start,1,&isrowa);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1651,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1652

} else {

1653

isrowa = *row;

1654

}

1655

if (!col) {

1656

start = A->cmap->rstart;

1657

cmap = a->garray;

1658

nzA = a->A->cmap->n;

1659

nzB = a->B->cmap->n;

1660

ierr = PetscMalloc1(nzA+nzB, &idx)PetscMallocA(1,PETSC_FALSE,1660,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,(size_t)(nzA+nzB)*sizeof(**(&idx)),(&idx));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1660,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1661

ncols = 0;

1662

for (i=0; i<nzB; i++) {

1663

if (cmap[i] < start) idx[ncols++] = cmap[i];

1664

else break;

1665

}

1666

imark = i;

1667

for (i=0; i<nzA; i++) idx[ncols++] = start + i;

1668

for (i=imark; i<nzB; i++) idx[ncols++] = cmap[i];

1669

ierr = ISCreateGeneral(PETSC_COMM_SELF((MPI_Comm)0x44000001),ncols,idx,PETSC_OWN_POINTER,&iscola);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1669,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1670

} else {

1671

iscola = *col;

1672

}

1673

if (scall != MAT_INITIAL_MATRIX) {

1674

ierr = PetscMalloc1(1,&aloc)PetscMallocA(1,PETSC_FALSE,1674,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,(size_t)(1)*sizeof(**(&aloc)),(&aloc));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1674,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1675

aloc[0] = *A_loc;

1676

}

1677

ierr = MatCreateSubMatrices(A,1,&isrowa,&iscola,scall,&aloc);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1677,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1678

*A_loc = aloc[0];

1679

ierr = PetscFree(aloc)((*PetscTrFree)((void*)(aloc),1679,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
) || ((aloc) = 0,0));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1679,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1680

if (!row) {

1681

ierr = ISDestroy(&isrowa);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1681,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1682

}

1683

if (!col) {

1684

ierr = ISDestroy(&iscola);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1684,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1685

}

1686

ierr = PetscLogEventEnd(MAT_Getlocalmatcondensed,A,0,0,0)(((PetscLogPLE && petsc_stageLog->stageInfo[petsc_stageLog
->curStage].perfInfo.active && petsc_stageLog->
stageInfo[petsc_stageLog->curStage].eventLog->eventInfo
[MAT_Getlocalmatcondensed].active) ? (*PetscLogPLE)((MAT_Getlocalmatcondensed
),0,(PetscObject)(A),(PetscObject)(0),(PetscObject)(0),(PetscObject
)(0)) : 0 ));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1686,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1687

1688

}

1689

1690

#include <../src/mat/impls/aij/mpi/mpiaij.h>

1691

1692

PetscErrorCode MatConvert_MPISELL_MPIAIJ(Mat A,MatType newtype,MatReuse reuse,Mat *newmat)

1693

{

1694

PetscErrorCode ierr;

1695

Mat_MPISELL *a=(Mat_MPISELL*)A->data;

1696

Mat B;

1697

Mat_MPIAIJ *b;

1698

1699

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 1699; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

1700

if (!A->assembled) SETERRQ(PetscObjectComm((PetscObject)A),PETSC_ERR_SUP,"Matrix must be assembled")return PetscError(PetscObjectComm((PetscObject)A),1700,__func__
,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,56,PETSC_ERROR_INITIAL,"Matrix must be assembled");

1701

1702

if (reuse == MAT_REUSE_MATRIX) {

1703

B = *newmat;

1704

} else {

1705

ierr = MatCreate(PetscObjectComm((PetscObject)A),&B);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1705,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1706

ierr = MatSetType(B,MATMPIAIJ"mpiaij");CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1706,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1707

ierr = MatSetSizes(B,A->rmap->n,A->cmap->n,A->rmap->N,A->cmap->N);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1707,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1708

ierr = MatSetBlockSizes(B,A->rmap->bs,A->cmap->bs);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1708,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1709

ierr = MatSeqAIJSetPreallocation(B,0,NULL((void*)0));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1709,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1710

ierr = MatMPIAIJSetPreallocation(B,0,NULL((void*)0),0,NULL((void*)0));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1710,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1711

}

1712

b = (Mat_MPIAIJ*) B->data;

1713

1714

if (reuse == MAT_REUSE_MATRIX) {

1715

ierr = MatConvert_SeqSELL_SeqAIJ(a->A, MATSEQAIJ"seqaij", MAT_REUSE_MATRIX, &b->A);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1715,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1716

ierr = MatConvert_SeqSELL_SeqAIJ(a->B, MATSEQAIJ"seqaij", MAT_REUSE_MATRIX, &b->B);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1716,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1717

} else {

1718

ierr = MatDestroy(&b->A);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1718,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1719

ierr = MatDestroy(&b->B);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1719,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1720

ierr = MatDisAssemble_MPISELL(A);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1720,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1721

ierr = MatConvert_SeqSELL_SeqAIJ(a->A, MATSEQAIJ"seqaij", MAT_INITIAL_MATRIX, &b->A);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1721,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1722

ierr = MatConvert_SeqSELL_SeqAIJ(a->B, MATSEQAIJ"seqaij", MAT_INITIAL_MATRIX, &b->B);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1722,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1723

ierr = MatAssemblyBegin(B,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1723,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1724

ierr = MatAssemblyEnd(B,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1724,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1725

ierr = MatAssemblyBegin(A,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1725,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1726

ierr = MatAssemblyEnd(A,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1726,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1727

}

1728

1729

if (reuse == MAT_INPLACE_MATRIX) {

1730

ierr = MatHeaderReplace(A,&B);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1730,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1731

} else {

1732

*newmat = B;

1733

}

1734

1735

}

1736

1737

PetscErrorCode MatConvert_MPIAIJ_MPISELL(Mat A,MatType newtype,MatReuse reuse,Mat *newmat)

1738

{

1739

PetscErrorCode ierr;

1740

Mat_MPIAIJ *a=(Mat_MPIAIJ*)A->data;

1741

Mat B;

1742

Mat_MPISELL *b;

1743

1744

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 1744; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

1745

if (!A->assembled) SETERRQ(PetscObjectComm((PetscObject)A),PETSC_ERR_SUP,"Matrix must be assembled")return PetscError(PetscObjectComm((PetscObject)A),1745,__func__
,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,56,PETSC_ERROR_INITIAL,"Matrix must be assembled");

1746

1747

if (reuse == MAT_REUSE_MATRIX) {

1748

B = *newmat;

1749

} else {

1750

ierr = MatCreate(PetscObjectComm((PetscObject)A),&B);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1750,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1751

ierr = MatSetType(B,MATMPISELL"mpisell");CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1751,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1752

ierr = MatSetSizes(B,A->rmap->n,A->cmap->n,A->rmap->N,A->cmap->N);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1752,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1753

ierr = MatSetBlockSizes(B,A->rmap->bs,A->cmap->bs);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1753,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1754

ierr = MatSeqAIJSetPreallocation(B,0,NULL((void*)0));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1754,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1755

ierr = MatMPIAIJSetPreallocation(B,0,NULL((void*)0),0,NULL((void*)0));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1755,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1756

}

1757

b = (Mat_MPISELL*) B->data;

1758

1759

if (reuse == MAT_REUSE_MATRIX) {

1760

ierr = MatConvert_SeqAIJ_SeqSELL(a->A, MATSEQSELL"seqsell", MAT_REUSE_MATRIX, &b->A);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1760,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1761

ierr = MatConvert_SeqAIJ_SeqSELL(a->B, MATSEQSELL"seqsell", MAT_REUSE_MATRIX, &b->B);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1761,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1762

} else {

1763

ierr = MatDestroy(&b->A);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1763,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1764

ierr = MatDestroy(&b->B);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1764,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1765

ierr = MatDisAssemble_MPIAIJ(A);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1765,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1766

ierr = MatConvert_SeqAIJ_SeqSELL(a->A, MATSEQSELL"seqsell", MAT_INITIAL_MATRIX, &b->A);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1766,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1767

ierr = MatConvert_SeqAIJ_SeqSELL(a->B, MATSEQSELL"seqsell", MAT_INITIAL_MATRIX, &b->B);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1767,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1768

ierr = MatAssemblyBegin(B,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1768,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1769

ierr = MatAssemblyEnd(B,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1769,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1770

ierr = MatAssemblyBegin(A,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1770,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1771

ierr = MatAssemblyEnd(A,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1771,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1772

}

1773

1774

if (reuse == MAT_INPLACE_MATRIX) {

1775

ierr = MatHeaderReplace(A,&B);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1775,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1776

} else {

1777

*newmat = B;

1778

}

1779

1780

}

1781

1782

PetscErrorCode MatSOR_MPISELL(Mat matin,Vec bb,PetscReal omega,MatSORType flag,PetscReal fshift,PetscInt its,PetscInt lits,Vec xx)

1783

{

1784

Mat_MPISELL *mat=(Mat_MPISELL*)matin->data;

1785

PetscErrorCode ierr;

1786

Vec bb1=0;

1787

1788

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 1788; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

1789

if (flag == SOR_APPLY_UPPER) {

1790

ierr = (*mat->A->ops->sor)(mat->A,bb,omega,flag,fshift,lits,1,xx);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1790,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1791

1792

}

1793

1794

if (its > 1 || ~flag & SOR_ZERO_INITIAL_GUESS || flag & SOR_EISENSTAT) {

1795

ierr = VecDuplicate(bb,&bb1);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1795,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1796

}

1797

1798

if ((flag & SOR_LOCAL_SYMMETRIC_SWEEP) == SOR_LOCAL_SYMMETRIC_SWEEP) {

1799

if (flag & SOR_ZERO_INITIAL_GUESS) {

1800

ierr = (*mat->A->ops->sor)(mat->A,bb,omega,flag,fshift,lits,1,xx);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1800,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1801

its--;

1802

}

1803

1804

while (its--) {

1805

ierr = VecScatterBegin(mat->Mvctx,xx,mat->lvec,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1805,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1806

ierr = VecScatterEnd(mat->Mvctx,xx,mat->lvec,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1806,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1807

1808

/* update rhs: bb1 = bb - B*x */

1809

ierr = VecScale(mat->lvec,-1.0);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1809,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1810

ierr = (*mat->B->ops->multadd)(mat->B,mat->lvec,bb,bb1);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1810,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1811

1812

/* local sweep */

1813

ierr = (*mat->A->ops->sor)(mat->A,bb1,omega,SOR_SYMMETRIC_SWEEP,fshift,lits,1,xx);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1813,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1814

}

1815

} else if (flag & SOR_LOCAL_FORWARD_SWEEP) {

1816

if (flag & SOR_ZERO_INITIAL_GUESS) {

1817

ierr = (*mat->A->ops->sor)(mat->A,bb,omega,flag,fshift,lits,1,xx);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1817,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1818

its--;

1819

}

1820

while (its--) {

1821

ierr = VecScatterBegin(mat->Mvctx,xx,mat->lvec,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1821,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1822

ierr = VecScatterEnd(mat->Mvctx,xx,mat->lvec,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1822,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1823

1824

/* update rhs: bb1 = bb - B*x */

1825

ierr = VecScale(mat->lvec,-1.0);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1825,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1826

ierr = (*mat->B->ops->multadd)(mat->B,mat->lvec,bb,bb1);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1826,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1827

1828

/* local sweep */

1829

ierr = (*mat->A->ops->sor)(mat->A,bb1,omega,SOR_FORWARD_SWEEP,fshift,lits,1,xx);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1829,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1830

}

1831

} else if (flag & SOR_LOCAL_BACKWARD_SWEEP) {

1832

if (flag & SOR_ZERO_INITIAL_GUESS) {

1833

ierr = (*mat->A->ops->sor)(mat->A,bb,omega,flag,fshift,lits,1,xx);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1833,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1834

its--;

1835

}

1836

while (its--) {

1837

ierr = VecScatterBegin(mat->Mvctx,xx,mat->lvec,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1837,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1838

ierr = VecScatterEnd(mat->Mvctx,xx,mat->lvec,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1838,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1839

1840

/* update rhs: bb1 = bb - B*x */

1841

ierr = VecScale(mat->lvec,-1.0);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1841,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1842

ierr = (*mat->B->ops->multadd)(mat->B,mat->lvec,bb,bb1);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1842,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1843

1844

/* local sweep */

1845

ierr = (*mat->A->ops->sor)(mat->A,bb1,omega,SOR_BACKWARD_SWEEP,fshift,lits,1,xx);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1845,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1846

}

1847

} else SETERRQ(PetscObjectComm((PetscObject)matin),PETSC_ERR_SUP,"Parallel SOR not supported")return PetscError(PetscObjectComm((PetscObject)matin),1847,__func__
,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,56,PETSC_ERROR_INITIAL,"Parallel SOR not supported");

1848

1849

ierr = VecDestroy(&bb1);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1849,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1850

1851

matin->factorerrortype = mat->A->factorerrortype;

1852

1853

}

1854

1855

/*MC

1856

MATMPISELL - MATMPISELL = "MPISELL" - A matrix type to be used for parallel sparse matrices.

1857

1858

Options Database Keys:

1859

. -mat_type MPISELL - sets the matrix type to "MPISELL" during a call to MatSetFromOptions()

1860

1861

Level: beginner

1862

1863

.seealso: MatCreateSELL()

1864

M*/

1865

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode MatCreate_MPISELL(Mat B)

1866

{

1867

Mat_MPISELL *b;

1868

PetscErrorCode ierr;

1869

PetscMPIInt size;

1870

1871

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
; petscstack->line[petscstack->currentsize] = 1871; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

1872

ierr = MPI_Comm_size(PetscObjectComm((PetscObject)B),&size);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1872,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1873

ierr = PetscNewLog(B,&b)(PetscMallocA(1,PETSC_TRUE,1873,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,(size_t)(1)*sizeof(**(((&b)))),(((&b)))) || PetscLogObjectMemory
((PetscObject)B,sizeof(**(&b))));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1873,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1874

B->data = (void*)b;

1875

ierr = PetscMemcpy(B->ops,&MatOps_Values,sizeof(struct _MatOps));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1875,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1876

B->assembled = PETSC_FALSE;

1877

B->insertmode = NOT_SET_VALUES;

1878

b->size = size;

1879

ierr = MPI_Comm_rank(PetscObjectComm((PetscObject)B),&b->rank);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1879,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1880

/* build cache for off array entries formed */

1881

ierr = MatStashCreate_Private(PetscObjectComm((PetscObject)B),1,&B->stash);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1881,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1882

1883

b->donotstash = PETSC_FALSE;

1884

b->colmap = 0;

1885

b->garray = 0;

1886

b->roworiented = PETSC_TRUE;

1887

1888

/* stuff used for matrix vector multiply */

1889

b->lvec = NULL((void*)0);

1890

b->Mvctx = NULL((void*)0);

1891

1892

/* stuff for MatGetRow() */

1893

b->rowindices = 0;

1894

b->rowvalues = 0;

1895

b->getrowactive = PETSC_FALSE;

1896

1897

ierr = PetscObjectComposeFunction((PetscObject)B,"MatStoreValues_C",MatStoreValues_MPISELL)PetscObjectComposeFunction_Private((PetscObject)B,"MatStoreValues_C"
,(PetscVoidFunction)(MatStoreValues_MPISELL));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1897,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1898

ierr = PetscObjectComposeFunction((PetscObject)B,"MatRetrieveValues_C",MatRetrieveValues_MPISELL)PetscObjectComposeFunction_Private((PetscObject)B,"MatRetrieveValues_C"
,(PetscVoidFunction)(MatRetrieveValues_MPISELL));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1898,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1899

ierr = PetscObjectComposeFunction((PetscObject)B,"MatIsTranspose_C",MatIsTranspose_MPISELL)PetscObjectComposeFunction_Private((PetscObject)B,"MatIsTranspose_C"
,(PetscVoidFunction)(MatIsTranspose_MPISELL));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1899,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1900

ierr = PetscObjectComposeFunction((PetscObject)B,"MatMPISELLSetPreallocation_C",MatMPISELLSetPreallocation_MPISELL)PetscObjectComposeFunction_Private((PetscObject)B,"MatMPISELLSetPreallocation_C"
,(PetscVoidFunction)(MatMPISELLSetPreallocation_MPISELL));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1900,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1901

ierr = PetscObjectComposeFunction((PetscObject)B,"MatConvert_mpisell_mpiaij_C",MatConvert_MPISELL_MPIAIJ)PetscObjectComposeFunction_Private((PetscObject)B,"MatConvert_mpisell_mpiaij_C"
,(PetscVoidFunction)(MatConvert_MPISELL_MPIAIJ));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1901,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1902

ierr = PetscObjectComposeFunction((PetscObject)B,"MatDiagonalScaleLocal_C",MatDiagonalScaleLocal_MPISELL)PetscObjectComposeFunction_Private((PetscObject)B,"MatDiagonalScaleLocal_C"
,(PetscVoidFunction)(MatDiagonalScaleLocal_MPISELL));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1902,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1903

ierr = PetscObjectChangeTypeName((PetscObject)B,MATMPISELL"mpisell");CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1903,__func__,"/sandbox/petsc/petsc.next-tmp/src/mat/impls/sell/mpi/mpisell.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1904

1905

}

←

/sandbox/petsc/petsc.next-tmp/include/petscctable.h

#ifndef PETSCCTABLE_H

#define PETSCCTABLE_H

#include <petscsys.h>

struct _n_PetscTable {

PetscInt *keytable;

PetscInt *table;

PetscInt count;

PetscInt tablesize;

PetscInt head;

PetscInt maxkey; /* largest key allowed */

};

typedef struct _n_PetscTable* PetscTable;

typedef PetscInt* PetscTablePosition;

PETSC_STATIC_INLINEstatic inline unsigned long PetscHash(PetscTable ta,unsigned long x)

{

return(x%(unsigned long)ta->tablesize);

}

PETSC_STATIC_INLINEstatic inline unsigned long PetscHashStep(PetscTable ta,unsigned long x)

{

return(1+(x%(unsigned long)(ta->tablesize-1)));

←

Division by zero

}

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscTableCreate(const PetscInt,PetscInt,PetscTable*);

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscTableCreateCopy(const PetscTable,PetscTable*);

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscTableDestroy(PetscTable*);

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscTableGetCount(const PetscTable,PetscInt*);

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscTableIsEmpty(const PetscTable,PetscInt*);

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscTableAddExpand(PetscTable,PetscInt,PetscInt,InsertMode);

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscTableAddCountExpand(PetscTable,PetscInt);

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscTableGetHeadPosition(PetscTable,PetscTablePosition*);

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscTableGetNext(PetscTable,PetscTablePosition*,PetscInt*,PetscInt*);

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscTableRemoveAll(PetscTable);

PETSC_STATIC_INLINEstatic inline PetscErrorCode PetscTableAdd(PetscTable ta,PetscInt key,PetscInt data,InsertMode imode)

{

PetscErrorCode ierr;

PetscInt i,hash = (PetscInt)PetscHash(ta,(unsigned long)key);

PetscInt hashstep = (PetscInt)PetscHashStep(ta,(unsigned long)key);

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/include/petscctable.h"; petscstack
->line[petscstack->currentsize] = 44; petscstack->petscroutine
[petscstack->currentsize] = PETSC_TRUE; petscstack->currentsize
++; } if (petscstack) { petscstack->hotdepth += (PETSC_FALSE
|| petscstack->hotdepth); } ; } while (0); ; } while (0);

if (key <= 0) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"key <= 0")return PetscError(((MPI_Comm)0x44000001),45,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscctable.h"
,63,PETSC_ERROR_INITIAL,"key <= 0");

if (key > ta->maxkey) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"key %D is greater than largest key allowed %D",key,ta->maxkey)return PetscError(((MPI_Comm)0x44000001),46,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscctable.h"
,63,PETSC_ERROR_INITIAL,"key %D is greater than largest key allowed %D"
,key,ta->maxkey);

if (!data) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Null data")return PetscError(((MPI_Comm)0x44000001),47,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscctable.h"
,63,PETSC_ERROR_INITIAL,"Null data");

for (i=0; i<ta->tablesize; i++) {

if (ta->keytable[hash] == key) {

switch (imode) {

case INSERT_VALUES:

ta->table[hash] = data; /* over write */

break;

case ADD_VALUES:

ta->table[hash] += data;

break;

case MAX_VALUES:

ta->table[hash] = PetscMax(ta->table[hash],data)(((ta->table[hash])<(data)) ? (data) : (ta->table[hash
]));

break;

case NOT_SET_VALUES:

case INSERT_ALL_VALUES:

case ADD_ALL_VALUES:

case INSERT_BC_VALUES:

case ADD_BC_VALUES:

SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SUP,"Unsupported InsertMode")return PetscError(((MPI_Comm)0x44000001),66,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscctable.h"
,56,PETSC_ERROR_INITIAL,"Unsupported InsertMode");

}

} else if (!ta->keytable[hash]) {

if (ta->count < 5*(ta->tablesize/6) - 1) {

ta->count++; /* add */

ta->keytable[hash] = key;

ta->table[hash] = data;

} else {

ierr = PetscTableAddExpand(ta,key,data,imode);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),75,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscctable.h"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

}

hash = (hash + hashstep)%ta->tablesize;

}

SETERRQ(PETSC_COMM_SELF,PETSC_ERR_COR,"Full table")return PetscError(((MPI_Comm)0x44000001),81,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscctable.h"
,74,PETSC_ERROR_INITIAL,"Full table");

/* PetscFunctionReturn(0); */

}

PETSC_STATIC_INLINEstatic inline PetscErrorCode PetscTableAddCount(PetscTable ta,PetscInt key)

{

PetscErrorCode ierr;

PetscInt i,hash = (PetscInt)PetscHash(ta,(unsigned long)key);

PetscInt hashstep = (PetscInt)PetscHashStep(ta,(unsigned long)key);

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/include/petscctable.h"; petscstack
->line[petscstack->currentsize] = 91; petscstack->petscroutine
[petscstack->currentsize] = PETSC_TRUE; petscstack->currentsize
++; } if (petscstack) { petscstack->hotdepth += (PETSC_FALSE
|| petscstack->hotdepth); } ; } while (0); ; } while (0);

if (key <= 0) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"key <= 0")return PetscError(((MPI_Comm)0x44000001),92,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscctable.h"
,63,PETSC_ERROR_INITIAL,"key <= 0");

if (key > ta->maxkey) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"key %D is greater than largest key allowed %D",key,ta->maxkey)return PetscError(((MPI_Comm)0x44000001),93,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscctable.h"
,63,PETSC_ERROR_INITIAL,"key %D is greater than largest key allowed %D"
,key,ta->maxkey);

for (i=0; i<ta->tablesize; i++) {

if (ta->keytable[hash] == key) {

} else if (!ta->keytable[hash]) {

if (ta->count < 5*(ta->tablesize/6) - 1) {

100

ta->count++; /* add */

101

ta->keytable[hash] = key;

102

ta->table[hash] = ta->count;

103

} else {

104

ierr = PetscTableAddCountExpand(ta,key);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),104,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscctable.h"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

105

}

106

107

}

108

hash = (hash + hashstep)%ta->tablesize;

109

}

110

SETERRQ(PETSC_COMM_SELF,PETSC_ERR_COR,"Full table")return PetscError(((MPI_Comm)0x44000001),110,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscctable.h"
,74,PETSC_ERROR_INITIAL,"Full table");

111

/* PetscFunctionReturn(0); */

112

}

113

114

115

PetscTableFind - checks if a key is in the table

116

117

If data==0, then no table entry exists.

118

119

120

PETSC_STATIC_INLINEstatic inline PetscErrorCode PetscTableFind(PetscTable ta,PetscInt key,PetscInt *data)

121

{

122

PetscInt ii = 0;

123

PetscInt hash = (PetscInt)PetscHash(ta,(unsigned long)key);

124

PetscInt hashstep = (PetscInt)PetscHashStep(ta,(unsigned long)key);

←

Calling 'PetscHashStep'

→

125

126

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/include/petscctable.h"; petscstack
->line[petscstack->currentsize] = 126; petscstack->petscroutine
[petscstack->currentsize] = PETSC_TRUE; petscstack->currentsize
++; } if (petscstack) { petscstack->hotdepth += (PETSC_FALSE
|| petscstack->hotdepth); } ; } while (0); ; } while (0);

127

*data = 0;

128

if (key <= 0) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Key <= 0")return PetscError(((MPI_Comm)0x44000001),128,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscctable.h"
,63,PETSC_ERROR_INITIAL,"Key <= 0");

129

if (key > ta->maxkey) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"key %D is greater than largest key allowed %D",key,ta->maxkey)return PetscError(((MPI_Comm)0x44000001),129,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscctable.h"
,63,PETSC_ERROR_INITIAL,"key %D is greater than largest key allowed %D"
,key,ta->maxkey);

130

131

while (ii++ < ta->tablesize) {

132

if (!ta->keytable[hash]) break;

133

else if (ta->keytable[hash] == key) {

134

*data = ta->table[hash];

135

break;

136

}

137

hash = (hash + hashstep)%ta->tablesize;

138

}

139

140

}

141

142

#endif