int PUGH_EnableGroupComm(cGH *GH, const char *groupname)
{
int group; /* group index */
cGroup pgroup; /* group information */
int rc; /* return code */
#ifdef DEBUG_PUGH
printf(" PUGH_EnableGroupComm: request for group '%s'\n", groupname);
fflush(stdout);
#endif
/* get the group info from its index */
group = CCTK_GroupIndex(groupname);
CCTK_GroupData(group, &pgroup);
if (pgroup.grouptype == CCTK_SCALAR)
{
rc = 1;
}
else if (pgroup.grouptype == CCTK_GF || pgroup.grouptype == CCTK_ARRAY)
{
rc = PUGH_EnableGArrayGroupComm(PUGH_pGH(GH),
CCTK_FirstVarIndexI(group),
PUGH_ALLCOMM);
}
else
{
CCTK_WARN(1, "Unknown group type in PUGH_EnableGroupComm");
rc = 0;
}
return (rc);
}
int PUGH_SyncGroup(cGH *GH, const char *groupname)
{
cGroup pgroup; /* group information */
int group; /* group index */
int rc; /* return code */
#ifdef DEBUG_PUGH
printf (" PUGH_SyncGroup: request for group '%s'\n", groupname);
fflush (stdout);
#endif
/* get the group info from its index */
group = CCTK_GroupIndex(groupname);
if (group < 0)
{
CCTK_VWarn (1, __LINE__, __FILE__, CCTK_THORNSTRING,
"PUGH_SyncGroup: Unknown group: %s", groupname);
rc = -1;
}
else
{
CCTK_GroupData(group, &pgroup);
if (pgroup.grouptype == CCTK_SCALAR)
{
rc = 0;
CCTK_VWarn(4, __LINE__, __FILE__, CCTK_THORNSTRING,
"PUGH_SyncGroup: Synchronising scalar group: %s",groupname);
}
else if (pgroup.grouptype == CCTK_GF || pgroup.grouptype == CCTK_ARRAY)
{
rc = PUGH_SyncGArrayGroup(PUGH_pGH(GH), CCTK_FirstVarIndexI(group));
}
else
{
CCTK_WARN(1, "PUGH_SyncGroup: Unknown group type");
rc = 0;
}
}
return (rc);
}
int PUGH_DisableGroupComm(cGH *GH, const char *groupname)
{
int group; /* group index */
cGroup pgroup; /* pointer to group information */
int rc; /* return code */
pGH *pughGH;
int var;
#ifdef DEBUG_PUGH
printf(" PUGH_DisableGroupComm: request for group '%s'\n", groupname);
fflush(stdout);
#endif
/* get the group info from its index */
group = CCTK_GroupIndex(groupname);
CCTK_GroupData(group, &pgroup);
if (pgroup.grouptype == CCTK_SCALAR)
{
rc = 1;
}
else if (pgroup.grouptype == CCTK_GF || pgroup.grouptype == CCTK_ARRAY)
{
pughGH=PUGH_pGH(GH);
var = CCTK_FirstVarIndexI(group);
/* FIXME: workaround. This one is really bad ! */
rc = PUGH_DisableGArrayGroupComm(pughGH, var,(((pGA ***)pughGH->variables)[var][0])->groupcomm);
}
else
{
CCTK_WARN(1, "Unknown group type in PUGH_DisableGroupComm");
rc = 0;
}
return (rc);
}
CCTK_INT Hyperslab_DefineGlobalMappingByIndex (
const cGH *GH,
CCTK_INT vindex,
CCTK_INT dim,
const CCTK_INT *direction /* vdim*dim */,
const CCTK_INT *origin /* vdim */,
const CCTK_INT *extent /* dim */,
const CCTK_INT *downsample /* dim */,
CCTK_INT table_handle,
CCTK_INT target_proc,
t_hslabConversionFn conversion_fn,
CCTK_INT *hsize /* dim */)
{
unsigned int vdim, hdim, num_dirs;
int retval;
int stagger_index;
int myproc;
int npoints;
hslab_mapping_t *mapping;
const char *error_msg;
const pGH *pughGH; /* pointer to the current pGH */
const pGA *GA; /* the variable's GA structure from PUGH */
cGroup vinfo;
/* PUGHSlab doesn't use table information */
if (table_handle >= 0)
{
CCTK_WARN (1, "Hyperslab_DefineGlobalMappingByIndex: table information is "
"ignored");
}
/* check parameter consistency */
retval = 0;
error_msg = NULL;
if (CCTK_GroupData (CCTK_GroupIndexFromVarI (vindex), &vinfo) < 0)
{
error_msg = "invalid variable index given";
retval = -1;
}
else if (vinfo.grouptype != CCTK_GF && vinfo.grouptype != CCTK_ARRAY)
{
error_msg = "invalid variable group type given "
"(not a CCTK_GF or CCTK_ARRAY type)";
retval = -2;
}
else if (dim < 0 || dim > vinfo.dim)
{
error_msg = "invalid hyperslab dimension given";
retval = -2;
}
else if (! direction || ! origin || ! extent || ! hsize)
{
error_msg = "NULL pointer(s) passed for direction/origin/extent/hsize "
"parameters";
retval = -3;
}
else if (target_proc >= CCTK_nProcs (GH))
{
error_msg = "invalid target procesor ID given";
retval = -4;
}
else if ((pughGH = (const pGH *) PUGH_pGH (GH)) == NULL)
{
error_msg = "no PUGH GH extension registered (PUGH not activated ?)";
retval = -4;
}
else
{
for (vdim = 0; vdim < (unsigned int) vinfo.dim; vdim++)
{
retval |= origin[vdim] < 0;
if (vdim < (unsigned int) dim)
{
retval |= extent[vdim] <= 0;
if (downsample)
{
retval |= downsample[vdim] <= 0;
}
}
}
if (retval)
{
error_msg = "invalid hyperslab origin/extent/downsample vectors given";
retval = -5;
}
}
if (! retval)
{
mapping = (hslab_mapping_t *) malloc (sizeof (hslab_mapping_t));
if (mapping)
{
mapping->vectors = (int *) malloc ((6*vinfo.dim + 2*dim) * sizeof (int));
}
if (mapping == NULL || mapping->vectors == NULL)
{
if (mapping)
{
free (mapping);
}
error_msg = "couldn't allocate hyperslab mapping structure";
retval = -6;
}
}
/* return in case of errors */
if (retval)
{
CCTK_VWarn (1, __LINE__, __FILE__, CCTK_THORNSTRING,
"Hyperslab_DefineGlobalMappingByIndex: %s", error_msg);
return (retval);
}
mapping->hdim = (unsigned int) dim;
mapping->vinfo = vinfo;
mapping->target_proc = target_proc;
mapping->conversion_fn = conversion_fn;
/* assign memory for the other vectors */
mapping->local_startpoint = mapping->vectors + 0*vinfo.dim;
mapping->local_endpoint = mapping->vectors + 1*vinfo.dim;
mapping->global_startpoint = mapping->vectors + 2*vinfo.dim;
mapping->global_endpoint = mapping->vectors + 3*vinfo.dim;
mapping->do_dir = mapping->vectors + 4*vinfo.dim;
mapping->downsample = mapping->vectors + 5*vinfo.dim;
mapping->local_hsize = mapping->vectors + 6*vinfo.dim + 0*dim;
mapping->global_hsize = mapping->vectors + 6*vinfo.dim + 1*dim;
/* check direction vectors */
for (hdim = 0; hdim < mapping->hdim; hdim++)
{
num_dirs = 0;
for (vdim = 0; vdim < (unsigned int) vinfo.dim; vdim++)
{
if (direction[hdim*vinfo.dim + vdim])
{
num_dirs++;
}
}
if (num_dirs == 0)
{
free (mapping->vectors); free (mapping);
CCTK_VWarn (1, __LINE__, __FILE__, CCTK_THORNSTRING,
"Hyperslab_DefineGlobalMappingByIndex: %d-direction vector "
"is a null vector", hdim);
return (-7);
}
mapping->is_diagonal_in_3D = num_dirs == 3 && mapping->hdim == 1;
if (num_dirs != 1 && ! mapping->is_diagonal_in_3D)
{
free (mapping->vectors); free (mapping);
CCTK_VWarn (1, __LINE__, __FILE__, CCTK_THORNSTRING,
"Hyperslab_DefineGlobalMappingByIndex: %d-direction vector "
"isn't axis-orthogonal", hdim);
return (-7);
}
}
/* diagonals can be extracted from non-staggered 3D variables only */
if (mapping->is_diagonal_in_3D && vinfo.stagtype != 0)
{
free (mapping->vectors); free (mapping);
CCTK_VWarn (1, __LINE__, __FILE__, CCTK_THORNSTRING,
"Hyperslab_DefineGlobalMappingByIndex: diagonals can be "
"extracted from non-staggered 3D variables only");
return (-7);
}
for (vdim = 0; vdim < (unsigned int) vinfo.dim; vdim++)
{
mapping->do_dir[vdim] = 0;
for (hdim = 0; hdim < mapping->hdim; hdim++)
{
if (direction[hdim*vinfo.dim + vdim])
{
mapping->do_dir[vdim]++;
}
}
if (mapping->do_dir[vdim] > 1)
{
free (mapping->vectors); free (mapping);
CCTK_WARN (1, "Hyperslab_DefineGlobalMappingByIndex: duplicate direction "
"vectors given");
return (-8);
}
}
/* get the pGH pointer and the variable's GA structure */
GA = (const pGA *) pughGH->variables[vindex][0];
myproc = CCTK_MyProc (GH);
/* check extent */
for (vdim = hdim = 0; vdim < (unsigned int) vinfo.dim; vdim++)
{
if (mapping->do_dir[vdim] && hdim < mapping->hdim)
{
if (origin[vdim] + extent[hdim] > GA->extras->nsize[vdim])
{
free (mapping->vectors); free (mapping);
CCTK_VWarn (1, __LINE__, __FILE__, CCTK_THORNSTRING,
"Hyperslab_DefineGlobalMappingByIndex: extent in "
"%d-direction exceeds grid size", hdim);
return (-8);
}
hdim++;
}
else if (mapping->is_diagonal_in_3D &&
origin[vdim] + extent[0] > GA->extras->nsize[vdim])
{
free (mapping->vectors); free (mapping);
CCTK_VWarn (1, __LINE__, __FILE__, CCTK_THORNSTRING,
"Hyperslab_DefineGlobalMappingByIndex: extent in "
"%d-direction exceeds grid size", vdim);
return (-8);
}
}
/* now fill out the hyperslab mapping structure */
for (vdim = hdim = 0; vdim < (unsigned int) vinfo.dim; vdim++)
{
mapping->downsample[vdim] = 1;
if (mapping->do_dir[vdim] && hdim < mapping->hdim)
{
if (downsample)
{
mapping->downsample[vdim] = downsample[hdim];
}
mapping->global_hsize[hdim] = extent[hdim] / mapping->downsample[vdim];
if (extent[hdim] % mapping->downsample[vdim])
{
mapping->global_hsize[hdim]++;
}
/* subtract ghostzones for periodic BC */
if (GA->connectivity->perme[vdim])
{
mapping->global_hsize[hdim] -= 2 * GA->extras->nghostzones[vdim];
}
hdim++;
}
else if (mapping->is_diagonal_in_3D)
{
mapping->totals = extent[0] / mapping->downsample[0];
if (extent[0] % mapping->downsample[0])
{
mapping->totals++;
}
/* subtract ghostzones for periodic BC */
if (GA->connectivity->perme[vdim])
{
mapping->totals -= 2 * GA->extras->nghostzones[vdim];
}
if ((unsigned int) mapping->global_hsize[0] > mapping->totals)
{
mapping->global_hsize[0] = mapping->totals;
}
}
}
/* check whether the full local data patch was requested as hyperslab */
mapping->is_full_hyperslab = IsFullHyperslab (GA, origin, extent, mapping);
if (mapping->is_full_hyperslab)
{
memset (mapping->local_startpoint, 0, vinfo.dim * sizeof (int));
memcpy (mapping->local_endpoint, GA->extras->lnsize, vinfo.dim*sizeof(int));
mapping->totals = GA->extras->npoints;
}
else if (mapping->is_diagonal_in_3D)
{
/* just initialize the downsample and global_startpoint vectors */
for (vdim = 0; vdim < (unsigned int) vinfo.dim; vdim++)
{
mapping->downsample[vdim] = mapping->downsample[0];
mapping->global_startpoint[vdim] = origin[vdim];
}
}
else
{
/* compute the global endpoint */
for (vdim = hdim = 0; vdim < (unsigned int) vinfo.dim; vdim++)
{
mapping->global_endpoint[vdim] = origin[vdim] +
(mapping->do_dir[vdim] ? extent[hdim++] : 1);
}
/* compute this processor's global startpoint from the global ranges */
for (vdim = 0; vdim < (unsigned int) vinfo.dim; vdim++)
{
stagger_index = CCTK_StaggerDirIndex (vdim, vinfo.stagtype);
if (origin[vdim] < MY_GLOBAL_EP (GA->extras, myproc, stagger_index, vdim))
{
mapping->global_startpoint[vdim] = origin[vdim];
if (origin[vdim] < MY_GLOBAL_SP (GA->extras, myproc,stagger_index,vdim))
{
npoints = (MY_GLOBAL_SP (GA->extras, myproc, stagger_index, vdim)
- origin[vdim]) / mapping->downsample[vdim];
if ((MY_GLOBAL_SP (GA->extras, myproc, stagger_index, vdim)
- origin[vdim]) % mapping->downsample[vdim])
{
npoints++;
}
mapping->global_startpoint[vdim] += npoints*mapping->downsample[vdim];
}
}
else
{
mapping->global_startpoint[vdim] = -1;
}
}
/* compute the local start- and endpoint from the global ranges */
mapping->totals = 1;
for (vdim = hdim = 0; vdim < (unsigned int) vinfo.dim; vdim++)
{
stagger_index = CCTK_StaggerDirIndex (vdim, vinfo.stagtype);
if (mapping->global_startpoint[vdim] >= 0 &&
mapping->global_startpoint[vdim] < MY_GLOBAL_EP (GA->extras, myproc,
stagger_index,vdim))
{
mapping->local_startpoint[vdim] = mapping->global_startpoint[vdim] -
GA->extras->lb[myproc][vdim];
}
else
{
mapping->local_startpoint[vdim] = -1;
}
if (mapping->global_endpoint[vdim] > MY_GLOBAL_SP (GA->extras, myproc,
stagger_index, vdim))
{
mapping->local_endpoint[vdim] =
MIN (MY_LOCAL_EP (GA->extras, stagger_index, vdim),
mapping->global_endpoint[vdim] -
GA->extras->lb[myproc][vdim]);
}
else
{
mapping->local_endpoint[vdim] = -1;
}
#ifdef DEBUG
printf ("direction %d: global ranges [%d, %d), local ranges[%d, %d)\n",
vdim,
mapping->global_startpoint[vdim], mapping->global_endpoint[vdim],
mapping->local_startpoint[vdim], mapping->local_endpoint[vdim]);
#endif
if (mapping->local_endpoint[vdim] < 0 ||
mapping->local_startpoint[vdim] < 0)
{
mapping->totals = 0;
mapping->local_endpoint[vdim] = mapping->local_startpoint[vdim];
}
if (mapping->do_dir[vdim])
{
/* compute the local size in each hyperslab dimension */
mapping->local_hsize[hdim] = (mapping->local_endpoint[vdim] -
mapping->local_startpoint[vdim]) /
mapping->downsample[vdim];
if ((mapping->local_endpoint[vdim] - mapping->local_startpoint[vdim]) %
mapping->downsample[vdim])
{
mapping->local_hsize[hdim]++;
}
mapping->totals *= mapping->local_hsize[hdim];
hdim++;
}
}
} /* end of else branch for 'if (mapping->is_full_hyperslab)' */
#ifdef DEBUG
printf ("total number of hyperslab data points: %d\n", mapping->totals);
#endif
#if 0
if (mapping->totals > 0)
{
/* if requested, compute the offsets into the global hyperslab */
if (hoffset_global)
{
for (i = hdim = 0; i < vinfo.dim; i++)
{
if (mapping->do_dir[i])
{
if (mapping->is_full_hyperslab)
{
hoffset_global[hdim] = GA->extras->lb[myproc][i];
}
else
{
hoffset_global[hdim] = (mapping->global_startpoint[i] -
origin[i]) / mapping->downsample[i];
if (GA->connectivity->perme[i])
{
hoffset_global[hdim] -= GA->extras->nghostzones[i];
}
}
#ifdef DEBUG
printf ("hoffset_global, hsize in direction %d: %d, %d\n",
hdim, hoffset_global[hdim], mapping->local_hsize[hdim]);
#endif
hdim++;
}
}
}
}
#endif
/* add this mapping to the mapping list */
if (mapping_list)
{
mapping_list->prev = mapping;
}
mapping->prev = NULL;
mapping->next = mapping_list;
mapping_list = mapping;
mapping->handle = nmapping_list++;
/* set the global hsize in the return arguments */
if (hsize)
{
for (hdim = 0; hdim < mapping->hdim; hdim++)
{
hsize[hdim] = mapping->global_hsize[hdim];
}
}
return (mapping->handle);
}
/*@@
@routine PUGH_DestroyPGH
@date Thu Aug 21 11:38:10 1997
@author Paul Walker
@desc
Destroys a GH object.
@enddesc
@var GHin
@vdesc address of PUGH GH extensions object to be destroyed
@vtype pGH **
@vio in
@endvar
@@*/
void PUGH_DestroyPGH (pGH **GHin)
{
pGH *GH;
pGA *GA;
cGroup pgroup;
int i;
int variable;
int group;
int this_var;
GH = *GHin;
#ifdef CCTK_MPI
CACTUS_MPI_ERROR (MPI_Comm_free (&GH->PUGH_COMM_WORLD));
CACTUS_MPI_ERROR (MPI_Type_free (&GH->PUGH_mpi_complex));
#ifdef CCTK_REAL4
CACTUS_MPI_ERROR (MPI_Type_free (&GH->PUGH_mpi_complex8));
#endif
#ifdef CCTK_REAL8
CACTUS_MPI_ERROR (MPI_Type_free (&GH->PUGH_mpi_complex16));
#endif
#ifdef CCTK_REAL16
CACTUS_MPI_ERROR (MPI_Type_free (&GH->PUGH_mpi_complex32));
#endif
#endif
/* Great. Now go about the work of destroying me. */
variable = 0;
for(group = 0; group < CCTK_NumGroups(); group++)
{
#ifdef DEBUG_PUGH
printf("Calling Destroying Group %s\n", CCTK_GroupName(group));
fflush(stdout);
#endif
CCTK_GroupData(group,&pgroup);
if (pgroup.grouptype == CCTK_ARRAY || pgroup.grouptype == CCTK_GF)
{
GA = (pGA *) GH->variables[variable][0];
/* Destroy group comm buffers */
if (GA->groupcomm)
{
if (GA->groupcomm->commflag != PUGH_NOCOMM)
{
PUGH_DisableGArrayGroupComm (GH, variable, GA->groupcomm);
}
PUGH_DestroyComm (&GA->groupcomm);
}
/* Destroy the group's connectivity and extras structure
for CCTK_ARRAY groups.
Remember that the connectivity and extras for CCTK_GF types
are shared between all such groups and are destroyed later. */
if (GA->connectivity != GH->Connectivity[pgroup.dim-1])
{
PUGH_DestroyConnectivity (&GA->connectivity);
}
if (GA->extras != GH->GFExtras[pgroup.dim-1])
{
PUGH_DestroyPGExtras (&GA->extras);
}
}
for (this_var = 0; this_var < pgroup.numvars; this_var++, variable++)
{
for(i = 0 ; i < pgroup.numtimelevels; i++)
{
switch(pgroup.grouptype)
{
case CCTK_GF:
case CCTK_ARRAY:
PUGH_DestroyGArray(&(((pGA ***)GH->variables)[variable][i]));
break;
case CCTK_SCALAR:
if (GH->variables[variable][i])
{
free(GH->variables[variable][i]);
}
break;
}
}
free(GH->variables[variable]);
}
}
for (i=1;i<=GH->dim;i++)
{
PUGH_DestroyConnectivity(&GH->Connectivity[i-1]);
PUGH_DestroyPGExtras(&GH->GFExtras[i-1]);
}
if(GH->identity_string)
{
free(GH->identity_string);
}
free(GH->Connectivity);
free(GH->GFExtras);
free(GH->variables);
free(GH);
*GHin = NULL;
}
/*@@
@routine PUGH_DisableGroupStorage
@author Tom Goodale
@date 30 Mar 1999
@desc
Disables storage for all variables in the group
indicated by groupname.
@enddesc
@calls CCTK_GroupIndex
CCTK_GroupData
CCTK_FirstVarIndexI
PUGH_DisableGArrayGroupStorage
@var GH
@vdesc Pointer to CCTK grid hierarchy
@vtype cGH *
@vio in
@endvar
@var groupname
@vdesc name of the group to enable storage for
@vtype const char *
@vio in
@endvar
@returntype int
@returndesc
1 if storage for given group was disabled
-1 if group type is invalid
@endreturndesc
@@*/
int PUGH_DisableGroupStorage (cGH *GH, const char *groupname)
{
DECLARE_CCTK_PARAMETERS
int group; /* group index */
cGroup pgroup; /* group information */
int vtypesize, retval;
pGA ***variables;
int first_var, var, level;
int unchanged; /* count how many aren't toggled */
char *temp;
#ifdef DEBUG_PUGH
printf (" PUGH_DisableGroupStorage: request for group '%s'\n", groupname);
fflush (stdout);
#endif
group = CCTK_GroupIndex (groupname);
CCTK_GroupData (group, &pgroup);
/* get global index of first variable in group */
first_var = CCTK_FirstVarIndexI (group);
variables = (pGA ***) PUGH_pGH (GH)->variables;
/* get the group info from its index */
unchanged = 0;
retval = 1;
if (pgroup.grouptype == CCTK_GF || pgroup.grouptype == CCTK_ARRAY)
{
for (var = first_var; var < first_var+pgroup.numvars; var++)
{
for (level = 0; level < pgroup.numtimelevels; level++)
{
unchanged += PUGH_DisableGArrayDataStorage (variables[var][level]);
}
}
}
else if (pgroup.grouptype == CCTK_SCALAR)
{
vtypesize = CCTK_VarTypeSize (pgroup.vartype);
for (var = first_var; var < first_var+pgroup.numvars; var++)
{
for (level = 0; level < pgroup.numtimelevels; level++)
{
temp = (char *) variables[var][level];
if (temp[vtypesize] == PUGH_STORAGE)
{
temp[vtypesize] = PUGH_NOSTORAGE;
}
else
{
unchanged++;
}
}
}
}
else
{
CCTK_WARN (1, "Unknown group type in PUGH_DisableGroupStorage");
retval = -1;
}
/* Report on memory usage */
if (!CCTK_Equals(storage_verbose,"no") && retval >= 0)
{
if (unchanged == 0)
{
/* Memory toggled */
if (pgroup.grouptype == CCTK_GF)
{
totalnumberGF -= pgroup.numvars;
}
else if (pgroup.grouptype == CCTK_ARRAY)
{
totalnumberGA -= pgroup.numvars;
}
totalstorage -= (variables[first_var][0]->extras->npoints *
variables[first_var][0]->varsize *
pgroup.numtimelevels * pgroup.numvars) /
(float) (1024 * 1024);
if (CCTK_Equals(storage_verbose,"yes"))
{
CCTK_VInfo (CCTK_THORNSTRING, "Switched memory off for group '%s'"
" [GFs: %d GAs: %d Total Size: %6.2fMB]",
groupname, totalnumberGF, totalnumberGA, totalstorage);
}
}
else if (unchanged == pgroup.numvars)
{
/* Memory already off */
if (CCTK_Equals(storage_verbose,"yes"))
{
CCTK_VInfo (CCTK_THORNSTRING, "Memory already off for group '%s'", groupname);
}
}
else
{
CCTK_WARN (1, "PUGH_DisableGroupStorage: Inconsistency in group memory assignment");
}
}
USE_CCTK_PARAMETERS; return (retval);
}
/*@@
@routine PUGH_EnableGroupStorage
@author Tom Goodale
@date 30 Mar 1999
@desc
Enables storage for all variables in the group
indicated by groupname.
@enddesc
@calls CCTK_GroupIndex
CCTK_GroupData
PUGH_EnableScalarGroupStorage
PUGH_EnableGArrayGroupStorage
@var GH
@vdesc Pointer to CCTK grid hierarchy
@vtype cGH *
@vio in
@endvar
@var groupname
@vdesc name of the group to enable storage for
@vtype const char *
@vio in
@endvar
@returntype int
@returndesc
return code of @seeroutine PUGH_EnableScalarGroupStorage or
@seeroutine PUGH_EnableGArrayGroupStorage: <BR>
1 if storage was already enabled, or <BR>
0 if storage was successfully enabled <BR>
-1 if group type is not one of the above <BR>
-2 if an invalid GH pointer was given <BR>
-3 if invalid groupname was given
@endreturndesc
@@*/
int PUGH_EnableGroupStorage (cGH *GH, const char *groupname)
{
DECLARE_CCTK_PARAMETERS
int group; /* group index */
int first_var; /* first variable's index */
cGroup pgroup; /* group information */
int retval;
pGA *GA;
pGH *pughGH;
#ifdef DEBUG_PUGH
printf (" PUGH_EnableGroupStorage: request for group '%s'\n", groupname);
fflush (stdout);
#endif
pughGH = PUGH_pGH (GH);
group = CCTK_GroupIndex (groupname);
if (pughGH && group >= 0)
{
first_var = CCTK_FirstVarIndexI (group);
/* get the group info from its index */
CCTK_GroupData (group, &pgroup);
if (pgroup.grouptype == CCTK_SCALAR)
{
retval = PUGH_EnableScalarGroupStorage (pughGH,
first_var,
pgroup.numvars,
pgroup.numtimelevels);
}
else if (pgroup.grouptype == CCTK_GF || pgroup.grouptype == CCTK_ARRAY)
{
retval = PUGH_EnableGArrayGroupStorage (pughGH,
first_var,
pgroup.numvars,
pgroup.numtimelevels);
if (!CCTK_Equals(storage_verbose,"no") && retval == 0)
{
/* get GA pointer of first var in group */
GA = (pGA *) pughGH->variables[first_var][0];
if (pgroup.grouptype == CCTK_GF)
{
totalnumberGF += pgroup.numvars * pgroup.numtimelevels;
}
else
{
totalnumberGA += pgroup.numvars * pgroup.numtimelevels;
}
totalstorage += (GA->extras->npoints * GA->varsize *
pgroup.numtimelevels * pgroup.numvars) /
(float) (1024*1024);
if (totalstorage > maxstorage)
{
numberGF = totalnumberGF;
numberGA = totalnumberGA;
maxstorage = totalstorage;
}
/* Report on memory usage */
if (CCTK_Equals(storage_verbose,"yes"))
{
CCTK_VInfo (CCTK_THORNSTRING, "Switched memory on for group '%s'"
" [GFs: %d GAs: %d Total Size: %6.2fMB]",
groupname, totalnumberGF, totalnumberGA, totalstorage);
}
}
}
else
{
CCTK_WARN (1, "PUGH_EnableGroupStorage: Unknown group type");
retval = -1;
}
}
else
{
if (! pughGH)
{
CCTK_VWarn (1, __LINE__, __FILE__, CCTK_THORNSTRING,
"PUGH_EnableGroupStorage: Error with cctkGH pointer "
"for group %s", groupname);
retval = -2;
}
else
{
CCTK_VWarn (1, __LINE__, __FILE__, CCTK_THORNSTRING,
"PUGH_EnableGroupStorage: Invalid group %s", groupname);
retval = -3;
}
}
USE_CCTK_PARAMETERS; return (retval);
}
