int
hypre_PointRelaxSetup( void *relax_vdata,
hypre_StructMatrix *A,
hypre_StructVector *b,
hypre_StructVector *x )
{
hypre_PointRelaxData *relax_data = (hypre_PointRelaxData *)relax_vdata;
int num_pointsets = (relax_data -> num_pointsets);
int *pointset_sizes = (relax_data -> pointset_sizes);
hypre_Index *pointset_strides = (relax_data -> pointset_strides);
hypre_Index **pointset_indices = (relax_data -> pointset_indices);
hypre_StructVector *t;
int diag_rank;
hypre_ComputePkg **compute_pkgs;
hypre_Index unit_stride;
hypre_Index diag_index;
hypre_IndexRef stride;
hypre_IndexRef index;
hypre_StructGrid *grid;
hypre_StructStencil *stencil;
hypre_BoxArrayArray *send_boxes;
hypre_BoxArrayArray *recv_boxes;
int **send_processes;
int **recv_processes;
hypre_BoxArrayArray *indt_boxes;
hypre_BoxArrayArray *dept_boxes;
hypre_BoxArrayArray *orig_indt_boxes;
hypre_BoxArrayArray *orig_dept_boxes;
hypre_BoxArrayArray *box_aa;
hypre_BoxArray *box_a;
hypre_Box *box;
int box_aa_size;
int box_a_size;
hypre_BoxArrayArray *new_box_aa;
hypre_BoxArray *new_box_a;
hypre_Box *new_box;
double scale;
int frac;
int i, j, k, p, m, compute_i;
int ierr = 0;
/*----------------------------------------------------------
* Set up the temp vector
*----------------------------------------------------------*/
if ((relax_data -> t) == NULL)
{
t = hypre_StructVectorCreate(hypre_StructVectorComm(b),
hypre_StructVectorGrid(b));
hypre_StructVectorSetNumGhost(t, hypre_StructVectorNumGhost(b));
hypre_StructVectorInitialize(t);
hypre_StructVectorAssemble(t);
(relax_data -> t) = t;
}
/*----------------------------------------------------------
* Find the matrix diagonal
*----------------------------------------------------------*/
grid = hypre_StructMatrixGrid(A);
stencil = hypre_StructMatrixStencil(A);
hypre_SetIndex(diag_index, 0, 0, 0);
diag_rank = hypre_StructStencilElementRank(stencil, diag_index);
/*----------------------------------------------------------
* Set up the compute packages
*----------------------------------------------------------*/
hypre_SetIndex(unit_stride, 1, 1, 1);
compute_pkgs = hypre_CTAlloc(hypre_ComputePkg *, num_pointsets);
for (p = 0; p < num_pointsets; p++)
{
hypre_CreateComputeInfo(grid, stencil,
&send_boxes, &recv_boxes,
&send_processes, &recv_processes,
&orig_indt_boxes, &orig_dept_boxes);
stride = pointset_strides[p];
for (compute_i = 0; compute_i < 2; compute_i++)
{
switch(compute_i)
{
case 0:
box_aa = orig_indt_boxes;
break;
case 1:
box_aa = orig_dept_boxes;
break;
}
box_aa_size = hypre_BoxArrayArraySize(box_aa);
new_box_aa = hypre_BoxArrayArrayCreate(box_aa_size);
for (i = 0; i < box_aa_size; i++)
{
box_a = hypre_BoxArrayArrayBoxArray(box_aa, i);
box_a_size = hypre_BoxArraySize(box_a);
new_box_a = hypre_BoxArrayArrayBoxArray(new_box_aa, i);
hypre_BoxArraySetSize(new_box_a, box_a_size * pointset_sizes[p]);
k = 0;
for (m = 0; m < pointset_sizes[p]; m++)
{
index = pointset_indices[p][m];
for (j = 0; j < box_a_size; j++)
{
box = hypre_BoxArrayBox(box_a, j);
new_box = hypre_BoxArrayBox(new_box_a, k);
hypre_CopyBox(box, new_box);
hypre_ProjectBox(new_box, index, stride);
k++;
}
}
}
switch(compute_i)
{
case 0:
indt_boxes = new_box_aa;
break;
case 1:
dept_boxes = new_box_aa;
break;
}
}
hypre_ComputePkgCreate(send_boxes, recv_boxes,
unit_stride, unit_stride,
send_processes, recv_processes,
indt_boxes, dept_boxes,
stride, grid,
hypre_StructVectorDataSpace(x), 1,
&compute_pkgs[p]);
hypre_BoxArrayArrayDestroy(orig_indt_boxes);
hypre_BoxArrayArrayDestroy(orig_dept_boxes);
}
/*----------------------------------------------------------
* Set up the relax data structure
*----------------------------------------------------------*/
(relax_data -> A) = hypre_StructMatrixRef(A);
(relax_data -> x) = hypre_StructVectorRef(x);
(relax_data -> b) = hypre_StructVectorRef(b);
(relax_data -> diag_rank) = diag_rank;
(relax_data -> compute_pkgs) = compute_pkgs;
/*-----------------------------------------------------
* Compute flops
*-----------------------------------------------------*/
scale = 0.0;
for (p = 0; p < num_pointsets; p++)
{
stride = pointset_strides[p];
frac = hypre_IndexX(stride);
frac *= hypre_IndexY(stride);
frac *= hypre_IndexZ(stride);
scale += (pointset_sizes[p] / frac);
}
(relax_data -> flops) = scale * (hypre_StructMatrixGlobalSize(A) +
hypre_StructVectorGlobalSize(x));
return ierr;
}
hypre_CommPkg *
hypre_CommPkgCreate( hypre_BoxArrayArray *send_boxes,
hypre_BoxArrayArray *recv_boxes,
hypre_Index send_stride,
hypre_Index recv_stride,
hypre_BoxArray *send_data_space,
hypre_BoxArray *recv_data_space,
int **send_processes,
int **recv_processes,
int num_values,
MPI_Comm comm,
hypre_Index periodic )
{
hypre_CommPkg *comm_pkg;
int num_sends;
int *send_procs;
hypre_CommType **send_types;
int num_recvs;
int *recv_procs;
hypre_CommType **recv_types;
hypre_CommType *copy_from_type;
hypre_CommType *copy_to_type;
int i;
/*------------------------------------------------------
* Put arguments into hypre_CommPkg
*------------------------------------------------------*/
comm_pkg = hypre_CTAlloc(hypre_CommPkg, 1);
hypre_CommPkgNumValues(comm_pkg) = num_values;
hypre_CommPkgComm(comm_pkg) = comm;
/*------------------------------------------------------
* Set up communication information
*------------------------------------------------------*/
hypre_CommPkgCreateInfo(send_boxes, send_stride,
send_data_space, send_processes,
num_values, comm, periodic,
&num_sends, &send_procs,
&send_types, ©_from_type);
hypre_CommPkgNumSends(comm_pkg) = num_sends;
hypre_CommPkgSendProcs(comm_pkg) = send_procs;
hypre_CommPkgSendTypes(comm_pkg) = send_types;
hypre_CommPkgCopyFromType(comm_pkg) = copy_from_type;
hypre_CommPkgCreateInfo(recv_boxes, recv_stride,
recv_data_space, recv_processes,
num_values, comm, periodic,
&num_recvs, &recv_procs,
&recv_types, ©_to_type);
hypre_CommPkgNumRecvs(comm_pkg) = num_recvs;
hypre_CommPkgRecvProcs(comm_pkg) = recv_procs;
hypre_CommPkgRecvTypes(comm_pkg) = recv_types;
hypre_CommPkgCopyToType(comm_pkg) = copy_to_type;
/*------------------------------------------------------
* Destroy the input boxes and processes
*------------------------------------------------------*/
hypre_ForBoxArrayI(i, send_boxes)
hypre_TFree(send_processes[i]);
hypre_BoxArrayArrayDestroy(send_boxes);
hypre_TFree(send_processes);
hypre_ForBoxArrayI(i, recv_boxes)
hypre_TFree(recv_processes[i]);
hypre_BoxArrayArrayDestroy(recv_boxes);
hypre_TFree(recv_processes);
#if defined(HYPRE_COMM_SIMPLE) || defined(HYPRE_COMM_VOLATILE)
#else
hypre_CommPkgCommit(comm_pkg);
/* free up comm types */
for (i = 0; i < hypre_CommPkgNumSends(comm_pkg); i++)
hypre_CommTypeDestroy(hypre_CommPkgSendType(comm_pkg, i));
hypre_TFree(hypre_CommPkgSendTypes(comm_pkg));
for (i = 0; i < hypre_CommPkgNumRecvs(comm_pkg); i++)
hypre_CommTypeDestroy(hypre_CommPkgRecvType(comm_pkg, i));
hypre_TFree(hypre_CommPkgRecvTypes(comm_pkg));
#endif
return comm_pkg;
}
HYPRE_Int
hypre_CommInfoDestroy( hypre_CommInfo *comm_info )
{
HYPRE_Int **processes;
HYPRE_Int **rboxnums;
HYPRE_Int **transforms;
HYPRE_Int i, size;
size = hypre_BoxArrayArraySize(hypre_CommInfoSendBoxes(comm_info));
hypre_BoxArrayArrayDestroy(hypre_CommInfoSendBoxes(comm_info));
processes = hypre_CommInfoSendProcesses(comm_info);
for (i = 0; i < size; i++)
{
hypre_TFree(processes[i]);
}
hypre_TFree(processes);
rboxnums = hypre_CommInfoSendRBoxnums(comm_info);
if (rboxnums != NULL)
{
for (i = 0; i < size; i++)
{
hypre_TFree(rboxnums[i]);
}
hypre_TFree(rboxnums);
}
hypre_BoxArrayArrayDestroy(hypre_CommInfoSendRBoxes(comm_info));
transforms = hypre_CommInfoSendTransforms(comm_info);
if (transforms != NULL)
{
for (i = 0; i < size; i++)
{
hypre_TFree(transforms[i]);
}
hypre_TFree(transforms);
}
size = hypre_BoxArrayArraySize(hypre_CommInfoRecvBoxes(comm_info));
hypre_BoxArrayArrayDestroy(hypre_CommInfoRecvBoxes(comm_info));
processes = hypre_CommInfoRecvProcesses(comm_info);
for (i = 0; i < size; i++)
{
hypre_TFree(processes[i]);
}
hypre_TFree(processes);
rboxnums = hypre_CommInfoRecvRBoxnums(comm_info);
if (rboxnums != NULL)
{
for (i = 0; i < size; i++)
{
hypre_TFree(rboxnums[i]);
}
hypre_TFree(rboxnums);
}
hypre_BoxArrayArrayDestroy(hypre_CommInfoRecvRBoxes(comm_info));
transforms = hypre_CommInfoRecvTransforms(comm_info);
if (transforms != NULL)
{
for (i = 0; i < size; i++)
{
hypre_TFree(transforms[i]);
}
hypre_TFree(transforms);
}
hypre_TFree(hypre_CommInfoCoords(comm_info));
hypre_TFree(hypre_CommInfoDirs(comm_info));
hypre_TFree(comm_info);
return hypre_error_flag;
}
