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); }
/*@@ @routine PUGH_ArrayGroupSize @author Gabrielle Allen @date 11 Apr 1999 @desc Returns size of arrays in a group, in a given direction. Either group index or its name must be given, the name takes precedence. @enddesc @calls CCTK_GroupIndex CCTK_FirstVarIndexI @var GH @vdesc Pointer to CCTK grid hierarchy @vtype const cGH * @vio in @endvar @var dir @vdesc direction to return size of @vtype int @vio in @endvar @var group @vdesc index of group @vtype int @vio in @endvar @var groupname @vdesc name of group @vtype const char * @vio in @endvar @returntype const int * @returndesc pointer to the size variable for the given direction, or NULL if given direction or group index/name are invalid @endreturndesc @@*/ const int *PUGH_ArrayGroupSize (const cGH *GH, int dir, int group, const char *groupname) { int first_var; pGA *GA; const int *retval; if (groupname) { group = CCTK_GroupIndex (groupname); } first_var = CCTK_FirstVarIndexI (group); if (first_var >= 0) { /* get pointer to pGA for a timelevel of first variable in this group */ GA = (pGA *) PUGH_pGH (GH)->variables[first_var][0]; if (GA->storage == PUGH_STORAGE) { if (dir >= 0 && dir < GA->extras->dim) { retval = &GA->extras->lnsize[dir]; } else { CCTK_WARN (1, "Wrong value for dir"); retval = NULL; } } else { retval = &_cctk_one; } } else { if (groupname) { CCTK_VWarn (1, __LINE__, __FILE__, CCTK_THORNSTRING, "PUGH_ArrayGroupSize: Invalid group name '%s'", groupname); } else { CCTK_VWarn (1, __LINE__, __FILE__, CCTK_THORNSTRING, "PUGH_ArrayGroupSize: Invalid group ID %d", group); } retval = NULL; } return (retval); }
int SetCartSymGN(cGH *GH, int *sym, const char *gn) { int gi = CCTK_GroupIndex(gn); if (gi>-1) { return(SetCartSymGI(GH, sym, gi)); } else { CCTK_VWarn(1,__LINE__,__FILE__,CCTK_THORNSTRING, "Cannot find group %s in SetCartSymGN",gn); return(-1); } }
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); }
/*@@ @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); }
/*@@ @routine PUGH_QueryGroupStorage @author Gabrielle Allen @date 13 Apr 1999 @desc Checks if group has storage assigned. Either group index or its name must be given, the name takes precedence. @enddesc @calls CCTK_GroupIndex CCTK_FirstVarIndexI CCTK_GroupTypeI @var GH @vdesc Pointer to CCTK grid hierarchy @vtype const cGH * @vio in @endvar @var group @vdesc index of group @vtype int @vio in @endvar @var groupname @vdesc name of the group to be queried @vtype const char * @vio in @endvar @returntype int @returndesc 1 if storage for this group is assigned 0 if storage for this group is not assigned -1 if given group index/name is invalid @endreturndesc @@*/ int PUGH_QueryGroupStorage (const cGH *GH, int group, const char *groupname) { int first_var; int storage; int grouptype; int vtypesize; int retval; pGH *pughGH; retval = -1; if (groupname) { group = CCTK_GroupIndex (groupname); } /* get first variable in group */ first_var = CCTK_FirstVarIndexI (group); if (first_var >= 0) { pughGH = PUGH_pGH (GH); grouptype = CCTK_GroupTypeI (group); if (grouptype == CCTK_SCALAR) { vtypesize = CCTK_VarTypeSize (CCTK_VarTypeI (first_var)); storage = ((char *) pughGH->variables[first_var][0])[vtypesize]; } else if (grouptype == CCTK_GF || grouptype == CCTK_ARRAY) { storage = ((pGA *) pughGH->variables[first_var][0])->storage; } else { storage = -1; CCTK_WARN (1, "Unknown group type in PUGH_QueryGroupStorage"); } if (storage == PUGH_STORAGE) { retval = 1; } else if (storage == PUGH_NOSTORAGE) { retval = 0; } else { CCTK_WARN (1, "Inconsistency in PUGH_QueryGroupStorage"); } } else { if (groupname) { CCTK_VWarn (1, __LINE__, __FILE__, CCTK_THORNSTRING, "PUGH_ArrayGroupSize: Invalid group name '%s'", groupname); } else { CCTK_VWarn (1, __LINE__, __FILE__, CCTK_THORNSTRING, "PUGH_ArrayGroupSize: Invalid group ID %d", group); } } return (retval); }