CFD/hypre
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
3bbc730d37
hypre/struct_matrix_vector/computation.c
falgout 0432470ab0 - Added new StructCoarsen routine to improve setup phase scalability. 
- Modified Neighbor and Grid classes, and in particular, the routines
  BoxNeighborsAssemble and StructGridAssemble.
- Grid boxes now have associated unique IDs to aid in implementation.
2000-03-21 16:52:39 +00:00

406 lines
13 KiB
C
Raw Blame History

/*BHEADER**********************************************************************
* (c) 1997 The Regents of the University of California
*
* See the file COPYRIGHT_and_DISCLAIMER for a complete copyright
* notice, contact person, and disclaimer.
*
* $Revision$
*********************************************************************EHEADER*/
/******************************************************************************
*
*****************************************************************************/
#include "headers.h"
/*==========================================================================*/
/*==========================================================================*/
/** Return descriptions of communications and computations patterns
for a given grid-stencil computation. If HYPRE\_OVERLAP\_COMM\_COMP
is defined, then the patterns are computed to allow for overlapping
communications and computations. The default is no overlap.
{\bf Note:} This routine assumes that the grid boxes do not overlap.
{\bf Input files:}
headers.h
@return Error code.
@param grid [IN]
computational grid
@param stencil [IN]
computational stencil
@param send_boxes_ptr [OUT]
description of the grid data to be sent to other processors.
@param recv_boxes_ptr [OUT]
description of the grid data to be received from other processors.
@param send_processes_ptr [OUT]
processors that data is to be sent to.
@param recv_processes_ptr [OUT]
processors that data is to be received from.
@param indt_boxes_ptr [OUT]
description of computations that do not depend on communicated data.
@param dept_boxes_ptr [OUT]
description of computations that depend on communicated data.
@see hypre_CreateCommInfoFromStencil */
/*--------------------------------------------------------------------------*/
int
hypre_CreateComputeInfo( hypre_StructGrid *grid,
hypre_StructStencil *stencil,
hypre_BoxArrayArray **send_boxes_ptr,
hypre_BoxArrayArray **recv_boxes_ptr,
int ***send_processes_ptr,
int ***recv_processes_ptr,
hypre_BoxArrayArray **indt_boxes_ptr,
hypre_BoxArrayArray **dept_boxes_ptr )
{
int ierr = 0;
/* output variables */
hypre_BoxArrayArray *send_boxes;
hypre_BoxArrayArray *recv_boxes;
int **send_processes;
int **recv_processes;
hypre_BoxArrayArray *indt_boxes;
hypre_BoxArrayArray *dept_boxes;
/* internal variables */
hypre_BoxArray *boxes;
hypre_BoxArray *cbox_array;
hypre_Box *cbox;
int i;
#ifdef HYPRE_OVERLAP_COMM_COMP
hypre_Box *rembox;
hypre_Index *stencil_shape;
int border[3][2] = {{0, 0}, {0, 0}, {0, 0}};
int cbox_array_size;
int s, d;
#endif
/*------------------------------------------------------
* Extract needed grid info
*------------------------------------------------------*/
boxes = hypre_StructGridBoxes(grid);
/*------------------------------------------------------
* Get communication info
*------------------------------------------------------*/
hypre_CreateCommInfoFromStencil(grid, stencil,
&send_boxes, &recv_boxes,
&send_processes, &recv_processes);
#ifdef HYPRE_OVERLAP_COMM_COMP
/*------------------------------------------------------
* Compute border info
*------------------------------------------------------*/
stencil_shape = hypre_StructStencilShape(stencil);
for (s = 0; s < hypre_StructStencilSize(stencil); s++)
{
for (d = 0; d < 3; d++)
{
i = hypre_IndexD(stencil_shape[s], d);
if (i < 0)
{
border[d][0] = hypre_max(border[d][0], -i);
}
else if (i > 0)
{
border[d][1] = hypre_max(border[d][1], i);
}
}
}
/*------------------------------------------------------
* Set up the dependent boxes
*------------------------------------------------------*/
dept_boxes = hypre_BoxArrayArrayCreate(hypre_BoxArraySize(boxes));
rembox = hypre_BoxCreate();
hypre_ForBoxI(i, boxes)
{
cbox_array = hypre_BoxArrayArrayBoxArray(dept_boxes, i);
hypre_BoxArraySetSize(cbox_array, 6);
hypre_CopyBox(hypre_BoxArrayBox(boxes, i), rembox);
cbox_array_size = 0;
for (d = 0; d < 3; d++)
{
if ( (hypre_BoxVolume(rembox)) && (border[d][0]) )
{
cbox = hypre_BoxArrayBox(cbox_array, cbox_array_size);
hypre_CopyBox(rembox, cbox);
hypre_BoxIMaxD(cbox, d) =
hypre_BoxIMinD(cbox, d) + border[d][0] - 1;
hypre_BoxIMinD(rembox, d) =
hypre_BoxIMinD(cbox, d) + border[d][0];
cbox_array_size++;
}
if ( (hypre_BoxVolume(rembox)) && (border[d][1]) )
{
cbox = hypre_BoxArrayBox(cbox_array, cbox_array_size);
hypre_CopyBox(rembox, cbox);
hypre_BoxIMinD(cbox, d) =
hypre_BoxIMaxD(cbox, d) - border[d][1] + 1;
hypre_BoxIMaxD(rembox, d) =
hypre_BoxIMaxD(cbox, d) - border[d][1];
cbox_array_size++;
}
}
hypre_BoxArraySetSize(cbox_array, cbox_array_size);
}
hypre_BoxDestroy(rembox);
/*------------------------------------------------------
* Set up the independent boxes
*------------------------------------------------------*/
indt_boxes = hypre_BoxArrayArrayCreate(hypre_BoxArraySize(boxes));
hypre_ForBoxI(i, boxes)
{
cbox_array = hypre_BoxArrayArrayBoxArray(indt_boxes, i);
hypre_BoxArraySetSize(cbox_array, 1);
cbox = hypre_BoxArrayBox(cbox_array, 0);
hypre_CopyBox(hypre_BoxArrayBox(boxes, i), cbox);
for (d = 0; d < 3; d++)
{
if ( (border[d][0]) )
{
hypre_BoxIMinD(cbox, d) += border[d][0];
}
if ( (border[d][1]) )
{
hypre_BoxIMaxD(cbox, d) -= border[d][1];
}
}
}
#else
/*------------------------------------------------------
* Set up the independent boxes
*------------------------------------------------------*/
indt_boxes = hypre_BoxArrayArrayCreate(hypre_BoxArraySize(boxes));
/*------------------------------------------------------
* Set up the dependent boxes
*------------------------------------------------------*/
dept_boxes = hypre_BoxArrayArrayCreate(hypre_BoxArraySize(boxes));
hypre_ForBoxI(i, boxes)
{
cbox_array = hypre_BoxArrayArrayBoxArray(dept_boxes, i);
hypre_BoxArraySetSize(cbox_array, 1);
cbox = hypre_BoxArrayBox(cbox_array, 0);
hypre_CopyBox(hypre_BoxArrayBox(boxes, i), cbox);
}
#endif
/*------------------------------------------------------
* Return
*------------------------------------------------------*/
*send_boxes_ptr = send_boxes;
*recv_boxes_ptr = recv_boxes;
*send_processes_ptr = send_processes;
*recv_processes_ptr = recv_processes;
*indt_boxes_ptr = indt_boxes;
*dept_boxes_ptr = dept_boxes;
return ierr;
}
/*==========================================================================*/
/*==========================================================================*/
/** Create a computation package from a grid-based description of a
communication-computation pattern.
{\bf Note:}
The input boxes and processes are destroyed.
{\bf Input files:}
headers.h
@return Error code.
@param send_boxes [IN]
description of the grid data to be sent to other processors.
@param recv_boxes [IN]
description of the grid data to be received from other processors.
@param send_stride [IN]
stride to use for send data.
@param recv_stride [IN]
stride to use for receive data.
@param send_processes [IN]
processors that data is to be sent to.
@param recv_processes [IN]
processors that data is to be received from.
@param indt_boxes_ptr [IN]
description of computations that do not depend on communicated data.
@param dept_boxes_ptr [IN]
description of computations that depend on communicated data.
@param stride [IN]
stride to use for computations.
@param grid [IN]
computational grid
@param data_space [IN]
description of the stored data associated with the grid.
@param num_values [IN]
number of data values associated with each grid index.
@param compute_pkg_ptr [OUT]
pointer to a computation package
@see hypre_CommPkgCreate, hypre_ComputePkgDestroy */
/*--------------------------------------------------------------------------*/
int
hypre_ComputePkgCreate( hypre_BoxArrayArray *send_boxes,
hypre_BoxArrayArray *recv_boxes,
hypre_Index send_stride,
hypre_Index recv_stride,
int **send_processes,
int **recv_processes,
hypre_BoxArrayArray *indt_boxes,
hypre_BoxArrayArray *dept_boxes,
hypre_Index stride,
hypre_StructGrid *grid,
hypre_BoxArray *data_space,
int num_values,
hypre_ComputePkg **compute_pkg_ptr )
{
int ierr = 0;
hypre_ComputePkg *compute_pkg;
compute_pkg = hypre_CTAlloc(hypre_ComputePkg, 1);
hypre_ComputePkgCommPkg(compute_pkg) =
hypre_CommPkgCreate(send_boxes, recv_boxes,
send_stride, recv_stride,
data_space, data_space,
send_processes, recv_processes,
num_values, hypre_StructGridComm(grid),
hypre_StructGridPeriodic(grid));
hypre_ComputePkgIndtBoxes(compute_pkg) = indt_boxes;
hypre_ComputePkgDeptBoxes(compute_pkg) = dept_boxes;
hypre_CopyIndex(stride, hypre_ComputePkgStride(compute_pkg));
hypre_StructGridRef(grid, &hypre_ComputePkgGrid(compute_pkg));
hypre_ComputePkgDataSpace(compute_pkg) = data_space;
hypre_ComputePkgNumValues(compute_pkg) = num_values;
*compute_pkg_ptr = compute_pkg;
return ierr;
}
/*==========================================================================*/
/*==========================================================================*/
/** Destroy a computation package.
{\bf Input files:}
headers.h
@return Error code.
@param compute_pkg [IN/OUT]
computation package.
@see hypre_ComputePkgCreate */
/*--------------------------------------------------------------------------*/
int
hypre_ComputePkgDestroy( hypre_ComputePkg *compute_pkg )
{
int ierr = 0;
if (compute_pkg)
{
hypre_CommPkgDestroy(hypre_ComputePkgCommPkg(compute_pkg));
hypre_BoxArrayArrayDestroy(hypre_ComputePkgIndtBoxes(compute_pkg));
hypre_BoxArrayArrayDestroy(hypre_ComputePkgDeptBoxes(compute_pkg));
hypre_StructGridDestroy(hypre_ComputePkgGrid(compute_pkg));
hypre_TFree(compute_pkg);
}
return ierr;
}
/*==========================================================================*/
/*==========================================================================*/
/** Initialize a non-blocking communication exchange. The independent
computations may be done after a call to this routine, to allow for
overlap of communications and computations.
{\bf Input files:}
headers.h
@return Error code.
@param compute_pkg [IN]
computation package.
@param data [IN]
pointer to the associated data.
@param comm_handle [OUT]
communication handle.
@see hypre_FinalizeIndtComputations, hypre_ComputePkgCreate,
hypre_InitializeCommunication */
/*--------------------------------------------------------------------------*/
int
hypre_InitializeIndtComputations( hypre_ComputePkg *compute_pkg,
double *data,
hypre_CommHandle **comm_handle_ptr )
{
int ierr = 0;
hypre_CommPkg *comm_pkg = hypre_ComputePkgCommPkg(compute_pkg);
ierr = hypre_InitializeCommunication(comm_pkg, data, data, comm_handle_ptr);
return ierr;
}
/*==========================================================================*/
/*==========================================================================*/
/** Finalize a communication exchange. The dependent computations may
be done after a call to this routine.
{\bf Input files:}
headers.h
@return Error code.
@param comm_handle [IN/OUT]
communication handle.
@see hypre_InitializeIndtComputations, hypre_FinalizeCommunication */
/*--------------------------------------------------------------------------*/
int
hypre_FinalizeIndtComputations( hypre_CommHandle *comm_handle )
{
int ierr = 0;
ierr = hypre_FinalizeCommunication(comm_handle);
return ierr;
}
Reference in New Issue View Git Blame Copy Permalink