/*
* pOctant Zoltan_Oct_POct_nextDfs(pOctant octant)
*
* returns the next octant in a DFS ordering
*/
pOctant Zoltan_Oct_POct_nextDfs(OCT_Global_Info *OCT_info, pOctant octant) {
pOctant parent, /* parent of an octant */
child; /* child of an octant */
int pid;
int i; /* index counter */
if (!octant)
return(NULL);
for (i=0; i<8; i++) {
child = Zoltan_Oct_child(octant,i);
pid = Zoltan_Oct_Cpid(octant,i);
if ((pid == OCT_info->OCT_localpid) && child)
return(child); /* Go down */
}
parent = Zoltan_Oct_parent(octant);
pid = Zoltan_Oct_Ppid(octant);
while ((pid == OCT_info->OCT_localpid) && parent) {
for (i=octant->which; i<7; i++) {
child = Zoltan_Oct_child(parent,i+1);
pid = Zoltan_Oct_Cpid(parent, i+1);
if ((pid == OCT_info->OCT_localpid) && child)
return(child);
}
octant=parent; /* Go up */
parent = Zoltan_Oct_parent(octant);
pid = Zoltan_Oct_Ppid(octant);
}
return(NULL); /* no more octants remain in dfs ordering */
}
/* KDDKDDFREE Changed root to *root to allow NULL from ZOLTAN_FREE to propagate
* KDDKDDFREE back to calling routine. */
int Zoltan_Oct_POct_delTree(OCT_Global_Info *OCT_info, pOctant *root) {
int i; /* index counter */
pOctant child; /* child of an octant */
if(*root == NULL)
return 1;
if(Zoltan_Oct_isTerminal(*root)) {
if(Zoltan_Oct_nRegions(*root))
Zoltan_Oct_clearRegions(*root);
Zoltan_Oct_POct_free(OCT_info, root);
}
else {
for(i=0; i<8; i++) {
child = Zoltan_Oct_child(*root, i);
if(child != NULL && Zoltan_Oct_POct_local(OCT_info,*root, i)) {
Zoltan_Oct_POct_delTree(OCT_info,&child);
/* KDDKDDFREE propagate NULL from Zoltan_Oct_POct_delTree to root->child */
(*root)->child[i] = NULL;
(*root)->cpid[i] = -1;
}
/* KDDKDDFREE Added this condition so that tests (in other parts of the
* KDDKDDFREE code) for NULL children work */
else if (child != NULL) {
(*root)->child[i] = NULL;
(*root)->cpid[i] = -1;
}
/* END KDDKDDFREE */
}
Zoltan_Oct_POct_free(OCT_info, root);
}
return 1;
}
/*
* Zoltan_Oct_children(pOctant octant, pOctant children[8])
*
* fill in values of all an octants children
*/
int Zoltan_Oct_children(pOctant oct, pOctant children[8]) {
int i; /* index counter */
for (i=0; i<8; i++)
children[i] = Zoltan_Oct_child(oct,i);
return(oct->numChild);
}
/*
* Zoltan_Oct_subtree_dref(oct)
*
* Coarsen octree so that leaf octants do not have less than MINOCTREGIONS
* regions. Refinement takes precedence, so coarsening will not take place
* unless all subtrees agree on it.
*/
static int Zoltan_Oct_subtree_dref(ZZ *zz, OCT_Global_Info *OCT_info,
pOctant oct)
{
pOctant child; /* child of an octant */
int coarsen; /* flag to indicate need to coarsen */
int i; /* index counter */
int nregions; /* number of regions */
int total; /* total number of regions */
/* if terminal octant, cannot coarsen on own */
if (Zoltan_Oct_isTerminal(oct)) {
nregions=Zoltan_Oct_nRegions(oct);
if (nregions > (MAXOCTREGIONS*2) ) {
fprintf(stderr,
"OCT Zoltan_Oct_subtree_dref: warning: too many (%d) regions "
"in oct (id=%d)\n",Zoltan_Oct_nRegions(oct),Zoltan_Oct_id(oct));
return(-1);
}
else
if (nregions < MINOCTREGIONS)
return(nregions);
else
return(-1);
}
coarsen=1; /* assume to be coarsen */
total=0;
/* look at each child, see if they need to be coarsened */
for (i=0; coarsen && i<8; i++) {
child = Zoltan_Oct_child(oct,i);
/* if child is off processor cannot coarsen */
/* if (!Zoltan_Oct_local(child) ) */
if(!Zoltan_Oct_POct_local(OCT_info, oct, i))
coarsen=0;
else {
/* get the number of region of the child */
nregions=Zoltan_Oct_subtree_dref(zz, OCT_info,child);
if (nregions<0)
coarsen=0;
else
total+=nregions; /* total the region count */
}
}
/* check if octant can be coarsened */
if (coarsen && total<MAXOCTREGIONS) {
Zoltan_Oct_terminal_coarsen(zz, OCT_info,oct);
if (total < MINOCTREGIONS)
return(total);
else
return(-1);
}
return(-1);
}
/*
* Zoltan_Oct_terminal_coarsen(oct)
*
* remove octant's children, accumulating regions
* to octant
*
*/
static void Zoltan_Oct_terminal_coarsen(ZZ *zz, OCT_Global_Info *OCT_info,
pOctant oct)
{
pOctant child; /* child of an octant */
pRegion region; /* region associated with an octant */
int i; /* index counter */
pRegion regionlist[8]; /* an array of region lists */
oct_ncoarse++; /* increment coarsening counter */
for(i=0; i<8; i++) {
/* get the ith child of an octant */
child = Zoltan_Oct_child(oct,i);
/* cannot coarsen if child is off-processor */
/* if(!Zoltan_Oct_POct_local(child)) X */
/* cannot be off-processor */
if(!Zoltan_Oct_POct_local(OCT_info, oct, i)) {
fprintf(stderr,"OCT Zoltan_Oct_terminal_coarsen: child not local\n");
abort();
}
if(!Zoltan_Oct_isTerminal(child)) {
fprintf(stderr,"OCT Zoltan_Oct_terminal_coarsen: child not terminal\n");
abort();
}
/* get each child's region list */
regionlist[i] = Zoltan_Oct_regionlist(child);
/* delete each child */
/* KDDKDDFREE Change child to &child. */
Zoltan_Oct_POct_free(OCT_info, &child);
oct->child[i] = NULL;
}
oct->numChild = 0;
/*
* copy contents of each region list into region list
* of coarsened parent (which is now a terminal octant)
*/
for(i=0; i < 8; i++) {
region = regionlist[i];
/* go through the regionlist and add to octant */
while(region != NULL) {
Zoltan_Oct_addRegion(zz, oct,region);
region = region->next;
}
}
}
/*
* int Zoltan_Oct_nlocal(pOctant octant)
*
* return the number of local leaves in the subtree
*/
static int Zoltan_Oct_nlocal(pOctant oct) {
int i; /* index counter */
pOctant child; /* child of an octant */
int total; /* total number of local octants */
if (Zoltan_Oct_isTerminal(oct))
return(1);
total=0;
for (i=0; i<8; i++) {
child = Zoltan_Oct_child(oct,i);
if (child)
total+=Zoltan_Oct_nlocal(child);
}
return(total);
}
/*
* Zoltan_Oct_findOctant(oct, coord)
* (replaces : PO_findOctant(oct,coord))
*
*
* find the octant in a subtree containing coord (if coord
* is not in the subtree, returns the closest octant in the subtree).
* NOTE: return NULL if we hit an off-processor link
*
*/
static pOctant Zoltan_Oct_findOctant(OCT_Global_Info *OCT_info,pOctant oct,
COORD coord)
{
pOctant child; /* child of an octant */
int cnum; /* child number */
/* if octant is terminal, then this is the right octant */
if (Zoltan_Oct_isTerminal(oct))
return(oct);
/* find closest child to coord */
cnum = Zoltan_Oct_child_which_wrapper(OCT_info,oct,coord);
child = Zoltan_Oct_child(oct, cnum); /* get that child */
/* ATTN: are these local checks necessary? */
/* if ( !Zoltan_Oct_POct_local(child) ) */
if(!Zoltan_Oct_POct_local(OCT_info,oct, cnum)) /* make sure oct is local */
return(NULL);
/* recursivly search down the tree */
return(Zoltan_Oct_findOctant(OCT_info,child,coord));
}
/*
* int Zoltan_Oct_dfs_SetIds(pOctant octant, int number_of_previous_octants)
*
* sets the ids of all the octants so that there is a global numbering
*/
static int Zoltan_Oct_dfs_SetIds(OCT_Global_Info *OCT_info, pOctant oct,
int nprevoct) {
int id, /* the id number of an octant */
i; /* index counter */
int pid;
pOctant child; /* ith child of an octant */
if(Zoltan_Oct_isTerminal(oct)) {
id = Zoltan_Oct_id(oct);
Zoltan_Oct_setID(oct, id+nprevoct); /* now have global id's */
}
else {
for(i=0; i<8; i++) {
child = Zoltan_Oct_child(oct, i);
pid = Zoltan_Oct_Cpid(oct,i);
if ((pid == OCT_info->OCT_localpid) && child != NULL)
Zoltan_Oct_dfs_SetIds(OCT_info,child, nprevoct);
}
id = Zoltan_Oct_id(oct);
Zoltan_Oct_setID(oct, id+nprevoct); /* now have global id's */
}
return 0;
}
/*
* void Zoltan_Oct_gen_tree_from_input_data()
*
* This function will create a root node of on each processor which will
* then be used to create an octree with regions associated with it. The
* tree will then be balanced and the output used to balance "mesh regions"
* on several processors.
*/
static void Zoltan_Oct_gen_tree_from_input_data(ZZ *zz, int oct_wgtflag,
int *c1, int *c2, int *c3,
float *c0, int createpartree)
{
char *yo = "Zoltan_Oct_gen_tree_from_input_data";
pRList RootList; /* list of all local roots */
pOctant RootOct; /* root octree octant */
COORD min, /* min coord bounds of objects */
max; /* max coord bounds of objects */
int num_extra; /* number of orphaned objects */
int num_objs; /* total number of local objects */
pRegion ptr, /* pointer to iterate trough region list */
ptr1; /* pointer to iterate trough region list */
pOctant root; /* root of the partition tree */
int i; /* index counter */
int count, /* count for leaf nodes in partition tree */
proc, /* proc leaf node of parition tree belongs to */
extra, /* extra leaf node flag, if not evenly divisible */
remainder; /* remainder of node, or processors to fill */
pOctant cursor, /* cursor to iterate through octant list */
cursor2, /* another cursor to iterate through octant list */
parent; /* parent of an octant */
int level, /* number of levels of refinement */
n, /* index counter */
part; /* partition counter */
Map *array; /* map of which processors own which octants */
int hold; /* used for calculating partition divisions */
int ierr = 0;
#ifdef KDDKDD_NEW_BOUNDS_GEOM_QUERY_FN
double bounds[6] = {DBL_MAX,DBL_MAX,DBL_MAX,-DBL_MAX,-DBL_MAX,-DBL_MAX};
COORD global_min, global_max;
#endif /* KDDKDD_NEW_BOUNDS_GEOM_QUERY_FN */
int nroots = 0;
/*test*/
/* COORD gmin,gmax; */
OCT_Global_Info *OCT_info = (OCT_Global_Info *) (zz->LB.Data_Structure);
ZOLTAN_TRACE_ENTER(zz, yo);
/*
* If there are no objects on this processor, do not create a root octant.
* The partitioner will probably assign objects to this processor
*/
if(zz->Get_Num_Obj == NULL) {
fprintf(stderr, "OCT %s\n\t%s\n", "Error in octree load balance:",
"Must register ZOLTAN_NUM_OBJ_FN function");
abort();
}
*c3 = num_objs = zz->Get_Num_Obj(zz->Get_Num_Obj_Data, &ierr);
if (ierr) {
fprintf(stderr, "OCT [%d] %s: Error returned from user defined "
"Get_Num_Obj function.\n", zz->Proc, yo);
exit (-1);
}
ptr1 = NULL;
ZOLTAN_TRACE_DETAIL(zz, yo, "Calling Zoltan_Oct_get_bounds");
/* Need A Function To Get The Bounds Of The Local Objects */
Zoltan_Oct_get_bounds(zz, &ptr1, &num_objs, min, max, oct_wgtflag, c0);
#ifndef KDDKDD_NEW_BOUNDS_GEOM_QUERY_FN
/* For now, don't want to add the new query function to Zoltan. */
/* Zoltan_Oct_get_bounds appears to compute the global min and max from */
/* the object input. */
vector_set(OCT_info->OCT_gmin, min);
vector_set(OCT_info->OCT_gmax, max);
#else
/*test*/
/*getMaxBounds(&gmin, &gmax);*/
if(zz->Get_Bounds_Geom == NULL) {
fprintf(stderr, "OCT %s\n\t%s\n", "Error in octree load balance:",
"Must register Get_Bounds_Geom function");
abort();
}
zz->Get_Bounds_Geom(zz->Get_Bounds_Geom_Data, bounds, &ierr);
MPI_Allreduce(&(bounds[0]), &(global_min[0]), 3,
MPI_DOUBLE, MPI_MIN, zz->Communicator);
MPI_Allreduce(&(bounds[3]), &(global_max[0]), 3,
MPI_DOUBLE, MPI_MAX, zz->Communicator);
vector_set(OCT_info->OCT_gmin, global_min);
vector_set(OCT_info->OCT_gmax, global_max);
#endif
/*
* the following code segment was added to create a pseudo global octree
* needed for the partitioner. The basic idea is to regroup all the
* regions into something close to an octree partitioning and build the
* tree from that.
* NOTE: This way of doing things is very costly, especially when calling
* this for the first time on a mesh not partitioned in an octree style
* partitioning.
*/
level = 0; /* initialize level count */
/*
* if more than 1 processor, need to find what level of refinement needed
* to initially partition bounding box among the processors
*/
if(zz->Num_Proc > 1) {
n = zz->Num_Proc;
if(OCT_info->OCT_dimension == 2)
hold = 4;
else
hold = 8;
remainder = hold;
for(; remainder > 0; level++) {
int pr = (int)POW(hold, level);
remainder = n - pr;
}
level--;
}
ZOLTAN_TRACE_DETAIL(zz, yo, "Before createpartree");
if(createpartree) {
/* create the global root octant */
root = Zoltan_Oct_POct_new(OCT_info);
Zoltan_Oct_setbounds(root, OCT_info->OCT_gmin, OCT_info->OCT_gmax);
/* Zoltan_Oct_setOrientation(root, 0); */
/* subdivide to as many levels as calculated */
for(i=0; i<level; i++) {
cursor = root;
while(cursor != NULL) {
if(Zoltan_Oct_isTerminal(cursor)) {
cursor2 = Zoltan_Oct_POct_nextDfs(OCT_info, cursor);
Zoltan_Oct_terminal_refine(zz, cursor, 0);
cursor = cursor2;
}
else
cursor = Zoltan_Oct_POct_nextDfs(OCT_info, cursor);
}
}
#if 0
if(zz->Proc == 0)
for(i=0; i<8; i++)
if(Zoltan_Oct_child(root, i) == NULL)
fprintf(stderr,"NULL child pointer\n");
else
fprintf(stderr, "child %d exists\n", i);
#endif
ZOLTAN_TRACE_DETAIL(zz, yo, "Before create map array");
/* this part creates the map array */
if(OCT_info->OCT_dimension == 2) {
hold = (int)POW(4, level); /* ignoring the z+ octants */
if(hold == 0)
hold = 1;
}
else
hold = (int)POW(8, level);
part = hold / zz->Num_Proc; /* how many octants per partition */
remainder = hold % zz->Num_Proc; /* extra octants, not evenly divisible */
extra = zz->Num_Proc - remainder;/* where to start adding extra octants */
array = (Map *) ZOLTAN_MALLOC(hold * sizeof(Map)); /* alloc map array */
if(array == NULL) {
fprintf(stderr, "OCT ERROR on proc %d, could not allocate array map\n",
zz->Proc);
abort();
}
/* initialize variables */
proc = 0;
count = 0;
i = 0;
cursor = root;
while(cursor != NULL) {
cursor2 = Zoltan_Oct_POct_nextDfs(OCT_info, cursor);
if((Zoltan_Oct_isTerminal(cursor)) && (i < hold)) {
if(proc == extra) {
part++;
extra = -1;
}
if(count != part) {
array[i].npid = proc;
array[i].list = RL_initRootList();
Zoltan_Oct_bounds(cursor, min, max);
vector_set(array[i].min, min);
vector_set(array[i].max, max);
count++;
}
else {
count = 1;
proc++;
array[i].npid = proc;
array[i].list = RL_initRootList();
Zoltan_Oct_bounds(cursor, min, max);
vector_set(array[i].min, min);
vector_set(array[i].max, max);
}
if(proc == zz->Proc) {
array[i].npid = -1;
/* KDDKDD Added RL_freeList below. The
* KDDKDD implementation from RPI leaked memory because the
* KDDKDD test cases for setting array[i].list were not mutually
* KDDKDD exclusive. Freeing the list produces the result we got
* KDDKDD before, without the memory leak.
*/
/* LGG -- it seems to me that this array[i].list assignment is
* not really necessary. It looks as though it has already been
* assigned with the same information from the prev if-else
* commented out RL_freeList(), and RL_initRootList()
*/
/*RL_freeList(&(array[i].list));*/
/* KDDKDD End addition */
/*array[i].list = RL_initRootList();*/
parent = Zoltan_Oct_parent(cursor);
if(parent != NULL)
Zoltan_Oct_setchild(parent, cursor->which, NULL);
/* octant into local root list */
Zoltan_Oct_POct_setparent(OCT_info, cursor, NULL, -1);
Zoltan_Oct_setMapIdx(cursor, i);
nroots++;
/* Zoltan_Oct_POct_setparent(OCT_info, cursor, NULL, zz->Proc);
octant into local root list */
}
i++;
}
cursor = cursor2;
}
RootList = Zoltan_Oct_POct_localroots(OCT_info);
RootOct = RL_nextRootOctant(&RootList);
if(RootOct != root) {
/* KDDKDDFREE changed root to &root to allow root to be reset to NULL */
Zoltan_Oct_POct_delTree(OCT_info,&root);
}
OCT_info->map = array;
OCT_info->mapsize = hold;
}
/*
* attach the regions to the root... Zoltan_Oct_fix will create the octree
* starting with the root and subdividing as needed
*/
num_extra = Zoltan_Oct_fix(zz, ptr1, num_objs);
ZOLTAN_TRACE_DETAIL(zz, yo, "Calling Zoltan_Oct_migreg_migrate_orphans");
Zoltan_Oct_migreg_migrate_orphans(zz, ptr1, num_extra, level, OCT_info->map,
c1, c2);
/* ZOLTAN_FREE(&array); */
while(ptr1 != NULL) {
ptr = ptr1->next;
ZOLTAN_FREE(&(ptr1->Global_ID));
ZOLTAN_FREE(&(ptr1->Local_ID));
ZOLTAN_FREE(&ptr1);
ptr1 = ptr;
}
ZOLTAN_TRACE_EXIT(zz, yo);
}
static int Zoltan_Oct_Update_Connections(
ZZ *zz,
pOctant *octs, /* octs[nocts] */
int *newpids, /* newpids[nocts] */
pOctant *newocts, /* newocts[nocts] */
int nocts) /* number of octants leaving this processor */
{
int i, j;
int nsends;
int nreceives;
pOctant parent;
pOctant child;
int ppid;
int cpid;
int childnum;
int *despid = NULL;
Update_msg umsg;
Update_msg *localumsg = NULL;
Update_msg *remoteumsg = NULL;
Update_msg *rcv_umsg = NULL;
int localcount;
int remotecount;
int ierr = ZOLTAN_OK;
ZOLTAN_COMM_OBJ *comm_plan; /* Object returned by communication routines */
char *yo = "Zoltan_Oct_Update_Connections";
OCT_Global_Info *OCT_info = (OCT_Global_Info *) zz->LB.Data_Structure;
localcount=0;
remotecount=0;
/* count number of sends */
nsends = 0;
for (i=0; i<nocts; i++)
if (newpids[i]!=zz->Proc)
nsends++;
if(nocts > 0) {
if((remoteumsg = (Update_msg *) ZOLTAN_MALLOC((nocts+1) * sizeof(Update_msg)*9)) == NULL) {
ZOLTAN_TRACE_EXIT(zz, yo);
return ZOLTAN_MEMERR;
}
if((localumsg = (Update_msg *) ZOLTAN_MALLOC((nocts+1) * sizeof(Update_msg)*9)) == NULL) {
ZOLTAN_TRACE_EXIT(zz, yo);
ZOLTAN_FREE(&remoteumsg);
return ZOLTAN_MEMERR;
}
if((despid = (int *) ZOLTAN_MALLOC((nocts+1) * sizeof(int)*9)) == NULL) {
ZOLTAN_TRACE_EXIT(zz, yo);
ZOLTAN_FREE(&remoteumsg);
ZOLTAN_FREE(&localumsg);
return ZOLTAN_MEMERR;
}
}
else {
remoteumsg = NULL;
localumsg = NULL;
despid = NULL;
}
localcount = 0;
remotecount = 0;
for (i=0; i<nocts; i++) /* Send connection updates */
if (newpids[i]!=zz->Proc) {
parent = Zoltan_Oct_parent(octs[i]);
ppid = Zoltan_Oct_Ppid(octs[i]);
childnum = Zoltan_Oct_childnum(octs[i]);
if (parent) { /* Let parent of oct[i] know that it's moving */
if (ppid==zz->Proc) {
FILLUPDATEMSG(localumsg[localcount], parent, childnum, newocts[i], newpids[i]);
localcount++;
}
else {
FILLUPDATEMSG(remoteumsg[remotecount], parent, childnum, newocts[i], newpids[i]);
despid[remotecount++] = ppid;
}
}
for (j=0; j<8; j++) {
child = Zoltan_Oct_child(octs[i],j);
cpid = octs[i]->cpid[j];
/* Tell child of oct[i] that it is moving */
if (child) {
if (cpid==zz->Proc) {
/* NOTE: -1 signals PARENT */
FILLUPDATEMSG(localumsg[localcount], child, -1, newocts[i], newpids[i]);
localcount++;
}
else {
/* NOTE: -1 signals PARENT */
FILLUPDATEMSG(remoteumsg[remotecount], child, -1, newocts[i], newpids[i]);
despid[remotecount++] = cpid;
}
}
}
}
ierr = Zoltan_Comm_Create(&comm_plan, remotecount, despid, zz->Communicator,
MigUpdCommCreate, &nreceives);
if(ierr != ZOLTAN_OK && ierr != ZOLTAN_WARN) {
ZOLTAN_TRACE_EXIT(zz, yo);
ZOLTAN_FREE(&remoteumsg);
ZOLTAN_FREE(&localumsg);
ZOLTAN_FREE(&despid);
return (ierr);
}
/* if(nreceives > 0) { */
if((rcv_umsg = (Update_msg *) ZOLTAN_MALLOC((nreceives +1) * sizeof(Update_msg)*9)) == NULL) {
ZOLTAN_TRACE_EXIT(zz, yo);
ZOLTAN_FREE(&remoteumsg);
ZOLTAN_FREE(&localumsg);
ZOLTAN_FREE(&despid);
return ZOLTAN_MEMERR;
}
ierr = Zoltan_Comm_Do(comm_plan, MigUpdCommDo, (char *) remoteumsg,
sizeof(Update_msg), (char *) rcv_umsg);
if(ierr != ZOLTAN_OK && ierr != ZOLTAN_WARN) {
ZOLTAN_TRACE_EXIT(zz, yo);
ZOLTAN_FREE(&remoteumsg);
ZOLTAN_FREE(&localumsg);
ZOLTAN_FREE(&despid);
ZOLTAN_FREE(&rcv_umsg);
return (ierr);
}
/* } */
/* else { */
/* rcv_umsg = NULL; */
/* } */
/* update new octants */
for (i=0; i< (localcount+nreceives); i++) {
if (i<localcount)
umsg=localumsg[i];
else
umsg=rcv_umsg[i-localcount];
if (umsg.childnum>=0) {
Zoltan_Oct_setchild(umsg.oct,umsg.childnum,umsg.newptr);
Zoltan_Oct_setCpid(umsg.oct,umsg.childnum,umsg.newpid);
}
else {
if((Zoltan_Oct_data_newpid(umsg.oct) == OCT_info->OCT_localpid) ||
((Zoltan_Oct_data_newpid(umsg.oct) != OCT_info->OCT_localpid) && (umsg.newpid == OCT_info->OCT_localpid)))
Zoltan_Oct_POct_setparent(OCT_info, umsg.oct,umsg.newptr,umsg.newpid);
else {
umsg.oct->ppid = umsg.newpid;
umsg.oct->parent = umsg.newptr;
}
}
}
ierr = Zoltan_Comm_Destroy(&comm_plan);
if(ierr != ZOLTAN_OK && ierr != ZOLTAN_WARN) {
ZOLTAN_TRACE_EXIT(zz, yo);
ZOLTAN_FREE(&remoteumsg);
ZOLTAN_FREE(&localumsg);
ZOLTAN_FREE(&despid);
ZOLTAN_FREE(&rcv_umsg);
return (ierr);
}
ZOLTAN_FREE(&remoteumsg);
ZOLTAN_FREE(&localumsg);
ZOLTAN_FREE(&rcv_umsg);
ZOLTAN_FREE(&despid);
return ierr;
}
