int Zoltan_LB_Special_Free_Part(
ZZ *zz,
ZOLTAN_ID_PTR *global_ids, /* Array of global IDs */
ZOLTAN_ID_PTR *local_ids, /* Array of local IDs */
int **procs, /* Array of processor IDs */
int **to_part /* Array of partition assignments */
)
{
/*
* Routine to free the arrays returning the results of the load balancing.
* This routine should be used within Zoltan to ensure that F90-allocated
* arrays are freed correctly.
* For example, Zoltan SPECIAL_MALLOCs return arrays, but then needs to
* free them while changing the return list format. Zoltan should call
* Zoltan_LB_Special_Free Part (not Zoltan_LB_Free_Part) to SPECIAL_FREE
* the memory that was SPECIAL_MALLOCed.
*
* External applications do not need to use this routine,
* as the correct malloc/free protocal for their language will be observed.
*/
Zoltan_Special_Free(zz, (void **)global_ids, ZOLTAN_SPECIAL_MALLOC_GID);
Zoltan_Special_Free(zz, (void **)local_ids, ZOLTAN_SPECIAL_MALLOC_LID);
Zoltan_Special_Free(zz, (void **)procs, ZOLTAN_SPECIAL_MALLOC_INT);
Zoltan_Special_Free(zz, (void **)to_part, ZOLTAN_SPECIAL_MALLOC_INT);
return (ZOLTAN_OK);
}
static int Zoltan_Reftree_Partition(ZZ *zz, float *part_sizes, int *num_export,
ZOLTAN_ID_PTR *export_global_ids, ZOLTAN_ID_PTR *export_local_ids,
int **export_to_partition, int **export_procs)
{
/*
* Function to partition the grid and fill the export arrays.
*/
char *yo = "Zoltan_Reftree_Partition";
char msg[256];
int num_exp; /* count the number of export objects */
ZOLTAN_REFTREE *root; /* root of the tree */
float *cutoff; /* the relative sizes of the partitions */
int part; /* partition under construction */
float current_size; /* amount of weight consumed so far */
int num_part; /* number of partitions */
int ierr; /* error flag */
int wdim; /* Max(zz->Obj_Weight_Dim, 1) */
ZOLTAN_TRACE_ENTER(zz, yo);
root = ((struct Zoltan_Reftree_data_struct *)zz->LB.Data_Structure)->reftree_root;
/*
* determine the size of the partitions and tolerance interval
*/
num_part = zz->LB.Num_Global_Parts;
/* Set the cutoff points of summed weights for the end of each partition */
/* TEMP HA
Determine a partition of unity for the sizes of the partitions
relative to the processing power of the processors, to support
heterogeneous architectures.
cutoff(0) = is the percent of work that should be assigned to
partition 0
cutoff(i) - cutoff(i-1) is the percent of work that should be
assigned to partition i.
cutoff(num_part-1) = 1.0
When support for heterogeneous architectures is added to Zoltan,
there should be a "vector of partition sizes" passed into this
routine, which would be used to define cutoff. For now, it is
just set to be equal sizes.
*/
cutoff = (float *)ZOLTAN_MALLOC((num_part)*sizeof(float));
if (cutoff == NULL) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Insufficient memory.");
ZOLTAN_TRACE_EXIT(zz, yo);
return(ZOLTAN_MEMERR);
}
cutoff[0] = part_sizes[0]; /* TEMP SINGLE WEIGHT */
wdim = ((zz->Obj_Weight_Dim == 0) ? 1 : zz->Obj_Weight_Dim);
for (part = 1; part < num_part; part++)
cutoff[part] = cutoff[part-1] + part_sizes[part*wdim]; /* TEMP SINGLE WEIGHT */
cutoff[num_part-1] = 1.0; /* just to make sure roundoff doesn't bite us */
/* multiply cutoff by the total weight so that cutoff gives the desired
actual weight of each partition instead of relative sizes */
/* TEMP HA
It is quite possible that once we know what is passed into this
routine to determine relative partition sizes, then this can be combined
with the above partition of unity to simplify the code. I just did it
this way to make it clear what is happening.
*/
for (part=0; part<num_part; part++) {
cutoff[part] = cutoff[part]*root->summed_weight[0]; /* TEMP SINGLE WEIGHT */
}
/*
* traverse the tree to define the partition and count the number of exports
*/
num_exp = 0;
part = 0;
current_size = 0.0;
ierr = Zoltan_Reftree_Part_Recursive(zz,root,&part,¤t_size,&num_exp,
cutoff,num_part);
ZOLTAN_FREE(&cutoff);
if (ierr != ZOLTAN_OK && ierr != ZOLTAN_WARN) {
ZOLTAN_TRACE_EXIT(zz, yo);
return(ierr);
}
/*
* if no exports, we're done
*/
if (zz->LB.Return_Lists == ZOLTAN_LB_NO_LISTS) {
ZOLTAN_TRACE_EXIT(zz, yo);
return(ZOLTAN_OK);
}
else if (zz->LB.Return_Lists == ZOLTAN_LB_CANDIDATE_LISTS) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Candidate Lists not supported in REFTREE;"
"change RETURN_LISTS parameter.");
ZOLTAN_TRACE_EXIT(zz, yo);
return(ZOLTAN_FATAL);
}
else if (num_exp == 0) {
*num_export = 0;
ZOLTAN_TRACE_EXIT(zz, yo);
return(ZOLTAN_OK);
}
/*
* allocate space for the export lists
*/
if (!Zoltan_Special_Malloc(zz,(void **)export_global_ids,num_exp,
ZOLTAN_SPECIAL_MALLOC_GID)) {
ZOLTAN_TRACE_EXIT(zz, yo);
return ZOLTAN_MEMERR;
}
if (!Zoltan_Special_Malloc(zz,(void **)export_local_ids,num_exp,
ZOLTAN_SPECIAL_MALLOC_LID)) {
Zoltan_Special_Free(zz,(void **)export_global_ids,ZOLTAN_SPECIAL_MALLOC_GID);
ZOLTAN_TRACE_EXIT(zz, yo);
return ZOLTAN_MEMERR;
}
if (!Zoltan_Special_Malloc(zz,(void **)export_to_partition,num_exp,
ZOLTAN_SPECIAL_MALLOC_INT)) {
Zoltan_Special_Free(zz,(void **)export_global_ids,ZOLTAN_SPECIAL_MALLOC_GID);
Zoltan_Special_Free(zz,(void **)export_local_ids,ZOLTAN_SPECIAL_MALLOC_LID);
ZOLTAN_TRACE_EXIT(zz, yo);
return ZOLTAN_MEMERR;
}
if (!Zoltan_Special_Malloc(zz,(void **)export_procs,num_exp,
ZOLTAN_SPECIAL_MALLOC_INT)) {
Zoltan_Special_Free(zz,(void **)export_to_partition,ZOLTAN_SPECIAL_MALLOC_INT);
Zoltan_Special_Free(zz,(void **)export_global_ids,ZOLTAN_SPECIAL_MALLOC_GID);
Zoltan_Special_Free(zz,(void **)export_local_ids,ZOLTAN_SPECIAL_MALLOC_LID);
ZOLTAN_TRACE_EXIT(zz, yo);
return ZOLTAN_MEMERR;
}
/*
* traverse the tree to make the export lists
*/
*num_export = 0;
ierr = Zoltan_Reftree_Export_Lists(zz,root,num_export,export_global_ids,
export_local_ids,export_to_partition,export_procs);
if (ierr != ZOLTAN_OK && ierr != ZOLTAN_WARN) {
ZOLTAN_TRACE_EXIT(zz, yo);
return(ierr);
}
if (num_exp != *num_export) {
sprintf(msg, "num_exp = %d not equal to num_export = %d.",
num_exp,*num_export);
ZOLTAN_PRINT_WARN(zz->Proc, yo, msg);
ZOLTAN_TRACE_EXIT(zz, yo);
return(ZOLTAN_WARN);
}
ZOLTAN_TRACE_EXIT(zz, yo);
return(ZOLTAN_OK);
}
static int Zoltan_LB(
ZZ *zz,
int include_parts, /* Flag indicating whether to generate
part informtion;
0 if called by Zoltan_LB_Balance,
1 if called by Zoltan_LB_Partition. */
int *changes, /* Set to zero or one depending on if
Zoltan determines a new
decomposition or not:
zero - No changes to the decomposition
were made by the load-balancing
algorithm; migration is not needed.
one - A new decomposition is suggested
by the load-balancer; migration is
needed to establish the new
decomposition. */
int *num_gid_entries, /* The number of array entries in a global ID;
set to be the max over all processors in
zz->Communicator of the parameter
Num_Global_ID_Entries. */
int *num_lid_entries, /* The number of array entries in a local ID;
set to be the max over all processors in
zz->Communicator of the parameter
Num_Local_ID_Entries. */
int *num_import_objs, /* The number of non-local objects in the
processor's new decomposition. */
ZOLTAN_ID_PTR *import_global_ids,/* Array of global IDs for non-local objects
(i.e., objs to be imported) in
the processor's new decomposition. */
ZOLTAN_ID_PTR *import_local_ids, /* Array of local IDs for non-local objects
(i.e., objs to be imported) in
the processor's new decomposition. */
int **import_procs, /* Array of processor IDs for processors
currently owning non-local objects (i.e.,
objs to be imported) in this processor's
new decomposition. */
int **import_to_part, /* Partition to which the objects should be
imported. */
int *num_export_objs, /* The number of local objects that need to
be exported from the processor to establish
the new decomposition. */
ZOLTAN_ID_PTR *export_global_ids,/* Array of global IDs for objects that need
to be exported (assigned and sent to other
processors) to establish the new
decomposition. */
ZOLTAN_ID_PTR *export_local_ids, /* Array of local IDs for objects that need
to be exported (assigned and sent to other
processors) to establish the new
decomposition. */
int **export_procs, /* Array of destination processor IDs for
objects that need to be exported
to establish the new decomposition. */
int **export_to_part /* Partition to which objects should be
exported. */
)
{
/*
* Main load-balancing routine.
* Input: a Zoltan structure with appropriate function pointers set.
* Output:
* changes
* num_import_objs
* import_global_ids
* import_local_ids
* import_procs
* import_to_part
* num_export_objs
* export_global_ids
* export_local_ids
* export_procs
* export_to_part
* Return values:
* Zoltan error code.
*/
char *yo = "Zoltan_LB";
int gmax; /* Maximum number of imported/exported objects
over all processors. */
int error = ZOLTAN_OK; /* Error code */
double start_time, end_time;
double lb_time[2] = {0.0,0.0};
char msg[256];
int comm[3],gcomm[3];
float *part_sizes = NULL, *fdummy = NULL;
int wgt_dim, part_dim;
int all_num_obj, i, ts, idIdx;
struct Hash_Node **ht;
int *export_all_procs, *export_all_to_part, *parts=NULL;
ZOLTAN_ID_PTR all_global_ids=NULL, all_local_ids=NULL;
ZOLTAN_ID_PTR gid;
#ifdef ZOLTAN_OVIS
struct OVIS_parameters ovisParameters;
#endif
ZOLTAN_TRACE_ENTER(zz, yo);
if (zz->Proc == zz->Debug_Proc && zz->Debug_Level >= ZOLTAN_DEBUG_PARAMS){
printf("Build configuration:\n");
Zoltan_Print_Configuration(" ");
printf("\n");
Zoltan_Print_Key_Params(zz);
}
start_time = Zoltan_Time(zz->Timer);
#ifdef ZOLTAN_OVIS
Zoltan_OVIS_Setup(zz, &ovisParameters);
if (zz->Proc == 0)
printf("OVIS PARAMETERS %s %s %d %f\n",
ovisParameters.hello,
ovisParameters.dll,
ovisParameters.outputLevel,
ovisParameters.minVersion);
ovis_enabled(zz->Proc, ovisParameters.dll);
#endif
/*
* Compute Max number of array entries per ID over all processors.
* Compute Max number of return arguments for Zoltan_LB_Balance.
* This is a sanity-maintaining step; we don't want different
* processors to have different values for these numbers.
*/
comm[0] = zz->Num_GID;
comm[1] = zz->Num_LID;
comm[2] = zz->LB.Return_Lists;
MPI_Allreduce(comm, gcomm, 3, MPI_INT, MPI_MAX, zz->Communicator);
zz->Num_GID = *num_gid_entries = gcomm[0];
zz->Num_LID = *num_lid_entries = gcomm[1];
zz->LB.Return_Lists = gcomm[2];
/* assume no changes */
*changes = 0;
*num_import_objs = *num_export_objs = 0;
*import_global_ids = NULL;
*import_local_ids = NULL;
*import_procs = NULL;
*import_to_part = NULL;
*export_global_ids = NULL;
*export_local_ids = NULL;
*export_procs = NULL;
*export_to_part = NULL;
/*
* Return if this processor is not in the Zoltan structure's
* communicator.
*/
if (ZOLTAN_PROC_NOT_IN_COMMUNICATOR(zz))
goto End;
if (zz->LB.Method == NONE) {
if (zz->Proc == zz->Debug_Proc && zz->Debug_Level >= ZOLTAN_DEBUG_PARAMS)
printf("%s Balancing method selected == NONE; no balancing performed\n",
yo);
error = ZOLTAN_WARN;
goto End;
}
/*
* Sync the random number generator across processors.
*/
Zoltan_Srand_Sync(Zoltan_Rand(NULL), NULL, zz->Communicator);
/* Since generating a new partition, need to free old mapping vector */
zz->LB.OldRemap = zz->LB.Remap;
zz->LB.Remap = NULL;
error = Zoltan_LB_Build_PartDist(zz);
if (error != ZOLTAN_OK && error != ZOLTAN_WARN)
goto End;
if (zz->Debug_Level >= ZOLTAN_DEBUG_ALL) {
int i, np, fp;
for (i = 0; i < zz->Num_Proc; i++) {
Zoltan_LB_Proc_To_Part(zz, i, &np, &fp);
printf("%d Proc_To_Part Proc %d NParts %d FPart %d\n",
zz->Proc, i, np, fp);
}
}
/*
* Generate parts sizes.
*/
#ifdef ZOLTAN_OVIS
/* set part sizes computed by OVIS, if requested. Processes set only their own value */
{
float part_sizes[1];
int part_ids[1], wgt_idx[1];
wgt_idx[0] = 0;
part_ids[0] = 0;
ovis_getPartsize(&(part_sizes[0]));
printf("Rank %d ps %f\n",zz->Proc, part_sizes[0]);
/* clear out old part size info first */
Zoltan_LB_Set_Part_Sizes(zz, 0, -1, NULL, NULL, NULL);
Zoltan_LB_Set_Part_Sizes(zz, 0, 1, part_ids, wgt_idx, part_sizes);
}
#endif
wgt_dim = zz->Obj_Weight_Dim;
part_dim = ((wgt_dim > 0) ? wgt_dim : 1);
part_sizes = (float *) ZOLTAN_MALLOC(sizeof(float) * part_dim
* zz->LB.Num_Global_Parts);
if (part_sizes == NULL) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Memory error.");
error = ZOLTAN_MEMERR;
goto End;
}
/* Get part sizes. */
Zoltan_LB_Get_Part_Sizes(zz, zz->LB.Num_Global_Parts, part_dim,
part_sizes);
#ifdef ZOLTAN_OVIS
/* if (ovisParameters.outputlevel > 3) */
{
int myRank = zz->Proc;
if (myRank == 0){
int i, j;
for (i = 0; i < zz->LB.Num_Global_Parts; i++){
for (j = 0; j < part_dim; j++){
printf("Rank %d AG: part_sizes[%d] = %f (Num_Global_Parts = %d, part_dim = %d)\n",zz->Proc,
(i*part_dim+j), part_sizes[i*part_dim+j],zz->LB.Num_Global_Parts, part_dim);
}
}
}
}
#endif
/*
* Call the actual load-balancing function.
*/
error = zz->LB.LB_Fn(zz, part_sizes,
num_import_objs, import_global_ids, import_local_ids,
import_procs, import_to_part,
num_export_objs, export_global_ids, export_local_ids,
export_procs, export_to_part);
ZOLTAN_FREE(&part_sizes);
if (error == ZOLTAN_FATAL || error == ZOLTAN_MEMERR){
sprintf(msg, "Partitioning routine returned code %d.", error);
#ifdef HOST_LINUX
if ((error == ZOLTAN_MEMERR) && (Zoltan_Memory_Get_Debug() > 0)){
Zoltan_write_linux_meminfo(0, "State of /proc/meminfo after malloc failure\n", 0);
}
#endif
ZOLTAN_PRINT_ERROR(zz->Proc, yo, msg);
goto End;
}
else if (error){
if (zz->Debug_Level >ZOLTAN_DEBUG_NONE) {
sprintf(msg, "Partitioning routine returned code %d.", error);
ZOLTAN_PRINT_WARN(zz->Proc, yo, msg);
}
}
ZOLTAN_TRACE_DETAIL(zz, yo, "Done partitioning");
if (*num_import_objs >= 0)
MPI_Allreduce(num_import_objs, &gmax, 1, MPI_INT, MPI_MAX,
zz->Communicator);
else /* use export data */
MPI_Allreduce(num_export_objs, &gmax, 1, MPI_INT, MPI_MAX,
zz->Communicator);
if (gmax == 0) {
/*
* Decomposition was not changed by the load balancing; no migration
* is needed.
*/
if (zz->Proc == zz->Debug_Proc && zz->Debug_Level >= ZOLTAN_DEBUG_PARAMS)
printf("%s No changes to the decomposition due to partitioning; "
"no migration is needed.\n", yo);
/*
* Reset num_import_objs and num_export_objs; don't want to return
* -1 for the arrays that weren't returned by ZOLTAN_LB_FN.
*/
*num_import_objs = *num_export_objs = 0;
if (zz->LB.Return_Lists == ZOLTAN_LB_COMPLETE_EXPORT_LISTS){
/*
* This parameter setting requires that all local objects
* and their assignments appear in the export list.
*/
error= Zoltan_Get_Obj_List_Special_Malloc(zz, num_export_objs,
export_global_ids, export_local_ids,
wgt_dim, &fdummy, export_to_part);
if (error == ZOLTAN_OK){
ZOLTAN_FREE(&fdummy);
if (Zoltan_Special_Malloc(zz, (void **)export_procs, *num_export_objs,
ZOLTAN_SPECIAL_MALLOC_INT)){
for (i=0; i<*num_export_objs; i++)
(*export_procs)[i] = zz->Proc;
}
else{
error = ZOLTAN_MEMERR;
}
}
}
goto End;
}
/*
* Check whether we know the import data, export data, or both.
*
* If we were given the import data,
* we know what the new decomposition should look like on the
* processor, but we don't know which of our local objects we have
* to export to other processors to establish the new decomposition.
* Reverse the argument if we were given the export data.
*
* Unless we were given both maps, compute the inverse map.
*/
if (zz->LB.Return_Lists == ZOLTAN_LB_NO_LISTS) {
if (*num_import_objs >= 0)
Zoltan_LB_Special_Free_Part(zz, import_global_ids, import_local_ids,
import_procs, import_to_part);
if (*num_export_objs >= 0)
Zoltan_LB_Special_Free_Part(zz, export_global_ids, export_local_ids,
export_procs, export_to_part);
*num_import_objs = *num_export_objs = -1;
}
if (*num_import_objs >= 0){
if (*num_export_objs >= 0) {
/* Both maps already available; nothing to do. */;
}
else if (zz->LB.Return_Lists == ZOLTAN_LB_ALL_LISTS ||
zz->LB.Return_Lists == ZOLTAN_LB_EXPORT_LISTS ||
zz->LB.Return_Lists == ZOLTAN_LB_COMPLETE_EXPORT_LISTS) {
/* Export lists are requested; compute export map */
error = Zoltan_Invert_Lists(zz, *num_import_objs, *import_global_ids,
*import_local_ids, *import_procs,
*import_to_part,
num_export_objs, export_global_ids,
export_local_ids, export_procs,
export_to_part);
if (error != ZOLTAN_OK && error != ZOLTAN_WARN) {
sprintf(msg, "Error building return arguments; "
"%d returned by Zoltan_Compute_Destinations\n", error);
ZOLTAN_PRINT_ERROR(zz->Proc, yo, msg);
goto End;
}
if (zz->LB.Return_Lists == ZOLTAN_LB_EXPORT_LISTS ||
zz->LB.Return_Lists == ZOLTAN_LB_COMPLETE_EXPORT_LISTS) {
/* Method returned import lists, but only export lists were desired. */
/* Import lists not needed; free them. */
*num_import_objs = -1;
Zoltan_LB_Special_Free_Part(zz, import_global_ids, import_local_ids,
import_procs, import_to_part);
}
}
}
else { /* (*num_import_objs < 0) */
if (*num_export_objs >= 0) {
/* Only export lists have been returned. */
if (zz->LB.Return_Lists == ZOLTAN_LB_ALL_LISTS ||
zz->LB.Return_Lists == ZOLTAN_LB_IMPORT_LISTS) {
/* Compute import map */
error = Zoltan_Invert_Lists(zz, *num_export_objs, *export_global_ids,
*export_local_ids, *export_procs,
*export_to_part,
num_import_objs, import_global_ids,
import_local_ids, import_procs,
import_to_part);
if (error != ZOLTAN_OK && error != ZOLTAN_WARN) {
sprintf(msg, "Error building return arguments; "
"%d returned by Zoltan_Compute_Destinations\n", error);
ZOLTAN_PRINT_ERROR(zz->Proc, yo, msg);
goto End;
}
if (zz->LB.Return_Lists == ZOLTAN_LB_IMPORT_LISTS) {
/* Method returned export lists, but only import lists are desired. */
/* Export lists not needed; free them. */
*num_export_objs = -1;
Zoltan_LB_Special_Free_Part(zz, export_global_ids, export_local_ids,
export_procs, export_to_part);
}
}
}
else { /* *num_export_objs < 0 && *num_import_objs < 0) */
if (zz->LB.Return_Lists) {
/* No map at all available */
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Load-balancing function returned "
"neither import nor export data.");
error = ZOLTAN_WARN;
goto End;
}
}
}
if (zz->LB.Return_Lists == ZOLTAN_LB_COMPLETE_EXPORT_LISTS) {
/*
* Normally, Zoltan_LB returns in the export lists all local
* objects that are moving off processor, or that are assigned
* to a part on the local processor that is not the
* default part. This setting of Return_Lists requests
* that all local objects be included in the export list.
*/
if (*num_export_objs == 0){
/* all local objects are remaining on processor */
error= Zoltan_Get_Obj_List_Special_Malloc(zz, num_export_objs,
export_global_ids, export_local_ids,
wgt_dim, &fdummy, export_to_part);
if (error == ZOLTAN_OK){
ZOLTAN_FREE(&fdummy);
if (*num_export_objs) {
if (Zoltan_Special_Malloc(zz, (void **)export_procs, *num_export_objs,
ZOLTAN_SPECIAL_MALLOC_INT)){
for (i=0; i<*num_export_objs; i++)
(*export_procs)[i] = zz->Proc;
}
else{
error = ZOLTAN_MEMERR;
}
}
}
if ((error != ZOLTAN_OK) && (error != ZOLTAN_WARN)) goto End;
}
else{
all_num_obj = zz->Get_Num_Obj(zz->Get_Num_Obj_Data, &error);
if (*num_export_objs < all_num_obj){
/* Create a lookup table for exported IDs */
ts = Zoltan_Recommended_Hash_Size(*num_export_objs);
ht = create_hash_table(zz, *export_global_ids, *num_export_objs, ts);
/* Create a list of all gids, lids and parts */
error= Zoltan_Get_Obj_List_Special_Malloc(zz, &all_num_obj,
&all_global_ids, &all_local_ids,
wgt_dim, &fdummy, &parts);
if ((error == ZOLTAN_OK) || (error == ZOLTAN_WARN)){
ZOLTAN_FREE(&fdummy);
if ((Zoltan_Special_Malloc(zz, (void **)(void*)&export_all_procs,
all_num_obj, ZOLTAN_SPECIAL_MALLOC_INT)==0) ||
(Zoltan_Special_Malloc(zz, (void **)(void*)&export_all_to_part,
all_num_obj, ZOLTAN_SPECIAL_MALLOC_INT)==0)){
error = ZOLTAN_MEMERR;
}
}
if ((error != ZOLTAN_OK) && (error != ZOLTAN_WARN)){
sprintf(msg, "Error building complete export list; "
"%d returned by Zoltan_Get_Obj_List\n", error);
ZOLTAN_PRINT_ERROR(zz->Proc, yo, msg);
goto End;
}
gid = all_global_ids;
for (i=0; i < all_num_obj; i++, gid += zz->Num_GID){
idIdx = search_hash_table(zz, gid, ht, ts);
if (idIdx >= 0){
export_all_procs[i] = (*export_procs)[idIdx];
export_all_to_part[i] = (*export_to_part)[idIdx];
}
else{
export_all_procs[i] = zz->Proc;
export_all_to_part[i] = parts[i];
}
}
free_hash_table(ht, ts);
Zoltan_LB_Special_Free_Part(zz, export_global_ids, export_local_ids,
export_procs, export_to_part);
Zoltan_Special_Free(zz, (void **)(void*)&parts,
ZOLTAN_SPECIAL_MALLOC_INT);
*export_global_ids = all_global_ids;
*export_local_ids = all_local_ids;
*export_procs = export_all_procs;
*export_to_part = export_all_to_part;
*num_export_objs = all_num_obj;
}
}
}
ZOLTAN_TRACE_DETAIL(zz, yo, "Done building return arguments");
end_time = Zoltan_Time(zz->Timer);
lb_time[0] = end_time - start_time;
if (zz->Debug_Level >= ZOLTAN_DEBUG_LIST) {
int i;
Zoltan_Print_Sync_Start(zz->Communicator, TRUE);
printf("ZOLTAN: Objects to be imported to Proc %d\n", zz->Proc);
for (i = 0; i < *num_import_objs; i++) {
printf(" Obj: ");
ZOLTAN_PRINT_GID(zz, &((*import_global_ids)[i*zz->Num_GID]));
printf(" To part: %4d",
(*import_to_part != NULL ? (*import_to_part)[i]
: zz->Proc));
printf(" From processor: %4d\n", (*import_procs)[i]);
}
printf("\n");
printf("ZOLTAN: Objects to be exported from Proc %d\n", zz->Proc);
for (i = 0; i < *num_export_objs; i++) {
printf(" Obj: ");
ZOLTAN_PRINT_GID(zz, &((*export_global_ids)[i*zz->Num_GID]));
printf(" To part: %4d",
(*export_to_part != NULL ? (*export_to_part)[i]
: (*export_procs)[i]));
printf(" To processor: %4d\n", (*export_procs)[i]);
}
Zoltan_Print_Sync_End(zz->Communicator, TRUE);
}
/*
* If the Help_Migrate flag is set, perform migration for the application.
*/
if (zz->Migrate.Auto_Migrate) {
ZOLTAN_TRACE_DETAIL(zz, yo, "Begin auto-migration");
start_time = Zoltan_Time(zz->Timer);
error = Zoltan_Migrate(zz,
*num_import_objs, *import_global_ids,
*import_local_ids, *import_procs, *import_to_part,
*num_export_objs, *export_global_ids,
*export_local_ids, *export_procs, *export_to_part);
if (error != ZOLTAN_OK && error != ZOLTAN_WARN) {
sprintf(msg, "Error in auto-migration; %d returned from "
"Zoltan_Help_Migrate\n", error);
ZOLTAN_PRINT_ERROR(zz->Proc, yo, msg);
goto End;
}
end_time = Zoltan_Time(zz->Timer);
lb_time[1] = end_time - start_time;
ZOLTAN_TRACE_DETAIL(zz, yo, "Done auto-migration");
}
/* Print timing info */
if (zz->Debug_Level >= ZOLTAN_DEBUG_ZTIME) {
if (zz->Proc == zz->Debug_Proc) {
printf("ZOLTAN Times: \n");
}
Zoltan_Print_Stats (zz->Communicator, zz->Debug_Proc, lb_time[0],
"ZOLTAN Partition: ");
if (zz->Migrate.Auto_Migrate)
Zoltan_Print_Stats (zz->Communicator, zz->Debug_Proc, lb_time[1],
"ZOLTAN Migrate: ");
}
*changes = 1;
End:
ZOLTAN_TRACE_EXIT(zz, yo);
return (error);
}
int Zoltan_LB_Balance(
ZZ *zz,
int *changes,
int *num_gid_entries,
int *num_lid_entries,
int *num_import_objs,
ZOLTAN_ID_PTR *import_global_ids,
ZOLTAN_ID_PTR *import_local_ids,
int **import_procs,
int *num_export_objs,
ZOLTAN_ID_PTR *export_global_ids,
ZOLTAN_ID_PTR *export_local_ids,
int **export_procs
)
{
/*
* Wrapper around Zoltan_LB for backward compatibility with
* previous Zoltan versions.
* Appropriate only when (# requested parts == # processors), uniformly
* distributed.
* Arguments correspond directly with arguments of Zoltan_LB.
*/
char *yo = "Zoltan_LB_Balance";
int ierr = ZOLTAN_OK; /* Error code */
int *import_to_part = NULL; /* Array used as dummy arg in partitioning. */
int *export_to_part = NULL; /* Array used as dummy arg in partitioning. */
#ifdef ZOLTAN_OVIS
struct OVIS_parameters ovisParameters;
#endif
ZOLTAN_TRACE_ENTER(zz, yo);
/* Determine whether part parameters were set. Report error if
* values are unreasonable. */
if ((zz->LB.Num_Global_Parts_Param != -1 &&
zz->LB.Num_Global_Parts_Param != zz->Num_Proc) ||
(zz->LB.Num_Local_Parts_Param != -1 &&
zz->LB.Num_Local_Parts_Param != 1)) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo,
"Non-uniform distribution of parts over processors is specified; "
"use Zoltan_LB_Partition.");
ierr = ZOLTAN_FATAL;
goto End;
}
#ifdef ZOLTAN_OVIS
Zoltan_OVIS_Setup(zz, &ovisParameters);
if (ovisParameters.outputLevel > 5){
int error = ZOLTAN_OK; /* Error code */
int acg_num_obj = zz->Get_Num_Obj(zz->Get_Num_Obj_Data, &error);
printf ("Entering Proc %d num_objs %d\n", zz->Proc, acg_num_obj);
}
#endif
ierr = Zoltan_LB(zz, 0, changes, num_gid_entries, num_lid_entries,
num_import_objs, import_global_ids, import_local_ids,
import_procs, &import_to_part,
num_export_objs, export_global_ids,
export_local_ids, export_procs, &export_to_part);
End:
#ifdef ZOLTAN_OVIS
if (ovisParameters.outputLevel > 5){
printf ("Exiting Proc %d num_import_objs %d num_export_objs %d\n", zz->Proc, *num_import_objs, *num_export_objs);
}
#endif
/* Not returning import/export part information; free it if allocated. */
if (import_to_part != NULL)
Zoltan_Special_Free(zz, (void **)(void*) &import_to_part,
ZOLTAN_SPECIAL_MALLOC_INT);
if (export_to_part != NULL)
Zoltan_Special_Free(zz, (void **)(void*) &export_to_part,
ZOLTAN_SPECIAL_MALLOC_INT);
ZOLTAN_TRACE_EXIT(zz, yo);
return(ierr);
}
/*
* void Zoltan_Oct_fix_tags()
*
* fixes the import tags so that region tags that were previously
* exported aren't counted when imported back.
*/
int Zoltan_Oct_fix_tags(ZZ *zz, ZOLTAN_ID_PTR *import_global_ids,
ZOLTAN_ID_PTR *import_local_ids, int **import_procs,
int **import_to_part, int nrectags,
pRegion import_regs) {
char *yo = "Zoltan_Oct_fix_tags";
int i; /* index counter */
int ierr = ZOLTAN_OK;
int num_gid_entries = zz->Num_GID;
int num_lid_entries = zz->Num_LID;
/* allocate memory */
if (!Zoltan_Special_Malloc(zz,(void **)import_global_ids,nrectags,
ZOLTAN_SPECIAL_MALLOC_GID)) {
ZOLTAN_PRINT_ERROR(zz->Proc,yo, "Insufficient memory.");
ZOLTAN_TRACE_EXIT(zz, yo);
return ZOLTAN_MEMERR;
}
if (!Zoltan_Special_Malloc(zz,(void **)import_local_ids,nrectags,
ZOLTAN_SPECIAL_MALLOC_LID)) {
Zoltan_Special_Free(zz,(void **)import_global_ids,
ZOLTAN_SPECIAL_MALLOC_GID);
ZOLTAN_PRINT_ERROR(zz->Proc,yo, "Insufficient memory.");
ZOLTAN_TRACE_EXIT(zz, yo);
return ZOLTAN_MEMERR;
}
if (!Zoltan_Special_Malloc(zz,(void **)import_procs,nrectags,
ZOLTAN_SPECIAL_MALLOC_INT)) {
Zoltan_Special_Free(zz,(void **)import_global_ids,
ZOLTAN_SPECIAL_MALLOC_GID);
Zoltan_Special_Free(zz,(void **)import_local_ids,
ZOLTAN_SPECIAL_MALLOC_LID);
ZOLTAN_PRINT_ERROR(zz->Proc,yo, "Insufficient memory.");
ZOLTAN_TRACE_EXIT(zz, yo);
return ZOLTAN_MEMERR;
}
if (!Zoltan_Special_Malloc(zz,(void **)import_to_part,nrectags,
ZOLTAN_SPECIAL_MALLOC_INT)) {
Zoltan_Special_Free(zz,(void **)import_global_ids,
ZOLTAN_SPECIAL_MALLOC_GID);
Zoltan_Special_Free(zz,(void **)import_local_ids,
ZOLTAN_SPECIAL_MALLOC_LID);
Zoltan_Special_Free(zz,(void **)import_procs,ZOLTAN_SPECIAL_MALLOC_INT);
ZOLTAN_PRINT_ERROR(zz->Proc,yo, "Insufficient memory.");
ZOLTAN_TRACE_EXIT(zz, yo);
return ZOLTAN_MEMERR;
}
/* for each region imported, look at its originating processor */
for(i=0; i<nrectags; i++) {
ZOLTAN_SET_GID(zz, &((*import_global_ids)[i*num_gid_entries]),
import_regs[i].Global_ID);
ZOLTAN_SET_LID(zz, &((*import_local_ids)[i*num_lid_entries]),
import_regs[i].Local_ID);
(*import_procs)[i] = import_regs[i].newProc;
/*(*import_to_part)[i] = zz->Proc;*/
(*import_to_part)[i] = import_regs[i].newProc;
}
return ierr;
}
static int _Zoltan_Get_Obj_List(
ZZ *zz,
int *num_obj,
ZOLTAN_ID_PTR *global_ids,
ZOLTAN_ID_PTR *local_ids,
int wdim,
float **objwgts,
int **parts,
int special_malloc
)
{
char *yo = "_Zoltan_Get_Obj_List";
int i, n;
int num_gid_entries = zz->Num_GID;
int num_lid_entries = zz->Num_LID;
int alloced_gids = 0, alloced_lids = 0;
int gid_off, lid_off;
ZOLTAN_ID_PTR lid, next_lid; /* Temporary pointers to local IDs; used to pass
NULL to query functions when
NUM_LID_ENTRIES == 0. */
float *next_objwgt; /* Temporarry pointer to an object weight; used
to pass NULL to query functions when wdim=0 */
int ierr = ZOLTAN_OK;
ZOLTAN_TRACE_ENTER(zz, yo);
*num_obj = 0;
*objwgts = NULL;
if (zz->Get_Num_Obj != NULL) {
*num_obj = zz->Get_Num_Obj(zz->Get_Num_Obj_Data, &ierr);
if (ierr != ZOLTAN_OK && ierr != ZOLTAN_WARN) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Error returned from Get_Num_Obj.");
goto End;
}
}
else {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Must register ZOLTAN_NUM_OBJ_FN.");
ierr = ZOLTAN_FATAL;
goto End;
}
if (*num_obj > 0) {
/*
* Test global_ids and local_ids for NULL.
* Should be NULL for doing partitioning.
* Should not be NULL if doing ordering.
*/
if (special_malloc){
if (*global_ids == NULL) {
Zoltan_Special_Malloc(zz, (void **)global_ids,
*num_obj, ZOLTAN_SPECIAL_MALLOC_GID);
alloced_gids = 1;
}
if (*local_ids == NULL) {
Zoltan_Special_Malloc(zz, (void **)local_ids,
*num_obj, ZOLTAN_SPECIAL_MALLOC_LID);
alloced_lids = 1;
}
Zoltan_Special_Malloc(zz, (void **)parts,
*num_obj, ZOLTAN_SPECIAL_MALLOC_INT);
}
else{
if (*global_ids == NULL) {
*global_ids = ZOLTAN_MALLOC_GID_ARRAY(zz, *num_obj);
alloced_gids = 1;
}
if (*local_ids == NULL) {
*local_ids = ZOLTAN_MALLOC_LID_ARRAY(zz, *num_obj);
alloced_lids = 1;
}
*parts = (int *) ZOLTAN_MALLOC(*num_obj * sizeof(int));
}
if (wdim > 0)
*objwgts = (float*) ZOLTAN_MALLOC (sizeof(float) * *num_obj * wdim);
if ((*global_ids == NULL) || (num_lid_entries > 0 && *local_ids == NULL) ||
(*parts == NULL) ||
(wdim > 0 && *objwgts == NULL)) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Memory Error.");
ierr = ZOLTAN_MEMERR;
goto End;
}
if (zz->Get_Obj_List != NULL){
/* Get object list directly */
zz->Get_Obj_List(zz->Get_Obj_List_Data,
num_gid_entries, num_lid_entries,
*global_ids, *local_ids,
wdim, *objwgts, &ierr);
}
else if ((zz->Get_First_Obj != NULL) && (zz->Get_Next_Obj != NULL)){
/* Use iterator functions to loop through object list */
if (zz->Get_First_Obj(zz->Get_First_Obj_Data,
num_gid_entries, num_lid_entries,
*global_ids, *local_ids,
wdim, *objwgts, &ierr)){
n = *num_obj;
i = 0;
while (!ierr && (i<n-1)){
gid_off = i * num_gid_entries;
lid_off = i * num_lid_entries;
lid = (num_lid_entries ? &((*local_ids)[lid_off]) : NULL);
next_lid = (num_lid_entries ? &((*local_ids)[lid_off+num_lid_entries])
: NULL);
next_objwgt = (wdim ? (*objwgts) + (i+1)*wdim : NULL);
zz->Get_Next_Obj(zz->Get_Next_Obj_Data,
num_gid_entries, num_lid_entries,
&((*global_ids)[gid_off]), lid,
&((*global_ids)[gid_off+num_gid_entries]),
next_lid,
wdim, next_objwgt, &ierr);
i++;
}
}
}
else { /* No way to get objects */
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Must register ZOLTAN_OBJ_LIST_FN or "
"ZOLTAN_FIRST_OBJ_FN/ZOLTAN_NEXT_OBJ_FN.");
ierr = ZOLTAN_FATAL;
goto End;
}
/* Get partition information for objects. */
/* Call user-callback if provided; otherwise, all parts == zz->Proc */
if (zz->Get_Part == NULL && zz->Get_Part_Multi == NULL) {
for (i = 0; i < *num_obj; i++)
(*parts)[i] = zz->Proc;
}
else if (zz->Get_Part_Multi) {
zz->Get_Part_Multi(zz->Get_Part_Multi_Data,
num_gid_entries, num_lid_entries, *num_obj,
*global_ids, *local_ids, *parts, &ierr);
if (ierr != ZOLTAN_OK && ierr != ZOLTAN_WARN) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo,
"Error returned from ZOLTAN_PART_MULTI_FN");
goto End;
}
}
else {
for (i = 0; i < *num_obj; i++) {
lid = (num_lid_entries ? &((*local_ids)[i*num_lid_entries]) : NULL);
(*parts)[i] = zz->Get_Part(zz->Get_Part_Data,
num_gid_entries, num_lid_entries,
&((*global_ids)[i*num_gid_entries]), lid, &ierr);
if (ierr != ZOLTAN_OK && ierr != ZOLTAN_WARN) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo,
"Error returned from ZOLTAN_PART_FN");
goto End;
}
}
}
}
End:
if (ierr != ZOLTAN_OK && ierr != ZOLTAN_WARN) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Error found; no lists returned.");
if (special_malloc){
if (alloced_gids)
Zoltan_Special_Free(zz, (void **)global_ids, ZOLTAN_SPECIAL_MALLOC_GID);
if (alloced_lids)
Zoltan_Special_Free(zz, (void **)local_ids, ZOLTAN_SPECIAL_MALLOC_LID);
Zoltan_Special_Free(zz, (void **)parts, ZOLTAN_SPECIAL_MALLOC_INT);
}
else{
if (alloced_gids) ZOLTAN_FREE(global_ids);
if (alloced_lids) ZOLTAN_FREE(local_ids);
ZOLTAN_FREE(parts);
}
ZOLTAN_FREE(objwgts);
}
ZOLTAN_TRACE_EXIT(zz, yo);
return ierr;
}
int Zoltan_Invert_Lists(
ZZ *zz, /* Zoltan structure. */
int num_in, /* Number of objects in the input lists. */
ZOLTAN_ID_PTR in_global_ids, /* Array of input global IDs. */
ZOLTAN_ID_PTR in_local_ids, /* Array of input local IDs. */
int *in_procs, /* Array of processor IDs of processors owning
the input objects. */
int *in_to_part, /* Optional: Array of partition numbers to
which input objects should be assigned. */
int *num_out, /* Returned value: Number of output objs. */
ZOLTAN_ID_PTR *out_global_ids,/* Returned value: Array of global IDs of
output objects. */
ZOLTAN_ID_PTR *out_local_ids, /* Returned value: Array of local IDs of
output objects. */
int **out_procs, /* Returned value: Array of processor IDs
to which output objects are assigned. */
int **out_to_part /* Optional: Returned value: Array of
partition numbers to which output
objects should be assigned. */
)
{
/*
* Routine to compute the inverse map. Can be used in two ways:
* 1. Given, for each processor, a list of objects to be received by the
* processor, compute the list of objects that the processor needs to send
* to other processors to satisfy their needs.
* 2. Given, for each processor, a list of objects to be sent to other
* processors, compute the list of objects that the processor needs to receive
* to satisfy its needs.
*/
char *yo = "Zoltan_Invert_Lists";
char msg[256];
ZOLTAN_COMM_OBJ *comm_plan; /* Object returned communication routines */
int msgtag, msgtag2; /* Message tags for communication routines */
int num_gid_entries, num_lid_entries; /* Length of global and local ids */
int include_parts; /* Flag indicating whether to compute
inverse list for partitions. */
int ierr, ret_ierr = ZOLTAN_OK;
ZOLTAN_TRACE_ENTER(zz, yo);
/*
* Return if this processor is not in the Zoltan structure's
* communicator.
*/
if (ZOLTAN_PROC_NOT_IN_COMMUNICATOR(zz)) {
ZOLTAN_TRACE_EXIT(zz, yo);
return (ZOLTAN_OK);
}
/*
* Check that all procs use the same id types.
*/
ierr = check_invert_input(zz, num_in, in_procs, in_to_part,
&num_gid_entries, &num_lid_entries, &include_parts);
if (ierr != ZOLTAN_OK) {
ZOLTAN_TRACE_EXIT(zz, yo);
return ierr;
}
/* Initialize returned arrays. */
*out_global_ids = NULL;
*out_local_ids = NULL;
*out_procs = NULL;
if (include_parts) *out_to_part = NULL;
/*
* Compute communication map and num_out, the number of objs this
* processor has to out to establish the new decomposition.
*/
msgtag = 32767;
ierr = Zoltan_Comm_Create(&comm_plan, num_in, in_procs, zz->Communicator,
msgtag, num_out);
if (ierr != ZOLTAN_OK && ierr != ZOLTAN_WARN) {
sprintf(msg, "Error %s returned from Zoltan_Comm_Create.",
(ierr == ZOLTAN_MEMERR ? "ZOLTAN_MEMERR" : "ZOLTAN_FATAL"));
ZOLTAN_PRINT_ERROR(zz->Proc, yo, msg);
ret_ierr = ierr;
goto End;
}
ZOLTAN_TRACE_DETAIL(zz, yo, "Done comm create");
/*
* Allocate space for the object tags that need to be outed. Communicate
* to get the list of objects to be outed.
*/
if (*num_out > 0) {
if (!Zoltan_Special_Malloc(zz,(void **)out_global_ids,*num_out,
ZOLTAN_SPECIAL_MALLOC_GID)) {
ret_ierr = ZOLTAN_MEMERR;
goto End;
}
if (!Zoltan_Special_Malloc(zz,(void **)out_local_ids,*num_out,
ZOLTAN_SPECIAL_MALLOC_LID)) {
ret_ierr = ZOLTAN_MEMERR;
goto End;
}
if (!Zoltan_Special_Malloc(zz,(void **)out_procs,*num_out,
ZOLTAN_SPECIAL_MALLOC_INT)) {
ret_ierr = ZOLTAN_MEMERR;
goto End;
}
if (include_parts) {
if (!Zoltan_Special_Malloc(zz,(void **)out_to_part,*num_out,
ZOLTAN_SPECIAL_MALLOC_INT)) {
ret_ierr = ZOLTAN_MEMERR;
goto End;
}
}
}
/*
* Use the communication plan to send global IDs, local IDs, and processor
* numbers. Do in separate communications to avoid a memory copy and to
* simplify implementation when a data type is added to the comm. package
* (to support heterogeneous computing).
*/
msgtag2 = 32766;
ierr = Zoltan_Comm_Do(comm_plan, msgtag2, (char *) in_global_ids,
(int) (sizeof(ZOLTAN_ID_TYPE)*(num_gid_entries)),
(char *) *out_global_ids);
if (ierr != ZOLTAN_OK && ierr != ZOLTAN_WARN) {
sprintf(msg, "Error %s returned from Zoltan_Comm_Do.",
(ierr == ZOLTAN_MEMERR ? "ZOLTAN_MEMERR" : "ZOLTAN_FATAL"));
ZOLTAN_PRINT_ERROR(zz->Proc, yo, msg);
ret_ierr = ierr;
}
if (num_lid_entries) {
msgtag2--;
ierr = Zoltan_Comm_Do(comm_plan, msgtag2, (char *) in_local_ids,
(int) (sizeof(ZOLTAN_ID_TYPE)*num_lid_entries),
(char *) *out_local_ids);
if (ierr != ZOLTAN_OK && ierr != ZOLTAN_WARN) {
sprintf(msg, "Error %s returned from Zoltan_Comm_Do.",
(ierr == ZOLTAN_MEMERR ? "ZOLTAN_MEMERR" : "ZOLTAN_FATAL"));
ZOLTAN_PRINT_ERROR(zz->Proc, yo, msg);
ret_ierr = ierr;
}
}
Zoltan_Comm_Info(comm_plan, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, *out_procs, NULL);
if (include_parts) {
msgtag2--;
ierr = Zoltan_Comm_Do(comm_plan, msgtag2, (char *) in_to_part,
(int) sizeof(int), (char *) *out_to_part);
if (ierr != ZOLTAN_OK && ierr != ZOLTAN_WARN) {
sprintf(msg, "Error %s returned from Zoltan_Comm_Do.",
(ierr == ZOLTAN_MEMERR ? "ZOLTAN_MEMERR" : "ZOLTAN_FATAL"));
ZOLTAN_PRINT_ERROR(zz->Proc, yo, msg);
ret_ierr = ierr;
}
}
ZOLTAN_TRACE_DETAIL(zz, yo, "Done comm_do");
End:
Zoltan_Comm_Destroy(&comm_plan);
if (ret_ierr == ZOLTAN_MEMERR) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Insufficient memory.");
Zoltan_Special_Free(zz,(void**)out_global_ids,ZOLTAN_SPECIAL_MALLOC_GID);
Zoltan_Special_Free(zz,(void**)out_local_ids,ZOLTAN_SPECIAL_MALLOC_LID);
Zoltan_Special_Free(zz,(void**)out_procs,ZOLTAN_SPECIAL_MALLOC_INT);
if (include_parts)
Zoltan_Special_Free(zz,(void**)out_to_part,ZOLTAN_SPECIAL_MALLOC_INT);
}
ZOLTAN_TRACE_EXIT(zz, yo);
return (ret_ierr);
}
static int Zoltan_PHG_Return_Lists (
ZZ *zz,
ZHG *zhg,
int *num_exp,
ZOLTAN_ID_PTR *exp_gids,
ZOLTAN_ID_PTR *exp_lids,
int **exp_procs,
int **exp_to_part)
{
/* Routine to build export lists of ZOLTAN_LB_FN. */
char *yo = "Zoltan_PHG_Return_Lists";
int i, j;
int ierr = ZOLTAN_OK;
int eproc;
int num_gid_entries = zz->Num_GID;
int num_lid_entries = zz->Num_LID;
int nObj = zhg->nObj;
Partition input_parts = zhg->Input_Parts;
ZOLTAN_ID_PTR gids = zhg->GIDs;
ZOLTAN_ID_PTR lids = zhg->LIDs;
int *outparts = zhg->Output_Parts;
if (zz->LB.Return_Lists == ZOLTAN_LB_NO_LISTS)
goto End;
/* Count number of objects with new partitions or new processors. */
*num_exp = 0;
for (i = 0; i < nObj; i++) {
eproc = Zoltan_LB_Part_To_Proc(zz, outparts[i], &gids[i*num_gid_entries]);
if (outparts[i] != input_parts[i] || zz->Proc != eproc)
(*num_exp)++;
}
/* Allocate memory for return lists. */
if (*num_exp > 0) {
if (!Zoltan_Special_Malloc(zz, (void**)exp_gids, *num_exp,
ZOLTAN_SPECIAL_MALLOC_GID)
|| !Zoltan_Special_Malloc(zz, (void**)exp_lids, *num_exp,
ZOLTAN_SPECIAL_MALLOC_LID)
|| !Zoltan_Special_Malloc(zz, (void**)exp_procs, *num_exp,
ZOLTAN_SPECIAL_MALLOC_INT)
|| !Zoltan_Special_Malloc(zz, (void**)exp_to_part, *num_exp,
ZOLTAN_SPECIAL_MALLOC_INT)) {
Zoltan_Special_Free(zz,(void**)exp_gids, ZOLTAN_SPECIAL_MALLOC_GID);
Zoltan_Special_Free(zz,(void**)exp_lids, ZOLTAN_SPECIAL_MALLOC_LID);
Zoltan_Special_Free(zz,(void**)exp_procs, ZOLTAN_SPECIAL_MALLOC_INT);
Zoltan_Special_Free(zz,(void**)exp_to_part,ZOLTAN_SPECIAL_MALLOC_INT);
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Memory error.");
ierr = ZOLTAN_MEMERR;
goto End;
}
for (j = 0, i = 0; i < nObj; i++) {
eproc = Zoltan_LB_Part_To_Proc(zz, outparts[i], &gids[i*num_gid_entries]);
if (outparts[i] != input_parts[i] || eproc != zz->Proc) {
ZOLTAN_SET_GID(zz, &((*exp_gids)[j*num_gid_entries]),
&(gids[i*num_gid_entries]));
if (num_lid_entries > 0)
ZOLTAN_SET_LID(zz, &((*exp_lids)[j*num_lid_entries]),
&(lids[i*num_lid_entries]));
(*exp_procs) [j] = eproc;
(*exp_to_part)[j] = outparts[i];
j++;
}
}
}
End:
return ierr;
}
static int
Zoltan_Postprocess_Partition (ZZ *zz,
ZOLTAN_Third_Graph *gr,
ZOLTAN_Third_Part *prt,
ZOLTAN_Output_Part *part,
ZOLTAN_ID_PTR global_ids,
ZOLTAN_ID_PTR local_ids)
{
static char * yo = "Zoltan_Postprocess_Partition";
int ierr = ZOLTAN_OK;
int i, j, nsend;
int *newproc, *tmp_part, *tmp_input_part;
int num_gid_entries = zz->Num_GID;
int num_lid_entries = zz->Num_LID;
/* Partitioning */
/* Determine new processor and number of objects to export */
newproc = (int *) ZOLTAN_MALLOC(gr->num_obj * sizeof(int));
if (gr->num_obj && !newproc){
/* Not enough memory */
ZOLTAN_THIRD_ERROR(ZOLTAN_MEMERR, "Out of memory. ");
}
for (i=0; i<gr->num_obj; i++){
newproc[i] = Zoltan_LB_Part_To_Proc(zz, (int)prt->part[i],
&(global_ids[i*num_gid_entries]));
if (newproc[i]<0){
ZOLTAN_FREE(&newproc);
ZOLTAN_THIRD_ERROR(ZOLTAN_FATAL,
"Zoltan_LB_Part_To_Proc returned invalid processor number.");
}
}
if (zz->LB.Remap_Flag) {
int new_map;
if (sizeof(indextype) == sizeof(int)){
ierr = Zoltan_LB_Remap(zz, &new_map, gr->num_obj, newproc, (int *)prt->input_part,
(int *)prt->part, 1);
}
else{
tmp_part = (int *)ZOLTAN_MALLOC(sizeof(int) * gr->num_obj);
tmp_input_part = (int *)ZOLTAN_MALLOC(sizeof(int) * gr->num_obj);
if (gr->num_obj && (!tmp_part || !tmp_input_part)){
ZOLTAN_THIRD_ERROR(ZOLTAN_MEMERR, "Not enough memory.");
}
for (i=0; i < gr->num_obj; i++){
tmp_part[i] = (int)prt->part[i];
tmp_input_part[i] = (int)prt->input_part[i];
}
ierr = Zoltan_LB_Remap(zz, &new_map, gr->num_obj, newproc, tmp_input_part, tmp_part, 1);
for (i=0; i < gr->num_obj; i++){
prt->part[i] = (indextype)tmp_part[i];
prt->input_part[i] = (indextype)tmp_input_part[i];
}
ZOLTAN_FREE(&tmp_part);
ZOLTAN_FREE(&tmp_input_part);
}
if (ierr < 0) {
ZOLTAN_FREE(&newproc);
ZOLTAN_THIRD_ERROR(ZOLTAN_FATAL,
"Error returned from Zoltan_LB_Remap");
}
}
nsend = 0;
for (i=0; i<gr->num_obj; i++){
if ((prt->part[i] != prt->input_part[i]) || ((!part->compute_only_part_changes) &&
(newproc[i] != zz->Proc)))
nsend++;
if (zz->Debug_Level >= ZOLTAN_DEBUG_ALL)
printf("[%1d] DEBUG: local object %1d: old part = " TPL_IDX_SPEC ", new part = " TPL_IDX_SPEC "\n",
zz->Proc, i, prt->input_part[i], prt->part[i]);
}
/* Create export lists */
if (zz->LB.Return_Lists){
if (zz->LB.Return_Lists == ZOLTAN_LB_CANDIDATE_LISTS) {
ZOLTAN_THIRD_ERROR(ZOLTAN_FATAL, "Candidate Lists not supported in GRAPH;"
"change RETURN_LISTS parameter.");
}
part->num_exp = nsend;
if (nsend > 0) {
if (!Zoltan_Special_Malloc(zz,(void **)part->exp_gids,nsend,ZOLTAN_SPECIAL_MALLOC_GID)) {
ZOLTAN_FREE(&newproc);
ZOLTAN_THIRD_ERROR(ZOLTAN_MEMERR, "Not enough memory.");
}
if (!Zoltan_Special_Malloc(zz,(void **)part->exp_lids,nsend,ZOLTAN_SPECIAL_MALLOC_LID)) {
Zoltan_Special_Free(zz,(void **)part->exp_gids,ZOLTAN_SPECIAL_MALLOC_GID);
ZOLTAN_FREE(&newproc);
ZOLTAN_THIRD_ERROR(ZOLTAN_MEMERR, "Not enough memory.");
}
if (!Zoltan_Special_Malloc(zz,(void **)part->exp_procs,nsend,ZOLTAN_SPECIAL_MALLOC_INT)) {
Zoltan_Special_Free(zz,(void **)part->exp_lids,ZOLTAN_SPECIAL_MALLOC_LID);
Zoltan_Special_Free(zz,(void **)part->exp_gids,ZOLTAN_SPECIAL_MALLOC_GID);
ZOLTAN_FREE(&newproc);
ZOLTAN_THIRD_ERROR(ZOLTAN_MEMERR, "Not enough memory.");
}
if (!Zoltan_Special_Malloc(zz,(void **)part->exp_part,nsend,ZOLTAN_SPECIAL_MALLOC_INT)) {
Zoltan_Special_Free(zz,(void **)part->exp_lids,ZOLTAN_SPECIAL_MALLOC_LID);
Zoltan_Special_Free(zz,(void **)part->exp_gids,ZOLTAN_SPECIAL_MALLOC_GID);
Zoltan_Special_Free(zz,(void **)part->exp_procs,ZOLTAN_SPECIAL_MALLOC_INT);
ZOLTAN_FREE(&newproc);
ZOLTAN_THIRD_ERROR(ZOLTAN_MEMERR, "Not enough memory.");
}
j = 0;
for (i=0; i<gr->num_obj; i++){
if ((prt->part[i] != prt->input_part[i]) || ((!part->compute_only_part_changes)
&& (newproc[i] != zz->Proc))){
/* Object should move to new partition or processor */
ZOLTAN_SET_GID(zz, &((*(part->exp_gids))[j*num_gid_entries]),
&(global_ids[i*num_gid_entries]));
if (num_lid_entries)
ZOLTAN_SET_LID(zz, &((*(part->exp_lids))[j*num_lid_entries]),
&(local_ids[i*num_lid_entries]));
(*(part->exp_part))[j] = (int)prt->part[i];
(*(part->exp_procs))[j] = newproc[i];
/* printf("[%1d] Debug: Move object %1d to part %1d, proc %1d\n", */
/* zz->Proc, i, prt->part[i], newproc[i]); */
j++;
}
}
}
}
ZOLTAN_FREE(&newproc);
return (ZOLTAN_OK);
}
