/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c

Bug Summary

File:	ksp/pc/impls/redundant/redundant.c
Warning:	line 2429, column 76 Access to field 'child' results in a dereference of a null pointer (loaded from variable 'scomm')

Annotated Source Code

[?] Use j/k keys for keyboard navigation

/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c

→

This file defines a "solve the problem redundantly on each subgroup of processor" preconditioner.

#include <petsc/private/pcimpl.h>

#include <petscksp.h> /*I "petscksp.h" I*/

typedef struct {

KSP ksp;

PC pc; /* actual preconditioner used on each processor */

Vec xsub,ysub; /* vectors of a subcommunicator to hold parallel vectors of PetscObjectComm((PetscObject)pc) */

Vec xdup,ydup; /* parallel vector that congregates xsub or ysub facilitating vector scattering */

Mat pmats; /* matrix and optional preconditioner matrix belong to a subcommunicator */

VecScatter scatterin,scatterout; /* scatter used to move all values to each processor group (subcommunicator) */

PetscBool useparallelmat;

PetscSubcomm psubcomm;

PetscInt nsubcomm; /* num of data structure PetscSubcomm */

PetscBool shifttypeset;

MatFactorShiftType shifttype;

} PC_Redundant;

PetscErrorCode PCFactorSetShiftType_Redundant(PC pc,MatFactorShiftType shifttype)

{

PC_Redundant *red = (PC_Redundant*)pc->data;

PetscErrorCode ierr;

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

if (red->ksp) {

PC pc;

ierr = KSPGetPC(red->ksp,&pc);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),30,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

ierr = PCFactorSetShiftType(pc,shifttype);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),31,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

} else {

red->shifttypeset = PETSC_TRUE;

red->shifttype = shifttype;

}

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);

}

static PetscErrorCode PCView_Redundant(PC pc,PetscViewer viewer)

{

PC_Redundant *red = (PC_Redundant*)pc->data;

PetscErrorCode ierr;

PetscBool iascii,isstring;

PetscViewer subviewer;

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

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

ierr = PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERSTRING"string",&isstring);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),48,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

if (iascii) {

if (!red->psubcomm) {

ierr = PetscViewerASCIIPrintf(viewer," Not yet setup\n");CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),51,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

} else {

ierr = PetscViewerASCIIPrintf(viewer," First (color=0) of %D PCs follows\n",red->nsubcomm);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),53,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

ierr = PetscViewerGetSubViewer(viewer,((PetscObject)red->pc)->comm,&subviewer);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),54,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

if (!red->psubcomm->color) { /* only view first redundant pc */

ierr = PetscViewerASCIIPushTab(subviewer);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),56,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

ierr = KSPView(red->ksp,subviewer);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),57,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

ierr = PetscViewerASCIIPopTab(subviewer);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),58,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

}

ierr = PetscViewerRestoreSubViewer(viewer,((PetscObject)red->pc)->comm,&subviewer);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),60,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

}

} else if (isstring) {

ierr = PetscViewerStringSPrintf(viewer," Redundant solver preconditioner");CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),63,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

}

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

static PetscErrorCode PCSetUp_Redundant(PC pc)

{

PC_Redundant *red = (PC_Redundant*)pc->data;

PetscErrorCode ierr;

PetscInt mstart,mend,mlocal,M;

PetscMPIInt size;

MPI_Comm comm,subcomm;

Vec x;

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

ierr = PetscObjectGetComm((PetscObject)pc,&comm);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),79,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

/* if pmatrix set by user is sequential then we do not need to gather the parallel matrix */

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

if (size == 1) red->useparallelmat = PETSC_FALSE;

Assuming 'size' is not equal to 1

→

←

Taking false branch

→

if (!pc->setupcalled) {

←

Assuming the condition is true

→

←

Taking true branch

→

PetscInt mloc_sub;

if (!red->psubcomm) { /* create red->psubcomm, new ksp and pc over subcomm */

←

Assuming pointer value is null

→

←

Taking true branch

→

KSP ksp;

ierr = PCRedundantGetKSP(pc,&ksp);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),89,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

}

subcomm = PetscSubcommChild(red->psubcomm);

←

Passing null pointer value via 1st parameter 'scomm'

→

←

Calling 'PetscSubcommChild'

→

if (red->useparallelmat) {

/* grab the parallel matrix and put it into processors of a subcomminicator */

ierr = MatCreateRedundantMatrix(pc->pmat,red->psubcomm->n,subcomm,MAT_INITIAL_MATRIX,&red->pmats);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),95,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

ierr = MPI_Comm_size(subcomm,&size);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),97,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

if (size > 1) {

PetscBool foundpack;

100

ierr = MatGetFactorAvailable(red->pmats,NULL((void*)0),MAT_FACTOR_LU,&foundpack);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),100,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

101

if (!foundpack) { /* reset default ksp and pc */

102

ierr = KSPSetType(red->ksp,KSPGMRES"gmres");CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),102,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

103

ierr = PCSetType(red->pc,PCBJACOBI"bjacobi");CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),103,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

104

} else {

105

ierr = PCFactorSetMatSolverType(red->pc,NULL((void*)0));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),105,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

106

}

107

}

108

109

ierr = KSPSetOperators(red->ksp,red->pmats,red->pmats);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),109,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

110

111

/* get working vectors xsub and ysub */

112

ierr = MatCreateVecs(red->pmats,&red->xsub,&red->ysub);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),112,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

113

114

/* create working vectors xdup and ydup.

115

xdup concatenates all xsub's contigously to form a mpi vector over dupcomm (see PetscSubcommCreate_interlaced())

116

ydup concatenates all ysub and has empty local arrays because ysub's arrays will be place into it.

117

Note: we use communicator dupcomm, not PetscObjectComm((PetscObject)pc)! */

118

ierr = MatGetLocalSize(red->pmats,&mloc_sub,NULL((void*)0));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),118,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

119

ierr = VecCreateMPI(PetscSubcommContiguousParent(red->psubcomm),mloc_sub,PETSC_DECIDE-1,&red->xdup);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),119,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

120

ierr = VecCreateMPIWithArray(PetscSubcommContiguousParent(red->psubcomm),1,mloc_sub,PETSC_DECIDE-1,NULL((void*)0),&red->ydup);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),120,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

121

122

/* create vecscatters */

123

if (!red->scatterin) { /* efficiency of scatterin is independent from psubcomm_type! */

124

IS is1,is2;

125

PetscInt *idx1,*idx2,i,j,k;

126

127

ierr = MatCreateVecs(pc->pmat,&x,0);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),127,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

128

ierr = VecGetSize(x,&M);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),128,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

129

ierr = VecGetOwnershipRange(x,&mstart,&mend);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),129,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

130

mlocal = mend - mstart;

131

ierr = PetscMalloc2(red->psubcomm->n*mlocal,&idx1,red->psubcomm->n*mlocal,&idx2)PetscMallocA(2,PETSC_FALSE,131,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,(size_t)(red->psubcomm->n*mlocal)*sizeof(**(&idx1)
),(&idx1),(size_t)(red->psubcomm->n*mlocal)*sizeof(
**(&idx2)),(&idx2));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),131,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

132

j = 0;

133

for (k=0; k<red->psubcomm->n; k++) {

134

for (i=mstart; i<mend; i++) {

135

idx1[j] = i;

136

idx2[j++] = i + M*k;

137

}

138

}

139

ierr = ISCreateGeneral(comm,red->psubcomm->n*mlocal,idx1,PETSC_COPY_VALUES,&is1);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),139,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

140

ierr = ISCreateGeneral(comm,red->psubcomm->n*mlocal,idx2,PETSC_COPY_VALUES,&is2);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),140,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

141

ierr = VecScatterCreate(x,is1,red->xdup,is2,&red->scatterin);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),141,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

142

ierr = ISDestroy(&is1);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),142,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

143

ierr = ISDestroy(&is2);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),143,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

144

145

/* Impl below is good for PETSC_SUBCOMM_INTERLACED (no inter-process communication) and PETSC_SUBCOMM_CONTIGUOUS (communication within subcomm) */

146

ierr = ISCreateStride(comm,mlocal,mstart+ red->psubcomm->color*M,1,&is1);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),146,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

147

ierr = ISCreateStride(comm,mlocal,mstart,1,&is2);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),147,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

148

ierr = VecScatterCreate(red->xdup,is1,x,is2,&red->scatterout);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),148,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

149

ierr = ISDestroy(&is1);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),149,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

150

ierr = ISDestroy(&is2);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),150,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

151

ierr = PetscFree2(idx1,idx2)PetscFreeA(2,151,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,&(idx1),&(idx2));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),151,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

152

ierr = VecDestroy(&x);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),152,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

153

}

154

} else { /* !red->useparallelmat */

155

ierr = KSPSetOperators(red->ksp,pc->mat,pc->pmat);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),155,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

156

}

157

} else { /* pc->setupcalled */

158

if (red->useparallelmat) {

159

MatReuse reuse;

160

/* grab the parallel matrix and put it into processors of a subcomminicator */

161

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

162

if (pc->flag == DIFFERENT_NONZERO_PATTERN) {

163

/* destroy old matrices */

164

ierr = MatDestroy(&red->pmats);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),164,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

165

reuse = MAT_INITIAL_MATRIX;

166

} else {

167

reuse = MAT_REUSE_MATRIX;

168

}

169

ierr = MatCreateRedundantMatrix(pc->pmat,red->psubcomm->n,PetscSubcommChild(red->psubcomm),reuse,&red->pmats);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),169,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

170

ierr = KSPSetOperators(red->ksp,red->pmats,red->pmats);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),170,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

171

} else { /* !red->useparallelmat */

172

ierr = KSPSetOperators(red->ksp,pc->mat,pc->pmat);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),172,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

173

}

174

}

175

176

if (pc->setfromoptionscalled) {

177

ierr = KSPSetFromOptions(red->ksp);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),177,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

178

}

179

ierr = KSPSetUp(red->ksp);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),179,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

180

181

}

182

183

static PetscErrorCode PCApply_Redundant(PC pc,Vec x,Vec y)

184

{

185

PC_Redundant *red = (PC_Redundant*)pc->data;

186

PetscErrorCode ierr;

187

PetscScalar *array;

188

189

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

190

if (!red->useparallelmat) {

191

ierr = KSPSolve(red->ksp,x,y);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),191,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

192

ierr = KSPCheckSolve(red->ksp,pc,y);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),192,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

193

194

}

195

196

/* scatter x to xdup */

197

ierr = VecScatterBegin(red->scatterin,x,red->xdup,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),197,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

198

ierr = VecScatterEnd(red->scatterin,x,red->xdup,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),198,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

199

200

/* place xdup's local array into xsub */

201

ierr = VecGetArray(red->xdup,&array);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),201,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

202

ierr = VecPlaceArray(red->xsub,(const PetscScalar*)array);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),202,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

203

204

/* apply preconditioner on each processor */

205

ierr = KSPSolve(red->ksp,red->xsub,red->ysub);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),205,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

206

ierr = KSPCheckSolve(red->ksp,pc,red->ysub);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),206,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

207

ierr = VecResetArray(red->xsub);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),207,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

208

ierr = VecRestoreArray(red->xdup,&array);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),208,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

209

210

/* place ysub's local array into ydup */

211

ierr = VecGetArray(red->ysub,&array);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),211,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

212

ierr = VecPlaceArray(red->ydup,(const PetscScalar*)array);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),212,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

213

214

/* scatter ydup to y */

215

ierr = VecScatterBegin(red->scatterout,red->ydup,y,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),215,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

216

ierr = VecScatterEnd(red->scatterout,red->ydup,y,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),216,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

217

ierr = VecResetArray(red->ydup);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),217,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

218

ierr = VecRestoreArray(red->ysub,&array);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),218,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

219

220

}

221

222

static PetscErrorCode PCApplyTranspose_Redundant(PC pc,Vec x,Vec y)

223

{

224

PC_Redundant *red = (PC_Redundant*)pc->data;

225

PetscErrorCode ierr;

226

PetscScalar *array;

227

228

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

229

if (!red->useparallelmat) {

230

ierr = KSPSolveTranspose(red->ksp,x,y);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),230,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

231

ierr = KSPCheckSolve(red->ksp,pc,y);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),231,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

232

233

}

234

235

/* scatter x to xdup */

236

ierr = VecScatterBegin(red->scatterin,x,red->xdup,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),236,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

237

ierr = VecScatterEnd(red->scatterin,x,red->xdup,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),237,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

238

239

/* place xdup's local array into xsub */

240

ierr = VecGetArray(red->xdup,&array);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),240,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

241

ierr = VecPlaceArray(red->xsub,(const PetscScalar*)array);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),241,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

242

243

/* apply preconditioner on each processor */

244

ierr = KSPSolveTranspose(red->ksp,red->xsub,red->ysub);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),244,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

245

ierr = KSPCheckSolve(red->ksp,pc,red->ysub);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),245,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

246

ierr = VecResetArray(red->xsub);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),246,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

247

ierr = VecRestoreArray(red->xdup,&array);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),247,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

248

249

/* place ysub's local array into ydup */

250

ierr = VecGetArray(red->ysub,&array);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),250,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

251

ierr = VecPlaceArray(red->ydup,(const PetscScalar*)array);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),251,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

252

253

/* scatter ydup to y */

254

ierr = VecScatterBegin(red->scatterout,red->ydup,y,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),254,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

255

ierr = VecScatterEnd(red->scatterout,red->ydup,y,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),255,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

256

ierr = VecResetArray(red->ydup);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),256,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

257

ierr = VecRestoreArray(red->ysub,&array);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),257,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

258

259

}

260

261

static PetscErrorCode PCReset_Redundant(PC pc)

262

{

263

PC_Redundant *red = (PC_Redundant*)pc->data;

264

PetscErrorCode ierr;

265

266

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

267

if (red->useparallelmat) {

268

ierr = VecScatterDestroy(&red->scatterin);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),268,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

269

ierr = VecScatterDestroy(&red->scatterout);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),269,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

270

ierr = VecDestroy(&red->ysub);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),270,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

271

ierr = VecDestroy(&red->xsub);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),271,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

272

ierr = VecDestroy(&red->xdup);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),272,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

273

ierr = VecDestroy(&red->ydup);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),273,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

274

}

275

ierr = MatDestroy(&red->pmats);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),275,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

276

ierr = KSPReset(red->ksp);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),276,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

277

278

}

279

280

static PetscErrorCode PCDestroy_Redundant(PC pc)

281

{

282

PC_Redundant *red = (PC_Redundant*)pc->data;

283

PetscErrorCode ierr;

284

285

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

286

ierr = PCReset_Redundant(pc);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),286,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

287

ierr = KSPDestroy(&red->ksp);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),287,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

288

ierr = PetscSubcommDestroy(&red->psubcomm);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),288,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

289

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

290

291

}

292

293

static PetscErrorCode PCSetFromOptions_Redundant(PetscOptionItems *PetscOptionsObject,PC pc)

294

{

295

PetscErrorCode ierr;

296

PC_Redundant *red = (PC_Redundant*)pc->data;

297

298

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

299

ierr = PetscOptionsHead(PetscOptionsObject,"Redundant options");CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),299,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

300

ierr = PetscOptionsInt("-pc_redundant_number","Number of redundant pc","PCRedundantSetNumber",red->nsubcomm,&red->nsubcomm,0)PetscOptionsInt_Private(PetscOptionsObject,"-pc_redundant_number"
,"Number of redundant pc","PCRedundantSetNumber",red->nsubcomm
,&red->nsubcomm,0,(-2147483647 - 1),2147483647);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),300,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

301

ierr = PetscOptionsTail()0; do {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);} while(0);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),301,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

302

303

}

304

305

static PetscErrorCode PCRedundantSetNumber_Redundant(PC pc,PetscInt nreds)

306

{

307

PC_Redundant *red = (PC_Redundant*)pc->data;

308

309

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

310

red->nsubcomm = nreds;

311

312

}

313

314

/*@

315

PCRedundantSetNumber - Sets the number of redundant preconditioner contexts.

316

317

Logically Collective on PC

318

319

Input Parameters:

320

+ pc - the preconditioner context

321

- nredundant - number of redundant preconditioner contexts; for example if you are using 64 MPI processes and

322

use an nredundant of 4 there will be 4 parallel solves each on 16 = 64/4 processes.

323

324

Level: advanced

325

326

@*/

327

PetscErrorCode PCRedundantSetNumber(PC pc,PetscInt nredundant)

328

{

329

PetscErrorCode ierr;

330

331

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

332

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

333

if (nredundant <= 0) SETERRQ1(PetscObjectComm((PetscObject)pc),PETSC_ERR_ARG_WRONG, "num of redundant pc %D must be positive",nredundant)return PetscError(PetscObjectComm((PetscObject)pc),333,__func__
,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,62,PETSC_ERROR_INITIAL,"num of redundant pc %D must be positive"
,nredundant);

334

ierr = PetscTryMethod(pc,"PCRedundantSetNumber_C",(PC,PetscInt),(pc,nredundant))0; do { PetscErrorCode (*f)(PC,PetscInt), __ierr; __ierr = PetscObjectQueryFunction_Private
(((PetscObject)pc),("PCRedundantSetNumber_C"),(PetscVoidFunction
*)(&f));do {if (__builtin_expect(!!(__ierr),0)) return PetscError
(((MPI_Comm)0x44000001),334,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,__ierr,PETSC_ERROR_REPEAT," ");} while (0); if (f) {__ierr =
(*f)(pc,nredundant);do {if (__builtin_expect(!!(__ierr),0)) return
PetscError(((MPI_Comm)0x44000001),334,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,__ierr,PETSC_ERROR_REPEAT," ");} while (0);} } while(0);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),334,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

335

336

}

337

338

static PetscErrorCode PCRedundantSetScatter_Redundant(PC pc,VecScatter in,VecScatter out)

339

{

340

PC_Redundant *red = (PC_Redundant*)pc->data;

341

PetscErrorCode ierr;

342

343

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

344

ierr = PetscObjectReference((PetscObject)in);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),344,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

345

ierr = VecScatterDestroy(&red->scatterin);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),345,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

346

347

red->scatterin = in;

348

349

ierr = PetscObjectReference((PetscObject)out);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),349,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

350

ierr = VecScatterDestroy(&red->scatterout);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),350,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

351

red->scatterout = out;

352

353

}

354

355

/*@

356

PCRedundantSetScatter - Sets the scatter used to copy values into the

357

redundant local solve and the scatter to move them back into the global

358

vector.

359

360

Logically Collective on PC

361

362

Input Parameters:

363

+ pc - the preconditioner context

364

. in - the scatter to move the values in

365

- out - the scatter to move them out

366

367

Level: advanced

368

369

@*/

370

PetscErrorCode PCRedundantSetScatter(PC pc,VecScatter in,VecScatter out)

371

{

372

PetscErrorCode ierr;

373

374

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

375

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

376

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

377

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

378

ierr = PetscTryMethod(pc,"PCRedundantSetScatter_C",(PC,VecScatter,VecScatter),(pc,in,out))0; do { PetscErrorCode (*f)(PC,VecScatter,VecScatter), __ierr
; __ierr = PetscObjectQueryFunction_Private(((PetscObject)pc)
,("PCRedundantSetScatter_C"),(PetscVoidFunction*)(&f));do
{if (__builtin_expect(!!(__ierr),0)) return PetscError(((MPI_Comm
)0x44000001),378,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,__ierr,PETSC_ERROR_REPEAT," ");} while (0); if (f) {__ierr =
(*f)(pc,in,out);do {if (__builtin_expect(!!(__ierr),0)) return
PetscError(((MPI_Comm)0x44000001),378,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,__ierr,PETSC_ERROR_REPEAT," ");} while (0);} } while(0);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),378,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

379

380

}

381

382

static PetscErrorCode PCRedundantGetKSP_Redundant(PC pc,KSP *innerksp)

383

{

384

PetscErrorCode ierr;

385

PC_Redundant *red = (PC_Redundant*)pc->data;

386

MPI_Comm comm,subcomm;

387

const char *prefix;

388

389

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

390

if (!red->psubcomm) {

391

ierr = PCGetOptionsPrefix(pc,&prefix);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),391,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

392

393

ierr = PetscObjectGetComm((PetscObject)pc,&comm);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),393,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

394

ierr = PetscSubcommCreate(comm,&red->psubcomm);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),394,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

395

ierr = PetscSubcommSetNumber(red->psubcomm,red->nsubcomm);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),395,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

396

ierr = PetscSubcommSetType(red->psubcomm,PETSC_SUBCOMM_CONTIGUOUS);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),396,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

397

398

ierr = PetscSubcommSetOptionsPrefix(red->psubcomm,prefix);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),398,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

399

ierr = PetscSubcommSetFromOptions(red->psubcomm);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),399,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

400

ierr = PetscLogObjectMemory((PetscObject)pc,sizeof(PetscSubcomm));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),400,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

401

402

/* create a new PC that processors in each subcomm have copy of */

403

subcomm = PetscSubcommChild(red->psubcomm);

404

405

ierr = KSPCreate(subcomm,&red->ksp);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),405,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

406

ierr = KSPSetErrorIfNotConverged(red->ksp,pc->erroriffailure);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),406,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

407

ierr = PetscObjectIncrementTabLevel((PetscObject)red->ksp,(PetscObject)pc,1);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),407,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

408

ierr = PetscLogObjectParent((PetscObject)pc,(PetscObject)red->ksp);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),408,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

409

ierr = KSPSetType(red->ksp,KSPPREONLY"preonly");CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),409,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

410

ierr = KSPGetPC(red->ksp,&red->pc);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),410,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

411

ierr = PCSetType(red->pc,PCLU"lu");CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),411,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

412

if (red->shifttypeset) {

413

ierr = PCFactorSetShiftType(red->pc,red->shifttype);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),413,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

414

red->shifttypeset = PETSC_FALSE;

415

}

416

ierr = KSPSetOptionsPrefix(red->ksp,prefix);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),416,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

417

ierr = KSPAppendOptionsPrefix(red->ksp,"redundant_");CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),417,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

418

}

419

*innerksp = red->ksp;

420

421

}

422

423

/*@

424

PCRedundantGetKSP - Gets the less parallel KSP created by the redundant PC.

425

426

Not Collective

427

428

Input Parameter:

429

. pc - the preconditioner context

430

431

Output Parameter:

432

. innerksp - the KSP on the smaller set of processes

433

434

Level: advanced

435

436

@*/

437

PetscErrorCode PCRedundantGetKSP(PC pc,KSP *innerksp)

438

{

439

PetscErrorCode ierr;

440

441

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

442

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

443

PetscValidPointer(innerksp,2)do { if (!innerksp) return PetscError(((MPI_Comm)0x44000001),
443,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",2); if
(!PetscCheckPointer(innerksp,PETSC_CHAR)) return PetscError(
((MPI_Comm)0x44000001),443,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",2);
} while (0);

444

ierr = PetscUseMethod(pc,"PCRedundantGetKSP_C",(PC,KSP*),(pc,innerksp))0; do { PetscErrorCode (*f)(PC,KSP*), __ierr; __ierr = PetscObjectQueryFunction_Private
(((PetscObject)pc),("PCRedundantGetKSP_C"),(PetscVoidFunction
*)(&f));do {if (__builtin_expect(!!(__ierr),0)) return PetscError
(((MPI_Comm)0x44000001),444,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,__ierr,PETSC_ERROR_REPEAT," ");} while (0); if (f) {__ierr =
(*f)(pc,innerksp);do {if (__builtin_expect(!!(__ierr),0)) return
PetscError(((MPI_Comm)0x44000001),444,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,__ierr,PETSC_ERROR_REPEAT," ");} while (0);} else return PetscError
(PetscObjectComm((PetscObject)pc),444,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,56,PETSC_ERROR_INITIAL,"Cannot locate function %s in object"
,"PCRedundantGetKSP_C"); } while(0);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),444,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

445

446

}

447

448

static PetscErrorCode PCRedundantGetOperators_Redundant(PC pc,Mat *mat,Mat *pmat)

449

{

450

PC_Redundant *red = (PC_Redundant*)pc->data;

451

452

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

453

if (mat) *mat = red->pmats;

454

if (pmat) *pmat = red->pmats;

455

456

}

457

458

/*@

459

PCRedundantGetOperators - gets the sequential matrix and preconditioner matrix

460

461

Not Collective

462

463

Input Parameter:

464

. pc - the preconditioner context

465

466

Output Parameters:

467

+ mat - the matrix

468

- pmat - the (possibly different) preconditioner matrix

469

470

Level: advanced

471

472

@*/

473

PetscErrorCode PCRedundantGetOperators(PC pc,Mat *mat,Mat *pmat)

474

{

475

PetscErrorCode ierr;

476

477

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

478

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

479

if (mat) PetscValidPointer(mat,2)do { if (!mat) return PetscError(((MPI_Comm)0x44000001),479,__func__
,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",2); if
(!PetscCheckPointer(mat,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),479,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",2);
} while (0);

480

if (pmat) PetscValidPointer(pmat,3)do { if (!pmat) return PetscError(((MPI_Comm)0x44000001),480,
__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",3); if
(!PetscCheckPointer(pmat,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),480,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",3);
} while (0);

481

ierr = PetscUseMethod(pc,"PCRedundantGetOperators_C",(PC,Mat*,Mat*),(pc,mat,pmat))0; do { PetscErrorCode (*f)(PC,Mat*,Mat*), __ierr; __ierr = PetscObjectQueryFunction_Private
(((PetscObject)pc),("PCRedundantGetOperators_C"),(PetscVoidFunction
*)(&f));do {if (__builtin_expect(!!(__ierr),0)) return PetscError
(((MPI_Comm)0x44000001),481,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,__ierr,PETSC_ERROR_REPEAT," ");} while (0); if (f) {__ierr =
(*f)(pc,mat,pmat);do {if (__builtin_expect(!!(__ierr),0)) return
PetscError(((MPI_Comm)0x44000001),481,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,__ierr,PETSC_ERROR_REPEAT," ");} while (0);} else return PetscError
(PetscObjectComm((PetscObject)pc),481,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,56,PETSC_ERROR_INITIAL,"Cannot locate function %s in object"
,"PCRedundantGetOperators_C"); } while(0);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),481,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

482

483

}

484

485

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

486

/*MC

487

PCREDUNDANT - Runs a KSP solver with preconditioner for the entire problem on subgroups of processors

488

489

Options for the redundant preconditioners can be set with -redundant_pc_xxx for the redundant KSP with -redundant_ksp_xxx

490

491

Options Database:

492

. -pc_redundant_number <n> - number of redundant solves, for example if you are using 64 MPI processes and

493

use an n of 4 there will be 4 parallel solves each on 16 = 64/4 processes.

494

495

Level: intermediate

496

497

Notes:

498

The default KSP is preonly and the default PC is LU.

499

500

PCFactorSetShiftType() applied to this PC will convey they shift type into the inner PC if it is factorization based.

501

502

Developer Notes:

503

Note that PCSetInitialGuessNonzero() is not used by this class but likely should be.

504

505

.seealso: PCCreate(), PCSetType(), PCType (for list of available types), PCRedundantSetScatter(),

506

PCRedundantGetKSP(), PCRedundantGetOperators(), PCRedundantSetNumber()

507

M*/

508

509

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PCCreate_Redundant(PC pc)

510

{

511

PetscErrorCode ierr;

512

PC_Redundant *red;

513

PetscMPIInt size;

514

515

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

516

ierr = PetscNewLog(pc,&red)(PetscMallocA(1,PETSC_TRUE,516,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,(size_t)(1)*sizeof(**(((&red)))),(((&red)))) || PetscLogObjectMemory
((PetscObject)pc,sizeof(**(&red))));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),516,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

517

ierr = MPI_Comm_size(PetscObjectComm((PetscObject)pc),&size);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),517,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

518

519

red->nsubcomm = size;

520

red->useparallelmat = PETSC_TRUE;

521

pc->data = (void*)red;

522

523

pc->ops->apply = PCApply_Redundant;

524

pc->ops->applytranspose = PCApplyTranspose_Redundant;

525

pc->ops->setup = PCSetUp_Redundant;

526

pc->ops->destroy = PCDestroy_Redundant;

527

pc->ops->reset = PCReset_Redundant;

528

pc->ops->setfromoptions = PCSetFromOptions_Redundant;

529

pc->ops->view = PCView_Redundant;

530

531

ierr = PetscObjectComposeFunction((PetscObject)pc,"PCRedundantSetScatter_C",PCRedundantSetScatter_Redundant)PetscObjectComposeFunction_Private((PetscObject)pc,"PCRedundantSetScatter_C"
,(PetscVoidFunction)(PCRedundantSetScatter_Redundant));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),531,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

532

ierr = PetscObjectComposeFunction((PetscObject)pc,"PCRedundantSetNumber_C",PCRedundantSetNumber_Redundant)PetscObjectComposeFunction_Private((PetscObject)pc,"PCRedundantSetNumber_C"
,(PetscVoidFunction)(PCRedundantSetNumber_Redundant));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),532,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

533

ierr = PetscObjectComposeFunction((PetscObject)pc,"PCRedundantGetKSP_C",PCRedundantGetKSP_Redundant)PetscObjectComposeFunction_Private((PetscObject)pc,"PCRedundantGetKSP_C"
,(PetscVoidFunction)(PCRedundantGetKSP_Redundant));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),533,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

534

ierr = PetscObjectComposeFunction((PetscObject)pc,"PCRedundantGetOperators_C",PCRedundantGetOperators_Redundant)PetscObjectComposeFunction_Private((PetscObject)pc,"PCRedundantGetOperators_C"
,(PetscVoidFunction)(PCRedundantGetOperators_Redundant));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),534,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

535

ierr = PetscObjectComposeFunction((PetscObject)pc,"PCFactorSetShiftType_C",PCFactorSetShiftType_Redundant)PetscObjectComposeFunction_Private((PetscObject)pc,"PCFactorSetShiftType_C"
,(PetscVoidFunction)(PCFactorSetShiftType_Redundant));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),535,__func__,"/sandbox/petsc/petsc.next-tmp/src/ksp/pc/impls/redundant/redundant.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

536

537

}

538

←

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

This is the main PETSc include file (for C and C++). It is included by all

other PETSc include files, so it almost never has to be specifically included.

#if !defined(PETSCSYS_H)

#define PETSCSYS_H

/* ========================================================================== */

petscconf.h is contained in ${PETSC_ARCH}/include/petscconf.h it is

found automatically by the compiler due to the -I${PETSC_DIR}/${PETSC_ARCH}/include.

For --prefix installs the ${PETSC_ARCH}/ does not exist and petscconf.h is in the same

directory as the other PETSc include files.

#include <petscconf.h>

#include <petscfix.h>

#if defined(PETSC_DESIRE_FEATURE_TEST_MACROS)

Feature test macros must be included before headers defined by IEEE Std 1003.1-2001

We only turn these in PETSc source files that require them by setting PETSC_DESIRE_FEATURE_TEST_MACROS

# if defined(PETSC__POSIX_C_SOURCE_200112L) && !defined(_POSIX_C_SOURCE200809L)

# define _POSIX_C_SOURCE200809L 200112L

# endif

# if defined(PETSC__BSD_SOURCE1) && !defined(_BSD_SOURCE1)

# define _BSD_SOURCE1

# endif

# if defined(PETSC__DEFAULT_SOURCE1) && !defined(_DEFAULT_SOURCE1)

# define _DEFAULT_SOURCE1

# endif

# if defined(PETSC__GNU_SOURCE1) && !defined(_GNU_SOURCE)

# define _GNU_SOURCE

# endif

#endif

#include <petscsystypes.h>

/* ========================================================================== */

This facilitates using the C version of PETSc from C++ and the C++ version from C.

#if defined(__cplusplus)

# define PETSC_FUNCTION_NAME__func__ PETSC_FUNCTION_NAME_CXX__func__

#else

# define PETSC_FUNCTION_NAME__func__ PETSC_FUNCTION_NAME_C__func__

#endif

/* ========================================================================== */

Since PETSc manages its own extern "C" handling users should never include PETSc include

files within extern "C". This will generate a compiler error if a user does put the include

file within an extern "C".

#if defined(__cplusplus)

void assert_never_put_petsc_headers_inside_an_extern_c(int); void assert_never_put_petsc_headers_inside_an_extern_c(double);

#endif

#if defined(__cplusplus)

# define PETSC_RESTRICT__restrict PETSC_CXX_RESTRICT__restrict

#else

# define PETSC_RESTRICT__restrict PETSC_C_RESTRICT__restrict

#endif

#if defined(__cplusplus)

# define PETSC_INLINEinline PETSC_CXX_INLINEinline

#else

# define PETSC_INLINEinline PETSC_C_INLINEinline

#endif

#define PETSC_STATIC_INLINEstatic inline static PETSC_INLINEinline

#if defined(_WIN32) && defined(PETSC_USE_SHARED_LIBRARIES1) /* For Win32 shared libraries */

# define PETSC_DLLEXPORT__attribute__((visibility ("default"))) __declspec(dllexport)

# define PETSC_DLLIMPORT__attribute__((visibility ("default"))) __declspec(dllimport)

# define PETSC_VISIBILITY_INTERNAL__attribute__((visibility ("hidden")))

#elif defined(PETSC_USE_VISIBILITY_CXX1) && defined(__cplusplus)

# define PETSC_DLLEXPORT__attribute__((visibility ("default"))) __attribute__((visibility ("default")))

# define PETSC_DLLIMPORT__attribute__((visibility ("default"))) __attribute__((visibility ("default")))

# define PETSC_VISIBILITY_INTERNAL__attribute__((visibility ("hidden"))) __attribute__((visibility ("hidden")))

#elif defined(PETSC_USE_VISIBILITY_C1) && !defined(__cplusplus)

# define PETSC_DLLEXPORT__attribute__((visibility ("default"))) __attribute__((visibility ("default")))

# define PETSC_DLLIMPORT__attribute__((visibility ("default"))) __attribute__((visibility ("default")))

# define PETSC_VISIBILITY_INTERNAL__attribute__((visibility ("hidden"))) __attribute__((visibility ("hidden")))

#else

# define PETSC_DLLEXPORT__attribute__((visibility ("default")))

# define PETSC_DLLIMPORT__attribute__((visibility ("default")))

# define PETSC_VISIBILITY_INTERNAL__attribute__((visibility ("hidden")))

#endif

#if defined(petsc_EXPORTS) /* CMake defines this when building the shared library */

# define PETSC_VISIBILITY_PUBLIC__attribute__((visibility ("default"))) PETSC_DLLEXPORT__attribute__((visibility ("default")))

#else /* Win32 users need this to import symbols from petsc.dll */

# define PETSC_VISIBILITY_PUBLIC__attribute__((visibility ("default"))) PETSC_DLLIMPORT__attribute__((visibility ("default")))

#endif

Functions tagged with PETSC_EXTERN in the header files are

always defined as extern "C" when compiled with C++ so they may be

used from C and are always visible in the shared libraries

100

101

#if defined(__cplusplus)

102

# define PETSC_EXTERNextern __attribute__((visibility ("default"))) extern "C" PETSC_VISIBILITY_PUBLIC__attribute__((visibility ("default")))

103

# define PETSC_EXTERN_TYPEDEF extern "C"

104

# define PETSC_INTERNextern __attribute__((visibility ("hidden"))) extern "C" PETSC_VISIBILITY_INTERNAL__attribute__((visibility ("hidden")))

105

#else

106

# define PETSC_EXTERNextern __attribute__((visibility ("default"))) extern PETSC_VISIBILITY_PUBLIC__attribute__((visibility ("default")))

107

# define PETSC_EXTERN_TYPEDEF

108

# define PETSC_INTERNextern __attribute__((visibility ("hidden"))) extern PETSC_VISIBILITY_INTERNAL__attribute__((visibility ("hidden")))

109

#endif

110

111

#include <petscversion.h>

112

#define PETSC_AUTHOR_INFO" The PETSc Team\n [email protected]\n https://www.mcs.anl.gov/petsc/\n" " The PETSc Team\n [email protected]\n https://www.mcs.anl.gov/petsc/\n"

113

114

/* ========================================================================== */

115

116

117

Defines the interface to MPI allowing the use of all MPI functions.

118

119

PETSc does not use the C++ binding of MPI at ALL. The following flag

120

makes sure the C++ bindings are not included. The C++ bindings REQUIRE

121

putting mpi.h before ANY C++ include files, we cannot control this

122

with all PETSc users. Users who want to use the MPI C++ bindings can include

123

mpicxx.h directly in their code

124

125

#if !defined(MPICH_SKIP_MPICXX1)

126

# define MPICH_SKIP_MPICXX1 1

127

#endif

128

#if !defined(OMPI_SKIP_MPICXX1)

129

# define OMPI_SKIP_MPICXX1 1

130

#endif

131

#if defined(PETSC_HAVE_MPIUNI)

132

# include <petsc/mpiuni/mpi.h>

133

#else

134

# include <mpi.h>

135

#endif

136

137

138

Perform various sanity checks that the correct mpi.h is being included at compile time.

139

This usually happens because

140

* either an unexpected mpi.h is in the default compiler path (i.e. in /usr/include) or

141

* an extra include path -I/something (which contains the unexpected mpi.h) is being passed to the compiler

142

143

#if defined(PETSC_HAVE_MPIUNI)

144

# if !defined(MPIUNI_H)

145

# error "PETSc was configured with --with-mpi=0 but now appears to be compiling using a different mpi.h"

146

# endif

147

#elif defined(PETSC_HAVE_I_MPI_NUMVERSION)

148

# if !defined(I_MPI_NUMVERSION)

149

# error "PETSc was configured with I_MPI but now appears to be compiling using a non-I_MPI mpi.h"

150

# elif I_MPI_NUMVERSION != PETSC_HAVE_I_MPI_NUMVERSION

151

# error "PETSc was configured with one I_MPI mpi.h version but now appears to be compiling using a different I_MPI mpi.h version"

152

# endif

153

#elif defined(PETSC_HAVE_MVAPICH2_NUMVERSION)

154

# if !defined(MVAPICH2_NUMVERSION)

155

# error "PETSc was configured with MVAPICH2 but now appears to be compiling using a non-MVAPICH2 mpi.h"

156

# elif MVAPICH2_NUMVERSION != PETSC_HAVE_MVAPICH2_NUMVERSION

157

# error "PETSc was configured with one MVAPICH2 mpi.h version but now appears to be compiling using a different MVAPICH2 mpi.h version"

158

# endif

159

#elif defined(PETSC_HAVE_MPICH_NUMVERSION30301300)

160

# if !defined(MPICH_NUMVERSION30301300) || defined(MVAPICH2_NUMVERSION) || defined(I_MPI_NUMVERSION)

161

# error "PETSc was configured with MPICH but now appears to be compiling using a non-MPICH mpi.h"

162

# elif (MPICH_NUMVERSION30301300/100000 != PETSC_HAVE_MPICH_NUMVERSION30301300/100000) || (MPICH_NUMVERSION30301300%100000/1000 < PETSC_HAVE_MPICH_NUMVERSION30301300%100000/1000)

163

# error "PETSc was configured with one MPICH mpi.h version but now appears to be compiling using a different MPICH mpi.h version"

164

# endif

165

#elif defined(PETSC_HAVE_OMPI_MAJOR_VERSION)

166

# if !defined(OMPI_MAJOR_VERSION)

167

# error "PETSc was configured with OpenMPI but now appears to be compiling using a non-OpenMPI mpi.h"

168

# elif (OMPI_MAJOR_VERSION != PETSC_HAVE_OMPI_MAJOR_VERSION) || (OMPI_MINOR_VERSION != PETSC_HAVE_OMPI_MINOR_VERSION) || (OMPI_RELEASE_VERSION < PETSC_HAVE_OMPI_RELEASE_VERSION)

169

# error "PETSc was configured with one OpenMPI mpi.h version but now appears to be compiling using a different OpenMPI mpi.h version"

170

# endif

171

#elif defined(OMPI_MAJOR_VERSION) || defined(MPICH_NUMVERSION30301300)

172

# error "PETSc was configured with undetermined MPI - but now appears to be compiling using either of OpenMPI or a MPICH variant"

173

#endif

174

175

176

Need to put stdio.h AFTER mpi.h for MPICH2 with C++ compiler

177

see the top of mpicxx.h in the MPICH2 distribution.

178

179

#include <stdio.h>

180

181

/* MSMPI on 32bit windows requires this yukky hack - that breaks MPI standard compliance */

182

#if !defined(MPIAPI)

183

#define MPIAPI

184

#endif

185

186

187

Support for Clang (>=3.2) matching type tag arguments with void* buffer types.

188

This allows the compiler to detect cases where the MPI datatype argument passed to a MPI routine

189

does not match the actual type of the argument being passed in

190

191

#if defined(__has_attribute)0 && defined(works_with_const_which_is_not_true)

192

# if __has_attribute(argument_with_type_tag)1 && __has_attribute(pointer_with_type_tag)1 && __has_attribute(type_tag_for_datatype)1

193

# define PetscAttrMPIPointerWithType(bufno,typeno) __attribute__((pointer_with_type_tag(MPI,bufno,typeno)))

194

# define PetscAttrMPITypeTag(type) __attribute__((type_tag_for_datatype(MPI,type)))

195

# define PetscAttrMPITypeTagLayoutCompatible(type) __attribute__((type_tag_for_datatype(MPI,type,layout_compatible)))

196

# endif

197

#endif

198

#if !defined(PetscAttrMPIPointerWithType)

199

# define PetscAttrMPIPointerWithType(bufno,typeno)

200

# define PetscAttrMPITypeTag(type)

201

# define PetscAttrMPITypeTagLayoutCompatible(type)

202

#endif

203

204

PETSC_EXTERNextern __attribute__((visibility ("default"))) MPI_Datatype MPIU_ENUM PetscAttrMPITypeTag(PetscEnum);

205

PETSC_EXTERNextern __attribute__((visibility ("default"))) MPI_Datatype MPIU_BOOL PetscAttrMPITypeTag(PetscBool);

206

207

/*MC

208

MPIU_INT - MPI datatype corresponding to PetscInt

209

210

Notes:

211

In MPI calls that require an MPI datatype that matches a PetscInt or array of PetscInt values, pass this value.

212

213

Level: beginner

214

215

.seealso: PetscReal, PetscScalar, PetscComplex, PetscInt, MPIU_REAL, MPIU_SCALAR, MPIU_COMPLEX

216

M*/

217

218

#if defined(PETSC_HAVE_STDINT_H1) && defined(PETSC_HAVE_INTTYPES_H1) && defined(PETSC_HAVE_MPI_INT64_T1) /* MPI_INT64_T is not guaranteed to be a macro */

219

# define MPIU_INT64((MPI_Datatype)0x4c00083a) MPI_INT64_T((MPI_Datatype)0x4c00083a)

220

# define PetscInt64_FMT"l" "d" PRId64"l" "d"

221

#elif (PETSC_SIZEOF_LONG_LONG8 == 8)

222

# define MPIU_INT64((MPI_Datatype)0x4c00083a) MPI_LONG_LONG_INT((MPI_Datatype)0x4c000809)

223

# define PetscInt64_FMT"l" "d" "lld"

224

#elif defined(PETSC_HAVE___INT64)

225

# define MPIU_INT64((MPI_Datatype)0x4c00083a) MPI_INT64_T((MPI_Datatype)0x4c00083a)

226

# define PetscInt64_FMT"l" "d" "ld"

227

#else

228

# error "cannot determine PetscInt64 type"

229

#endif

230

231

PETSC_EXTERNextern __attribute__((visibility ("default"))) MPI_Datatype MPIU_FORTRANADDR;

232

233

#if defined(PETSC_USE_64BIT_INDICES)

234

# define MPIU_INT((MPI_Datatype)0x4c000405) MPIU_INT64((MPI_Datatype)0x4c00083a)

235

# define PetscInt_FMT"d" PetscInt64_FMT"l" "d"

236

#else

237

# define MPIU_INT((MPI_Datatype)0x4c000405) MPI_INT((MPI_Datatype)0x4c000405)

238

# define PetscInt_FMT"d" "d"

239

#endif

240

241

242

For the rare cases when one needs to send a size_t object with MPI

243

244

PETSC_EXTERNextern __attribute__((visibility ("default"))) MPI_Datatype MPIU_SIZE_T;

245

246

247

You can use PETSC_STDOUT as a replacement of stdout. You can also change

248

the value of PETSC_STDOUT to redirect all standard output elsewhere

249

250

PETSC_EXTERNextern __attribute__((visibility ("default"))) FILE* PETSC_STDOUT;

251

252

253

You can use PETSC_STDERR as a replacement of stderr. You can also change

254

the value of PETSC_STDERR to redirect all standard error elsewhere

255

256

PETSC_EXTERNextern __attribute__((visibility ("default"))) FILE* PETSC_STDERR;

257

258

/*MC

259

PetscUnlikely - hints the compiler that the given condition is usually FALSE

260

261

Synopsis:

262

#include <petscsys.h>

263

PetscBool PetscUnlikely(PetscBool cond)

264

265

Not Collective

266

267

Input Parameters:

268

. cond - condition or expression

269

270

Notes:

271

This returns the same truth value, it is only a hint to compilers that the resulting

272

branch is unlikely.

273

274

Level: advanced

275

276

.seealso: PetscLikely(), CHKERRQ

277

M*/

278

279

/*MC

280

PetscLikely - hints the compiler that the given condition is usually TRUE

281

282

Synopsis:

283

#include <petscsys.h>

284

PetscBool PetscLikely(PetscBool cond)

285

286

Not Collective

287

288

Input Parameters:

289

. cond - condition or expression

290

291

Notes:

292

This returns the same truth value, it is only a hint to compilers that the resulting

293

branch is likely.

294

295

Level: advanced

296

297

.seealso: PetscUnlikely()

298

M*/

299

#if defined(PETSC_HAVE_BUILTIN_EXPECT1)

300

# define PetscUnlikely(cond)__builtin_expect(!!(cond),0) __builtin_expect(!!(cond),0)

301

# define PetscLikely(cond)__builtin_expect(!!(cond),1) __builtin_expect(!!(cond),1)

302

#else

303

# define PetscUnlikely(cond)__builtin_expect(!!(cond),0) (cond)

304

# define PetscLikely(cond)__builtin_expect(!!(cond),1) (cond)

305

#endif

306

307

308

Declare extern C stuff after including external header files

309

310

311

PETSC_EXTERNextern __attribute__((visibility ("default"))) const char *const PetscBools[];

312

313

314

Defines elementary mathematics functions and constants.

315

316

#include <petscmath.h>

317

318

PETSC_EXTERNextern __attribute__((visibility ("default"))) const char *const PetscCopyModes[];

319

320

/*MC

321

PETSC_IGNORE - same as NULL, means PETSc will ignore this argument

322

323

Level: beginner

324

325

Note:

326

Accepted by many PETSc functions to not set a parameter and instead use

327

some default

328

329

Fortran Notes:

330

This macro does not exist in Fortran; you must use PETSC_NULL_INTEGER,

331

PETSC_NULL_DOUBLE_PRECISION etc

332

333

.seealso: PETSC_DECIDE, PETSC_DEFAULT, PETSC_DETERMINE

334

335

M*/

336

#define PETSC_IGNORE((void*)0) NULL((void*)0)

337

338

/* This is deprecated */

339

#define PETSC_NULL((void*)0) NULL((void*)0)

340

341

/*MC

342

PETSC_DECIDE - standard way of passing in integer or floating point parameter

343

where you wish PETSc to use the default.

344

345

Level: beginner

346

347

.seealso: PETSC_DEFAULT, PETSC_IGNORE, PETSC_DETERMINE

348

349

M*/

350

#define PETSC_DECIDE-1 -1

351

352

/*MC

353

PETSC_DETERMINE - standard way of passing in integer or floating point parameter

354

where you wish PETSc to compute the required value.

355

356

Level: beginner

357

358

Developer Note:

359

I would like to use const PetscInt PETSC_DETERMINE = PETSC_DECIDE; but for

360

some reason this is not allowed by the standard even though PETSC_DECIDE is a constant value.

361

362

.seealso: PETSC_DECIDE, PETSC_DEFAULT, PETSC_IGNORE, VecSetSizes()

363

364

M*/

365

#define PETSC_DETERMINE-1 PETSC_DECIDE-1

366

367

/*MC

368

PETSC_DEFAULT - standard way of passing in integer or floating point parameter

369

where you wish PETSc to use the default.

370

371

Level: beginner

372

373

Fortran Notes:

374

You need to use PETSC_DEFAULT_INTEGER or PETSC_DEFAULT_REAL.

375

376

.seealso: PETSC_DECIDE, PETSC_IGNORE, PETSC_DETERMINE

377

378

M*/

379

#define PETSC_DEFAULT-2 -2

380

381

/*MC

382

PETSC_COMM_WORLD - the equivalent of the MPI_COMM_WORLD communicator which represents

383

all the processes that PETSc knows about.

384

385

Level: beginner

386

387

Notes:

388

By default PETSC_COMM_WORLD and MPI_COMM_WORLD are identical unless you wish to

389

run PETSc on ONLY a subset of MPI_COMM_WORLD. In that case create your new (smaller)

390

communicator, call it, say comm, and set PETSC_COMM_WORLD = comm BEFORE calling

391

PetscInitialize(), but after MPI_Init() has been called.

392

393

The value of PETSC_COMM_WORLD should never be USED/accessed before PetscInitialize()

394

is called because it may not have a valid value yet.

395

396

.seealso: PETSC_COMM_SELF

397

398

M*/

399

PETSC_EXTERNextern __attribute__((visibility ("default"))) MPI_Comm PETSC_COMM_WORLD;

400

401

/*MC

402

PETSC_COMM_SELF - This is always MPI_COMM_SELF

403

404

Level: beginner

405

406

Notes:

407

Do not USE/access or set this variable before PetscInitialize() has been called.

408

409

.seealso: PETSC_COMM_WORLD

410

411

M*/

412

#define PETSC_COMM_SELF((MPI_Comm)0x44000001) MPI_COMM_SELF((MPI_Comm)0x44000001)

413

414

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscBool PetscBeganMPI;

415

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscBool PetscInitializeCalled;

416

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscBool PetscFinalizeCalled;

417

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscBool PetscViennaCLSynchronize;

418

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscBool PetscCUDASynchronize;

419

420

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSetHelpVersionFunctions(PetscErrorCode (*)(MPI_Comm),PetscErrorCode (*)(MPI_Comm));

421

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscCommDuplicate(MPI_Comm,MPI_Comm*,int*);

422

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscCommDestroy(MPI_Comm*);

423

424

#if defined(PETSC_HAVE_CUDA)

425

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscCUDAInitialize(MPI_Comm);

426

#endif

427

428

/*MC

429

PetscMalloc - Allocates memory, One should use PetscNew(), PetscMalloc1() or PetscCalloc1() usually instead of this

430

431

Synopsis:

432

#include <petscsys.h>

433

PetscErrorCode PetscMalloc(size_t m,void **result)

434

435

Not Collective

436

437

Input Parameter:

438

. m - number of bytes to allocate

439

440

Output Parameter:

441

. result - memory allocated

442

443

Level: beginner

444

445

Notes:

446

Memory is always allocated at least double aligned

447

448

It is safe to allocate size 0 and pass the resulting pointer (which may or may not be NULL) to PetscFree().

449

450

.seealso: PetscFree(), PetscNew()

451

452

M*/

453

#define PetscMalloc(a,b)((*PetscTrMalloc)((a),PETSC_FALSE,453,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscsys.h"
,(void**)(b))) ((*PetscTrMalloc)((a),PETSC_FALSE,__LINE__453,PETSC_FUNCTION_NAME__func__,__FILE__"/sandbox/petsc/petsc.next-tmp/include/petscsys.h",(void**)(b)))

454

455

/*MC

456

PetscRealloc - Rellocates memory

457

458

Synopsis:

459

#include <petscsys.h>

460

PetscErrorCode PetscRealloc(size_t m,void **result)

461

462

Not Collective

463

464

Input Parameters:

465

+ m - number of bytes to allocate

466

- result - initial memory allocated

467

468

Output Parameter:

469

. result - new memory allocated

470

471

Level: developer

472

473

Notes:

474

Memory is always allocated at least double aligned

475

476

.seealso: PetscMalloc(), PetscFree(), PetscNew()

477

478

M*/

479

#define PetscRealloc(a,b)((*PetscTrRealloc)((a),479,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscsys.h"
,(void**)(b))) ((*PetscTrRealloc)((a),__LINE__479,PETSC_FUNCTION_NAME__func__,__FILE__"/sandbox/petsc/petsc.next-tmp/include/petscsys.h",(void**)(b)))

480

481

/*MC

482

PetscAddrAlign - Rounds up an address to PETSC_MEMALIGN alignment

483

484

Synopsis:

485

#include <petscsys.h>

486

void *PetscAddrAlign(void *addr)

487

488

Not Collective

489

490

Input Parameters:

491

. addr - address to align (any pointer type)

492

493

Level: developer

494

495

.seealso: PetscMallocAlign()

496

497

M*/

498

#define PetscAddrAlign(a)(void*)((((uintptr_t)(a))+(16 -1)) & ~(16 -1)) (void*)((((PETSC_UINTPTR_Tuintptr_t)(a))+(PETSC_MEMALIGN16-1)) & ~(PETSC_MEMALIGN16-1))

499

500

/*MC

501

PetscMalloc1 - Allocates an array of memory aligned to PETSC_MEMALIGN

502

503

Synopsis:

504

#include <petscsys.h>

505

PetscErrorCode PetscMalloc1(size_t m1,type **r1)

506

507

Not Collective

508

509

Input Parameter:

510

. m1 - number of elements to allocate (may be zero)

511

512

Output Parameter:

513

. r1 - memory allocated in first chunk

514

515

Note:

516

This uses the sizeof() of the memory type requested to determine the total memory to be allocated, therefore you should not

517

multiply the number of elements requested by the sizeof() the type. For example use

518

$ PetscInt *id;

519

$ PetscMalloc1(10,&id);

520

not

521

$ PetscInt *id;

522

$ PetscMalloc1(10*sizeof(PetscInt),&id);

523

524

Does not zero the memory allocatd, used PetscCalloc1() to obtain memory that has been zeroed.

525

526

Level: beginner

527

528

.seealso: PetscFree(), PetscNew(), PetscMalloc(), PetscCalloc1(), PetscMalloc2()

529

530

M*/

531

#define PetscMalloc1(m1,r1)PetscMallocA(1,PETSC_FALSE,531,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscsys.h"
,(size_t)(m1)*sizeof(**(r1)),(r1)) PetscMallocA(1,PETSC_FALSE,__LINE__531,PETSC_FUNCTION_NAME__func__,__FILE__"/sandbox/petsc/petsc.next-tmp/include/petscsys.h",(size_t)(m1)*sizeof(**(r1)),(r1))

532

533

/*MC

534

PetscCalloc1 - Allocates a cleared (zeroed) array of memory aligned to PETSC_MEMALIGN

535

536

Synopsis:

537

#include <petscsys.h>

538

PetscErrorCode PetscCalloc1(size_t m1,type **r1)

539

540

Not Collective

541

542

Input Parameter:

543

. m1 - number of elements to allocate in 1st chunk (may be zero)

544

545

Output Parameter:

546

. r1 - memory allocated in first chunk

547

548

Notes:

549

See PetsMalloc1() for more details on usage.

550

551

Level: beginner

552

553

.seealso: PetscFree(), PetscNew(), PetscMalloc(), PetscMalloc1(), PetscCalloc2()

554

555

M*/

556

#define PetscCalloc1(m1,r1)PetscMallocA(1,PETSC_TRUE,556,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscsys.h"
,(size_t)(m1)*sizeof(**(r1)),(r1)) PetscMallocA(1,PETSC_TRUE,__LINE__556,PETSC_FUNCTION_NAME__func__,__FILE__"/sandbox/petsc/petsc.next-tmp/include/petscsys.h",(size_t)(m1)*sizeof(**(r1)),(r1))

557

558

/*MC

559

PetscMalloc2 - Allocates 2 arrays of memory both aligned to PETSC_MEMALIGN

560

561

Synopsis:

562

#include <petscsys.h>

563

PetscErrorCode PetscMalloc2(size_t m1,type **r1,size_t m2,type **r2)

564

565

Not Collective

566

567

Input Parameter:

568

+ m1 - number of elements to allocate in 1st chunk (may be zero)

569

- m2 - number of elements to allocate in 2nd chunk (may be zero)

570

571

Output Parameter:

572

+ r1 - memory allocated in first chunk

573

- r2 - memory allocated in second chunk

574

575

Level: developer

576

577

.seealso: PetscFree(), PetscNew(), PetscMalloc(), PetscMalloc1(), PetscCalloc2()

578

579

M*/

580

#define PetscMalloc2(m1,r1,m2,r2)PetscMallocA(2,PETSC_FALSE,580,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscsys.h"
,(size_t)(m1)*sizeof(**(r1)),(r1),(size_t)(m2)*sizeof(**(r2))
,(r2)) PetscMallocA(2,PETSC_FALSE,__LINE__580,PETSC_FUNCTION_NAME__func__,__FILE__"/sandbox/petsc/petsc.next-tmp/include/petscsys.h",(size_t)(m1)*sizeof(**(r1)),(r1),(size_t)(m2)*sizeof(**(r2)),(r2))

581

582

/*MC

583

PetscCalloc2 - Allocates 2 cleared (zeroed) arrays of memory both aligned to PETSC_MEMALIGN

584

585

Synopsis:

586

#include <petscsys.h>

587

PetscErrorCode PetscCalloc2(size_t m1,type **r1,size_t m2,type **r2)

588

589

Not Collective

590

591

Input Parameter:

592

+ m1 - number of elements to allocate in 1st chunk (may be zero)

593

- m2 - number of elements to allocate in 2nd chunk (may be zero)

594

595

Output Parameter:

596

+ r1 - memory allocated in first chunk

597

- r2 - memory allocated in second chunk

598

599

Level: developer

600

601

.seealso: PetscFree(), PetscNew(), PetscMalloc(), PetscCalloc1(), PetscMalloc2()

602

603

M*/

604

#define PetscCalloc2(m1,r1,m2,r2)PetscMallocA(2,PETSC_TRUE,604,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscsys.h"
,(size_t)(m1)*sizeof(**(r1)),(r1),(size_t)(m2)*sizeof(**(r2))
,(r2)) PetscMallocA(2,PETSC_TRUE,__LINE__604,PETSC_FUNCTION_NAME__func__,__FILE__"/sandbox/petsc/petsc.next-tmp/include/petscsys.h",(size_t)(m1)*sizeof(**(r1)),(r1),(size_t)(m2)*sizeof(**(r2)),(r2))

605

606

/*MC

607

PetscMalloc3 - Allocates 3 arrays of memory, all aligned to PETSC_MEMALIGN

608

609

Synopsis:

610

#include <petscsys.h>

611

PetscErrorCode PetscMalloc3(size_t m1,type **r1,size_t m2,type **r2,size_t m3,type **r3)

612

613

Not Collective

614

615

Input Parameter:

616

+ m1 - number of elements to allocate in 1st chunk (may be zero)

617

. m2 - number of elements to allocate in 2nd chunk (may be zero)

618

- m3 - number of elements to allocate in 3rd chunk (may be zero)

619

620

Output Parameter:

621

+ r1 - memory allocated in first chunk

622

. r2 - memory allocated in second chunk

623

- r3 - memory allocated in third chunk

624

625

Level: developer

626

627

.seealso: PetscFree(), PetscNew(), PetscMalloc(), PetscMalloc2(), PetscCalloc3(), PetscFree3()

628

629

M*/

630

#define PetscMalloc3(m1,r1,m2,r2,m3,r3)PetscMallocA(3,PETSC_FALSE,630,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscsys.h"
,(size_t)(m1)*sizeof(**(r1)),(r1),(size_t)(m2)*sizeof(**(r2))
,(r2),(size_t)(m3)*sizeof(**(r3)),(r3)) PetscMallocA(3,PETSC_FALSE,__LINE__630,PETSC_FUNCTION_NAME__func__,__FILE__"/sandbox/petsc/petsc.next-tmp/include/petscsys.h",(size_t)(m1)*sizeof(**(r1)),(r1),(size_t)(m2)*sizeof(**(r2)),(r2),(size_t)(m3)*sizeof(**(r3)),(r3))

631

632

/*MC

633

PetscCalloc3 - Allocates 3 cleared (zeroed) arrays of memory, all aligned to PETSC_MEMALIGN

634

635

Synopsis:

636

#include <petscsys.h>

637

PetscErrorCode PetscCalloc3(size_t m1,type **r1,size_t m2,type **r2,size_t m3,type **r3)

638

639

Not Collective

640

641

Input Parameter:

642

+ m1 - number of elements to allocate in 1st chunk (may be zero)

643

. m2 - number of elements to allocate in 2nd chunk (may be zero)

644

- m3 - number of elements to allocate in 3rd chunk (may be zero)

645

646

Output Parameter:

647

+ r1 - memory allocated in first chunk

648

. r2 - memory allocated in second chunk

649

- r3 - memory allocated in third chunk

650

651

Level: developer

652

653

.seealso: PetscFree(), PetscNew(), PetscMalloc(), PetscCalloc2(), PetscMalloc3(), PetscFree3()

654

655

M*/

656

#define PetscCalloc3(m1,r1,m2,r2,m3,r3)PetscMallocA(3,PETSC_TRUE,656,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscsys.h"
,(size_t)(m1)*sizeof(**(r1)),(r1),(size_t)(m2)*sizeof(**(r2))
,(r2),(size_t)(m3)*sizeof(**(r3)),(r3)) PetscMallocA(3,PETSC_TRUE,__LINE__656,PETSC_FUNCTION_NAME__func__,__FILE__"/sandbox/petsc/petsc.next-tmp/include/petscsys.h",(size_t)(m1)*sizeof(**(r1)),(r1),(size_t)(m2)*sizeof(**(r2)),(r2),(size_t)(m3)*sizeof(**(r3)),(r3))

657

658

/*MC

659

PetscMalloc4 - Allocates 4 arrays of memory, all aligned to PETSC_MEMALIGN

660

661

Synopsis:

662

#include <petscsys.h>

663

PetscErrorCode PetscMalloc4(size_t m1,type **r1,size_t m2,type **r2,size_t m3,type **r3,size_t m4,type **r4)

664

665

Not Collective

666

667

Input Parameter:

668

+ m1 - number of elements to allocate in 1st chunk (may be zero)

669

. m2 - number of elements to allocate in 2nd chunk (may be zero)

670

. m3 - number of elements to allocate in 3rd chunk (may be zero)

671

- m4 - number of elements to allocate in 4th chunk (may be zero)

672

673

Output Parameter:

674

+ r1 - memory allocated in first chunk

675

. r2 - memory allocated in second chunk

676

. r3 - memory allocated in third chunk

677

- r4 - memory allocated in fourth chunk

678

679

Level: developer

680

681

.seealso: PetscFree(), PetscNew(), PetscMalloc(), PetscMalloc2(), PetscCalloc4(), PetscFree4()

682

683

M*/

684

#define PetscMalloc4(m1,r1,m2,r2,m3,r3,m4,r4)PetscMallocA(4,PETSC_FALSE,684,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscsys.h"
,(size_t)(m1)*sizeof(**(r1)),(r1),(size_t)(m2)*sizeof(**(r2))
,(r2),(size_t)(m3)*sizeof(**(r3)),(r3),(size_t)(m4)*sizeof(**
(r4)),(r4)) PetscMallocA(4,PETSC_FALSE,__LINE__684,PETSC_FUNCTION_NAME__func__,__FILE__"/sandbox/petsc/petsc.next-tmp/include/petscsys.h",(size_t)(m1)*sizeof(**(r1)),(r1),(size_t)(m2)*sizeof(**(r2)),(r2),(size_t)(m3)*sizeof(**(r3)),(r3),(size_t)(m4)*sizeof(**(r4)),(r4))

685

686

/*MC

687

PetscCalloc4 - Allocates 4 cleared (zeroed) arrays of memory, all aligned to PETSC_MEMALIGN

688

689

Synopsis:

690

#include <petscsys.h>

691

PetscErrorCode PetscCalloc4(size_t m1,type **r1,size_t m2,type **r2,size_t m3,type **r3,size_t m4,type **r4)

692

693

Not Collective

694

695

Input Parameters:

696

+ m1 - number of elements to allocate in 1st chunk (may be zero)

697

. m2 - number of elements to allocate in 2nd chunk (may be zero)

698

. m3 - number of elements to allocate in 3rd chunk (may be zero)

699

- m4 - number of elements to allocate in 4th chunk (may be zero)

700

701

Output Parameters:

702

+ r1 - memory allocated in first chunk

703

. r2 - memory allocated in second chunk

704

. r3 - memory allocated in third chunk

705

- r4 - memory allocated in fourth chunk

706

707

Level: developer

708

709

.seealso: PetscFree(), PetscNew(), PetscMalloc(), PetscMalloc2(), PetscCalloc4(), PetscFree4()

710

711

M*/

712

#define PetscCalloc4(m1,r1,m2,r2,m3,r3,m4,r4)PetscMallocA(4,PETSC_TRUE,712,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscsys.h"
,(size_t)(m1)*sizeof(**(r1)),(r1),(size_t)(m2)*sizeof(**(r2))
,(r2),(size_t)(m3)*sizeof(**(r3)),(r3),(size_t)(m4)*sizeof(**
(r4)),(r4)) PetscMallocA(4,PETSC_TRUE,__LINE__712,PETSC_FUNCTION_NAME__func__,__FILE__"/sandbox/petsc/petsc.next-tmp/include/petscsys.h",(size_t)(m1)*sizeof(**(r1)),(r1),(size_t)(m2)*sizeof(**(r2)),(r2),(size_t)(m3)*sizeof(**(r3)),(r3),(size_t)(m4)*sizeof(**(r4)),(r4))

713

714

/*MC

715

PetscMalloc5 - Allocates 5 arrays of memory, all aligned to PETSC_MEMALIGN

716

717

Synopsis:

718

#include <petscsys.h>

719

PetscErrorCode PetscMalloc5(size_t m1,type **r1,size_t m2,type **r2,size_t m3,type **r3,size_t m4,type **r4,size_t m5,type **r5)

720

721

Not Collective

722

723

Input Parameters:

724

+ m1 - number of elements to allocate in 1st chunk (may be zero)

725

. m2 - number of elements to allocate in 2nd chunk (may be zero)

726

. m3 - number of elements to allocate in 3rd chunk (may be zero)

727

. m4 - number of elements to allocate in 4th chunk (may be zero)

728

- m5 - number of elements to allocate in 5th chunk (may be zero)

729

730

Output Parameters:

731

+ r1 - memory allocated in first chunk

732

. r2 - memory allocated in second chunk

733

. r3 - memory allocated in third chunk

734

. r4 - memory allocated in fourth chunk

735

- r5 - memory allocated in fifth chunk

736

737

Level: developer

738

739

.seealso: PetscFree(), PetscNew(), PetscMalloc(), PetscMalloc2(), PetscCalloc5(), PetscFree5()

740

741

M*/

742

#define PetscMalloc5(m1,r1,m2,r2,m3,r3,m4,r4,m5,r5)PetscMallocA(5,PETSC_FALSE,742,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscsys.h"
,(size_t)(m1)*sizeof(**(r1)),(r1),(size_t)(m2)*sizeof(**(r2))
,(r2),(size_t)(m3)*sizeof(**(r3)),(r3),(size_t)(m4)*sizeof(**
(r4)),(r4),(size_t)(m5)*sizeof(**(r5)),(r5)) PetscMallocA(5,PETSC_FALSE,__LINE__742,PETSC_FUNCTION_NAME__func__,__FILE__"/sandbox/petsc/petsc.next-tmp/include/petscsys.h",(size_t)(m1)*sizeof(**(r1)),(r1),(size_t)(m2)*sizeof(**(r2)),(r2),(size_t)(m3)*sizeof(**(r3)),(r3),(size_t)(m4)*sizeof(**(r4)),(r4),(size_t)(m5)*sizeof(**(r5)),(r5))

743

744

/*MC

745

PetscCalloc5 - Allocates 5 cleared (zeroed) arrays of memory, all aligned to PETSC_MEMALIGN

746

747

Synopsis:

748

#include <petscsys.h>

749

PetscErrorCode PetscCalloc5(size_t m1,type **r1,size_t m2,type **r2,size_t m3,type **r3,size_t m4,type **r4,size_t m5,type **r5)

750

751

Not Collective

752

753

Input Parameters:

754

+ m1 - number of elements to allocate in 1st chunk (may be zero)

755

. m2 - number of elements to allocate in 2nd chunk (may be zero)

756

. m3 - number of elements to allocate in 3rd chunk (may be zero)

757

. m4 - number of elements to allocate in 4th chunk (may be zero)

758

- m5 - number of elements to allocate in 5th chunk (may be zero)

759

760

Output Parameters:

761

+ r1 - memory allocated in first chunk

762

. r2 - memory allocated in second chunk

763

. r3 - memory allocated in third chunk

764

. r4 - memory allocated in fourth chunk

765

- r5 - memory allocated in fifth chunk

766

767

Level: developer

768

769

.seealso: PetscFree(), PetscNew(), PetscMalloc(), PetscMalloc5(), PetscFree5()

770

771

M*/

772

#define PetscCalloc5(m1,r1,m2,r2,m3,r3,m4,r4,m5,r5)PetscMallocA(5,PETSC_TRUE,772,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscsys.h"
,(size_t)(m1)*sizeof(**(r1)),(r1),(size_t)(m2)*sizeof(**(r2))
,(r2),(size_t)(m3)*sizeof(**(r3)),(r3),(size_t)(m4)*sizeof(**
(r4)),(r4),(size_t)(m5)*sizeof(**(r5)),(r5)) PetscMallocA(5,PETSC_TRUE,__LINE__772,PETSC_FUNCTION_NAME__func__,__FILE__"/sandbox/petsc/petsc.next-tmp/include/petscsys.h",(size_t)(m1)*sizeof(**(r1)),(r1),(size_t)(m2)*sizeof(**(r2)),(r2),(size_t)(m3)*sizeof(**(r3)),(r3),(size_t)(m4)*sizeof(**(r4)),(r4),(size_t)(m5)*sizeof(**(r5)),(r5))

773

774

/*MC

775

PetscMalloc6 - Allocates 6 arrays of memory, all aligned to PETSC_MEMALIGN

776

777

Synopsis:

778

#include <petscsys.h>

779

PetscErrorCode PetscMalloc6(size_t m1,type **r1,size_t m2,type **r2,size_t m3,type **r3,size_t m4,type **r4,size_t m5,type **r5,size_t m6,type **r6)

780

781

Not Collective

782

783

Input Parameters:

784

+ m1 - number of elements to allocate in 1st chunk (may be zero)

785

. m2 - number of elements to allocate in 2nd chunk (may be zero)

786

. m3 - number of elements to allocate in 3rd chunk (may be zero)

787

. m4 - number of elements to allocate in 4th chunk (may be zero)

788

. m5 - number of elements to allocate in 5th chunk (may be zero)

789

- m6 - number of elements to allocate in 6th chunk (may be zero)

790

791

Output Parameteasr:

792

+ r1 - memory allocated in first chunk

793

. r2 - memory allocated in second chunk

794

. r3 - memory allocated in third chunk

795

. r4 - memory allocated in fourth chunk

796

. r5 - memory allocated in fifth chunk

797

- r6 - memory allocated in sixth chunk

798

799

Level: developer

800

801

.seealso: PetscFree(), PetscNew(), PetscMalloc(), PetscMalloc2(), PetscCalloc6(), PetscFree3(), PetscFree4(), PetscFree5(), PetscFree6()

802

803

M*/

804

#define PetscMalloc6(m1,r1,m2,r2,m3,r3,m4,r4,m5,r5,m6,r6)PetscMallocA(6,PETSC_FALSE,804,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscsys.h"
,(size_t)(m1)*sizeof(**(r1)),(r1),(size_t)(m2)*sizeof(**(r2))
,(r2),(size_t)(m3)*sizeof(**(r3)),(r3),(size_t)(m4)*sizeof(**
(r4)),(r4),(size_t)(m5)*sizeof(**(r5)),(r5),(size_t)(m6)*sizeof
(**(r6)),(r6)) PetscMallocA(6,PETSC_FALSE,__LINE__804,PETSC_FUNCTION_NAME__func__,__FILE__"/sandbox/petsc/petsc.next-tmp/include/petscsys.h",(size_t)(m1)*sizeof(**(r1)),(r1),(size_t)(m2)*sizeof(**(r2)),(r2),(size_t)(m3)*sizeof(**(r3)),(r3),(size_t)(m4)*sizeof(**(r4)),(r4),(size_t)(m5)*sizeof(**(r5)),(r5),(size_t)(m6)*sizeof(**(r6)),(r6))

805

806

/*MC

807

PetscCalloc6 - Allocates 6 cleared (zeroed) arrays of memory, all aligned to PETSC_MEMALIGN

808

809

Synopsis:

810

#include <petscsys.h>

811

PetscErrorCode PetscCalloc6(size_t m1,type **r1,size_t m2,type **r2,size_t m3,type **r3,size_t m4,type **r4,size_t m5,type **r5,size_t m6,type **r6)

812

813

Not Collective

814

815

Input Parameters:

816

+ m1 - number of elements to allocate in 1st chunk (may be zero)

817

. m2 - number of elements to allocate in 2nd chunk (may be zero)

818

. m3 - number of elements to allocate in 3rd chunk (may be zero)

819

. m4 - number of elements to allocate in 4th chunk (may be zero)

820

. m5 - number of elements to allocate in 5th chunk (may be zero)

821

- m6 - number of elements to allocate in 6th chunk (may be zero)

822

823

Output Parameters:

824

+ r1 - memory allocated in first chunk

825

. r2 - memory allocated in second chunk

826

. r3 - memory allocated in third chunk

827

. r4 - memory allocated in fourth chunk

828

. r5 - memory allocated in fifth chunk

829

- r6 - memory allocated in sixth chunk

830

831

Level: developer

832

833

.seealso: PetscFree(), PetscNew(), PetscMalloc(), PetscMalloc2(), PetscMalloc6(), PetscFree6()

834

835

M*/

836

#define PetscCalloc6(m1,r1,m2,r2,m3,r3,m4,r4,m5,r5,m6,r6)PetscMallocA(6,PETSC_TRUE,836,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscsys.h"
,(size_t)(m1)*sizeof(**(r1)),(r1),(size_t)(m2)*sizeof(**(r2))
,(r2),(size_t)(m3)*sizeof(**(r3)),(r3),(size_t)(m4)*sizeof(**
(r4)),(r4),(size_t)(m5)*sizeof(**(r5)),(r5),(size_t)(m6)*sizeof
(**(r6)),(r6)) PetscMallocA(6,PETSC_TRUE,__LINE__836,PETSC_FUNCTION_NAME__func__,__FILE__"/sandbox/petsc/petsc.next-tmp/include/petscsys.h",(size_t)(m1)*sizeof(**(r1)),(r1),(size_t)(m2)*sizeof(**(r2)),(r2),(size_t)(m3)*sizeof(**(r3)),(r3),(size_t)(m4)*sizeof(**(r4)),(r4),(size_t)(m5)*sizeof(**(r5)),(r5),(size_t)(m6)*sizeof(**(r6)),(r6))

837

838

/*MC

839

PetscMalloc7 - Allocates 7 arrays of memory, all aligned to PETSC_MEMALIGN

840

841

Synopsis:

842

#include <petscsys.h>

843

PetscErrorCode PetscMalloc7(size_t m1,type **r1,size_t m2,type **r2,size_t m3,type **r3,size_t m4,type **r4,size_t m5,type **r5,size_t m6,type **r6,size_t m7,type **r7)

844

845

Not Collective

846

847

Input Parameters:

848

+ m1 - number of elements to allocate in 1st chunk (may be zero)

849

. m2 - number of elements to allocate in 2nd chunk (may be zero)

850

. m3 - number of elements to allocate in 3rd chunk (may be zero)

851

. m4 - number of elements to allocate in 4th chunk (may be zero)

852

. m5 - number of elements to allocate in 5th chunk (may be zero)

853

. m6 - number of elements to allocate in 6th chunk (may be zero)

854

- m7 - number of elements to allocate in 7th chunk (may be zero)

855

856

Output Parameters:

857

+ r1 - memory allocated in first chunk

858

. r2 - memory allocated in second chunk

859

. r3 - memory allocated in third chunk

860

. r4 - memory allocated in fourth chunk

861

. r5 - memory allocated in fifth chunk

862

. r6 - memory allocated in sixth chunk

863

- r7 - memory allocated in seventh chunk

864

865

Level: developer

866

867

.seealso: PetscFree(), PetscNew(), PetscMalloc(), PetscMalloc2(), PetscCalloc7(), PetscFree7()

868

869

M*/

870

#define PetscMalloc7(m1,r1,m2,r2,m3,r3,m4,r4,m5,r5,m6,r6,m7,r7)PetscMallocA(7,PETSC_FALSE,870,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscsys.h"
,(size_t)(m1)*sizeof(**(r1)),(r1),(size_t)(m2)*sizeof(**(r2))
,(r2),(size_t)(m3)*sizeof(**(r3)),(r3),(size_t)(m4)*sizeof(**
(r4)),(r4),(size_t)(m5)*sizeof(**(r5)),(r5),(size_t)(m6)*sizeof
(**(r6)),(r6),(size_t)(m7)*sizeof(**(r7)),(r7)) PetscMallocA(7,PETSC_FALSE,__LINE__870,PETSC_FUNCTION_NAME__func__,__FILE__"/sandbox/petsc/petsc.next-tmp/include/petscsys.h",(size_t)(m1)*sizeof(**(r1)),(r1),(size_t)(m2)*sizeof(**(r2)),(r2),(size_t)(m3)*sizeof(**(r3)),(r3),(size_t)(m4)*sizeof(**(r4)),(r4),(size_t)(m5)*sizeof(**(r5)),(r5),(size_t)(m6)*sizeof(**(r6)),(r6),(size_t)(m7)*sizeof(**(r7)),(r7))

871

872

/*MC

873

PetscCalloc7 - Allocates 7 cleared (zeroed) arrays of memory, all aligned to PETSC_MEMALIGN

874

875

Synopsis:

876

#include <petscsys.h>

877

PetscErrorCode PetscCalloc7(size_t m1,type **r1,size_t m2,type **r2,size_t m3,type **r3,size_t m4,type **r4,size_t m5,type **r5,size_t m6,type **r6,size_t m7,type **r7)

878

879

Not Collective

880

881

Input Parameters:

882

+ m1 - number of elements to allocate in 1st chunk (may be zero)

883

. m2 - number of elements to allocate in 2nd chunk (may be zero)

884

. m3 - number of elements to allocate in 3rd chunk (may be zero)

885

. m4 - number of elements to allocate in 4th chunk (may be zero)

886

. m5 - number of elements to allocate in 5th chunk (may be zero)

887

. m6 - number of elements to allocate in 6th chunk (may be zero)

888

- m7 - number of elements to allocate in 7th chunk (may be zero)

889

890

Output Parameters:

891

+ r1 - memory allocated in first chunk

892

. r2 - memory allocated in second chunk

893

. r3 - memory allocated in third chunk

894

. r4 - memory allocated in fourth chunk

895

. r5 - memory allocated in fifth chunk

896

. r6 - memory allocated in sixth chunk

897

- r7 - memory allocated in seventh chunk

898

899

Level: developer

900

901

.seealso: PetscFree(), PetscNew(), PetscMalloc(), PetscMalloc2(), PetscMalloc7(), PetscFree7()

902

903

M*/

904

#define PetscCalloc7(m1,r1,m2,r2,m3,r3,m4,r4,m5,r5,m6,r6,m7,r7)PetscMallocA(7,PETSC_TRUE,904,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscsys.h"
,(size_t)(m1)*sizeof(**(r1)),(r1),(size_t)(m2)*sizeof(**(r2))
,(r2),(size_t)(m3)*sizeof(**(r3)),(r3),(size_t)(m4)*sizeof(**
(r4)),(r4),(size_t)(m5)*sizeof(**(r5)),(r5),(size_t)(m6)*sizeof
(**(r6)),(r6),(size_t)(m7)*sizeof(**(r7)),(r7)) PetscMallocA(7,PETSC_TRUE,__LINE__904,PETSC_FUNCTION_NAME__func__,__FILE__"/sandbox/petsc/petsc.next-tmp/include/petscsys.h",(size_t)(m1)*sizeof(**(r1)),(r1),(size_t)(m2)*sizeof(**(r2)),(r2),(size_t)(m3)*sizeof(**(r3)),(r3),(size_t)(m4)*sizeof(**(r4)),(r4),(size_t)(m5)*sizeof(**(r5)),(r5),(size_t)(m6)*sizeof(**(r6)),(r6),(size_t)(m7)*sizeof(**(r7)),(r7))

905

906

/*MC

907

PetscNew - Allocates memory of a particular type, zeros the memory! Aligned to PETSC_MEMALIGN

908

909

Synopsis:

910

#include <petscsys.h>

911

PetscErrorCode PetscNew(type **result)

912

913

Not Collective

914

915

Output Parameter:

916

. result - memory allocated, sized to match pointer type

917

918

Level: beginner

919

920

.seealso: PetscFree(), PetscMalloc(), PetscNewLog(), PetscCalloc1(), PetscMalloc1()

921

922

M*/

923

#define PetscNew(b)PetscMallocA(1,PETSC_TRUE,923,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscsys.h"
,(size_t)(1)*sizeof(**((b))),((b))) PetscCalloc1(1,(b))PetscMallocA(1,PETSC_TRUE,923,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscsys.h"
,(size_t)(1)*sizeof(**((b))),((b)))

924

925

/*MC

926

PetscNewLog - Allocates memory of a type matching pointer, zeros the memory! Aligned to PETSC_MEMALIGN. Associates the memory allocated

927

with the given object using PetscLogObjectMemory().

928

929

Synopsis:

930

#include <petscsys.h>

931

PetscErrorCode PetscNewLog(PetscObject obj,type **result)

932

933

Not Collective

934

935

Input Parameter:

936

. obj - object memory is logged to

937

938

Output Parameter:

939

. result - memory allocated, sized to match pointer type

940

941

Level: developer

942

943

.seealso: PetscFree(), PetscMalloc(), PetscNew(), PetscLogObjectMemory(), PetscCalloc1(), PetscMalloc1()

944

945

M*/

946

#define PetscNewLog(o,b)(PetscMallocA(1,PETSC_TRUE,946,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscsys.h"
,(size_t)(1)*sizeof(**(((b)))),(((b)))) || PetscLogObjectMemory
((PetscObject)o,sizeof(**(b)))) (PetscNew((b))PetscMallocA(1,PETSC_TRUE,946,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscsys.h"
,(size_t)(1)*sizeof(**(((b)))),(((b)))) || PetscLogObjectMemory((PetscObject)o,sizeof(**(b))))

947

948

/*MC

949

PetscFree - Frees memory

950

951

Synopsis:

952

#include <petscsys.h>

953

PetscErrorCode PetscFree(void *memory)

954

955

Not Collective

956

957

Input Parameter:

958

. memory - memory to free (the pointer is ALWAYS set to NULL upon sucess)

959

960

Level: beginner

961

962

Notes:

963

Do not free memory obtained with PetscMalloc2(), PetscCalloc2() etc, they must be freed with PetscFree2() etc.

964

965

It is safe to call PetscFree() on a NULL pointer.

966

967

.seealso: PetscNew(), PetscMalloc(), PetscNewLog(), PetscMalloc1(), PetscCalloc1()

968

969

M*/

970

#define PetscFree(a)((*PetscTrFree)((void*)(a),970,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscsys.h"
) || ((a) = 0,0)) ((*PetscTrFree)((void*)(a),__LINE__970,PETSC_FUNCTION_NAME__func__,__FILE__"/sandbox/petsc/petsc.next-tmp/include/petscsys.h") || ((a) = 0,0))

971

972

/*MC

973

PetscFree2 - Frees 2 chunks of memory obtained with PetscMalloc2()

974

975

Synopsis:

976

#include <petscsys.h>

977

PetscErrorCode PetscFree2(void *memory1,void *memory2)

978

979

Not Collective

980

981

Input Parameters:

982

+ memory1 - memory to free

983

- memory2 - 2nd memory to free

984

985

Level: developer

986

987

Notes:

988

Memory must have been obtained with PetscMalloc2()

989

990

.seealso: PetscNew(), PetscMalloc(), PetscMalloc2(), PetscFree()

991

992

M*/

993

#define PetscFree2(m1,m2)PetscFreeA(2,993,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscsys.h"
,&(m1),&(m2)) PetscFreeA(2,__LINE__993,PETSC_FUNCTION_NAME__func__,__FILE__"/sandbox/petsc/petsc.next-tmp/include/petscsys.h",&(m1),&(m2))

994

995

/*MC

996

PetscFree3 - Frees 3 chunks of memory obtained with PetscMalloc3()

997

998

Synopsis:

999

#include <petscsys.h>

1000

PetscErrorCode PetscFree3(void *memory1,void *memory2,void *memory3)

1001

1002

Not Collective

1003

1004

Input Parameters:

1005

+ memory1 - memory to free

1006

. memory2 - 2nd memory to free

1007

- memory3 - 3rd memory to free

1008

1009

Level: developer

1010

1011

Notes:

1012

Memory must have been obtained with PetscMalloc3()

1013

1014

.seealso: PetscNew(), PetscMalloc(), PetscMalloc2(), PetscFree(), PetscMalloc3()

1015

1016

M*/

1017

#define PetscFree3(m1,m2,m3)PetscFreeA(3,1017,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscsys.h"
,&(m1),&(m2),&(m3)) PetscFreeA(3,__LINE__1017,PETSC_FUNCTION_NAME__func__,__FILE__"/sandbox/petsc/petsc.next-tmp/include/petscsys.h",&(m1),&(m2),&(m3))

1018

1019

/*MC

1020

PetscFree4 - Frees 4 chunks of memory obtained with PetscMalloc4()

1021

1022

Synopsis:

1023

#include <petscsys.h>

1024

PetscErrorCode PetscFree4(void *m1,void *m2,void *m3,void *m4)

1025

1026

Not Collective

1027

1028

Input Parameters:

1029

+ m1 - memory to free

1030

. m2 - 2nd memory to free

1031

. m3 - 3rd memory to free

1032

- m4 - 4th memory to free

1033

1034

Level: developer

1035

1036

Notes:

1037

Memory must have been obtained with PetscMalloc4()

1038

1039

.seealso: PetscNew(), PetscMalloc(), PetscMalloc2(), PetscFree(), PetscMalloc3(), PetscMalloc4()

1040

1041

M*/

1042

#define PetscFree4(m1,m2,m3,m4)PetscFreeA(4,1042,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscsys.h"
,&(m1),&(m2),&(m3),&(m4)) PetscFreeA(4,__LINE__1042,PETSC_FUNCTION_NAME__func__,__FILE__"/sandbox/petsc/petsc.next-tmp/include/petscsys.h",&(m1),&(m2),&(m3),&(m4))

1043

1044

/*MC

1045

PetscFree5 - Frees 5 chunks of memory obtained with PetscMalloc5()

1046

1047

Synopsis:

1048

#include <petscsys.h>

1049

PetscErrorCode PetscFree5(void *m1,void *m2,void *m3,void *m4,void *m5)

1050

1051

Not Collective

1052

1053

Input Parameters:

1054

+ m1 - memory to free

1055

. m2 - 2nd memory to free

1056

. m3 - 3rd memory to free

1057

. m4 - 4th memory to free

1058

- m5 - 5th memory to free

1059

1060

Level: developer

1061

1062

Notes:

1063

Memory must have been obtained with PetscMalloc5()

1064

1065

.seealso: PetscNew(), PetscMalloc(), PetscMalloc2(), PetscFree(), PetscMalloc3(), PetscMalloc4(), PetscMalloc5()

1066

1067

M*/

1068

#define PetscFree5(m1,m2,m3,m4,m5)PetscFreeA(5,1068,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscsys.h"
,&(m1),&(m2),&(m3),&(m4),&(m5)) PetscFreeA(5,__LINE__1068,PETSC_FUNCTION_NAME__func__,__FILE__"/sandbox/petsc/petsc.next-tmp/include/petscsys.h",&(m1),&(m2),&(m3),&(m4),&(m5))

1069

1070

/*MC

1071

PetscFree6 - Frees 6 chunks of memory obtained with PetscMalloc6()

1072

1073

Synopsis:

1074

#include <petscsys.h>

1075

PetscErrorCode PetscFree6(void *m1,void *m2,void *m3,void *m4,void *m5,void *m6)

1076

1077

Not Collective

1078

1079

Input Parameters:

1080

+ m1 - memory to free

1081

. m2 - 2nd memory to free

1082

. m3 - 3rd memory to free

1083

. m4 - 4th memory to free

1084

. m5 - 5th memory to free

1085

- m6 - 6th memory to free

1086

1087

1088

Level: developer

1089

1090

Notes:

1091

Memory must have been obtained with PetscMalloc6()

1092

1093

.seealso: PetscNew(), PetscMalloc(), PetscMalloc2(), PetscFree(), PetscMalloc3(), PetscMalloc4(), PetscMalloc5(), PetscMalloc6()

1094

1095

M*/

1096

#define PetscFree6(m1,m2,m3,m4,m5,m6)PetscFreeA(6,1096,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscsys.h"
,&(m1),&(m2),&(m3),&(m4),&(m5),&(m6)) PetscFreeA(6,__LINE__1096,PETSC_FUNCTION_NAME__func__,__FILE__"/sandbox/petsc/petsc.next-tmp/include/petscsys.h",&(m1),&(m2),&(m3),&(m4),&(m5),&(m6))

1097

1098

/*MC

1099

PetscFree7 - Frees 7 chunks of memory obtained with PetscMalloc7()

1100

1101

Synopsis:

1102

#include <petscsys.h>

1103

PetscErrorCode PetscFree7(void *m1,void *m2,void *m3,void *m4,void *m5,void *m6,void *m7)

1104

1105

Not Collective

1106

1107

Input Parameters:

1108

+ m1 - memory to free

1109

. m2 - 2nd memory to free

1110

. m3 - 3rd memory to free

1111

. m4 - 4th memory to free

1112

. m5 - 5th memory to free

1113

. m6 - 6th memory to free

1114

- m7 - 7th memory to free

1115

1116

1117

Level: developer

1118

1119

Notes:

1120

Memory must have been obtained with PetscMalloc7()

1121

1122

.seealso: PetscNew(), PetscMalloc(), PetscMalloc2(), PetscFree(), PetscMalloc3(), PetscMalloc4(), PetscMalloc5(), PetscMalloc6(),

1123

PetscMalloc7()

1124

1125

M*/

1126

#define PetscFree7(m1,m2,m3,m4,m5,m6,m7)PetscFreeA(7,1126,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscsys.h"
,&(m1),&(m2),&(m3),&(m4),&(m5),&(m6),
&(m7)) PetscFreeA(7,__LINE__1126,PETSC_FUNCTION_NAME__func__,__FILE__"/sandbox/petsc/petsc.next-tmp/include/petscsys.h",&(m1),&(m2),&(m3),&(m4),&(m5),&(m6),&(m7))

1127

1128

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscMallocA(int,PetscBool,int,const char *,const char *,size_t,void *,...);

1129

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscFreeA(int,int,const char *,const char *,void *,...);

1130

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode (*PetscTrMalloc)(size_t,PetscBool,int,const char[],const char[],void**);

1131

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode (*PetscTrFree)(void*,int,const char[],const char[]);

1132

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode (*PetscTrRealloc)(size_t,int,const char[],const char[],void**);

1133

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscMallocSetCoalesce(PetscBool);

1134

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscMallocSet(PetscErrorCode (*)(size_t,PetscBool,int,const char[],const char[],void**),PetscErrorCode (*)(void*,int,const char[],const char[]));

1135

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscMallocClear(void);

1136

1137

1138

Unlike PetscMallocSet and PetscMallocClear which overwrite the existing settings, these two functions save the previous choice of allocator, and should be used in pair.

1139

1140

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscMallocSetDRAM(void);

1141

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscMallocResetDRAM(void);

1142

1143

#define MPIU_PETSCLOGDOUBLE((MPI_Datatype)0x4c00080b) MPI_DOUBLE((MPI_Datatype)0x4c00080b)

1144

#define MPIU_2PETSCLOGDOUBLE((MPI_Datatype)1275072547) MPI_2DOUBLE_PRECISION((MPI_Datatype)1275072547)

1145

1146

1147

Routines for tracing memory corruption/bleeding with default PETSc memory allocation

1148

1149

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscMallocDump(FILE *);

1150

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscMallocDumpLog(FILE *);

1151

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscMallocGetCurrentUsage(PetscLogDouble *);

1152

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscMallocGetMaximumUsage(PetscLogDouble *);

1153

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscMallocPushMaximumUsage(int);

1154

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscMallocPopMaximumUsage(int,PetscLogDouble*);

1155

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscMallocDebug(PetscBool);

1156

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscMallocGetDebug(PetscBool*);

1157

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscMallocValidate(int,const char[],const char[]);

1158

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscMallocSetDumpLog(void);

1159

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscMallocSetDumpLogThreshold(PetscLogDouble);

1160

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscMallocGetDumpLog(PetscBool*);

1161

1162

PETSC_EXTERNextern __attribute__((visibility ("default"))) const char *const PetscDataTypes[];

1163

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscDataTypeToMPIDataType(PetscDataType,MPI_Datatype*);

1164

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscMPIDataTypeToPetscDataType(MPI_Datatype,PetscDataType*);

1165

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscDataTypeGetSize(PetscDataType,size_t*);

1166

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscDataTypeFromString(const char*,PetscDataType*,PetscBool*);

1167

1168

1169

Basic memory and string operations. These are usually simple wrappers

1170

around the basic Unix system calls, but a few of them have additional

1171

functionality and/or error checking.

1172

1173

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscBitMemcpy(void*,PetscInt,const void*,PetscInt,PetscInt,PetscDataType);

1174

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscMemcmp(const void*,const void*,size_t,PetscBool *);

1175

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscStrlen(const char[],size_t*);

1176

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscStrToArray(const char[],char,int*,char ***);

1177

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscStrToArrayDestroy(int,char **);

1178

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscStrcmp(const char[],const char[],PetscBool *);

1179

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscStrgrt(const char[],const char[],PetscBool *);

1180

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscStrcasecmp(const char[],const char[],PetscBool *);

1181

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscStrncmp(const char[],const char[],size_t,PetscBool *);

1182

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscStrcpy(char[],const char[]);

1183

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscStrcat(char[],const char[]);

1184

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscStrlcat(char[],const char[],size_t);

1185

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscStrncpy(char[],const char[],size_t);

1186

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscStrchr(const char[],char,char *[]);

1187

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscStrtolower(char[]);

1188

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscStrtoupper(char[]);

1189

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscStrrchr(const char[],char,char *[]);

1190

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscStrstr(const char[],const char[],char *[]);

1191

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscStrrstr(const char[],const char[],char *[]);

1192

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscStrendswith(const char[],const char[],PetscBool*);

1193

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscStrbeginswith(const char[],const char[],PetscBool*);

1194

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscStrendswithwhich(const char[],const char *const*,PetscInt*);

1195

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscStrallocpy(const char[],char *[]);

1196

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscStrArrayallocpy(const char *const*,char***);

1197

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscStrArrayDestroy(char***);

1198

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscStrNArrayallocpy(PetscInt,const char *const*,char***);

1199

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscStrNArrayDestroy(PetscInt,char***);

1200

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscStrreplace(MPI_Comm,const char[],char[],size_t);

1201

1202

PETSC_EXTERNextern __attribute__((visibility ("default"))) void PetscStrcmpNoError(const char[],const char[],PetscBool *);

1203

1204

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscTokenCreate(const char[],const char,PetscToken*);

1205

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscTokenFind(PetscToken,char *[]);

1206

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscTokenDestroy(PetscToken*);

1207

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscStrInList(const char[],const char[],char,PetscBool*);

1208

1209

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscEListFind(PetscInt,const char *const*,const char*,PetscInt*,PetscBool*);

1210

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscEnumFind(const char *const*,const char*,PetscEnum*,PetscBool*);

1211

1212

1213

These are MPI operations for MPI_Allreduce() etc

1214

1215

PETSC_EXTERNextern __attribute__((visibility ("default"))) MPI_Op MPIU_MAXSUM_OP;

1216

#if (defined(PETSC_HAVE_COMPLEX1) && !defined(PETSC_HAVE_MPI_C_DOUBLE_COMPLEX1)) || defined(PETSC_USE_REAL___FLOAT128) || defined(PETSC_USE_REAL___FP16)

1217

PETSC_EXTERNextern __attribute__((visibility ("default"))) MPI_Op MPIU_SUM(MPI_Op)(0x58000003);

1218

#else

1219

#define MPIU_SUM(MPI_Op)(0x58000003) MPI_SUM(MPI_Op)(0x58000003)

1220

#endif

1221

#if defined(PETSC_USE_REAL___FLOAT128) || defined(PETSC_USE_REAL___FP16)

1222

PETSC_EXTERNextern __attribute__((visibility ("default"))) MPI_Op MPIU_MAX(MPI_Op)(0x58000001);

1223

PETSC_EXTERNextern __attribute__((visibility ("default"))) MPI_Op MPIU_MIN(MPI_Op)(0x58000002);

1224

#else

1225

#define MPIU_MAX(MPI_Op)(0x58000001) MPI_MAX(MPI_Op)(0x58000001)

1226

#define MPIU_MIN(MPI_Op)(0x58000002) MPI_MIN(MPI_Op)(0x58000002)

1227

#endif

1228

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscMaxSum(MPI_Comm,const PetscInt[],PetscInt*,PetscInt*);

1229

1230

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode MPIULong_Send(void*,PetscInt,MPI_Datatype,PetscMPIInt,PetscMPIInt,MPI_Comm);

1231

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode MPIULong_Recv(void*,PetscInt,MPI_Datatype,PetscMPIInt,PetscMPIInt,MPI_Comm);

1232

1233

PETSC_EXTERNextern __attribute__((visibility ("default"))) const char *const PetscFileModes[];

1234

1235

1236

Defines PETSc error handling.

1237

1238

#include <petscerror.h>

1239

1240

#define PETSC_SMALLEST_CLASSID1211211 1211211

1241

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscClassId PETSC_LARGEST_CLASSID;

1242

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscClassId PETSC_OBJECT_CLASSID;

1243

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscClassIdRegister(const char[],PetscClassId *);

1244

1245

1246

Routines that get memory usage information from the OS

1247

1248

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscMemoryGetCurrentUsage(PetscLogDouble *);

1249

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscMemoryGetMaximumUsage(PetscLogDouble *);

1250

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscMemorySetGetMaximumUsage(void);

1251

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscMemoryTrace(const char[]);

1252

1253

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscInfoAllow(PetscBool ,const char []);

1254

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSleep(PetscReal);

1255

1256

1257

Initialization of PETSc

1258

1259

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscInitialize(int*,char***,const char[],const char[]);

1260

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscInitializeNoPointers(int,char**,const char[],const char[]);

1261

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscInitializeNoArguments(void);

1262

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscInitialized(PetscBool *);

1263

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscFinalized(PetscBool *);

1264

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscFinalize(void);

1265

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscInitializeFortran(void);

1266

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscGetArgs(int*,char ***);

1267

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscGetArguments(char ***);

1268

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscFreeArguments(char **);

1269

1270

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscEnd(void);

1271

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSysInitializePackage(void);

1272

1273

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscPythonInitialize(const char[],const char[]);

1274

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscPythonFinalize(void);

1275

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscPythonPrintError(void);

1276

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscPythonMonitorSet(PetscObject,const char[]);

1277

1278

1279

These are so that in extern C code we can caste function pointers to non-extern C

1280

function pointers. Since the regular C++ code expects its function pointers to be C++

1281

1282

PETSC_EXTERN_TYPEDEF typedef void (**PetscVoidStarFunction)(void);

1283

PETSC_EXTERN_TYPEDEF typedef void (*PetscVoidFunction)(void);

1284

PETSC_EXTERN_TYPEDEF typedef PetscErrorCode (*PetscErrorCodeFunction)(void);

1285

1286

1287

Functions that can act on any PETSc object.

1288

1289

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectDestroy(PetscObject*);

1290

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectGetComm(PetscObject,MPI_Comm *);

1291

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectGetClassId(PetscObject,PetscClassId *);

1292

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectGetClassName(PetscObject,const char *[]);

1293

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectSetType(PetscObject,const char []);

1294

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectGetType(PetscObject,const char *[]);

1295

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectSetName(PetscObject,const char[]);

1296

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectGetName(PetscObject,const char*[]);

1297

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectSetTabLevel(PetscObject,PetscInt);

1298

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectGetTabLevel(PetscObject,PetscInt*);

1299

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectIncrementTabLevel(PetscObject,PetscObject,PetscInt);

1300

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectReference(PetscObject);

1301

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectGetReference(PetscObject,PetscInt*);

1302

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectDereference(PetscObject);

1303

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectGetNewTag(PetscObject,PetscMPIInt *);

1304

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectCompose(PetscObject,const char[],PetscObject);

1305

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectRemoveReference(PetscObject,const char[]);

1306

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectQuery(PetscObject,const char[],PetscObject *);

1307

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectComposeFunction_Private(PetscObject,const char[],void (*)(void));

1308

#define PetscObjectComposeFunction(a,b,d)PetscObjectComposeFunction_Private(a,b,(PetscVoidFunction)(d)
) PetscObjectComposeFunction_Private(a,b,(PetscVoidFunction)(d))

1309

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectSetFromOptions(PetscObject);

1310

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectSetUp(PetscObject);

1311

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectSetPrintedOptions(PetscObject);

1312

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectInheritPrintedOptions(PetscObject,PetscObject);

1313

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscCommGetNewTag(MPI_Comm,PetscMPIInt *);

1314

1315

#include <petscviewertypes.h>

1316

#include <petscoptions.h>

1317

1318

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectsListGetGlobalNumbering(MPI_Comm,PetscInt,PetscObject*,PetscInt*,PetscInt*);

1319

1320

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscMemoryShowUsage(PetscViewer,const char[]);

1321

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscMemoryView(PetscViewer,const char[]);

1322

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectPrintClassNamePrefixType(PetscObject,PetscViewer);

1323

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectView(PetscObject,PetscViewer);

1324

#define PetscObjectQueryFunction(obj,name,fptr)PetscObjectQueryFunction_Private((obj),(name),(PetscVoidFunction
*)(fptr)) PetscObjectQueryFunction_Private((obj),(name),(PetscVoidFunction*)(fptr))

1325

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectQueryFunction_Private(PetscObject,const char[],void (**)(void));

1326

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectSetOptionsPrefix(PetscObject,const char[]);

1327

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectAppendOptionsPrefix(PetscObject,const char[]);

1328

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectPrependOptionsPrefix(PetscObject,const char[]);

1329

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectGetOptionsPrefix(PetscObject,const char*[]);

1330

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectChangeTypeName(PetscObject,const char[]);

1331

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectRegisterDestroy(PetscObject);

1332

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectRegisterDestroyAll(void);

1333

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectViewFromOptions(PetscObject,PetscObject,const char[]);

1334

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectName(PetscObject);

1335

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectTypeCompare(PetscObject,const char[],PetscBool *);

1336

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectBaseTypeCompare(PetscObject,const char[],PetscBool *);

1337

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectTypeCompareAny(PetscObject,PetscBool*,const char[],...);

1338

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectBaseTypeCompareAny(PetscObject,PetscBool*,const char[],...);

1339

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscRegisterFinalize(PetscErrorCode (*)(void));

1340

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscRegisterFinalizeAll(void);

1341

1342

#if defined(PETSC_HAVE_SAWS)

1343

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSAWsBlock(void);

1344

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectSAWsViewOff(PetscObject)0;

1345

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectSAWsSetBlock(PetscObject,PetscBool)0;

1346

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectSAWsBlock(PetscObject)0;

1347

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectSAWsGrantAccess(PetscObject)0;

1348

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectSAWsTakeAccess(PetscObject)0;

1349

PETSC_EXTERNextern __attribute__((visibility ("default"))) void PetscStackSAWsGrantAccess(void);

1350

PETSC_EXTERNextern __attribute__((visibility ("default"))) void PetscStackSAWsTakeAccess(void);

1351

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscStackViewSAWs(void);

1352

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscStackSAWsViewOff(void);

1353

1354

#else

1355

#define PetscSAWsBlock()0 0

1356

#define PetscObjectSAWsViewOff(obj)0 0

1357

#define PetscObjectSAWsSetBlock(obj,flg)0 0

1358

#define PetscObjectSAWsBlock(obj)0 0

1359

#define PetscObjectSAWsGrantAccess(obj)0 0

1360

#define PetscObjectSAWsTakeAccess(obj)0 0

1361

#define PetscStackViewSAWs()0 0

1362

#define PetscStackSAWsViewOff()0 0

1363

#define PetscStackSAWsTakeAccess()

1364

#define PetscStackSAWsGrantAccess()

1365

1366

#endif

1367

1368

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscDLOpen(const char[],PetscDLMode,PetscDLHandle *);

1369

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscDLClose(PetscDLHandle *);

1370

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscDLSym(PetscDLHandle,const char[],void **);

1371

1372

#if defined(PETSC_USE_DEBUG1)

1373

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscMallocGetStack(void*,PetscStack**);

1374

#endif

1375

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectsDump(FILE*,PetscBool);

1376

1377

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectListDestroy(PetscObjectList*);

1378

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectListFind(PetscObjectList,const char[],PetscObject*);

1379

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectListReverseFind(PetscObjectList,PetscObject,char**,PetscBool*);

1380

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectListAdd(PetscObjectList *,const char[],PetscObject);

1381

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectListRemoveReference(PetscObjectList *,const char[]);

1382

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscObjectListDuplicate(PetscObjectList,PetscObjectList *);

1383

1384

1385

Dynamic library lists. Lists of names of routines in objects or in dynamic

1386

link libraries that will be loaded as needed.

1387

1388

1389

#define PetscFunctionListAdd(list,name,fptr)PetscFunctionListAdd_Private((list),(name),(PetscVoidFunction
)(fptr)) PetscFunctionListAdd_Private((list),(name),(PetscVoidFunction)(fptr))

1390

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscFunctionListAdd_Private(PetscFunctionList*,const char[],void (*)(void));

1391

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscFunctionListDestroy(PetscFunctionList*);

1392

#define PetscFunctionListFind(list,name,fptr)PetscFunctionListFind_Private((list),(name),(PetscVoidFunction
*)(fptr)) PetscFunctionListFind_Private((list),(name),(PetscVoidFunction*)(fptr))

1393

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscFunctionListFind_Private(PetscFunctionList,const char[],void (**)(void));

1394

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscFunctionListPrintTypes(MPI_Comm,FILE*,const char[],const char[],const char[],const char[],PetscFunctionList,const char[],const char[]);

1395

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscFunctionListDuplicate(PetscFunctionList,PetscFunctionList *);

1396

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscFunctionListView(PetscFunctionList,PetscViewer);

1397

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscFunctionListGet(PetscFunctionList,const char ***,int*);

1398

1399

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscDLLibrary PetscDLLibrariesLoaded;

1400

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscDLLibraryAppend(MPI_Comm,PetscDLLibrary *,const char[]);

1401

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscDLLibraryPrepend(MPI_Comm,PetscDLLibrary *,const char[]);

1402

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscDLLibrarySym(MPI_Comm,PetscDLLibrary *,const char[],const char[],void **);

1403

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscDLLibraryPrintPath(PetscDLLibrary);

1404

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscDLLibraryRetrieve(MPI_Comm,const char[],char *,size_t,PetscBool *);

1405

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscDLLibraryOpen(MPI_Comm,const char[],PetscDLLibrary *);

1406

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscDLLibraryClose(PetscDLLibrary);

1407

1408

1409

Useful utility routines

1410

1411

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSplitOwnership(MPI_Comm,PetscInt*,PetscInt*);

1412

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSplitOwnershipBlock(MPI_Comm,PetscInt,PetscInt*,PetscInt*);

1413

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSequentialPhaseBegin(MPI_Comm,PetscMPIInt);

1414

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSequentialPhaseEnd(MPI_Comm,PetscMPIInt);

1415

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscBarrier(PetscObject);

1416

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscMPIDump(FILE*);

1417

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscGlobalMinMaxInt(MPI_Comm,PetscInt[],PetscInt[]);

1418

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscGlobalMinMaxReal(MPI_Comm,PetscReal[],PetscReal[]);

1419

1420

/*MC

1421

PetscNot - negates a logical type value and returns result as a PetscBool

1422

1423

Notes:

1424

This is useful in cases like

1425

$ int *a;

1426

$ PetscBool flag = PetscNot(a)

1427

where !a would not return a PetscBool because we cannot provide a cast from int to PetscBool in C.

1428

1429

Level: beginner

1430

1431

.seealso : PetscBool, PETSC_TRUE, PETSC_FALSE

1432

M*/

1433

#define PetscNot(a)((a) ? PETSC_FALSE : PETSC_TRUE) ((a) ? PETSC_FALSE : PETSC_TRUE)

1434

1435

/*MC

1436

PetscHelpPrintf - Prints help messages.

1437

1438

Synopsis:

1439

#include <petscsys.h>

1440

PetscErrorCode (*PetscHelpPrintf)(const char format[],...);

1441

1442

Not Collective

1443

1444

Input Parameters:

1445

. format - the usual printf() format string

1446

1447

Level: developer

1448

1449

Fortran Note:

1450

This routine is not supported in Fortran.

1451

1452

1453

.seealso: PetscFPrintf(), PetscSynchronizedPrintf(), PetscErrorPrintf()

1454

M*/

1455

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode (*PetscHelpPrintf)(MPI_Comm,const char[],...);

1456

1457

1458

Defines PETSc profiling.

1459

1460

#include <petsclog.h>

1461

1462

1463

Simple PETSc parallel IO for ASCII printing

1464

1465

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscFixFilename(const char[],char[]);

1466

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscFOpen(MPI_Comm,const char[],const char[],FILE**);

1467

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscFClose(MPI_Comm,FILE*);

1468

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscFPrintf(MPI_Comm,FILE*,const char[],...);

1469

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscPrintf(MPI_Comm,const char[],...);

1470

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSNPrintf(char*,size_t,const char [],...);

1471

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSNPrintfCount(char*,size_t,const char [],size_t*,...);

1472

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscFormatRealArray(char[],size_t,const char*,PetscInt,const PetscReal[]);

1473

1474

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscErrorPrintfDefault(const char [],...);

1475

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscErrorPrintfNone(const char [],...);

1476

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscHelpPrintfDefault(MPI_Comm,const char [],...);

1477

1478

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscFormatConvertGetSize(const char*,size_t*);

1479

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscFormatConvert(const char*,char *);

1480

1481

#if defined(PETSC_HAVE_POPEN1)

1482

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscPOpen(MPI_Comm,const char[],const char[],const char[],FILE **);

1483

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscPClose(MPI_Comm,FILE*);

1484

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscPOpenSetMachine(const char[]);

1485

#endif

1486

1487

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSynchronizedPrintf(MPI_Comm,const char[],...);

1488

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSynchronizedFPrintf(MPI_Comm,FILE*,const char[],...);

1489

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSynchronizedFlush(MPI_Comm,FILE*);

1490

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSynchronizedFGets(MPI_Comm,FILE*,size_t,char[]);

1491

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscStartMatlab(MPI_Comm,const char[],const char[],FILE**);

1492

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscStartJava(MPI_Comm,const char[],const char[],FILE**);

1493

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscGetPetscDir(const char*[]);

1494

1495

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscClassId PETSC_CONTAINER_CLASSID;

1496

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscContainerGetPointer(PetscContainer,void **);

1497

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscContainerSetPointer(PetscContainer,void *);

1498

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscContainerDestroy(PetscContainer*);

1499

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscContainerCreate(MPI_Comm,PetscContainer *);

1500

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscContainerSetUserDestroy(PetscContainer, PetscErrorCode (*)(void*));

1501

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscContainerUserDestroyDefault(void*);

1502

1503

1504

For use in debuggers

1505

1506

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscMPIInt PetscGlobalRank;

1507

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscMPIInt PetscGlobalSize;

1508

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscIntView(PetscInt,const PetscInt[],PetscViewer);

1509

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscRealView(PetscInt,const PetscReal[],PetscViewer);

1510

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscScalarView(PetscInt,const PetscScalar[],PetscViewer);

1511

1512

#include <stddef.h>

1513

#include <string.h> /* for memcpy, memset */

1514

#if defined(PETSC_HAVE_STDLIB_H1)

1515

#include <stdlib.h>

1516

#endif

1517

1518

#if defined(PETSC_HAVE_XMMINTRIN_H1) && !defined(__CUDACC__)

1519

#include <xmmintrin.h>

1520

#endif

1521

1522

/*@C

1523

PetscMemmove - Copies n bytes, beginning at location b, to the space

1524

beginning at location a. Copying between regions that overlap will

1525

take place correctly. Use PetscMemcpy() if the locations do not overlap

1526

1527

Not Collective

1528

1529

Input Parameters:

1530

+ b - pointer to initial memory space

1531

. a - pointer to copy space

1532

- n - length (in bytes) of space to copy

1533

1534

Level: intermediate

1535

1536

Note:

1537

PetscArraymove() is preferred

1538

This routine is analogous to memmove().

1539

1540

Developers Note: This is inlined for performance

1541

1542

.seealso: PetscMemcpy(), PetscMemcmp(), PetscArrayzero(), PetscMemzero(), PetscArraycmp(), PetscArraycpy(), PetscStrallocpy(),

1543

PetscArraymove()

1544

@*/

1545

PETSC_STATIC_INLINEstatic inline PetscErrorCode PetscMemmove(void *a,const void *b,size_t n)

1546

{

1547

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

1548

if (n > 0 && !a) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_NULL,"Trying to copy to null pointer")return PetscError(((MPI_Comm)0x44000001),1548,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscsys.h"
,85,PETSC_ERROR_INITIAL,"Trying to copy to null pointer");

1549

if (n > 0 && !b) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_NULL,"Trying to copy from a null pointer")return PetscError(((MPI_Comm)0x44000001),1549,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscsys.h"
,85,PETSC_ERROR_INITIAL,"Trying to copy from a null pointer");

1550

#if !defined(PETSC_HAVE_MEMMOVE1)

1551

if (a < b) {

1552

if (a <= b - n) memcpy(a,b,n);

1553

else {

1554

memcpy(a,b,(int)(b - a));

1555

PetscMemmove(b,b + (int)(b - a),n - (int)(b - a));

1556

}

1557

} else {

1558

if (b <= a - n) memcpy(a,b,n);

1559

else {

1560

memcpy(b + n,b + (n - (int)(a - b)),(int)(a - b));

1561

PetscMemmove(a,b,n - (int)(a - b));

1562

}

1563

}

1564

#else

1565

memmove((char*)(a),(char*)(b),n);

1566

#endif

1567

1568

}

1569

1570

/*@C

1571

PetscMemcpy - Copies n bytes, beginning at location b, to the space

1572

beginning at location a. The two memory regions CANNOT overlap, use

1573

PetscMemmove() in that case.

1574

1575

Not Collective

1576

1577

Input Parameters:

1578

+ b - pointer to initial memory space

1579

- n - length (in bytes) of space to copy

1580

1581

Output Parameter:

1582

. a - pointer to copy space

1583

1584

Level: intermediate

1585

1586

Compile Option:

1587

PETSC_PREFER_DCOPY_FOR_MEMCPY will cause the BLAS dcopy() routine to be used

1588

for memory copies on double precision values.

1589

PETSC_PREFER_COPY_FOR_MEMCPY will cause C code to be used

1590

for memory copies on double precision values.

1591

PETSC_PREFER_FORTRAN_FORMEMCPY will cause Fortran code to be used

1592

for memory copies on double precision values.

1593

1594

Note:

1595

Prefer PetscArraycpy()

1596

This routine is analogous to memcpy().

1597

Not available from Fortran

1598

1599

Developer Note: this is inlined for fastest performance

1600

1601

.seealso: PetscMemzero(), PetscMemcmp(), PetscArrayzero(), PetscArraycmp(), PetscArraycpy(), PetscMemmove(), PetscStrallocpy()

1602

1603

@*/

1604

PETSC_STATIC_INLINEstatic inline PetscErrorCode PetscMemcpy(void *a,const void *b,size_t n)

1605

{

1606

#if defined(PETSC_USE_DEBUG1)

1607

size_t al = (size_t) a,bl = (size_t) b;

1608

size_t nl = (size_t) n;

1609

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/include/petscsys.h"; 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

if (n > 0 && !b) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_NULL,"Trying to copy from a null pointer")return PetscError(((MPI_Comm)0x44000001),1610,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscsys.h"
,85,PETSC_ERROR_INITIAL,"Trying to copy from a null pointer");

1611

if (n > 0 && !a) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_NULL,"Trying to copy to a null pointer")return PetscError(((MPI_Comm)0x44000001),1611,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscsys.h"
,85,PETSC_ERROR_INITIAL,"Trying to copy to a null pointer");

1612

#else

1613

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

1614

#endif

1615

if (a != b && n > 0) {

1616

#if defined(PETSC_USE_DEBUG1)

1617

if ((al > bl && (al - bl) < nl) || (bl - al) < nl) SETERRQ3(PETSC_COMM_SELF,PETSC_ERR_ARG_INCOMP,"Memory regions overlap: either use PetscMemmov()\n\return PetscError(((MPI_Comm)0x44000001),1619,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscsys.h"
,75,PETSC_ERROR_INITIAL,"Memory regions overlap: either use PetscMemmov()\n or make sure your copy regions and lengths are correct. \n Length (bytes) %ld first address %ld second address %ld"
,nl,al,bl)

1618

or make sure your copy regions and lengths are correct. \n\return PetscError(((MPI_Comm)0x44000001),1619,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscsys.h"
,75,PETSC_ERROR_INITIAL,"Memory regions overlap: either use PetscMemmov()\n or make sure your copy regions and lengths are correct. \n Length (bytes) %ld first address %ld second address %ld"
,nl,al,bl)

1619

Length (bytes) %ld first address %ld second address %ld",nl,al,bl)return PetscError(((MPI_Comm)0x44000001),1619,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscsys.h"
,75,PETSC_ERROR_INITIAL,"Memory regions overlap: either use PetscMemmov()\n or make sure your copy regions and lengths are correct. \n Length (bytes) %ld first address %ld second address %ld"
,nl,al,bl);

1620

#endif

1621

#if (defined(PETSC_PREFER_DCOPY_FOR_MEMCPY) || defined(PETSC_PREFER_COPY_FOR_MEMCPY) || defined(PETSC_PREFER_FORTRAN_FORMEMCPY))

1622

if (!(a % sizeof(PetscScalar)) && !(n % sizeof(PetscScalar))) {

1623

size_t len = n/sizeof(PetscScalar);

1624

#if defined(PETSC_PREFER_DCOPY_FOR_MEMCPY)

1625

PetscBLASInt one = 1,blen;

1626

PetscErrorCode ierr;

1627

ierr = PetscBLASIntCast(len,&blen);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1627,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscsys.h"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1628

PetscStackCallBLAS("BLAScopy",BLAScopy_(&blen,(PetscScalar *)b,&one,(PetscScalar *)a,&one));

1629

#elif defined(PETSC_PREFER_FORTRAN_FORMEMCPY)

1630

fortrancopy_(&len,(PetscScalar*)b,(PetscScalar*)a);

1631

#else

1632

size_t i;

1633

PetscScalar *x = (PetscScalar*)b, *y = (PetscScalar*)a;

1634

for (i=0; i<len; i++) y[i] = x[i];

1635

#endif

1636

} else {

1637

memcpy((char*)(a),(char*)(b),n);

1638

}

1639

#else

1640

memcpy((char*)(a),(char*)(b),n);

1641

#endif

1642

}

1643

1644

}

1645

1646

/*@C

1647

PetscMemzero - Zeros the specified memory.

1648

1649

Not Collective

1650

1651

Input Parameters:

1652

+ a - pointer to beginning memory location

1653

- n - length (in bytes) of memory to initialize

1654

1655

Level: intermediate

1656

1657

Compile Option:

1658

PETSC_PREFER_BZERO - on certain machines (the IBM RS6000) the bzero() routine happens

1659

to be faster than the memset() routine. This flag causes the bzero() routine to be used.

1660

1661

Not available from Fortran

1662

Prefer PetscArrayzero()

1663

1664

Developer Note: this is inlined for fastest performance

1665

1666

.seealso: PetscMemcpy(), PetscMemcmp(), PetscArrayzero(), PetscArraycmp(), PetscArraycpy(), PetscMemmove(), PetscStrallocpy()

1667

@*/

1668

PETSC_STATIC_INLINEstatic inline PetscErrorCode PetscMemzero(void *a,size_t n)

1669

{

1670

if (n > 0) {

1671

#if defined(PETSC_USE_DEBUG1)

1672

if (!a) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_NULL,"Trying to zero at a null pointer")return PetscError(((MPI_Comm)0x44000001),1672,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscsys.h"
,85,PETSC_ERROR_INITIAL,"Trying to zero at a null pointer");

1673

#endif

1674

#if defined(PETSC_PREFER_ZERO_FOR_MEMZERO)

1675

if (!(((long) a) % sizeof(PetscScalar)) && !(n % sizeof(PetscScalar))) {

1676

size_t i,len = n/sizeof(PetscScalar);

1677

PetscScalar *x = (PetscScalar*)a;

1678

for (i=0; i<len; i++) x[i] = 0.0;

1679

} else {

1680

#elif defined(PETSC_PREFER_FORTRAN_FOR_MEMZERO)

1681

if (!(((long) a) % sizeof(PetscScalar)) && !(n % sizeof(PetscScalar))) {

1682

PetscInt len = n/sizeof(PetscScalar);

1683

fortranzero_(&len,(PetscScalar*)a);

1684

} else {

1685

#endif

1686

#if defined(PETSC_PREFER_BZERO)

1687

bzero((char *)a,n);

1688

#else

1689

memset((char*)a,0,n);

1690

#endif

1691

#if defined(PETSC_PREFER_ZERO_FOR_MEMZERO) || defined(PETSC_PREFER_FORTRAN_FOR_MEMZERO)

1692

}

1693

#endif

1694

}

1695

return 0;

1696

}

1697

1698

/*MC

1699

PetscArraycmp - Compares two arrays in memory.

1700

1701

Synopsis:

1702

#include <petscsys.h>

1703

PetscErrorCode PetscArraycmp(const anytype *str1,const anytype *str2,size_t cnt,PetscBool *e)

1704

1705

Not Collective

1706

1707

Input Parameters:

1708

+ str1 - First array

1709

. str2 - Second array

1710

- cnt - Count of the array, not in bytes, but number of entries in the arrays

1711

1712

Output Parameters:

1713

. e - PETSC_TRUE if equal else PETSC_FALSE.

1714

1715

Level: intermediate

1716

1717

Note:

1718

This routine is a preferred replacement to PetscMemcmp()

1719

The arrays must be of the same type

1720

1721

.seealso: PetscMemcpy(), PetscMemcmp(), PetscArrayzero(), PetscMemzero(), PetscArraycpy(), PetscMemmove(), PetscStrallocpy(),

1722

PetscArraymove()

1723

M*/

1724

#define PetscArraycmp(str1,str2,cnt,e)((sizeof(*(str1)) != sizeof(*(str2))) || PetscMemcmp(str1,str2
,(cnt)*sizeof(*(str1)),e)); ((sizeof(*(str1)) != sizeof(*(str2))) || PetscMemcmp(str1,str2,(cnt)*sizeof(*(str1)),e));

1725

1726

/*MC

1727

PetscArraymove - Copies from one array in memory to another, the arrays may overlap. Use PetscArraycpy() when the arrays

1728

do not overlap

1729

1730

Synopsis:

1731

#include <petscsys.h>

1732

PetscErrorCode PetscArraymove(anytype *str1,const anytype *str2,size_t cnt)

1733

1734

Not Collective

1735

1736

Input Parameters:

1737

+ str1 - First array

1738

. str2 - Second array

1739

- cnt - Count of the array, not in bytes, but number of entries in the arrays

1740

1741

Level: intermediate

1742

1743

Note:

1744

This routine is a preferred replacement to PetscMemmove()

1745

The arrays must be of the same type

1746

1747

.seealso: PetscMemcpy(), PetscMemcmp(), PetscArrayzero(), PetscMemzero(), PetscArraycpy(), PetscMemmove(), PetscArraycmp(), PetscStrallocpy()

1748

M*/

1749

#define PetscArraymove(str1,str2,cnt)((sizeof(*(str1)) != sizeof(*(str2))) || PetscMemmove(str1,str2
,(cnt)*sizeof(*(str1)))); ((sizeof(*(str1)) != sizeof(*(str2))) || PetscMemmove(str1,str2,(cnt)*sizeof(*(str1))));

1750

1751

/*MC

1752

PetscArraycpy - Copies from one array in memory to another

1753

1754

Synopsis:

1755

#include <petscsys.h>

1756

PetscErrorCode PetscArraycpy(anytype *str1,const anytype *str2,size_t cnt)

1757

1758

Not Collective

1759

1760

Input Parameters:

1761

+ str1 - First array

1762

. str2 - Second array

1763

- cnt - Count of the array, not in bytes, but number of entries in the arrays

1764

1765

Level: intermediate

1766

1767

Note:

1768

This routine is a preferred replacement to PetscMemcpy()

1769

The arrays must be of the same type

1770

1771

.seealso: PetscMemcpy(), PetscMemcmp(), PetscArrayzero(), PetscMemzero(), PetscArraymove(), PetscMemmove(), PetscArraycmp(), PetscStrallocpy()

1772

M*/

1773

#define PetscArraycpy(str1,str2,cnt)((sizeof(*(str1)) != sizeof(*(str2))) || PetscMemcpy(str1,str2
,(cnt)*sizeof(*(str1)))); ((sizeof(*(str1)) != sizeof(*(str2))) || PetscMemcpy(str1,str2,(cnt)*sizeof(*(str1))));

1774

1775

/*MC

1776

PetscArrayzero - Zeros an array in memory.

1777

1778

Synopsis:

1779

#include <petscsys.h>

1780

PetscErrorCode PetscArrayzero(anytype *str1,size_t cnt)

1781

1782

Not Collective

1783

1784

Input Parameters:

1785

+ str1 - array

1786

- cnt - Count of the array, not in bytes, but number of entries in the array

1787

1788

Level: intermediate

1789

1790

Note:

1791

This routine is a preferred replacement to PetscMemzero()

1792

1793

.seealso: PetscMemcpy(), PetscMemcmp(), PetscMemzero(), PetscArraycmp(), PetscArraycpy(), PetscMemmove(), PetscStrallocpy(), PetscArraymove()

1794

M*/

1795

#define PetscArrayzero(str1,cnt)PetscMemzero(str1,(cnt)*sizeof(*(str1))); PetscMemzero(str1,(cnt)*sizeof(*(str1)));

1796

1797

/*MC

1798

PetscPrefetchBlock - Prefetches a block of memory

1799

1800

Synopsis:

1801

#include <petscsys.h>

1802

void PetscPrefetchBlock(const anytype *a,size_t n,int rw,int t)

1803

1804

Not Collective

1805

1806

Input Parameters:

1807

+ a - pointer to first element to fetch (any type but usually PetscInt or PetscScalar)

1808

. n - number of elements to fetch

1809

. rw - 1 if the memory will be written to, otherwise 0 (ignored by many processors)

1810

- t - temporal locality (PETSC_PREFETCH_HINT_{NTA,T0,T1,T2}), see note

1811

1812

Level: developer

1813

1814

Notes:

1815

The last two arguments (rw and t) must be compile-time constants.

1816

1817

Adopting Intel's x86/x86-64 conventions, there are four levels of temporal locality. Not all architectures offer

1818

equivalent locality hints, but the following macros are always defined to their closest analogue.

1819

+ PETSC_PREFETCH_HINT_NTA - Non-temporal. Prefetches directly to L1, evicts to memory (skips higher level cache unless it was already there when prefetched).

1820

. PETSC_PREFETCH_HINT_T0 - Fetch to all levels of cache and evict to the closest level. Use this when the memory will be reused regularly despite necessary eviction from L1.

1821

. PETSC_PREFETCH_HINT_T1 - Fetch to level 2 and higher (not L1).

1822

- PETSC_PREFETCH_HINT_T2 - Fetch to high-level cache only. (On many systems, T0 and T1 are equivalent.)

1823

1824

This function does nothing on architectures that do not support prefetch and never errors (even if passed an invalid

1825

address).

1826

1827

M*/

1828

#define PetscPrefetchBlock(a,n,rw,t)do { const char *_p = (const char*)(a),*_end = (const char*)(
(a)+(n)); for ( ; _p < _end; _p += 64) (__builtin_prefetch
((void *)((const char*)(_p)), ((((t))) >> 2) & 1, (
((t))) & 0x3)); } while (0) do { \

1829

const char *_p = (const char*)(a),*_end = (const char*)((a)+(n)); \

1830

for ( ; _p < _end; _p += PETSC_LEVEL1_DCACHE_LINESIZE64) PETSC_Prefetch(_p,(rw),(t))(__builtin_prefetch((void *)((const char*)(_p)), ((((t))) >>
2) & 1, (((t))) & 0x3)); \

1831

} while (0)

1832

1833

1834

Determine if some of the kernel computation routines use

1835

Fortran (rather than C) for the numerical calculations. On some machines

1836

and compilers (like complex numbers) the Fortran version of the routines

1837

is faster than the C/C++ versions. The flag --with-fortran-kernels

1838

should be used with ./configure to turn these on.

1839

1840

#if defined(PETSC_USE_FORTRAN_KERNELS)

1841

1842

#if !defined(PETSC_USE_FORTRAN_KERNEL_MULTCRL)

1843

#define PETSC_USE_FORTRAN_KERNEL_MULTCRL

1844

#endif

1845

1846

#if !defined(PETSC_USE_FORTRAN_KERNEL_MULTAIJPERM)

1847

#define PETSC_USE_FORTRAN_KERNEL_MULTAIJPERM

1848

#endif

1849

1850

#if !defined(PETSC_USE_FORTRAN_KERNEL_MULTAIJ)

1851

#define PETSC_USE_FORTRAN_KERNEL_MULTAIJ

1852

#endif

1853

1854

#if !defined(PETSC_USE_FORTRAN_KERNEL_MULTTRANSPOSEAIJ)

1855

#define PETSC_USE_FORTRAN_KERNEL_MULTTRANSPOSEAIJ

1856

#endif

1857

1858

#if !defined(PETSC_USE_FORTRAN_KERNEL_NORM)

1859

#define PETSC_USE_FORTRAN_KERNEL_NORM

1860

#endif

1861

1862

#if !defined(PETSC_USE_FORTRAN_KERNEL_MAXPY)

1863

#define PETSC_USE_FORTRAN_KERNEL_MAXPY

1864

#endif

1865

1866

#if !defined(PETSC_USE_FORTRAN_KERNEL_SOLVEAIJ)

1867

#define PETSC_USE_FORTRAN_KERNEL_SOLVEAIJ

1868

#endif

1869

1870

#if !defined(PETSC_USE_FORTRAN_KERNEL_RELAXAIJ)

1871

#define PETSC_USE_FORTRAN_KERNEL_RELAXAIJ

1872

#endif

1873

1874

#if !defined(PETSC_USE_FORTRAN_KERNEL_SOLVEBAIJ)

1875

#define PETSC_USE_FORTRAN_KERNEL_SOLVEBAIJ

1876

#endif

1877

1878

#if !defined(PETSC_USE_FORTRAN_KERNEL_MULTADDAIJ)

1879

#define PETSC_USE_FORTRAN_KERNEL_MULTADDAIJ

1880

#endif

1881

1882

#if !defined(PETSC_USE_FORTRAN_KERNEL_MDOT)

1883

#define PETSC_USE_FORTRAN_KERNEL_MDOT

1884

#endif

1885

1886

#if !defined(PETSC_USE_FORTRAN_KERNEL_XTIMESY)

1887

#define PETSC_USE_FORTRAN_KERNEL_XTIMESY

1888

#endif

1889

1890

#if !defined(PETSC_USE_FORTRAN_KERNEL_AYPX)

1891

#define PETSC_USE_FORTRAN_KERNEL_AYPX

1892

#endif

1893

1894

#if !defined(PETSC_USE_FORTRAN_KERNEL_WAXPY)

1895

#define PETSC_USE_FORTRAN_KERNEL_WAXPY

1896

#endif

1897

1898

#endif

1899

1900

1901

Macros for indicating code that should be compiled with a C interface,

1902

rather than a C++ interface. Any routines that are dynamically loaded

1903

(such as the PCCreate_XXX() routines) must be wrapped so that the name

1904

mangler does not change the functions symbol name. This just hides the

1905

ugly extern "C" {} wrappers.

1906

1907

#if defined(__cplusplus)

1908

# define EXTERN_C_BEGIN extern "C" {

1909

# define EXTERN_C_END }

1910

#else

1911

# define EXTERN_C_BEGIN

1912

# define EXTERN_C_END

1913

#endif

1914

1915

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

1916

1917

/*MC

1918

MPI_Comm - the basic object used by MPI to determine which processes are involved in a

1919

communication

1920

1921

Level: beginner

1922

1923

Note: This manual page is a place-holder because MPICH does not have a manual page for MPI_Comm

1924

1925

.seealso: PETSC_COMM_WORLD, PETSC_COMM_SELF

1926

M*/

1927

1928

#if defined(PETSC_HAVE_MPIIO1)

1929

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode MPIU_File_write_all(MPI_File,void*,PetscMPIInt,MPI_Datatype,MPI_Status*);

1930

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode MPIU_File_read_all(MPI_File,void*,PetscMPIInt,MPI_Datatype,MPI_Status*);

1931

#endif

1932

1933

/* the following petsc_static_inline require petscerror.h */

1934

1935

/* Limit MPI to 32-bits */

1936

#define PETSC_MPI_INT_MAX2147483647 2147483647

1937

#define PETSC_MPI_INT_MIN-2147483647 -2147483647

1938

/* Limit BLAS to 32-bits */

1939

#define PETSC_BLAS_INT_MAX2147483647 2147483647

1940

#define PETSC_BLAS_INT_MIN-2147483647 -2147483647

1941

1942

/*@C

1943

PetscBLASIntCast - casts a PetscInt (which may be 64 bits in size) to a PetscBLASInt (which may be 32 bits in size), generates an

1944

error if the PetscBLASInt is not large enough to hold the number.

1945

1946

Not Collective

1947

1948

Input Parameter:

1949

. a - the PetscInt value

1950

1951

Output Parameter:

1952

. b - the resulting PetscBLASInt value

1953

1954

Level: advanced

1955

1956

Not available from Fortran

1957

1958

.seealso: PetscBLASInt, PetscMPIInt, PetscInt, PetscMPIIntCast()

1959

@*/

1960

PETSC_STATIC_INLINEstatic inline PetscErrorCode PetscBLASIntCast(PetscInt a,PetscBLASInt *b)

1961

{

1962

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

1963

*b = (PetscBLASInt)(a);

1964

#if defined(PETSC_USE_64BIT_INDICES) && !defined(PETSC_HAVE_64BIT_BLAS_INDICES)

1965

if ((a) > PETSC_BLAS_INT_MAX2147483647) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Array too long for BLAS/LAPACK")return PetscError(((MPI_Comm)0x44000001),1965,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscsys.h"
,63,PETSC_ERROR_INITIAL,"Array too long for BLAS/LAPACK");

1966

#endif

1967

1968

}

1969

1970

/*@C

1971

PetscMPIIntCast - casts a PetscInt (which may be 64 bits in size) to a PetscMPIInt (which may be 32 bits in size), generates an

1972

error if the PetscMPIInt is not large enough to hold the number.

1973

1974

Not Collective

1975

1976

Input Parameter:

1977

. a - the PetscInt value

1978

1979

Output Parameter:

1980

. b - the resulting PetscMPIInt value

1981

1982

Level: advanced

1983

1984

Not available from Fortran

1985

1986

.seealso: PetscBLASInt, PetscMPIInt, PetscInt, PetscBLASIntCast()

1987

@*/

1988

PETSC_STATIC_INLINEstatic inline PetscErrorCode PetscMPIIntCast(PetscInt a,PetscMPIInt *b)

1989

{

1990

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

1991

*b = (PetscMPIInt)(a);

1992

#if defined(PETSC_USE_64BIT_INDICES)

1993

if ((a) > PETSC_MPI_INT_MAX2147483647) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Array too long for MPI")return PetscError(((MPI_Comm)0x44000001),1993,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscsys.h"
,63,PETSC_ERROR_INITIAL,"Array too long for MPI");

1994

#endif

1995

1996

}

1997

1998

#define PetscInt64Mult(a,b)((PetscInt64)(a))*((PetscInt64)(b)) ((PetscInt64)(a))*((PetscInt64)(b))

1999

2000

/*@C

2001

2002

PetscRealIntMultTruncate - Computes the product of a positive PetscReal and a positive PetscInt and truncates the value to slightly less than the maximal possible value

2003

2004

Not Collective

2005

2006

Input Parameter:

2007

+ a - the PetscReal value

2008

- b - the second value

2009

2010

Returns:

2011

the result as a PetscInt value

2012

2013

Use PetscInt64Mult() to compute the product of two PetscInt as a PetscInt64

2014

Use PetscIntMultTruncate() to compute the product of two positive PetscInt and truncate to fit a PetscInt

2015

Use PetscIntMultError() to compute the product of two PetscInt if you wish to generate an error if the result will not fit in a PetscInt

2016

2017

Developers Note:

2018

We currently assume that PetscInt addition can never overflow, this is obviously wrong but requires many more checks.

2019

2020

This is used where we compute approximate sizes for workspace and need to insure the workspace is index-able.

2021

2022

Not available from Fortran

2023

2024

Level: advanced

2025

2026

.seealso: PetscBLASInt, PetscMPIInt, PetscInt, PetscBLASIntCast(), PetscInt64Mult()

2027

@*/

2028

PETSC_STATIC_INLINEstatic inline PetscInt PetscRealIntMultTruncate(PetscReal a,PetscInt b)

2029

{

2030

PetscInt64 r;

2031

2032

r = (PetscInt64) (a*(PetscReal)b);

2033

if (r > PETSC_MAX_INT2147483647 - 100) r = PETSC_MAX_INT2147483647 - 100;

2034

return (PetscInt) r;

2035

}

2036

2037

/*@C

2038

2039

PetscIntMultTruncate - Computes the product of two positive PetscInt and truncates the value to slightly less than the maximal possible value

2040

2041

Not Collective

2042

2043

Input Parameter:

2044

+ a - the PetscInt value

2045

- b - the second value

2046

2047

Returns:

2048

the result as a PetscInt value

2049

2050

Use PetscInt64Mult() to compute the product of two PetscInt as a PetscInt64

2051

Use PetscRealIntMultTruncate() to compute the product of a PetscReal and a PetscInt and truncate to fit a PetscInt

2052

Use PetscIntMultError() to compute the product of two PetscInt if you wish to generate an error if the result will not fit in a PetscInt

2053

2054

Not available from Fortran

2055

2056

Developers Note: We currently assume that PetscInt addition can never overflow, this is obviously wrong but requires many more checks.

2057

2058

This is used where we compute approximate sizes for workspace and need to insure the workspace is index-able.

2059

2060

Level: advanced

2061

2062

.seealso: PetscBLASInt, PetscMPIInt, PetscInt, PetscBLASIntCast(), PetscInt64Mult()

2063

@*/

2064

PETSC_STATIC_INLINEstatic inline PetscInt PetscIntMultTruncate(PetscInt a,PetscInt b)

2065

{

2066

PetscInt64 r;

2067

2068

r = PetscInt64Mult(a,b)((PetscInt64)(a))*((PetscInt64)(b));

2069

if (r > PETSC_MAX_INT2147483647 - 100) r = PETSC_MAX_INT2147483647 - 100;

2070

return (PetscInt) r;

2071

}

2072

2073

/*@C

2074

2075

PetscIntSumTruncate - Computes the sum of two positive PetscInt and truncates the value to slightly less than the maximal possible value

2076

2077

Not Collective

2078

2079

Input Parameter:

2080

+ a - the PetscInt value

2081

- b - the second value

2082

2083

Returns:

2084

the result as a PetscInt value

2085

2086

Use PetscInt64Mult() to compute the product of two PetscInt as a PetscInt64

2087

Use PetscRealIntMultTruncate() to compute the product of a PetscReal and a PetscInt and truncate to fit a PetscInt

2088

Use PetscIntMultError() to compute the product of two PetscInt if you wish to generate an error if the result will not fit in a PetscInt

2089

2090

This is used where we compute approximate sizes for workspace and need to insure the workspace is index-able.

2091

2092

Not available from Fortran

2093

2094

Level: advanced

2095

2096

.seealso: PetscBLASInt, PetscMPIInt, PetscInt, PetscBLASIntCast(), PetscInt64Mult()

2097

@*/

2098

PETSC_STATIC_INLINEstatic inline PetscInt PetscIntSumTruncate(PetscInt a,PetscInt b)

2099

{

2100

PetscInt64 r;

2101

2102

r = ((PetscInt64)a) + ((PetscInt64)b);

2103

if (r > PETSC_MAX_INT2147483647 - 100) r = PETSC_MAX_INT2147483647 - 100;

2104

return (PetscInt) r;

2105

}

2106

2107

/*@C

2108

2109

PetscIntMultError - Computes the product of two positive PetscInt and generates an error with overflow.

2110

2111

Not Collective

2112

2113

Input Parameter:

2114

+ a - the PetscInt value

2115

- b - the second value

2116

2117

Output Parameter:ma

2118

. result - the result as a PetscInt value, or NULL if you do not want the result, you just want to check if it overflows

2119

2120

Use PetscInt64Mult() to compute the product of two 32 bit PetscInt and store in a PetscInt64

2121

Use PetscIntMultTruncate() to compute the product of two PetscInt and truncate it to fit in a PetscInt

2122

2123

Not available from Fortran

2124

2125

Developers Note: We currently assume that PetscInt addition does not overflow, this is obviously wrong but requires many more checks.

2126

2127

Level: advanced

2128

2129

.seealso: PetscBLASInt, PetscMPIInt, PetscInt, PetscBLASIntCast(), PetscIntMult64(), PetscIntSumError()

2130

@*/

2131

PETSC_STATIC_INLINEstatic inline PetscErrorCode PetscIntMultError(PetscInt a,PetscInt b,PetscInt *result)

2132

{

2133

PetscInt64 r;

2134

2135

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

2136

r = PetscInt64Mult(a,b)((PetscInt64)(a))*((PetscInt64)(b));

2137

#if !defined(PETSC_USE_64BIT_INDICES)

2138

if (r > PETSC_MAX_INT2147483647) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_SUP,"Product of two integer %d %d overflow, you must ./configure PETSc with --with-64-bit-indices for the case you are running",a,b)return PetscError(((MPI_Comm)0x44000001),2138,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscsys.h"
,56,PETSC_ERROR_INITIAL,"Product of two integer %d %d overflow, you must ./configure PETSc with --with-64-bit-indices for the case you are running"
,a,b);

2139

#endif

2140

if (result) *result = (PetscInt) r;

2141

2142

}

2143

2144

/*@C

2145

2146

PetscIntSumError - Computes the sum of two positive PetscInt and generates an error with overflow.

2147

2148

Not Collective

2149

2150

Input Parameter:

2151

+ a - the PetscInt value

2152

- b - the second value

2153

2154

Output Parameter:ma

2155

. c - the result as a PetscInt value, or NULL if you do not want the result, you just want to check if it overflows

2156

2157

Use PetscInt64Mult() to compute the product of two 32 bit PetscInt and store in a PetscInt64

2158

Use PetscIntMultTruncate() to compute the product of two PetscInt and truncate it to fit in a PetscInt

2159

2160

Not available from Fortran

2161

2162

Level: advanced

2163

2164

.seealso: PetscBLASInt, PetscMPIInt, PetscInt, PetscBLASIntCast(), PetscInt64Mult()

2165

@*/

2166

PETSC_STATIC_INLINEstatic inline PetscErrorCode PetscIntSumError(PetscInt a,PetscInt b,PetscInt *result)

2167

{

2168

PetscInt64 r;

2169

2170

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

2171

r = ((PetscInt64)a) + ((PetscInt64)b);

2172

#if !defined(PETSC_USE_64BIT_INDICES)

2173

if (r > PETSC_MAX_INT2147483647) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_SUP,"Sum of two integer %d %d overflow, you must ./configure PETSc with --with-64-bit-indices for the case you are running",a,b)return PetscError(((MPI_Comm)0x44000001),2173,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscsys.h"
,56,PETSC_ERROR_INITIAL,"Sum of two integer %d %d overflow, you must ./configure PETSc with --with-64-bit-indices for the case you are running"
,a,b);

2174

#endif

2175

if (result) *result = (PetscInt) r;

2176

2177

}

2178

2179

2180

The IBM include files define hz, here we hide it so that it may be used as a regular user variable.

2181

2182

#if defined(hz)

2183

# undef hz

2184

#endif

2185

2186

#include <limits.h>

2187

2188

/* The number of bits in a byte */

2189

2190

#define PETSC_BITS_PER_BYTE8 CHAR_BIT8

2191

2192

/* For arrays that contain filenames or paths */

2193

2194

#if defined(PETSC_HAVE_SYS_PARAM_H1)

2195

# include <sys/param.h>

2196

#endif

2197

#if defined(PETSC_HAVE_SYS_TYPES_H1)

2198

# include <sys/types.h>

2199

#endif

2200

#if defined(MAXPATHLEN4096)

2201

# define PETSC_MAX_PATH_LEN4096 MAXPATHLEN4096

2202

#elif defined(MAX_PATH)

2203

# define PETSC_MAX_PATH_LEN4096 MAX_PATH

2204

#elif defined(_MAX_PATH)

2205

# define PETSC_MAX_PATH_LEN4096 _MAX_PATH

2206

#else

2207

# define PETSC_MAX_PATH_LEN4096 4096

2208

#endif

2209

2210

/*MC

2211

2212

PETSC_VERSION - This manual page provides information about how PETSc documents and uses its version information. This information is available to both C/C++

2213

and Fortran compilers when petscsys.h is included.

2214

2215

2216

The current PETSc version and the API for accessing it are defined in petscversion.h

2217

2218

The complete version number is given as the triple PETSC_VERSION_MAJOR.PETSC_VERSION_MINOR.PETSC_VERSION_SUBMINOR (in short hand x.y.z)

2219

2220

A change in the minor version number (y) indicates possible/likely changes in the PETSc API. Note this is different than with the semantic versioning convention

2221

where only a change in the major version number (x) indicates a change in the API.

2222

2223

A subminor greater than zero indicates a patch release. Version x.y.z maintains source and binary compatibility with version x.y.w for all z and w

2224

2225

Use the macros PETSC_VERSION_EQ(x,y,z), PETSC_VERSION_LT(x,y,z), PETSC_VERSION_LE(x,y,z), PETSC_VERSION_GT(x,y,z),

2226

PETSC_VERSION_GE(x,y,z) to determine if the current version is equal to, less than, less than or equal to, greater than or greater than or equal to a given

2227

version number (x.y.z).

2228

2229

PETSC_RELEASE_DATE is the date the x.y version was released (i.e. the version before any patch releases)

2230

2231

PETSC_VERSION_DATE is the date the x.y.z version was released

2232

2233

PETSC_VERSION_GIT is the last git commit to the repository given in the form vx.y.z-wwwww

2234

2235

PETSC_VERSION_DATE_GIT is the date of the last git commit to the repository

2236

2237

Level: intermediate

2238

2239

PETSC_VERSION_() and PETSC_VERSION_PATCH are deprecated and will eventually be removed. For several releases PETSC_VERSION_PATCH is always 0

2240

2241

M*/

2242

2243

/*MC

2244

2245

UsingFortran - To use PETSc with Fortran you must use both PETSc include files and modules. At the beginning

2246

of every function and module definition you need something like

2247

2248

2249

$#include "petsc/finclude/petscXXX.h"

2250

$ use petscXXX

2251

2252

You can declare PETSc variables using either of the following.

2253

2254

$ XXX variablename

2255

$ type(tXXX) variablename

2256

2257

For example,

2258

2259

$#include "petsc/finclude/petscvec.h"

2260

$ use petscvec

2261

2262

$ Vec b

2263

$ type(tVec) x

2264

2265

Level: beginner

2266

2267

M*/

2268

2269

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscGetArchType(char[],size_t);

2270

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscGetHostName(char[],size_t);

2271

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscGetUserName(char[],size_t);

2272

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscGetProgramName(char[],size_t);

2273

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSetProgramName(const char[]);

2274

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscGetDate(char[],size_t);

2275

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscGetVersion(char[], size_t);

2276

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscGetVersionNumber(PetscInt*,PetscInt*,PetscInt*,PetscInt*);

2277

2278

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSortInt(PetscInt,PetscInt[]);

2279

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSortedRemoveDupsInt(PetscInt*,PetscInt[]);

2280

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSortRemoveDupsInt(PetscInt*,PetscInt[]);

2281

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscFindInt(PetscInt, PetscInt, const PetscInt[], PetscInt*);

2282

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscFindMPIInt(PetscMPIInt, PetscInt, const PetscMPIInt[], PetscInt*);

2283

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSortIntWithPermutation(PetscInt,const PetscInt[],PetscInt[]);

2284

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSortStrWithPermutation(PetscInt,const char*[],PetscInt[]);

2285

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSortIntWithArray(PetscInt,PetscInt[],PetscInt[]);

2286

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSortIntWithArrayPair(PetscInt,PetscInt[],PetscInt[],PetscInt[]);

2287

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSortMPIInt(PetscInt,PetscMPIInt[]);

2288

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSortRemoveDupsMPIInt(PetscInt*,PetscMPIInt[]);

2289

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSortMPIIntWithArray(PetscMPIInt,PetscMPIInt[],PetscMPIInt[]);

2290

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSortMPIIntWithIntArray(PetscMPIInt,PetscMPIInt[],PetscInt[]);

2291

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSortIntWithScalarArray(PetscInt,PetscInt[],PetscScalar[]);

2292

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSortIntWithDataArray(PetscInt,PetscInt[],void*,size_t,void*);

2293

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSortReal(PetscInt,PetscReal[]);

2294

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSortRealWithArrayInt(PetscInt,PetscReal[],PetscInt[]);

2295

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSortRealWithPermutation(PetscInt,const PetscReal[],PetscInt[]);

2296

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSortRemoveDupsReal(PetscInt*,PetscReal[]);

2297

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscFindReal(PetscReal,PetscInt,const PetscReal[],PetscReal,PetscInt*);

2298

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSortSplit(PetscInt,PetscInt,PetscScalar[],PetscInt[]);

2299

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSortSplitReal(PetscInt,PetscInt,PetscReal[],PetscInt[]);

2300

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscProcessTree(PetscInt,const PetscBool [],const PetscInt[],PetscInt*,PetscInt**,PetscInt**,PetscInt**,PetscInt**);

2301

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscMergeIntArrayPair(PetscInt,const PetscInt[],const PetscInt[],PetscInt,const PetscInt[],const PetscInt[],PetscInt*,PetscInt**,PetscInt**);

2302

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscMergeIntArray(PetscInt,const PetscInt[],PetscInt,const PetscInt[],PetscInt*,PetscInt**);

2303

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscMergeMPIIntArray(PetscInt,const PetscMPIInt[],PetscInt,const PetscMPIInt[],PetscInt*,PetscMPIInt**);

2304

2305

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSetDisplay(void);

2306

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscGetDisplay(char[],size_t);

2307

2308

/*J

2309

PetscRandomType - String with the name of a PETSc randomizer

2310

2311

Level: beginner

2312

2313

Notes:

2314

To use SPRNG or RANDOM123 you must have ./configure PETSc

2315

with the option --download-sprng or --download-random123

2316

2317

.seealso: PetscRandomSetType(), PetscRandom, PetscRandomCreate()

2318

J*/

2319

typedef const char* PetscRandomType;

2320

#define PETSCRAND"rand" "rand"

2321

#define PETSCRAND48"rand48" "rand48"

2322

#define PETSCSPRNG"sprng" "sprng"

2323

#define PETSCRANDER48"rander48" "rander48"

2324

#define PETSCRANDOM123"random123" "random123"

2325

2326

/* Logging support */

2327

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscClassId PETSC_RANDOM_CLASSID;

2328

2329

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscRandomInitializePackage(void);

2330

2331

/* Dynamic creation and loading functions */

2332

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscFunctionList PetscRandomList;

2333

2334

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscRandomRegister(const char[],PetscErrorCode (*)(PetscRandom));

2335

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscRandomSetType(PetscRandom, PetscRandomType);

2336

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscRandomSetFromOptions(PetscRandom);

2337

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscRandomGetType(PetscRandom, PetscRandomType*);

2338

PETSC_STATIC_INLINEstatic inline PetscErrorCode PetscRandomViewFromOptions(PetscRandom A,PetscObject obj,const char name[]) {return PetscObjectViewFromOptions((PetscObject)A,obj,name);}

2339

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscRandomView(PetscRandom,PetscViewer);

2340

2341

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscRandomCreate(MPI_Comm,PetscRandom*);

2342

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscRandomGetValue(PetscRandom,PetscScalar*);

2343

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscRandomGetValueReal(PetscRandom,PetscReal*);

2344

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscRandomGetInterval(PetscRandom,PetscScalar*,PetscScalar*);

2345

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscRandomSetInterval(PetscRandom,PetscScalar,PetscScalar);

2346

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscRandomSetSeed(PetscRandom,unsigned long);

2347

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscRandomGetSeed(PetscRandom,unsigned long *);

2348

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscRandomSeed(PetscRandom);

2349

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscRandomDestroy(PetscRandom*);

2350

2351

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscGetFullPath(const char[],char[],size_t);

2352

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscGetRelativePath(const char[],char[],size_t);

2353

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscGetWorkingDirectory(char[],size_t);

2354

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscGetRealPath(const char[],char[]);

2355

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscGetHomeDirectory(char[],size_t);

2356

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscTestFile(const char[],char,PetscBool *);

2357

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscTestDirectory(const char[],char,PetscBool *);

2358

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscMkdir(const char[]);

2359

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscMkdtemp(char[]);

2360

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscRMTree(const char[]);

2361

2362

PETSC_STATIC_INLINEstatic inline PetscBool PetscBinaryBigEndian(void) {long _petsc_v = 1; return ((char*)&_petsc_v)[0] ? PETSC_FALSE : PETSC_TRUE;}

2363

2364

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscBinaryRead(int,void*,PetscInt,PetscInt*,PetscDataType);

2365

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscBinarySynchronizedRead(MPI_Comm,int,void*,PetscInt,PetscInt*,PetscDataType);

2366

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscBinaryWrite(int,void*,PetscInt,PetscDataType,PetscBool);

2367

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscBinarySynchronizedWrite(MPI_Comm,int,void*,PetscInt,PetscDataType,PetscBool);

2368

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscBinaryOpen(const char[],PetscFileMode,int *);

2369

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscBinaryClose(int);

2370

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSharedTmp(MPI_Comm,PetscBool *);

2371

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSharedWorkingDirectory(MPI_Comm,PetscBool *);

2372

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscGetTmp(MPI_Comm,char[],size_t);

2373

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscFileRetrieve(MPI_Comm,const char[],char[],size_t,PetscBool *);

2374

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscLs(MPI_Comm,const char[],char[],size_t,PetscBool *);

2375

#if defined(PETSC_USE_SOCKET_VIEWER1)

2376

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscOpenSocket(const char[],int,int*);

2377

#endif

2378

2379

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscBinarySeek(int,off_t,PetscBinarySeekType,off_t*);

2380

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscBinarySynchronizedSeek(MPI_Comm,int,off_t,PetscBinarySeekType,off_t*);

2381

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscByteSwap(void *,PetscDataType,PetscInt);

2382

2383

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSetDebugTerminal(const char[]);

2384

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSetDebugger(const char[],PetscBool );

2385

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSetDefaultDebugger(void);

2386

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSetDebuggerFromString(const char*);

2387

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscAttachDebugger(void);

2388

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscStopForDebugger(void);

2389

2390

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscGatherNumberOfMessages(MPI_Comm,const PetscMPIInt[],const PetscMPIInt[],PetscMPIInt*);

2391

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscGatherMessageLengths(MPI_Comm,PetscMPIInt,PetscMPIInt,const PetscMPIInt[],PetscMPIInt**,PetscMPIInt**);

2392

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscGatherMessageLengths2(MPI_Comm,PetscMPIInt,PetscMPIInt,const PetscMPIInt[],const PetscMPIInt[],PetscMPIInt**,PetscMPIInt**,PetscMPIInt**);

2393

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscPostIrecvInt(MPI_Comm,PetscMPIInt,PetscMPIInt,const PetscMPIInt[],const PetscMPIInt[],PetscInt***,MPI_Request**);

2394

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscPostIrecvScalar(MPI_Comm,PetscMPIInt,PetscMPIInt,const PetscMPIInt[],const PetscMPIInt[],PetscScalar***,MPI_Request**);

2395

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscCommBuildTwoSided(MPI_Comm,PetscMPIInt,MPI_Datatype,PetscMPIInt,const PetscMPIInt*,const void*,PetscMPIInt*,PetscMPIInt**,void*)

2396

PetscAttrMPIPointerWithType(6,3);

2397

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscCommBuildTwoSidedF(MPI_Comm,PetscMPIInt,MPI_Datatype,PetscMPIInt,const PetscMPIInt[],const void*,PetscMPIInt*,PetscMPIInt**,void*,PetscMPIInt,

2398

PetscErrorCode (*send)(MPI_Comm,const PetscMPIInt[],PetscMPIInt,PetscMPIInt,void*,MPI_Request[],void*),

2399

PetscErrorCode (*recv)(MPI_Comm,const PetscMPIInt[],PetscMPIInt,void*,MPI_Request[],void*),void *ctx)

2400

PetscAttrMPIPointerWithType(6,3);

2401

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscCommBuildTwoSidedFReq(MPI_Comm,PetscMPIInt,MPI_Datatype,PetscMPIInt,const PetscMPIInt[],const void*,PetscMPIInt*,PetscMPIInt**,void*,PetscMPIInt,

2402

MPI_Request**,MPI_Request**,

2403

PetscErrorCode (*send)(MPI_Comm,const PetscMPIInt[],PetscMPIInt,PetscMPIInt,void*,MPI_Request[],void*),

2404

PetscErrorCode (*recv)(MPI_Comm,const PetscMPIInt[],PetscMPIInt,void*,MPI_Request[],void*),void *ctx)

2405

PetscAttrMPIPointerWithType(6,3);

2406

2407

PETSC_EXTERNextern __attribute__((visibility ("default"))) const char *const PetscBuildTwoSidedTypes[];

2408

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscCommBuildTwoSidedSetType(MPI_Comm,PetscBuildTwoSidedType);

2409

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscCommBuildTwoSidedGetType(MPI_Comm,PetscBuildTwoSidedType*);

2410

2411

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSSEIsEnabled(MPI_Comm,PetscBool*,PetscBool*);

2412

2413

PETSC_EXTERNextern __attribute__((visibility ("default"))) MPI_Comm PetscObjectComm(PetscObject);

2414

2415

PETSC_EXTERNextern __attribute__((visibility ("default"))) const char *const PetscSubcommTypes[];

2416

2417

struct _n_PetscSubcomm {

2418

MPI_Comm parent; /* parent communicator */

2419

MPI_Comm dupparent; /* duplicate parent communicator, under which the processors of this subcomm have contiguous rank */

2420

MPI_Comm child; /* the sub-communicator */

2421

PetscMPIInt n; /* num of subcommunicators under the parent communicator */

2422

PetscMPIInt color; /* color of processors belong to this communicator */

2423

PetscMPIInt *subsize; /* size of subcommunicator[color] */

2424

PetscSubcommType type;

2425

char *subcommprefix;

2426

};

2427

2428

PETSC_STATIC_INLINEstatic inline MPI_Comm PetscSubcommParent(PetscSubcomm scomm) {return scomm->parent;}

2429

PETSC_STATIC_INLINEstatic inline MPI_Comm PetscSubcommChild(PetscSubcomm scomm) {return scomm->child;}

←

Access to field 'child' results in a dereference of a null pointer (loaded from variable 'scomm')

2430

PETSC_STATIC_INLINEstatic inline MPI_Comm PetscSubcommContiguousParent(PetscSubcomm scomm) {return scomm->dupparent;}

2431

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSubcommCreate(MPI_Comm,PetscSubcomm*);

2432

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSubcommDestroy(PetscSubcomm*);

2433

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSubcommSetNumber(PetscSubcomm,PetscInt);

2434

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSubcommSetType(PetscSubcomm,PetscSubcommType);

2435

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSubcommSetTypeGeneral(PetscSubcomm,PetscMPIInt,PetscMPIInt);

2436

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSubcommView(PetscSubcomm,PetscViewer);

2437

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSubcommSetFromOptions(PetscSubcomm);

2438

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSubcommSetOptionsPrefix(PetscSubcomm,const char[]);

2439

2440

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscHeapCreate(PetscInt,PetscHeap*);

2441

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscHeapAdd(PetscHeap,PetscInt,PetscInt);

2442

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscHeapPop(PetscHeap,PetscInt*,PetscInt*);

2443

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscHeapPeek(PetscHeap,PetscInt*,PetscInt*);

2444

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscHeapStash(PetscHeap,PetscInt,PetscInt);

2445

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscHeapUnstash(PetscHeap);

2446

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscHeapDestroy(PetscHeap*);

2447

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscHeapView(PetscHeap,PetscViewer);

2448

2449

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscProcessPlacementView(PetscViewer);

2450

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscShmCommGet(MPI_Comm,PetscShmComm*);

2451

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscShmCommGlobalToLocal(PetscShmComm,PetscMPIInt,PetscMPIInt*);

2452

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscShmCommLocalToGlobal(PetscShmComm,PetscMPIInt,PetscMPIInt*);

2453

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscShmCommGetMpiShmComm(PetscShmComm,MPI_Comm*);

2454

2455

/* routines to better support OpenMP multithreading needs of some PETSc third party libraries */

2456

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscOmpCtrlCreate(MPI_Comm,PetscInt,PetscOmpCtrl*);

2457

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscOmpCtrlGetOmpComms(PetscOmpCtrl,MPI_Comm*,MPI_Comm*,PetscBool*);

2458

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscOmpCtrlDestroy(PetscOmpCtrl*);

2459

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscOmpCtrlBarrier(PetscOmpCtrl);

2460

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscOmpCtrlOmpRegionOnMasterBegin(PetscOmpCtrl);

2461

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscOmpCtrlOmpRegionOnMasterEnd(PetscOmpCtrl);

2462

2463

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSegBufferCreate(size_t,size_t,PetscSegBuffer*);

2464

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSegBufferDestroy(PetscSegBuffer*);

2465

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSegBufferGet(PetscSegBuffer,size_t,void*);

2466

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSegBufferExtractAlloc(PetscSegBuffer,void*);

2467

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSegBufferExtractTo(PetscSegBuffer,void*);

2468

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSegBufferExtractInPlace(PetscSegBuffer,void*);

2469

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSegBufferGetSize(PetscSegBuffer,size_t*);

2470

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscSegBufferUnuse(PetscSegBuffer,size_t);

2471

2472

2473

/* Type-safe wrapper to encourage use of PETSC_RESTRICT. Does not use PetscFunctionBegin because the error handling

2474

* prevents the compiler from completely erasing the stub. This is called in inner loops so it has to be as fast as

2475

* possible. */

2476

PETSC_STATIC_INLINEstatic inline PetscErrorCode PetscSegBufferGetInts(PetscSegBuffer seg,PetscInt count,PetscInt *PETSC_RESTRICT__restrict *slot) {return PetscSegBufferGet(seg,(size_t)count,(void**)slot);}

2477

2478

extern PetscOptionsHelpPrinted PetscOptionsHelpPrintedSingleton;

2479

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscOptionsHelpPrintedDestroy(PetscOptionsHelpPrinted*);

2480

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscOptionsHelpPrintedCreate(PetscOptionsHelpPrinted*);

2481

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscOptionsHelpPrintedCheck(PetscOptionsHelpPrinted,const char*,const char*,PetscBool*);

2482

2483

#include <stdarg.h>

2484

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscVSNPrintf(char*,size_t,const char[],size_t*,va_list);

2485

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode (*PetscVFPrintf)(FILE*,const char[],va_list);

2486

2487

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscSegBuffer PetscCitationsList;

2488

2489

/*@C

2490

PetscCitationsRegister - Register a bibtex item to obtain credit for an implemented algorithm used in the code.

2491

2492

Not Collective - only what is registered on rank 0 of PETSC_COMM_WORLD will be printed

2493

2494

Input Parameters:

2495

+ cite - the bibtex item, formated to displayed on multiple lines nicely

2496

- set - a boolean variable initially set to PETSC_FALSE; this is used to insure only a single registration of the citation

2497

2498

Level: intermediate

2499

2500

Not available from Fortran

2501

2502

Options Database:

2503

. -citations [filename] - print out the bibtex entries for the given computation

2504

@*/

2505

PETSC_STATIC_INLINEstatic inline PetscErrorCode PetscCitationsRegister(const char cit[],PetscBool *set)

2506

{

2507

size_t len;

2508

char *vstring;

2509

PetscErrorCode ierr;

2510

2511

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

2512

if (set && *set) 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);

2513

ierr = PetscStrlen(cit,&len);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),2513,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscsys.h"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

2514

ierr = PetscSegBufferGet(PetscCitationsList,len,&vstring);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),2514,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscsys.h"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

2515

ierr = PetscArraycpy(vstring,cit,len)((sizeof(*(vstring)) != sizeof(*(cit))) || PetscMemcpy(vstring
,cit,(len)*sizeof(*(vstring))));;CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),2515,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscsys.h"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

2516

if (set) *set = PETSC_TRUE;

2517

2518

}

2519

2520

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscURLShorten(const char[],char[],size_t);

2521

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscGoogleDriveAuthorize(MPI_Comm,char[],char[],size_t);

2522

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscGoogleDriveRefresh(MPI_Comm,const char[],char[],size_t);

2523

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscGoogleDriveUpload(MPI_Comm,const char[],const char []);

2524

2525

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscBoxAuthorize(MPI_Comm,char[],char[],size_t);

2526

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscBoxRefresh(MPI_Comm,const char[],char[],char[],size_t);

2527

2528

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscGlobusGetTransfers(MPI_Comm,const char[],char[],size_t);

2529

2530

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscTextBelt(MPI_Comm,const char[],const char[],PetscBool*);

2531

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscTellMyCell(MPI_Comm,const char[],const char[],PetscBool*);

2532

2533

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscPullJSONValue(const char[],const char[],char[],size_t,PetscBool*);

2534

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscPushJSONValue(char[],const char[],const char[],size_t);

2535

2536

2537

#if defined(PETSC_USE_DEBUG1)

2538

2539

Verify that all processes in the communicator have called this from the same line of code

2540

2541

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode PetscAllreduceBarrierCheck(MPI_Comm,PetscMPIInt,int,const char*,const char *);

2542

2543

/*MC

2544

MPIU_Allreduce - a PETSc replacement for MPI_Allreduce() that tries to determine if the call from all the MPI processes occur from the

2545

same place in the PETSc code. This helps to detect bugs where different MPI processes follow different code paths

2546

resulting in inconsistent and incorrect calls to MPI_Allreduce().

2547

2548

Collective

2549

2550

Synopsis:

2551

#include <petscsys.h>

2552

PetscErrorCode MPIU_Allreduce(void *indata,void *outdata,PetscMPIInt count,MPI_Datatype datatype, MPI_Op op, MPI_Comm comm);

2553

2554

Input Parameters:

2555

+ indata - pointer to the input data to be reduced

2556

. count - the number of MPI data items in indata and outdata

2557

. datatype - the MPI datatype, for example MPI_INT

2558

. op - the MPI operation, for example MPI_SUM

2559

- comm - the MPI communicator on which the operation occurs

2560

2561

Output Parameter:

2562

. outdata - the reduced values

2563

2564

Notes:

2565

In optimized mode this directly calls MPI_Allreduce()

2566

2567

Level: developer

2568

2569

.seealso: MPI_Allreduce()

2570

M*/

2571

#define MPIU_Allreduce(a,b,c,d,e,fcomm)(PetscAllreduceBarrierCheck(fcomm,c,2571,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscsys.h"
) || ((petsc_allreduce_ct += PetscMPIParallelComm((fcomm)),0)
|| MPI_Allreduce((a),(b),(c),(d),(e),(fcomm)))) (PetscAllreduceBarrierCheck(fcomm,c,__LINE__2571,PETSC_FUNCTION_NAME__func__,__FILE__"/sandbox/petsc/petsc.next-tmp/include/petscsys.h") || MPI_Allreduce(a,b,c,d,e,fcomm)((petsc_allreduce_ct += PetscMPIParallelComm((fcomm)),0) || MPI_Allreduce
((a),(b),(c),(d),(e),(fcomm))))

2572

#else

2573

#define MPIU_Allreduce(a,b,c,d,e,fcomm)(PetscAllreduceBarrierCheck(fcomm,c,2573,__func__,"/sandbox/petsc/petsc.next-tmp/include/petscsys.h"
) || ((petsc_allreduce_ct += PetscMPIParallelComm((fcomm)),0)
|| MPI_Allreduce((a),(b),(c),(d),(e),(fcomm)))) MPI_Allreduce(a,b,c,d,e,fcomm)((petsc_allreduce_ct += PetscMPIParallelComm((fcomm)),0) || MPI_Allreduce
((a),(b),(c),(d),(e),(fcomm)))

2574

#endif

2575

2576

#if defined(PETSC_HAVE_MPI_WIN_CREATE_FEATURE1)

2577

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode MPIU_Win_allocate_shared(MPI_Aint,PetscMPIInt,MPI_Info,MPI_Comm,void*,MPI_Win*);

2578

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscErrorCode MPIU_Win_shared_query(MPI_Win,PetscMPIInt,MPI_Aint*,PetscMPIInt*,void*);

2579

#endif

2580

2581

2582

Returned from PETSc functions that are called from MPI, such as related to attributes

2583

2584

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscMPIInt PETSC_MPI_ERROR_CLASS;

2585

PETSC_EXTERNextern __attribute__((visibility ("default"))) PetscMPIInt PETSC_MPI_ERROR_CODE;

2586

2587

#endif