int Zoltan_OVIS_Setup(
ZZ *zz, /* Input: Zoltan structure with input parameter strings */
struct OVIS_parameters *ovisParameters /* Output: parameter values */
)
{
/* Allow OVIS parameters to be passed to Zoltan via Zoltan_Set_Param */
/* Three example parameters below. */
/* Declare variables for parameter values; initialize to default values */
ovisParameters->outputLevel = 1;
ovisParameters->minVersion = 0.1;
strcpy(ovisParameters->hello, "Howdy!");
strcpy(ovisParameters->dll, "");
/* Tell Zoltan to associate parameter names with the variables. */
Zoltan_Bind_Param(OVIS_params, "OVIS_HELLO",
ovisParameters->hello);
Zoltan_Bind_Param(OVIS_params, "OVIS_DLL",
ovisParameters->dll);
Zoltan_Bind_Param(OVIS_params, "OVIS_OUTPUT_LEVEL",
(void *) &(ovisParameters->outputLevel));
Zoltan_Bind_Param(OVIS_params, "OVIS_MINVERSION",
(void *) &(ovisParameters->minVersion));
/* Tell Zoltan to look for parameters matching the names above */
Zoltan_Assign_Param_Vals(zz->Params, OVIS_params, zz->Debug_Level, zz->Proc,
zz->Debug_Proc);
return ZOLTAN_OK;
}
int Zoltan_Build_Machine_Desc(
ZZ *zz /* The Zoltan structure. */
)
{
char *yo = "Zoltan_Build_Machine_Desc";
int ierr = ZOLTAN_OK;
int use_mach_desc;
char filename[256];
Zoltan_Bind_Param(Mach_params, "USE_MACHINE_DESC", (void *) &use_mach_desc);
Zoltan_Bind_Param(Mach_params, "MACHINE_DESC_FILE", (void *) filename);
use_mach_desc = 0;
strcpy(filename, MACHINE_DESC_FILE_DEFAULT);
Zoltan_Assign_Param_Vals(zz->Params, Mach_params, zz->Debug_Level, zz->Proc,
zz->Debug_Proc);
if (use_mach_desc > 0) {
/* If zz->Machine_Desc already exists, don't rebuild it
* unless USE_MACHINE_DESC has been set to 2.
*/
if ((zz->Machine_Desc == NULL) || (use_mach_desc==2)){
/* Read machine description from file.
* Use Zoltan_Get_Processor_Name to extract the sub-machine
* on which this Zoltan structure is running.
* Broadcast the machine structure to all procs.
*/
ZOLTAN_PRINT_WARN(zz->Proc, yo, "Sorry, heterogeneous load-balancing "
"is still under development!");
ierr = ZOLTAN_WARN;
}
}
else {
zz->Machine_Desc = NULL;
}
return ierr;
}
int Zoltan_Preprocess_Timer(ZZ *zz, int *use_timers)
{
static int timer_p = -1;
*use_timers = 0;
Zoltan_Bind_Param(Graph_params, "USE_TIMERS", (void *) use_timers);
if (*use_timers) {
if (timer_p < 0)
timer_p = Zoltan_Timer_Init(zz->ZTime, 1, "ThirdLibrary");
ZOLTAN_TIMER_START(zz->ZTime, timer_p, zz->Communicator);
}
return (timer_p);
}
int Zoltan_Random(
ZZ *zz, /* The Zoltan structure. */
float *part_sizes, /* Input: Array of size zz->LB.Num_Global_Parts
* zz->Obj_Weight_Dim
containing the percentage of work to be
assigned to each partition. */
int *num_import, /* Return -1. Random uses only export lists. */
ZOLTAN_ID_PTR *import_global_ids, /* Not used. */
ZOLTAN_ID_PTR *import_local_ids, /* Not used. */
int **import_procs, /* Not used. */
int **import_to_part, /* Not used. */
int *num_export, /* Output: Number of objects to export. */
ZOLTAN_ID_PTR *export_global_ids, /* Output: GIDs to export. */
ZOLTAN_ID_PTR *export_local_ids, /* Output: LIDs to export. */
int **export_procs, /* Output: Processsors to export to. */
int **export_to_part /* Output: Partitions to export to. */
)
{
int ierr = ZOLTAN_OK;
int i, count, num_obj;
int max_export;
double rand_frac = 1.0; /* Default is to move all objects. */
ZOLTAN_ID_PTR global_ids = NULL;
ZOLTAN_ID_PTR local_ids = NULL;
int *parts = NULL;
float *dummy = NULL;
static char *yo = "Zoltan_Random";
static int first_time = 1;
ZOLTAN_TRACE_ENTER(zz, yo);
/* Synchronize the random number generator.
* This synchronization is needed only for sanity in our nightly testing.
* If some other operation (eg., Zoltan_LB_Eval) changes the status of
* the random number generator, the answers here will change. They won't
* be wrong, but they will be different from our accepted answers.
*/
if (first_time) {
Zoltan_Srand(zz->Seed, NULL);
Zoltan_Rand(NULL);
first_time=0;
}
/* No import lists computed. */
*num_import = -1;
/* Get parameter values. */
Zoltan_Bind_Param(Random_params, "RANDOM_MOVE_FRACTION", (void *) &rand_frac);
Zoltan_Assign_Param_Vals(zz->Params, Random_params, zz->Debug_Level,
zz->Proc, zz->Debug_Proc);
/* Get list of local objects. */
ierr = Zoltan_Get_Obj_List(zz, &num_obj, &global_ids, &local_ids, 0,
&dummy, &parts);
/* Bound number of objects to export. */
max_export = 1.5*rand_frac*num_obj;
/* Allocate export lists. */
*export_global_ids = *export_local_ids = NULL;
*export_procs = *export_to_part = NULL;
if (max_export > 0) {
if (!Zoltan_Special_Malloc(zz, (void **)export_global_ids, max_export,
ZOLTAN_SPECIAL_MALLOC_GID)
|| !Zoltan_Special_Malloc(zz, (void **)export_local_ids, max_export,
ZOLTAN_SPECIAL_MALLOC_LID)
|| !Zoltan_Special_Malloc(zz, (void **)export_procs, max_export,
ZOLTAN_SPECIAL_MALLOC_INT)
|| !Zoltan_Special_Malloc(zz, (void **)export_to_part, max_export,
ZOLTAN_SPECIAL_MALLOC_INT)) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Memory error.");
ierr = ZOLTAN_MEMERR;
goto End;
}
}
/* Randomly assign ids to procs. */
count=0;
for (i=0; i<num_obj; i++){
/* Randomly select some objects to move (export) */
if ((count<max_export) && (Zoltan_Rand(NULL)<rand_frac*ZOLTAN_RAND_MAX)){
/* export_global_ids[count] = global_ids[i]; */
ZOLTAN_SET_GID(zz, &((*export_global_ids)[count*zz->Num_GID]),
&global_ids[i*zz->Num_GID]);
if (local_ids)
/* export_local_ids[count] = local_ids[i]; */
ZOLTAN_SET_LID(zz, &((*export_local_ids)[count*zz->Num_LID]),
&local_ids[i*zz->Num_LID]);
/* Randomly pick new partition number. */
(*export_to_part)[count] = Zoltan_Rand_InRange(NULL, zz->LB.Num_Global_Parts);
/* Processor number is derived from partition number. */
(*export_procs)[count] = Zoltan_LB_Part_To_Proc(zz,
(*export_to_part)[count], &global_ids[i*zz->Num_GID]);
/* printf("Debug: Export gid %u to part %d and proc %d.\n", (*export_global_ids)[count], (*export_to_part)[count], (*export_procs)[count]); */
++count;
}
}
(*num_export) = count;
End:
/* Free local memory, but not export lists. */
ZOLTAN_FREE(&global_ids);
ZOLTAN_FREE(&local_ids);
ZOLTAN_FREE(&parts);
ZOLTAN_TRACE_EXIT(zz, yo);
return ierr;
}
int Zoltan_Get_Coordinates(
ZZ *zz,
int num_obj, /* Input: number of objects */
ZOLTAN_ID_PTR global_ids, /* Input: global IDs of objects */
ZOLTAN_ID_PTR local_ids, /* Input: local IDs of objects; may be NULL. */
int *num_dim, /* Output: dimension of coordinates */
double **coords /* Output: array of coordinates; malloc'ed by
fn if NULL upon input. */
)
{
char *yo = "Zoltan_Get_Coordinates";
int i,j,rc;
int num_gid_entries = zz->Num_GID;
int num_lid_entries = zz->Num_LID;
int alloced_coords = 0;
ZOLTAN_ID_PTR lid; /* Temporary pointers to local IDs; used to pass
NULL to query functions when NUM_LID_ENTRIES == 0. */
double dist[3];
double im[3][3];
double deg_ratio;
double x;
int order[3];
int reduce_dimensions, d, axis_aligned;
int target_dim;
int ierr = ZOLTAN_OK;
char msg[256];
ZZ_Transform *tran;
ZOLTAN_TRACE_ENTER(zz, yo);
/* Error check -- make sure needed callback functions are registered. */
if (zz->Get_Num_Geom == NULL ||
(zz->Get_Geom == NULL && zz->Get_Geom_Multi == NULL)) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Must register ZOLTAN_NUM_GEOM_FN and "
"either ZOLTAN_GEOM_MULTI_FN or ZOLTAN_GEOM_FN");
goto End;
}
/* Get problem dimension. */
*num_dim = zz->Get_Num_Geom(zz->Get_Num_Geom_Data, &ierr);
if (ierr != ZOLTAN_OK && ierr != ZOLTAN_WARN) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo,
"Error returned from ZOLTAN_GET_NUM_GEOM_FN");
goto End;
}
if (*num_dim < 0 || *num_dim > 3) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo,
"Invalid dimension returned from ZOLTAN_NUM_GEOM_FN");
goto End;
}
/* Get coordinates for object; allocate memory if not already provided. */
if (*num_dim > 0 && num_obj > 0) {
if (*coords == NULL) {
alloced_coords = 1;
*coords = (double *) ZOLTAN_MALLOC(num_obj * (*num_dim) * sizeof(double));
if (*coords == NULL) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Memory error");
goto End;
}
}
if (zz->Get_Geom_Multi != NULL) {
zz->Get_Geom_Multi(zz->Get_Geom_Multi_Data, zz->Num_GID, zz->Num_LID,
num_obj, global_ids, local_ids, *num_dim, *coords,
&ierr);
if (ierr != ZOLTAN_OK && ierr != ZOLTAN_WARN) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo,
"Error returned from ZOLTAN_GET_GEOM_MULTI_FN");
goto End;
}
}
else {
for (i = 0; i < num_obj; i++) {
lid = (num_lid_entries ? &(local_ids[i*num_lid_entries]) : NULL);
zz->Get_Geom(zz->Get_Geom_Data, num_gid_entries, num_lid_entries,
global_ids + i*num_gid_entries, lid,
(*coords) + i*(*num_dim), &ierr);
if (ierr != ZOLTAN_OK && ierr != ZOLTAN_WARN) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo,
"Error returned from ZOLTAN_GET_GEOM_FN");
goto End;
}
}
}
}
/*
* For RCB, RIB, and HSFC: if REDUCE_DIMENSIONS was selected, compute the
* center of mass and inertial matrix of the coordinates.
*
* For 3D problems: If the geometry is "flat", transform the points so the
* two primary directions lie along the X and Y coordinate axes and project
* to the Z=0 plane. If in addition the geometry is "skinny", project to
* the X axis. (This creates a 2D or 1D problem respectively.)
*
* For 2D problems: If the geometry is essentially a line, transform it's
* primary direction to the X axis and project to the X axis, yielding a
* 1D problem.
*
* Return these points to the partitioning algorithm, in effect partitioning
* in only the 2 (or 1) significant dimensions.
*/
if (((*num_dim == 3) || (*num_dim == 2)) &&
((zz->LB.Method==RCB) || (zz->LB.Method==RIB) || (zz->LB.Method==HSFC))){
Zoltan_Bind_Param(Reduce_Dim_Params, "KEEP_CUTS", (void *)&i);
Zoltan_Bind_Param(Reduce_Dim_Params, "REDUCE_DIMENSIONS",
(void *)&reduce_dimensions);
Zoltan_Bind_Param(Reduce_Dim_Params, "DEGENERATE_RATIO", (void *)°_ratio);
i = 0;
reduce_dimensions = 0;
deg_ratio = 10.0;
Zoltan_Assign_Param_Vals(zz->Params, Reduce_Dim_Params, zz->Debug_Level,
zz->Proc, zz->Debug_Proc);
if (reduce_dimensions == 0){
goto End;
}
if (deg_ratio <= 1){
if (zz->Proc == 0){
ZOLTAN_PRINT_WARN(0, yo, "DEGENERATE_RATIO <= 1, setting it to 10.0");
}
deg_ratio = 10.0;
}
if (zz->LB.Method == RCB){
tran = &(((RCB_STRUCT *)(zz->LB.Data_Structure))->Tran);
}
else if (zz->LB.Method == RIB){
tran = &(((RIB_STRUCT *)(zz->LB.Data_Structure))->Tran);
}
else{
tran = &(((HSFC_Data*)(zz->LB.Data_Structure))->tran);
}
d = *num_dim;
if (tran->Target_Dim >= 0){
/*
* On a previous load balancing call, we determined whether
* or not the geometry was degenerate. If the geometry was
* determined to be not degenerate, then we assume it is still
* not degenerate, and we skip the degeneracy calculation.
*/
if (tran->Target_Dim > 0){
/*
* The geometry *was* degenerate. We test the extent
* of the geometry along the principal directions determined
* last time to determine if it is still degenerate with that
* orientation. If so, we transform the coordinates using the
* same transformation we used last time. If not, we do the
* entire degeneracy calculation again.
*/
if ((tran->Axis_Order[0] >= 0) &&
(tran->Axis_Order[1] >= 0) && (tran->Axis_Order[2] >= 0)){
axis_aligned = 1;
}
else{
axis_aligned = 0;
}
projected_distances(zz, *coords, num_obj, tran->CM,
tran->Evecs, dist, d, axis_aligned, tran->Axis_Order);
target_dim = get_target_dimension(dist, order, deg_ratio, d);
if (target_dim > 0){
transform_coordinates(*coords, num_obj, d, tran);
}
else{
/* Set's Target_Dim to -1, flag to recompute degeneracy */
Zoltan_Initialize_Transformation(tran);
}
}
}
if (tran->Target_Dim < 0){
tran->Target_Dim = 0;
/*
* Get the center of mass and inertial matrix of coordinates. Ignore
* vertex weights, we are only interested in geometry. Global operation.
*/
if (d == 2){
inertial_matrix2D(zz, *coords, num_obj, tran->CM, im);
}
else{
inertial_matrix3D(zz, *coords, num_obj, tran->CM, im);
}
/*
* The inertial matrix is a 3x3 or 2x2 real symmetric matrix. Get its
* three or two orthonormal eigenvectors. These usually indicate the
* orientation of the geometry.
*/
rc = eigenvectors(im, tran->Evecs, d);
if (rc){
if (zz->Proc == 0){
ZOLTAN_PRINT_WARN(0, yo, "REDUCE_DIMENSIONS calculation failed");
}
goto End;
}
/*
* Here we check to see if the eigenvectors are very close
* to the coordinate axes. If so, we can more quickly
* determine whether the geometry is degenerate, and also more
* quickly transform the geometry to the lower dimensional
* space.
*/
axis_aligned = 0;
for (i=0; i<d; i++){
tran->Axis_Order[i] = -1;
}
for (j=0; j<d; j++){
for (i=0; i<d; i++){
x = fabs(tran->Evecs[i][j]);
if (NEAR_ONE(x)){
tran->Axis_Order[j] = i; /* e'vector j is very close to i axis */
break;
}
}
if (tran->Axis_Order[j] < 0){
break;
}
}
if ((tran->Axis_Order[0] >= 0) &&
(tran->Axis_Order[1] >= 0) && (tran->Axis_Order[2] >= 0)){
axis_aligned = 1;
}
/*
* Calculate the extent of the geometry along the three lines defined
* by the direction of the eigenvectors through the center of mass.
*/
projected_distances(zz, *coords, num_obj, tran->CM, tran->Evecs, dist,
d, axis_aligned, tran->Axis_Order);
/*
* Decide whether these distances indicate the geometry is
* very flat in one or two directions.
*/
target_dim = get_target_dimension(dist, order, deg_ratio, d);
if (target_dim > 0){
/*
* Yes, geometry is degenerate
*/
if ((zz->Debug_Level > 0) && (zz->Proc == 0)){
if (d == 2){
sprintf(msg,
"Geometry (~%lf x %lf), exceeds %lf to 1.0 ratio",
dist[order[0]], dist[order[1]], deg_ratio);
}
else{
sprintf(msg,
"Geometry (~%lf x %lf x %lf), exceeds %lf to 1.0 ratio",
dist[order[0]], dist[order[1]], dist[order[2]], deg_ratio);
}
ZOLTAN_PRINT_INFO(zz->Proc, yo, msg);
sprintf(msg, "We'll treat it as %d dimensional",target_dim);
ZOLTAN_PRINT_INFO(zz->Proc, yo, msg);
}
if (axis_aligned){
/*
** Create new geometry, transforming the primary direction
** to the X-axis, and the secondary to the Y-axis.
*/
tran->Permutation[0] = tran->Axis_Order[order[0]];
if (target_dim == 2){
tran->Permutation[1] = tran->Axis_Order[order[1]];
}
}
else{
/*
* Reorder the eigenvectors (they're the columns of evecs) from
* longest projected distance to shorted projected distance. Compute
* the transpose (the inverse) of the matrix. This will transform
* the geometry to align along the X-Y plane, or along the X axis.
*/
for (i=0; i< target_dim; i++){
tran->Transformation[i][2] = 0.0;
for (j=0; j<d; j++){
tran->Transformation[i][j] = tran->Evecs[j][order[i]];
}
}
for (i=target_dim; i< 3; i++){
for (j=0; j<3; j++){
tran->Transformation[i][j] = 0.0;
}
}
}
tran->Target_Dim = target_dim;
transform_coordinates(*coords, num_obj, d, tran);
} /* If geometry is very flat */
} /* If REDUCE_DIMENSIONS is true */
} /* If 2-D or 3-D rcb, rib or hsfc */
End:
if (ierr != ZOLTAN_OK && ierr != ZOLTAN_WARN) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Error found; no coordinates returned.");
if (alloced_coords) ZOLTAN_FREE(coords);
}
ZOLTAN_TRACE_EXIT(zz, yo);
return ierr;
}
int Zoltan_Order(
ZZ *zz, /* Zoltan structure */
int *num_gid_entries, /* # of entries for a global id */
int *num_lid_entries, /* # of entries for a local id */
int num_obj, /* Number of objects to order */
ZOLTAN_ID_PTR gids, /* List of global ids (local to this proc) */
/* The application must allocate enough space */
ZOLTAN_ID_PTR lids, /* List of local ids (local to this proc) */
/* The application must allocate enough space */
int *rank, /* rank[i] is the rank of gids[i] */
int *iperm, /* inverse permutation of rank */
ZOS *order_info /* Method-specific ordering info. Currently not used. */
)
{
/*
* Main user-call for ordering.
* Input:
* zz, a Zoltan structure with appropriate function pointers set.
* gids, a list of global ids or enough space to store such a list
* lids, a list of local ids or enough space to store such a list
* Output:
* num_gid_entries
* num_lid_entries
* gids, a list of global ids (filled in if empty on entry)
* lids, a list of local ids (filled in if empty on entry)
* rank, rank[i] is the global rank of gids[i]
* iperm, inverse permutation of rank
* order_info, a Zoltan Ordering Struct with additional info.
* Return values:
* Zoltan error code.
*/
char *yo = "Zoltan_Order";
int ierr;
int *vtxdist;
double start_time, end_time;
double order_time[2] = {0.0,0.0};
char msg[256];
int comm[2],gcomm[2];
ZOLTAN_ORDER_FN *Order_fn;
struct Zoltan_Order_Options opt;
ZOLTAN_TRACE_ENTER(zz, yo);
if (zz->Proc == zz->Debug_Proc && zz->Debug_Level >= ZOLTAN_DEBUG_PARAMS)
Zoltan_Print_Key_Params(zz);
start_time = Zoltan_Time(zz->Timer);
/*
* Compute Max number of array entries per ID over all processors.
* 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;
MPI_Allreduce(comm, gcomm, 2, MPI_INT, MPI_MAX, zz->Communicator);
zz->Num_GID = *num_gid_entries = gcomm[0];
zz->Num_LID = *num_lid_entries = gcomm[1];
/*
* 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);
}
/*
* Get ordering options from parameter list.
*/
/* Set default parameter values */
strncpy(opt.method, "PARMETIS", MAX_PARAM_STRING_LEN);
strncpy(opt.order_type, "GLOBAL", MAX_PARAM_STRING_LEN);
opt.use_order_info = 0;
opt.start_index = 0;
opt.reorder = 0;
Zoltan_Bind_Param(Order_params, "ORDER_METHOD", (void *) opt.method);
Zoltan_Bind_Param(Order_params, "ORDER_TYPE", (void *) opt.order_type);
Zoltan_Bind_Param(Order_params, "ORDER_START_INDEX", (void *) &opt.start_index);
Zoltan_Bind_Param(Order_params, "REORDER", (void *) &opt.reorder);
Zoltan_Bind_Param(Order_params, "USE_ORDER_INFO", (void *) &opt.use_order_info);
Zoltan_Assign_Param_Vals(zz->Params, Order_params, zz->Debug_Level,
zz->Proc, zz->Debug_Proc);
if (opt.use_order_info == 0) order_info = NULL;
/*
* Check that the user has allocated space for the return args.
*/
if (!(gids && lids && rank && iperm)){
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Input argument is NULL. Please allocate all required arrays before calling this routine.");
ZOLTAN_TRACE_EXIT(zz, yo);
return (ZOLTAN_FATAL);
}
/*
* Find the selected method.
*/
if (!strcmp(opt.method, "NONE")) {
if (zz->Proc == zz->Debug_Proc && zz->Debug_Level >= ZOLTAN_DEBUG_PARAMS)
ZOLTAN_PRINT_WARN(zz->Proc, yo, "Ordering method selected == NONE; no ordering performed\n");
ZOLTAN_TRACE_EXIT(zz, yo);
return (ZOLTAN_WARN);
}
else if (!strcmp(opt.method, "NODEND")) {
Order_fn = Zoltan_ParMetis_Order;
}
else if (!strcmp(opt.method, "METIS")) {
Order_fn = Zoltan_ParMetis_Order;
/* Set ORDER_METHOD to NODEND and ORDER_TYPE to LOCAL */
strcpy(opt.method, "NODEND");
strcpy(opt.order_type, "LOCAL");
}
else if (!strcmp(opt.method, "PARMETIS")) {
Order_fn = Zoltan_ParMetis_Order;
/* Set ORDER_METHOD to NODEND and ORDER_TYPE to LOCAL */
strcpy(opt.method, "NODEND");
strcpy(opt.order_type, "GLOBAL");
}
else {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Unknown ordering method");
ZOLTAN_TRACE_EXIT(zz, yo);
return (ZOLTAN_FATAL);
}
/*
* Construct the heterogenous machine description.
*/
ierr = Zoltan_Build_Machine_Desc(zz);
if (ierr == ZOLTAN_FATAL){
ZOLTAN_TRACE_EXIT(zz, yo);
return (ierr);
}
ZOLTAN_TRACE_DETAIL(zz, yo, "Done machine description");
/*
* Call the actual ordering function.
*/
ierr = (*Order_fn)(zz, num_obj, gids, lids, rank, iperm, &opt, order_info);
if (ierr) {
sprintf(msg, "Ordering routine returned error code %d.", ierr);
if (ierr == ZOLTAN_WARN){
ZOLTAN_PRINT_WARN(zz->Proc, yo, msg);
} else {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, msg);
ZOLTAN_TRACE_EXIT(zz, yo);
return (ierr);
}
}
ZOLTAN_TRACE_DETAIL(zz, yo, "Done ordering");
/* Compute inverse permutation if necessary */
ierr = Zoltan_Get_Distribution(zz, &vtxdist);
if (ierr){
/* Error */
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Error returned from Zoltan_Get_Distribution.\n");
return (ierr);
}
if (!(opt.return_args & RETURN_RANK)){
/* Compute rank from iperm */
ZOLTAN_TRACE_DETAIL(zz, yo, "Inverting permutation");
Zoltan_Inverse_Perm(zz, iperm, rank, vtxdist, opt.order_type, opt.start_index);
}
else if (!(opt.return_args & RETURN_IPERM)){
/* Compute iperm from rank */
ZOLTAN_TRACE_DETAIL(zz, yo, "Inverting permutation");
Zoltan_Inverse_Perm(zz, rank, iperm, vtxdist, opt.order_type, opt.start_index);
}
ZOLTAN_FREE(&vtxdist);
ZOLTAN_TRACE_DETAIL(zz, yo, "Done ordering");
end_time = Zoltan_Time(zz->Timer);
order_time[0] = end_time - start_time;
if (zz->Debug_Level >= ZOLTAN_DEBUG_LIST) {
int i, nobjs;
nobjs = zz->Get_Num_Obj(zz->Get_Num_Obj_Data, &i);
Zoltan_Print_Sync_Start(zz->Communicator, TRUE);
printf("ZOLTAN: rank for ordering on Proc %d\n", zz->Proc);
for (i = 0; i < nobjs; i++) {
printf("GID = ");
ZOLTAN_PRINT_GID(zz, &(gids[i*(*num_gid_entries)]));
printf(", rank = %3d\n", rank[i]);
}
printf("\n");
printf("ZOLTAN: inverse permutation on Proc %d\n", zz->Proc);
for (i = 0; i < nobjs; i++) {
printf("iperm[%3d] = %3d\n", i, iperm[i]);
}
printf("\n");
Zoltan_Print_Sync_End(zz->Communicator, TRUE);
}
/* 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, order_time[0],
"ZOLTAN Balance: ");
}
ZOLTAN_TRACE_EXIT(zz, yo);
if (ierr)
return (ierr);
else
return (ZOLTAN_OK);
}
int Zoltan_RIB(
ZZ *zz, /* The Zoltan structure with info for
the RIB balancer. */
float *part_sizes, /* Input: Array of size
zz->Num_Global_Parts * max(zz->Obj_Weight_Dim, 1)
containing the percentage of work to be
assigned to each part. */
int *num_import, /* Returned value: Number of non-local
objects assigned to
this processor in the new decomposition.*/
ZOLTAN_ID_PTR *import_global_ids, /* Returned value: array of global IDs for
non-local objects in this processor's new
decomposition. */
ZOLTAN_ID_PTR *import_local_ids, /* Returned value: array of local IDs for
non-local objects in this processor's new
decomposition. */
int **import_procs, /* Returned value: array of processor IDs for
processors owning the non-local objects in
this processor's new decomposition. */
int **import_to_part, /* Returned value: array of parts to
which imported objects should be assigned. */
int *num_export, /* Not computed, set to -1 */
ZOLTAN_ID_PTR *export_global_ids, /* Not computed. */
ZOLTAN_ID_PTR *export_local_ids, /* Not computed. */
int **export_procs, /* Not computed. */
int **export_to_part /* Not computed. */
)
{
/* Wrapper routine to set parameter values and call the real rib. */
double overalloc; /* amount to overallocate by when realloc
of dot array must be done.
1.0 = no extra; 1.5 = 50% extra; etc. */
int wgtflag; /* No. of weights per dot. */
int check_geom; /* Check input & output for consistency? */
int stats; /* Print timing & count summary? */
int gen_tree; /* (0) don't (1) generate whole treept to use
later for point and box drop. */
int average_cuts; /* (0) don't (1) compute the cut to be the
average of the closest dots. */
int idummy;
int final_output;
double ddummy;
int ierr;
Zoltan_Bind_Param(RIB_params, "RIB_OVERALLOC", (void *) &overalloc);
Zoltan_Bind_Param(RIB_params, "CHECK_GEOM", (void *) &check_geom);
Zoltan_Bind_Param(RIB_params, "RIB_OUTPUT_LEVEL", (void *) &stats);
Zoltan_Bind_Param(RIB_params, "AVERAGE_CUTS", (void *) &average_cuts);
Zoltan_Bind_Param(RIB_params, "KEEP_CUTS", (void *) &gen_tree);
Zoltan_Bind_Param(RIB_params, "REDUCE_DIMENSIONS", (void *) &idummy);
Zoltan_Bind_Param(RIB_params, "DEGENERATE_RATIO", (void *) &ddummy);
Zoltan_Bind_Param(RIB_params, "FINAL_OUTPUT", (void *) &final_output);
overalloc = RIB_DEFAULT_OVERALLOC;
check_geom = DEFAULT_CHECK_GEOM;
stats = RIB_DEFAULT_OUTPUT_LEVEL;
gen_tree = 0;
final_output = 0;
average_cuts = 0;
wgtflag = zz->Obj_Weight_Dim;
idummy = 0;
ddummy = 0.0;
Zoltan_Assign_Param_Vals(zz->Params, RIB_params, zz->Debug_Level, zz->Proc,
zz->Debug_Proc);
/* Initializations in case of early exit. */
*num_import = -1;
*num_export = -1; /* We don't compute the export map. */
if (final_output && (stats < 1)){
/* FINAL_OUTPUT is a graph/phg param, corresponds to our OUTPUT_LEVEL 1 */
stats = 1;
}
ierr = rib_fn(zz, num_import, import_global_ids, import_local_ids,
import_procs, import_to_part, num_export, export_global_ids,
overalloc, wgtflag, check_geom, stats, gen_tree, average_cuts,
part_sizes);
return(ierr);
}
static int Zoltan_Parmetis_Parse(
ZZ* zz,
indextype *options,
char* alg,
realtype* itr,
double *pmv3_itr,
ZOLTAN_Output_Order *ord
)
{
static char * yo = "Zoltan_Parmetis_Parse";
int i;
int output_level, seed, coarse_alg, fold, use_obj_size;
/* Always use ParMetis option array because Zoltan by default
produces no output (silent mode). ParMetis requires options[0]=1
when options array is to be used. */
options[0] = 1;
for (i = 1; i < MAX_PARMETIS_OPTIONS; i++)
options[i] = 0;
/* Set the default option values. */
output_level = 0;
coarse_alg = 2;
use_obj_size = 1;
fold = 0;
seed = GLOBAL_SEED;
if(ord == NULL) {
/* Map LB_APPROACH to suitable PARMETIS_METHOD */
if (!strcasecmp(zz->LB.Approach, "partition")){
strcpy(alg, "PARTKWAY");
}
else if (!strcasecmp(zz->LB.Approach, "repartition")){
strcpy(alg, "ADAPTIVEREPART");
*pmv3_itr = 100.; /* Ratio of inter-proc comm. time to data redist. time;
100 gives similar partition quality to GDiffusion */
}
else if (!strcasecmp(zz->LB.Approach, "refine")){
strcpy(alg, "REFINEKWAY");
}
else { /* If no LB_APPROACH is set, use repartition */
strcpy(alg, "ADAPTIVEREPART");
*pmv3_itr = 100.; /* Ratio of inter-proc comm. time to data redist. time;
100 gives similar partition quality to GDiffusion */
}
}
else {
strcpy(alg, "NODEND");
}
Zoltan_Bind_Param(Parmetis_params, "PARMETIS_METHOD",
(void *) alg);
Zoltan_Bind_Param(Parmetis_params, "PARMETIS_OUTPUT_LEVEL",
(void *) &output_level);
Zoltan_Bind_Param(Parmetis_params, "PARMETIS_SEED",
(void *) &seed);
Zoltan_Bind_Param(Parmetis_params, "PARMETIS_ITR",
(void *) pmv3_itr);
Zoltan_Bind_Param(Parmetis_params, "PARMETIS_COARSE_ALG",
(void *) &coarse_alg);
Zoltan_Bind_Param(Parmetis_params, "PARMETIS_FOLD",
(void *) &fold);
Zoltan_Assign_Param_Vals(zz->Params, Parmetis_params, zz->Debug_Level,
zz->Proc, zz->Debug_Proc);
/* Copy option values to ParMetis options array */
/* In this version of Zoltan, processors and partitions are coupled. */
/* This will likely change in future releases, and then the options */
/* value should change to DISCOUPLED. */
options[PMV3_OPTION_PSR] = COUPLED;
if (pmv3method(alg)){
/* ParMetis 3.0 options */
options[PMV3_OPTION_DBGLVL] = output_level;
options[PMV3_OPTION_SEED] = seed;
options[PMV3_OPT_USE_OBJ_SIZE] = use_obj_size;
if (ord == NULL)
*itr = (realtype)*pmv3_itr;
}
/* If ordering, use ordering method instead of load-balancing method */
if (ord && ord->order_opt && ord->order_opt->method){
strcpy(alg, ord->order_opt->method);
}
if ((zz->Num_Proc == 1) &&
(!strcmp(alg, "ADAPTIVEREPART") ||
!strcmp(alg, "REPARTLDIFFUSION") ||
!strcmp(alg, "REPARTGDIFFUSION") ||
!strcmp(alg, "REPARTREMAP") ||
!strcmp(alg, "REPARTMLREMAP"))) {
/* These ParMETIS methods fail on one processor; an MPI command assumes
at least two processors. */
char str[256];
sprintf(str, "ParMETIS method %s fails on one processor due to a bug"
" in ParMETIS v3.x; resetting method to PartKway.", alg);
ZOLTAN_PRINT_WARN(zz->Proc, yo, str);
strcpy(alg, "PARTKWAY");
return (ZOLTAN_WARN);
}
return(ZOLTAN_OK);
}
int Zoltan_PHG_Initialize_Params(
ZZ *zz, /* the Zoltan data structure */
float *part_sizes,
PHGPartParams *hgp
)
{
int err = ZOLTAN_OK;
char *yo = "Zoltan_PHG_Initialize_Params";
int nProc;
int usePrimeComm;
MPI_Comm communicator;
char add_obj_weight[MAX_PARAM_STRING_LEN];
char edge_weight_op[MAX_PARAM_STRING_LEN];
char cut_objective[MAX_PARAM_STRING_LEN];
char *package = hgp->hgraph_pkg;
char *method = hgp->hgraph_method;
char buf[1024];
memset(hgp, 0, sizeof(*hgp)); /* in the future if we forget to initialize
another param at least it will be 0 */
Zoltan_Bind_Param(PHG_params, "HYPERGRAPH_PACKAGE", &hgp->hgraph_pkg);
Zoltan_Bind_Param(PHG_params, "PHG_MULTILEVEL", &hgp->useMultilevel);
Zoltan_Bind_Param(PHG_params, "PHG_FROM_GRAPH_METHOD", hgp->convert_str);
Zoltan_Bind_Param(PHG_params, "PHG_OUTPUT_LEVEL", &hgp->output_level);
Zoltan_Bind_Param(PHG_params, "FINAL_OUTPUT", &hgp->final_output);
Zoltan_Bind_Param(PHG_params, "CHECK_GRAPH", &hgp->check_graph);
Zoltan_Bind_Param(PHG_params, "CHECK_HYPERGRAPH", &hgp->check_graph);
Zoltan_Bind_Param(PHG_params, "PHG_NPROC_VERTEX", &hgp->nProc_x_req);
Zoltan_Bind_Param(PHG_params, "PHG_NPROC_EDGE", &hgp->nProc_y_req);
Zoltan_Bind_Param(PHG_params, "PHG_COARSENING_LIMIT", &hgp->redl);
Zoltan_Bind_Param(PHG_params, "PHG_COARSENING_NCANDIDATE", &hgp->nCand);
Zoltan_Bind_Param(PHG_params, "PHG_COARSENING_METHOD", hgp->redm_str);
Zoltan_Bind_Param(PHG_params, "PHG_COARSENING_METHOD_FAST", hgp->redm_fast);
Zoltan_Bind_Param(PHG_params, "PHG_VERTEX_VISIT_ORDER", &hgp->visit_order);
Zoltan_Bind_Param(PHG_params, "PHG_EDGE_SCALING", &hgp->edge_scaling);
Zoltan_Bind_Param(PHG_params, "PHG_VERTEX_SCALING", &hgp->vtx_scaling);
Zoltan_Bind_Param(PHG_params, "PHG_REFINEMENT_METHOD", hgp->refinement_str);
Zoltan_Bind_Param(PHG_params, "PHG_DIRECT_KWAY", &hgp->kway);
Zoltan_Bind_Param(PHG_params, "PHG_REFINEMENT_LOOP_LIMIT",
&hgp->fm_loop_limit);
Zoltan_Bind_Param(PHG_params, "PHG_REFINEMENT_MAX_NEG_MOVE",
&hgp->fm_max_neg_move);
Zoltan_Bind_Param(PHG_params, "PHG_REFINEMENT_QUALITY",
&hgp->refinement_quality);
Zoltan_Bind_Param(PHG_params, "PHG_COARSEPARTITION_METHOD",
hgp->coarsepartition_str);
Zoltan_Bind_Param(PHG_params, "PHG_USE_TIMERS",
(void*) &hgp->use_timers);
Zoltan_Bind_Param(PHG_params, "USE_TIMERS",
(void*) &hgp->use_timers);
Zoltan_Bind_Param(PHG_params, "PHG_EDGE_SIZE_THRESHOLD",
(void*) &hgp->EdgeSizeThreshold);
Zoltan_Bind_Param(PHG_params, "PHG_MATCH_EDGE_SIZE_THRESHOLD",
(void*) &hgp->MatchEdgeSizeThreshold);
Zoltan_Bind_Param(PHG_params, "PHG_BAL_TOL_ADJUSTMENT",
(void*) &hgp->bal_tol_adjustment);
Zoltan_Bind_Param(PHG_params, "PARKWAY_SERPART",
(void *) hgp->parkway_serpart);
Zoltan_Bind_Param(PHG_params, "PHG_CUT_OBJECTIVE",
(void *) &cut_objective);
Zoltan_Bind_Param(PHG_params, "ADD_OBJ_WEIGHT",
(void *) add_obj_weight);
Zoltan_Bind_Param(PHG_params, "PHG_EDGE_WEIGHT_OPERATION",
(void *) edge_weight_op);
Zoltan_Bind_Param(PHG_params, "PHG_RANDOMIZE_INPUT",
(void*) &hgp->RandomizeInitDist);
Zoltan_Bind_Param(PHG_params, "PHG_PROCESSOR_REDUCTION_LIMIT",
(void*) &hgp->ProRedL);
Zoltan_Bind_Param(PHG_params, "PHG_REPART_MULTIPLIER",
(void*) &hgp->RepartMultiplier);
Zoltan_Bind_Param(PHG_params, "PATOH_ALLOC_POOL0",
(void*) &hgp->patoh_alloc_pool0);
Zoltan_Bind_Param(PHG_params, "PATOH_ALLOC_POOL1",
(void*) &hgp->patoh_alloc_pool1);
/* Set default values */
strncpy(hgp->hgraph_pkg, "phg", MAX_PARAM_STRING_LEN);
strncpy(hgp->convert_str, "neighbors", MAX_PARAM_STRING_LEN);
strncpy(hgp->redm_str, "agg", MAX_PARAM_STRING_LEN);
hgp->match_array_type = 0;
strncpy(hgp->redm_fast, "l-ipm", MAX_PARAM_STRING_LEN);
strncpy(hgp->coarsepartition_str, "auto", MAX_PARAM_STRING_LEN);
strncpy(hgp->refinement_str, "fm2", MAX_PARAM_STRING_LEN);
strncpy(hgp->parkway_serpart, "patoh", MAX_PARAM_STRING_LEN);
strncpy(cut_objective, "connectivity", MAX_PARAM_STRING_LEN);
strncpy(add_obj_weight, "none", MAX_PARAM_STRING_LEN);
strncpy(edge_weight_op, "max", MAX_PARAM_STRING_LEN);
/* LB.Approach is initialized to "REPARTITION", and set in Set_Key_Params */
strncpy(hgp->hgraph_method, zz->LB.Approach, MAX_PARAM_STRING_LEN);
if (!strcasecmp(zz->LB.Approach,"REFINE"))
hgp->useMultilevel = 0;
else
hgp->useMultilevel = 1;
hgp->use_timers = 0;
hgp->LocalCoarsePartition = 0;
hgp->edge_scaling = 0;
hgp->vtx_scaling = 0;
hgp->vtx_scal_size = 0;
hgp->vtx_scal = NULL; /* Array for storing vertex degree scale vector.
Should perhaps go in hg structure, not the
param struct? */
hgp->connectivity_cut = 1;
hgp->visit_order = 0; /* Random */
hgp->check_graph = 0;
hgp->bal_tol = zz->LB.Imbalance_Tol[0]; /* Make vector for multiconstraint */
hgp->bal_tol_adjustment = 0.7;
hgp->nCand = 100;
hgp->redl = MAX(2*zz->LB.Num_Global_Parts, 100);
hgp->output_level = PHG_DEBUG_NONE;
hgp->final_output = 0;
hgp->nProc_x_req = -1;
hgp->nProc_y_req = -1;
hgp->kway = 0;
hgp->fm_loop_limit = 10;
hgp->fm_max_neg_move = 250;
hgp->refinement_quality = 1;
hgp->RandomizeInitDist = 0;
hgp->EdgeSizeThreshold = 0.25;
hgp->MatchEdgeSizeThreshold = 500;
hgp->hybrid_keep_factor = 0.;
hgp->ProRedL = 0.0; /* UVCUVC: CHECK default set to 0 until we run more experiments */
hgp->RepartMultiplier = 100.;
hgp->patoh_alloc_pool0 = 0;
hgp->patoh_alloc_pool1 = 0;
hgp->UseFixedVtx = 0;
hgp->UsePrefPart = 0;
/* Get application values of parameters. */
err = Zoltan_Assign_Param_Vals(zz->Params, PHG_params, zz->Debug_Level,
zz->Proc, zz->Debug_Proc);
nProc = zz->Num_Proc;
usePrimeComm = 0;
/* Parse add_obj_weight parameter */
if (!strcasecmp(add_obj_weight, "none")) {
hgp->add_obj_weight = PHG_ADD_NO_WEIGHT;
hgp->part_sizes = part_sizes;
}
else if (zz->Obj_Weight_Dim > 0) {
/* Do not add_obj_weight until multiconstraint PHG is implemented */
ZOLTAN_PRINT_WARN(zz->Proc, yo,
"Both application supplied *and* ADD_OBJ_WEIGHT "
"calculated vertex weights were provided.");
ZOLTAN_PRINT_WARN(zz->Proc, yo,
"Only the first application supplied weight per vertex will be used.");
hgp->add_obj_weight = PHG_ADD_NO_WEIGHT;
hgp->part_sizes = part_sizes;
}
else {
if (!strcasecmp(add_obj_weight, "vertices")){
hgp->add_obj_weight = PHG_ADD_UNIT_WEIGHT;
} else if (!strcasecmp(add_obj_weight, "unit")){
hgp->add_obj_weight = PHG_ADD_UNIT_WEIGHT;
} else if (!strcasecmp(add_obj_weight, "vertex degree")){
hgp->add_obj_weight = PHG_ADD_PINS_WEIGHT;
} else if (!strcasecmp(add_obj_weight, "nonzeros")){
hgp->add_obj_weight = PHG_ADD_PINS_WEIGHT;
} else if (!strcasecmp(add_obj_weight, "pins")){
hgp->add_obj_weight = PHG_ADD_PINS_WEIGHT;
} else{
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Invalid ADD_OBJ_WEIGHT parameter.\n");
err = ZOLTAN_WARN;
}
/* Set hgp->part_sizes to new array of part_sizes with added obj weight. */
if (part_sizes)
err = Zoltan_LB_Add_Part_Sizes_Weight(zz,
(zz->Obj_Weight_Dim ? zz->Obj_Weight_Dim : 1),
zz->Obj_Weight_Dim+1,
part_sizes, &(hgp->part_sizes));
}
if ((zz->Obj_Weight_Dim==0) && /* no application supplied weights */
(hgp->add_obj_weight==PHG_ADD_NO_WEIGHT)){ /* no calculated weight */
hgp->add_obj_weight = PHG_ADD_UNIT_WEIGHT; /* default object weight */
}
if (!strcasecmp(cut_objective, "default")
|| !strcasecmp(cut_objective, "connectivity"))
hgp->connectivity_cut = 1;
else if (!strcasecmp(cut_objective, "hyperedges"))
hgp->connectivity_cut = 0;
else {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Invalid PHG_CUT_OBJECTIVE parameter.\n");
goto End;
}
if (!strcasecmp(edge_weight_op, "max")){
hgp->edge_weight_op = PHG_MAX_EDGE_WEIGHTS;
} else if (!strcasecmp(edge_weight_op, "add")){
hgp->edge_weight_op = PHG_ADD_EDGE_WEIGHTS;
} else if (!strcasecmp(edge_weight_op, "error")){
hgp->edge_weight_op = PHG_FLAG_ERROR_EDGE_WEIGHTS;
} else{
ZOLTAN_PRINT_ERROR(zz->Proc, yo,
"Invalid PHG_EDGE_WEIGHT_OPERATION parameter.\n");
err = ZOLTAN_WARN;
}
if ((strcasecmp(method, "PARTITION")) &&
(strcasecmp(method, "REPARTITION")) &&
(strcasecmp(method, "REFINE"))) {
sprintf(buf,"%s is not a valid hypergraph method\n",method);
ZOLTAN_PRINT_ERROR (zz->Proc, yo, buf);
err = ZOLTAN_FATAL;
goto End;
}
/* Adjust refinement parameters using hgp->refinement_quality */
if (hgp->refinement_quality < 0.5/hgp->fm_loop_limit)
/* No refinement */
strncpy(hgp->refinement_str, "no", MAX_PARAM_STRING_LEN);
else {
/* Scale FM parameters */
hgp->fm_loop_limit *= hgp->refinement_quality;
hgp->fm_max_neg_move *= hgp->refinement_quality;
}
if (!strcasecmp(package, "PHG")){
/* Test to determine whether we should change the number of processors
used for partitioning to make more efficient 2D decomposition */
if (hgp->nProc_x_req != 1 && hgp->nProc_y_req != 1) /* Want 2D decomp */
if (zz->Num_Proc > SMALL_PRIME && Zoltan_PHG_isPrime(zz->Num_Proc))
/* 2D data decomposition is requested but we have a prime
* number of processors. */
usePrimeComm = 1;
if ((!strcasecmp(method, "REPARTITION"))){
zz->LB.Remap_Flag = 0;
}
if ((!strcasecmp(method, "REPARTITION")) ||
(!strcasecmp(method, "REFINE"))) {
hgp->fm_loop_limit = 4; /* experimental evaluation showed that for
repartitioning/refinement small number of passes
is "good enough". These are all heuristics hence
it is possible to create a pathological cases;
but in general this seems to be sufficient */
}
if (!hgp->useMultilevel) {
/* don't do coarsening */
strncpy(hgp->redm_str, "no", MAX_PARAM_STRING_LEN);
/* we have modified all coarse partitioners to handle preferred part
if user wants to choose one she can choose; otherwise default
partitioner
(greedy growing) does work better than previous default partitioning
for phg_refine ("no"). */
hgp->UsePrefPart = 1;
}
if (!strcasecmp(method, "REFINE") && hgp->useMultilevel){
/* UVCUVC: as a heuristic we prefer local matching;
in our experiments for IPDPS'07 and WileyChapter multilevel_refine
didn't prove itself useful; it is too costly even with local matching
hence it will not be be released yet (i.e. not in v3). */
strncpy(hgp->redm_str, "l-ipm", MAX_PARAM_STRING_LEN);
hgp->UsePrefPart = 1;
}
}
else if (!strcasecmp(package, "PARKWAY")){
if (hgp->nProc_x_req>1) {
err = ZOLTAN_FATAL;
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "ParKway requires nProc_x=1 or -1.");
goto End;
}
hgp->nProc_x_req = 1;
}
else if (!strcasecmp(package, "PATOH")){
if (zz->Num_Proc>1) {
err = ZOLTAN_FATAL;
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "PaToH only works with Num_Proc=1.");
goto End;
}
}
if (!usePrimeComm)
MPI_Comm_dup(zz->Communicator, &communicator);
else {
MPI_Group newgrp, zzgrp;
nProc--;
MPI_Comm_group(zz->Communicator, &zzgrp);
MPI_Group_excl(zzgrp, 1, &nProc, &newgrp);
MPI_Comm_create(zz->Communicator, newgrp, &communicator);
MPI_Group_free(&newgrp);
MPI_Group_free(&zzgrp);
}
err = Zoltan_PHG_Set_2D_Proc_Distrib(zz, communicator, zz->Proc,
nProc, hgp->nProc_x_req,
hgp->nProc_y_req,
&hgp->globalcomm);
if (err != ZOLTAN_OK)
goto End;
/* Convert strings to function pointers. */
err = Zoltan_PHG_Set_Part_Options (zz, hgp);
End:
return err;
}
int Zoltan_Color_Test(
ZZ *zz, /* Zoltan structure */
int *num_gid_entries, /* # of entries for a global id */
int *num_lid_entries, /* # of entries for a local id */
int num_obj, /* Input: number of objects */
ZOLTAN_ID_PTR global_ids, /* Input: global ids of the vertices */
/* The application must allocate enough space */
ZOLTAN_ID_PTR local_ids, /* Input: local ids of the vertices */
/* The application must allocate enough space */
int *color_exp /* Input: Colors assigned to local vertices */
)
{
static char *yo = "color_test_fn";
int nvtx = num_obj; /* number of vertices */
int i, j;
int ierr = ZOLTAN_OK;
int ferr = ZOLTAN_OK; /* final error signal */
char coloring_problem; /* Input: which coloring to perform;
currently only supports D1, D2 coloring and variants */
char coloring_problemStr[MAX_PARAM_STRING_LEN]; /* string version coloring problem name */
int ss=100;
char comm_pattern='S', coloring_order='I', coloring_method='F';
int comm[2],gcomm[2];
int *color=NULL;
int *adjproc=NULL, *xadj=NULL;
ZOLTAN_GNO_TYPE gvtx; /* number of global vertices */
ZOLTAN_GNO_TYPE *vtxdist=NULL, *adjncy=NULL;
ZG graph;
ZOLTAN_GNO_TYPE *requested_GNOs = NULL; /* Return GNOs of
the requested GIDs. */
int *loc_partialD2 = NULL; /* local binary array showing which vertices to be colored */
int *partialD2 = NULL; /* global binary array showing which vertices to be colored */
struct Zoltan_DD_Struct *dd_color; /* DDirectory for colors */
ZOLTAN_GNO_TYPE *local_GNOs = NULL;
ZOLTAN_GNO_TYPE *global_GNOs = NULL;
memset (&graph, 0, sizeof(ZG));
/* PARAMETER SETTINGS */
Zoltan_Bind_Param(Color_params, "COLORING_PROBLEM", (void *) &coloring_problemStr);
Zoltan_Bind_Param(Color_params, "SUPERSTEP_SIZE", (void *) &ss);
Zoltan_Bind_Param(Color_params, "COMM_PATTERN", (void *) &comm_pattern);
Zoltan_Bind_Param(Color_params, "VERTEX_VISIT_ORDER", (void *) &coloring_order);
Zoltan_Bind_Param(Color_params, "COLORING_METHOD", (void *) &coloring_method);
strncpy(coloring_problemStr, "distance-1", MAX_PARAM_STRING_LEN);
Zoltan_Assign_Param_Vals(zz->Params, Color_params, zz->Debug_Level, zz->Proc,
zz->Debug_Proc);
/* Check validity of parameters - they should be consistent with Zoltan_Color */
if (!strcasecmp(coloring_problemStr, "distance-1"))
coloring_problem = '1';
else if (!strcasecmp(coloring_problemStr, "distance-2"))
coloring_problem = '2';
else if (!strcasecmp(coloring_problemStr, "partial-distance-2")
|| !strcasecmp(coloring_problemStr, "bipartite"))
coloring_problem = 'P';
else {
ZOLTAN_PRINT_WARN(zz->Proc, yo, "Unknown coloring requested. Using Distance-1 coloring.");
coloring_problem = '1';
}
if (ss == 0) {
ZOLTAN_PRINT_WARN(zz->Proc, yo, "Invalid superstep size. Using default value 100.");
ss = 100;
}
if (comm_pattern != 'S' && comm_pattern != 'A') {
ZOLTAN_PRINT_WARN(zz->Proc, yo, "Invalid communication pattern. Using synchronous communication (S).");
comm_pattern = 'S';
}
if (comm_pattern == 'A' && (coloring_problem == '2' || coloring_problem == 'P')) {
ZOLTAN_PRINT_WARN(zz->Proc, yo, "Asynchronous communication pattern is not implemented for distance-2 coloring and its variants. Using synchronous communication (S).");
comm_pattern = 'S';
}
if (coloring_order != 'I' && coloring_order != 'B' && coloring_order != 'U' && coloring_order != 'L' && coloring_order != 'N' && coloring_order != 'S') {
ZOLTAN_PRINT_WARN(zz->Proc, yo, "Invalid coloring order. Using internal first coloring order (I).");
coloring_order = 'I';
}
if (coloring_order == 'U' && (coloring_problem == '2' || coloring_problem == 'P')) {
ZOLTAN_PRINT_WARN(zz->Proc, yo, "Interleaved coloring order is not implemented for distance-2 coloring and its variants. Using internal first coloring order (I).");
coloring_order = 'I';
}
if (coloring_method !='F') {
ZOLTAN_PRINT_WARN(zz->Proc, yo, "Invalid coloring method. Using first fit method (F).");
coloring_method = 'F';
}
/* Compute Max number of array entries per ID over all processors.
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;
MPI_Allreduce(comm, gcomm, 2, MPI_INT, MPI_MAX, zz->Communicator);
zz->Num_GID = *num_gid_entries = gcomm[0];
zz->Num_LID = *num_lid_entries = gcomm[1];
/* Return if this processor is not in the Zoltan structure's
communicator. */
if (ZOLTAN_PROC_NOT_IN_COMMUNICATOR(zz))
return ZOLTAN_OK;
/* BUILD THE GRAPH */
/* Check that the user has allocated space for the return args. */
if (!color_exp)
ZOLTAN_COLOR_ERROR(ZOLTAN_FATAL, "Color argument is NULL. Please give colors of local vertices.");
requested_GNOs = (ZOLTAN_GNO_TYPE *) ZOLTAN_MALLOC(num_obj *
sizeof(ZOLTAN_GNO_TYPE));
Zoltan_ZG_Build (zz, &graph, 0, 1, num_obj,
global_ids, requested_GNOs);
Zoltan_ZG_Export (zz, &graph,
&gvtx, &nvtx, NULL, NULL,
&vtxdist, &xadj, &adjncy, &adjproc,
NULL, NULL);
if (gvtx > (ZOLTAN_GNO_TYPE)INT_MAX){
if (zz->Proc == 0){
fprintf(stderr,
"Zoltan_Color_Test assumes number of vertices (%ld) is less than INT_MAX\n",gvtx);
}
ierr = ZOLTAN_FATAL;
goto End;
}
KDDKDDKDD(zz->Proc, "COLORTEST DD");
/* Exchange global color information */
if (vtxdist[zz->Num_Proc] && !(color = (int *) ZOLTAN_CALLOC(vtxdist[zz->Num_Proc], sizeof(int))))
MEMORY_ERROR;
if (nvtx && !(local_GNOs = (ZOLTAN_GNO_TYPE *) ZOLTAN_MALLOC(nvtx * sizeof(ZOLTAN_GNO_TYPE))))
MEMORY_ERROR;
for (i=0; i<nvtx; ++i)
local_GNOs[i] = i+vtxdist[zz->Proc];
if (vtxdist[zz->Num_Proc] && !(global_GNOs = (ZOLTAN_GNO_TYPE *) ZOLTAN_MALLOC(vtxdist[zz->Num_Proc] * sizeof(ZOLTAN_GNO_TYPE))))
MEMORY_ERROR;
for (i=0; i<vtxdist[zz->Num_Proc]; ++i)
global_GNOs[i] = i;
ierr = Zoltan_DD_Create (&dd_color, zz->Communicator,
sizeof(ZOLTAN_GNO_TYPE)/sizeof(ZOLTAN_ID_TYPE), 0, 0, num_obj, 0);
if (ierr != ZOLTAN_OK)
ZOLTAN_COLOR_ERROR(ierr, "Cannot construct DDirectory.");
/* Put req obs with 1 but first inialize the rest with 0 */
ierr = Zoltan_DD_Update (dd_color, (ZOLTAN_ID_PTR)local_GNOs, NULL,
NULL, color, nvtx);
if (ierr != ZOLTAN_OK)
ZOLTAN_COLOR_ERROR(ierr, "Cannot update DDirectory.");
ierr = Zoltan_DD_Update (dd_color, (ZOLTAN_ID_PTR)requested_GNOs, NULL,
NULL, color_exp, num_obj);
if (ierr != ZOLTAN_OK)
ZOLTAN_COLOR_ERROR(ierr, "Cannot update DDirectory.");
/* Get requested colors from the DDirectory. */
ierr = Zoltan_DD_Find (dd_color, (ZOLTAN_ID_PTR)global_GNOs, NULL, NULL,
color, vtxdist[zz->Num_Proc], NULL);
if (ierr != ZOLTAN_OK)
ZOLTAN_COLOR_ERROR(ierr, "Cannot find object in DDirectory.");
/* Free DDirectory */
Zoltan_DD_Destroy(&dd_color);
ZOLTAN_FREE(&local_GNOs);
ZOLTAN_FREE(&global_GNOs);
KDDKDDKDD(zz->Proc, "COLORTEST CHECK");
if (coloring_problem == 'P' || coloring_problem == '2') {
if (vtxdist[zz->Num_Proc] && !(partialD2 = (int *) ZOLTAN_CALLOC(vtxdist[zz->Num_Proc], sizeof(int))))
MEMORY_ERROR;
if (vtxdist[zz->Num_Proc] && !(loc_partialD2 = (int *) ZOLTAN_CALLOC(vtxdist[zz->Num_Proc], sizeof(int))))
MEMORY_ERROR;
if (coloring_problem == 'P') {
for (i=0; i<num_obj; ++i) {
int gno=requested_GNOs[i];
loc_partialD2[gno] = 1;
}
MPI_Allreduce(loc_partialD2, partialD2, vtxdist[zz->Num_Proc], MPI_INT, MPI_LOR, zz->Communicator);
} else {
for (i=0; i<vtxdist[zz->Num_Proc]; ++i)
partialD2[i] = 1;
}
}
/* Check if there is an error in coloring */
if (coloring_problem == '1') {
for (i=0; i<nvtx; i++) {
int gno = i + (int)vtxdist[zz->Proc];
if (color[gno] <= 0) { /* object i is not colored properly */
ierr = ZOLTAN_FATAL;
printf("Error in coloring! u:%d, cu:%d\n", gno, color[gno]);
break;
}
for (j = xadj[i]; j < xadj[i+1]; ++j) {
int v = (int)adjncy[j];
if (color[gno] == color[v]) { /* neighbors have the same color */
ierr = ZOLTAN_FATAL;
printf("Error in coloring! u:%d, v:%d, cu:%d, cv:%d\n", gno, v, color[gno], color[v]);
break;
}
}
if (ierr == ZOLTAN_FATAL)
break;
}
} else if (coloring_problem == '2' || coloring_problem == 'P') {
for (i=0; i<nvtx; i++) {
int gno = i + (int)vtxdist[zz->Proc];
if (partialD2[gno] && color[gno] <= 0) { /* object i is not colored properly */
ierr = ZOLTAN_FATAL;
printf("Error in coloring! u:%d, cu:%d\n", gno, color[gno]);
break;
}
for (j = xadj[i]; j < xadj[i+1]; ++j) {
int v = (int)adjncy[j], k;
if (partialD2[v] && color[v] <= 0) {
ierr = ZOLTAN_FATAL;
printf("Error in coloring! d1-neigh: u:%d, v:%d, cu:%d, cv:%d pu:%d pv:%d\n", gno, v, color[gno], color[v], partialD2[gno], partialD2[v]);
break;
}
if (partialD2[gno] && partialD2[v] && color[gno] == color[v]) { /* d-1 neighbors have the same color */
ierr = ZOLTAN_FATAL;
printf("Error in coloring! d1-neigh: u:%d, v:%d, cu:%d, cv:%d pu:%d pv:%d\n", gno, v, color[gno], color[v], partialD2[gno], partialD2[v]);
break;
}
for (k = j+1; k < xadj[i+1]; ++k) {
int w = (int)adjncy[k];
if (partialD2[v] && partialD2[w] && color[v] == color[w]) { /* d-2 neighbors have the same color */
ierr = ZOLTAN_FATAL;
printf("Error in coloring! d2-neigh: v:%d, w:%d, cv:%d, cw:%d pv:%d pw:%d\n", v, w, color[v], color[w], partialD2[v], partialD2[w]);
break;
}
}
}
if (ierr == ZOLTAN_FATAL)
break;
}
} else
ZOLTAN_COLOR_ERROR(ZOLTAN_WARN, "Zoltan_Color_Test is only implemented for distance-1 and distance-2 coloring. Unknown coloring, skipping verification.");
End:
KDDKDDKDD(zz->Proc, "COLORTEST DONE");
if (ierr==ZOLTAN_FATAL)
ierr = 2;
MPI_Allreduce(&ierr, &ferr, 1, MPI_INT, MPI_MAX, zz->Communicator);
if (ferr == 2)
ierr = ZOLTAN_FATAL;
else
ierr = ZOLTAN_OK;
Zoltan_ZG_Free (&graph);
ZOLTAN_FREE(&adjproc);
ZOLTAN_FREE(&color);
ZOLTAN_FREE(&requested_GNOs);
ZOLTAN_FREE(&partialD2);
ZOLTAN_FREE(&loc_partialD2);
return ierr;
}
int Zoltan_Octpart(
ZZ *zz, /* The Zoltan structure with info for
the OCTPART balancer. */
float *part_sizes, /* Input: Array of size zz->Num_Global_Parts
containing the percentage of work to be
assigned to each partition. */
int *num_import, /* Returned value: Number of non-local
objects assigned to this
processor in the new decomposition. */
ZOLTAN_ID_PTR *import_global_ids, /* Returned value: array of global IDs for
non-local objects in this processor's new
decomposition. */
ZOLTAN_ID_PTR *import_local_ids, /* Returned value: array of local IDs for
non-local objects in this processor's new
decomposition. */
int **import_procs, /* Returned value: array of processor IDs for
processors owning the non-local objects in
this processor's new decomposition. */
int **import_to_part, /* Returned value: array of partitions to
which imported objects should be assigned.
KDDKDD Currently unused. */
int *num_export, /* Not computed; return -1. */
ZOLTAN_ID_PTR *export_global_ids, /* Not computed. */
ZOLTAN_ID_PTR *export_local_ids, /* Not computed. */
int **export_procs, /* Not computed. */
int **export_to_part /* Not computed. */
)
{
char *yo = "Zoltan_Octpart";
int oct_dim = 3; /* Dimension of method to be used (2D or 3D) */
int oct_method = 2; /* Flag specifying curve to be used. */
int oct_maxoctregions=MAXOCTREGIONS_DEF; /* max # of objs in leaves */
int oct_minoctregions=MINOCTREGIONS_DEF; /* min # of objs in leaves */
int oct_output_level = 0; /* Flag specifying amount of output. */
int oct_wgtflag = 0; /* Flag specifying use of object weights. */
int error = FALSE; /* error flag */
Zoltan_Bind_Param(OCT_params, "OCT_DIM", (void *)&oct_dim);
Zoltan_Bind_Param(OCT_params, "OCT_METHOD", (void *)&oct_method);
Zoltan_Bind_Param(OCT_params, "OCT_MAXOBJECTS", (void *)&oct_maxoctregions);
Zoltan_Bind_Param(OCT_params, "OCT_MINOBJECTS", (void *)&oct_minoctregions);
Zoltan_Bind_Param(OCT_params, "OCT_OUTPUT_LEVEL",(void *)&oct_output_level);
Zoltan_Assign_Param_Vals(zz->Params, OCT_params, zz->Debug_Level, zz->Proc,
zz->Debug_Proc);
/* Set oct_wgtflag based on the "key" parameter Obj_Weight_Dim */
oct_wgtflag = (zz->Obj_Weight_Dim > 0);
if (zz->Obj_Weight_Dim > 1) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo,
"OBJ_WEIGHT_DIM > 1 not yet implemented in OCTPART. "
"Try a different LB_METHOD.");
error = TRUE;
}
/* Initialization in case of early exit */
*num_import = -1; /* We don't compute any import data */
*num_export = -1;
/* Error checking for unimplemented features */
if (zz->LB.PartDist) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo,
"# partitions != # processors not yet implemented in OCTPART. "
"Try a different LB_METHOD.");
error = TRUE;
}
/*if (!zz->LB.Uniform_Parts) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo,
"Non-uniform partition sizes not yet implemented in OCTPART. "
"Try a different LB_METHOD.");
error = TRUE;
}*/
/* Error checking for parameters */
if (oct_dim < 2 || oct_dim > 3) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "OCT_DIM must be 2 or 3. ");
error = TRUE;
}
if (oct_method < 0 || oct_method > 2) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "OCT_METHOD must be 0, 1, or 2");
error = TRUE;
}
if (oct_maxoctregions < 1) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "OCT_MAXOBJECTS must be greater than 0");
error = TRUE;
}
if (oct_minoctregions < 1) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "OCT_MINOBJECTS must be greater than 0");
error = TRUE;
}
if (oct_minoctregions > oct_maxoctregions) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "OCT_MINOBJECTS must be less than "
"OCT_MAXOBJECTS");
error = TRUE;
}
if (oct_output_level < 0 || oct_output_level > 3) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo,"OCT_OUTPUT_LEVEL must be 0, 1, 2, or 3");
error = TRUE;
}
if (error)
return(ZOLTAN_FATAL);
else {
error = lb_oct_init(zz, num_export, export_global_ids, export_local_ids,
export_procs, export_to_part,
oct_dim, oct_method, oct_maxoctregions,
oct_minoctregions, oct_output_level, oct_wgtflag,
part_sizes);
return(error);
}
}
int Zoltan_Preprocess_Graph(
ZZ *zz, /* Zoltan structure */
ZOLTAN_ID_PTR *global_ids,
ZOLTAN_ID_PTR *local_ids,
ZOLTAN_Third_Graph *gr, /* Graph for third part libs */
ZOLTAN_Third_Geom *geo,
ZOLTAN_Third_Part *prt,
ZOLTAN_Third_Vsize *vsp
)
{
static char *yo = "Zoltan_Preprocess_Graph";
int ierr;
float *float_vwgt, *float_ewgts;
char msg[256];
char add_obj_weight[MAX_PARAM_STRING_LEN+1];
ZOLTAN_TRACE_ENTER(zz, yo);
/* Initialize all local pointers to NULL. This is necessary
* because we free all non-NULL pointers upon errors.
*/
gr->vtxdist = gr->xadj = gr->adjncy = NULL;
gr->vwgt = gr->ewgts = NULL;
float_vwgt = float_ewgts = NULL;
if (gr->obj_wgt_dim >= 0) {
/* Check weight dimensions */
if (zz->Obj_Weight_Dim<0){
sprintf(msg, "Object weight dimension is %d, "
"but should be >= 0. Using Obj_Weight_Dim = 0.",
zz->Obj_Weight_Dim);
ZOLTAN_PRINT_WARN(zz->Proc, yo, msg);
gr->obj_wgt_dim = 0;
}
else {
gr->obj_wgt_dim = zz->Obj_Weight_Dim;
}
}
else
gr->obj_wgt_dim = 0;
if (gr->edge_wgt_dim >= 0) {
if (zz->Edge_Weight_Dim<0){
sprintf(msg, "Edge weight dimension is %d, "
"but should be >= 0. Using Edge_Weight_Dim = 0.",
zz->Edge_Weight_Dim);
ZOLTAN_PRINT_WARN(zz->Proc, yo, msg);
gr->edge_wgt_dim = 0;
}
else if (zz->Edge_Weight_Dim>1){
ZOLTAN_PRINT_WARN(zz->Proc, yo, "This method does not support "
"multidimensional edge weights. Using Edge_Weight_Dim = 1.");
gr->edge_wgt_dim = 1;
}
else {
gr->edge_wgt_dim = zz->Edge_Weight_Dim;
}
}
else
gr->edge_wgt_dim = 0;
if (gr->graph_type >= 0)
/* Default graph type is GLOBAL. */
gr->graph_type = GLOBAL_GRAPH;
else
gr->graph_type = - gr->graph_type;
/* Get parameter options shared by ParMetis and Jostle */
gr->check_graph = 1; /* default */
gr->scatter = 1; /* default */
gr->final_output = 0;
strcpy(add_obj_weight, "NONE"); /* default */
Zoltan_Bind_Param(Graph_params, "CHECK_GRAPH", (void *) &gr->check_graph);
Zoltan_Bind_Param(Graph_params, "SCATTER_GRAPH", (void *) &gr->scatter);
Zoltan_Bind_Param(Graph_params, "FINAL_OUTPUT", (void *) &gr->final_output);
Zoltan_Bind_Param(Graph_params, "ADD_OBJ_WEIGHT", (void *) add_obj_weight);
Zoltan_Assign_Param_Vals(zz->Params, Graph_params, zz->Debug_Level, zz->Proc,
zz->Debug_Proc);
/* If reorder is true, we already have the id lists. Ignore weights. */
if ((*global_ids == NULL) || (!gr->id_known)){
int * input_part;
ierr = Zoltan_Get_Obj_List(zz, &gr->num_obj, global_ids, local_ids,
gr->obj_wgt_dim, &float_vwgt, &input_part);
if (prt) {
prt->input_part = input_part;
}
else { /* Ordering, dont need part */
ZOLTAN_FREE(&input_part);
}
if (ierr){
/* Return error */
ZOLTAN_PARMETIS_ERROR(ierr, "Get_Obj_List returned error.");
}
}
/* Build Graph for third party library data structures, or just get vtxdist. */
ierr = Zoltan_Build_Graph(zz, gr->graph_type, gr->check_graph, gr->num_obj,
*global_ids, *local_ids, gr->obj_wgt_dim, gr->edge_wgt_dim,
&gr->vtxdist, &gr->xadj, &gr->adjncy, &float_ewgts, &gr->adjproc);
if (ierr != ZOLTAN_OK && ierr != ZOLTAN_WARN){
ZOLTAN_PARMETIS_ERROR(ierr, "Zoltan_Build_Graph returned error.");
}
if (prt) {
prt->part_sizes = prt->input_part_sizes;
if (gr->num_obj >0) {
prt->part = (indextype *)ZOLTAN_MALLOC((gr->num_obj+1) * sizeof(indextype));
if (!prt->part){
/* Not enough memory */
ZOLTAN_PARMETIS_ERROR(ZOLTAN_MEMERR, "Out of memory.");
}
memcpy (prt->part, prt->input_part, (gr->num_obj) * sizeof(indextype));
}
else {
prt->input_part = prt->part = NULL;
}
}
/* Convert from float. */
/* Get vertex weights if needed */
if (gr->obj_wgt_dim){
ierr = Zoltan_Preprocess_Scale_Weights (gr, float_vwgt, &gr->vwgt,
gr->num_obj, gr->obj_wgt_dim, 1, zz,
"vertex", gr->vtxdist[zz->Proc]);
if (ierr != ZOLTAN_OK && ierr != ZOLTAN_WARN){
/* Return error code */
ZOLTAN_PARMETIS_ERROR(ierr, "Error in scaling of weights.");
}
ZOLTAN_FREE(&float_vwgt);
}
if (strcasecmp(add_obj_weight, "NONE")){
if (Zoltan_Preprocess_Add_Weight(zz, gr, prt, add_obj_weight) != ZOLTAN_OK)
ZOLTAN_PARMETIS_ERROR(ierr, "Error in adding vertex weights.");
}
/* Get edge weights if needed */
if (gr->get_data)
gr->num_edges = gr->xadj[gr->num_obj];
else {
gr->num_edges = 0;
gr->edge_wgt_dim = 0;
}
if (gr->edge_wgt_dim){
ierr = Zoltan_Preprocess_Scale_Weights (gr, float_ewgts, &gr->ewgts,
gr->num_edges, gr->edge_wgt_dim, 1, zz,
"edge", 0);
if (ierr != ZOLTAN_OK && ierr != ZOLTAN_WARN){
/* Return error code */
ZOLTAN_PARMETIS_ERROR(ierr, "Error in scaling of weights.");
}
if (!gr->final_output)
ZOLTAN_FREE(&float_ewgts);
else
gr->float_ewgts = float_ewgts;
}
else
ZOLTAN_FREE(&float_ewgts);
if (geo){
ierr = Zoltan_Preprocess_Extract_Geom (zz, global_ids, local_ids, gr, geo);
if (ierr) {
ZOLTAN_PARMETIS_ERROR(ZOLTAN_FATAL,
"Error returned from Zoltan_Preprocess_Extract_Geom");
}
}
if (vsp) {
ierr = Zoltan_Preprocess_Extract_Vsize (zz, global_ids, local_ids, gr, vsp);
if (ierr) {
ZOLTAN_PARMETIS_ERROR(ZOLTAN_FATAL,
"Error returned from Zoltan_Preprocess_Extract_Vsize");
}
}
/* Scatter graph?
* If data distribution is highly imbalanced, it is better to
* redistribute the graph data structure before calling ParMetis.
* After partitioning, the results must be mapped back.
*/
if (gr->scatter < gr->scatter_min) gr->scatter = gr->scatter_min;
if (gr->scatter>0) {
ierr = Zoltan_Preprocess_Scatter_Graph (zz, gr, prt, geo, vsp);
if (ierr != ZOLTAN_OK && ierr != ZOLTAN_WARN) {
ZOLTAN_PARMETIS_ERROR(ZOLTAN_FATAL,
"Error returned from Zoltan_Preprocess_Scatter_Graph");
}
}
/* Verify that graph is correct */
if (gr->get_data){
int flag;
if (zz->Debug_Level >= ZOLTAN_DEBUG_ALL)
flag = 2; /* Maximum output level */
else
flag = 1; /* Medium output level */
ierr = Zoltan_Verify_Graph(zz->Communicator, gr->vtxdist, gr->xadj, gr->adjncy, gr->vwgt,
gr->ewgts, gr->obj_wgt_dim, gr->edge_wgt_dim, gr->graph_type, gr->check_graph, flag);
}
End:
ZOLTAN_TRACE_EXIT(zz, yo);
return (ierr);
}
int Zoltan_Order(
ZZ *zz, /* Zoltan structure */
int num_gid_entries, /* # of entries for a global id */
int num_obj, /* Number of objects to order */
ZOLTAN_ID_PTR gids, /* List of global ids (local to this proc) */
/* The application must allocate enough space */
int *rank, /* rank[i] is the rank of gids[i] */
int *iperm /* iperm[rank[i]]=i, only for sequential ordering */
)
{
/*
* Main user-call for ordering.
* Input:
* zz, a Zoltan structure with appropriate function pointers set.
* gids, a list of global ids or enough space to store such a list
* lids, a list of local ids or enough space to store such a list
* Output:
* num_gid_entries
* num_lid_entries
* gids, a list of global ids (filled in if empty on entry)
* lids, a list of local ids (filled in if empty on entry)
* rank, rank[i] is the global rank of gids[i]
* Return values:
* Zoltan error code.
*/
char *yo = "Zoltan_Order";
int ierr;
double start_time, end_time;
double order_time[2] = {0.0,0.0};
char msg[256];
int comm[2],gcomm[2];
ZOLTAN_ORDER_FN *Order_fn;
struct Zoltan_Order_Options opt;
int * vtxdist = NULL;
ZOLTAN_ID_PTR local_gids=NULL, lids=NULL;
int local_num_obj;
int *local_rank = NULL, *local_iperm=NULL;
struct Zoltan_DD_Struct *dd = NULL;
ZOLTAN_TRACE_ENTER(zz, yo);
if (zz->Proc == zz->Debug_Proc && zz->Debug_Level >= ZOLTAN_DEBUG_PARAMS)
Zoltan_Print_Key_Params(zz);
start_time = Zoltan_Time(zz->Timer);
/*
* Compute Max number of array entries per ID over all processors.
* 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;
MPI_Allreduce(comm, gcomm, 2, MPI_INT, MPI_MAX, zz->Communicator);
zz->Num_GID = gcomm[0];
if (num_gid_entries != zz->Num_GID) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "num_gid_entries doesn't have the good value");
return (ZOLTAN_FATAL);
}
zz->Order.nbr_objects = num_obj;
zz->Order.rank = rank;
zz->Order.iperm = iperm;
zz->Order.gids = gids;
zz->Order.lids = lids;
zz->Order.start = NULL;
zz->Order.ancestor = NULL;
zz->Order.leaves = NULL;
zz->Order.nbr_leaves = 0;
zz->Order.nbr_blocks = 0;
/*
* 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);
}
/*
* Get ordering options from parameter list.
*/
/* Set default parameter values */
strncpy(opt.method, "PARMETIS", MAX_PARAM_STRING_LEN);
#ifdef HAVE_MPI
strncpy(opt.order_type, "DIST", MAX_PARAM_STRING_LEN);
#else
strncpy(opt.order_type, "SERIAL", MAX_PARAM_STRING_LEN);
#endif /* HAVE_MPI */
opt.use_order_info = 0;
opt.start_index = 0;
opt.reorder = 0;
Zoltan_Bind_Param(Order_params, "ORDER_METHOD", (void *) opt.method);
Zoltan_Bind_Param(Order_params, "ORDER_TYPE", (void *) opt.order_type);
Zoltan_Bind_Param(Order_params, "ORDER_START_INDEX", (void *) &opt.start_index);
Zoltan_Bind_Param(Order_params, "REORDER", (void *) &opt.reorder);
Zoltan_Bind_Param(Order_params, "USE_ORDER_INFO", (void *) &opt.use_order_info);
Zoltan_Assign_Param_Vals(zz->Params, Order_params, zz->Debug_Level,
zz->Proc, zz->Debug_Proc);
zz->Order.start_index = opt.start_index;
/*
* Check that the user has allocated space for the return args.
*/
if (!(gids && rank)) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Input argument is NULL. Please allocate all required arrays before calling this routine.");
ZOLTAN_TRACE_EXIT(zz, yo);
return (ZOLTAN_FATAL);
}
/*
* Find the selected method.
*/
if (!strcmp(opt.method, "NONE")) {
if (zz->Proc == zz->Debug_Proc && zz->Debug_Level >= ZOLTAN_DEBUG_PARAMS)
ZOLTAN_PRINT_WARN(zz->Proc, yo, "Ordering method selected == NONE; no ordering performed\n");
ZOLTAN_TRACE_EXIT(zz, yo);
return (ZOLTAN_WARN);
}
#ifdef ZOLTAN_PARMETIS
else if (!strcmp(opt.method, "NODEND")) {
Order_fn = Zoltan_ParMetis_Order;
}
else if (!strcmp(opt.method, "METIS")) {
Order_fn = Zoltan_ParMetis_Order;
/* Set ORDER_METHOD to NODEND and ORDER_TYPE to LOCAL */
strcpy(opt.method, "NODEND");
strcpy(opt.order_type, "LOCAL");
}
else if (!strcmp(opt.method, "PARMETIS")) {
Order_fn = Zoltan_ParMetis_Order;
/* Set ORDER_METHOD to NODEND and ORDER_TYPE to LOCAL */
strcpy(opt.method, "NODEND");
strcpy(opt.order_type, "GLOBAL");
}
#endif /* ZOLTAN_PARMETIS */
#ifdef ZOLTAN_SCOTCH
else if (!strcmp(opt.method, "SCOTCH")) {
Order_fn = Zoltan_Scotch_Order;
/* Set ORDER_METHOD to NODEND and ORDER_TYPE to LOCAL */
strcpy(opt.method, "NODEND");
/* strcpy(opt.order_type, "GLOBAL"); */
}
#endif /* ZOLTAN_SCOTCH */
else {
fprintf(stderr, "%s\n", opt.method);
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Unknown ordering method");
ZOLTAN_TRACE_EXIT(zz, yo);
return (ZOLTAN_FATAL);
}
if (!strcmp(opt.order_type, "GLOBAL"))
strcpy (opt.order_type, "DIST");
if (!strcmp(opt.order_type, "LOCAL"))
strcpy (opt.order_type, "SERIAL");
strcpy(zz->Order.order_type, opt.order_type);
/*
* Construct the heterogenous machine description.
*/
ierr = Zoltan_Build_Machine_Desc(zz);
if (ierr == ZOLTAN_FATAL) {
ZOLTAN_TRACE_EXIT(zz, yo);
return (ierr);
}
ZOLTAN_TRACE_DETAIL(zz, yo, "Done machine description");
/*
* Call the actual ordering function.
* Compute gid according to the local graph.
*/
if (zz->Get_Num_Obj != NULL) {
local_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.");
return (ierr);
}
}
else {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Must register ZOLTAN_NUM_OBJ_FN.");
return (ZOLTAN_FATAL);
}
local_gids = ZOLTAN_MALLOC_GID_ARRAY(zz, local_num_obj);
local_rank = (int*) ZOLTAN_MALLOC(local_num_obj*sizeof(int));
local_iperm = (int*) ZOLTAN_MALLOC(local_num_obj*sizeof(int));
lids = ZOLTAN_MALLOC_LID_ARRAY(zz, local_num_obj);
ierr = (*Order_fn)(zz, local_num_obj, local_gids, lids, local_rank, local_iperm, &opt);
ZOLTAN_FREE(&lids);
if (ierr) {
sprintf(msg, "Ordering routine returned error code %d.", ierr);
if (ierr == ZOLTAN_WARN) {
ZOLTAN_PRINT_WARN(zz->Proc, yo, msg);
} else {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, msg);
Zoltan_Multifree(__FILE__, __LINE__, 3,
&local_gids, &local_rank, &local_iperm);
ZOLTAN_TRACE_EXIT(zz, yo);
return (ierr);
}
}
ZOLTAN_TRACE_DETAIL(zz, yo, "Done ordering");
/* Compute inverse permutation if necessary */
if ((!(opt.return_args & RETURN_RANK) && (rank != NULL))
|| (!(opt.return_args & RETURN_IPERM) && (iperm != NULL))) {
ierr = Zoltan_Get_Distribution(zz, &vtxdist);
if (ierr) {
/* Error */
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Error returned from Zoltan_Get_Distribution.\n");
return (ierr);
}
if (!(opt.return_args & RETURN_RANK) && (rank != NULL)) {
/* Compute rank from iperm */
ZOLTAN_TRACE_DETAIL(zz, yo, "Inverting permutation");
Zoltan_Inverse_Perm(zz, local_iperm, local_rank, vtxdist, opt.order_type, opt.start_index);
}
else if (!(opt.return_args & RETURN_IPERM) && (iperm != NULL)) {
/* Compute iperm from rank */
ZOLTAN_TRACE_DETAIL(zz, yo, "Inverting permutation");
Zoltan_Inverse_Perm(zz, local_rank, local_iperm, vtxdist, opt.order_type, opt.start_index);
}
ZOLTAN_FREE(&vtxdist);
}
ZOLTAN_TRACE_DETAIL(zz, yo, "Done Invert Permutation");
/* TODO: Use directly the "graph" structure to avoid to duplicate things. */
/* I store : GNO, rank, iperm */
ierr = Zoltan_DD_Create (&dd, zz->Communicator, zz->Num_GID, (local_rank==NULL)?0:1, (local_iperm==NULL)?0:1, local_num_obj, 0);
/* Hope a linear assignment will help a little */
Zoltan_DD_Set_Neighbor_Hash_Fn1(dd, local_num_obj);
/* Associate all the data with our xGNO */
Zoltan_DD_Update (dd, local_gids, (ZOLTAN_ID_PTR)local_rank, (ZOLTAN_ID_PTR) local_iperm, NULL, local_num_obj);
ZOLTAN_FREE(&local_gids);
ZOLTAN_FREE(&local_rank);
ZOLTAN_FREE(&local_iperm);
Zoltan_DD_Find (dd, gids, (ZOLTAN_ID_PTR)rank, (ZOLTAN_ID_PTR)iperm, NULL,
num_obj, NULL);
Zoltan_DD_Destroy(&dd);
ZOLTAN_TRACE_DETAIL(zz, yo, "Done Registering results");
end_time = Zoltan_Time(zz->Timer);
order_time[0] = end_time - start_time;
if (zz->Debug_Level >= ZOLTAN_DEBUG_LIST) {
int i;
Zoltan_Print_Sync_Start(zz->Communicator, TRUE);
printf("ZOLTAN: rank for ordering on Proc %d\n", zz->Proc);
for (i = 0; i < num_obj; i++) {
printf("GID = ");
ZOLTAN_PRINT_GID(zz, &(gids[i*(num_gid_entries)]));
printf(", rank = %3d\n", rank[i]);
}
printf("\n");
Zoltan_Print_Sync_End(zz->Communicator, TRUE);
}
/* 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, order_time[0],
"ZOLTAN Balance: ");
}
ZOLTAN_TRACE_EXIT(zz, yo);
if (ierr)
return (ierr);
else
return (ZOLTAN_OK);
}
int Zoltan_Order (
struct Zoltan_Struct *zz,
int num_gid_entries,
int num_obj,
ZOLTAN_ID_PTR gids,
ZOLTAN_ID_PTR permuted_global_ids
)
{
/*
* Main user-call for ordering.
* Input:
* zz, a Zoltan structure with appropriate function pointers set.
* gids, a list of global ids.
* num_gid_entries
* Output:
* permuted_global_ids
* Return values:
* Zoltan error code.
*/
char *yo = "Zoltan_Order";
int ierr;
double start_time, end_time;
double order_time[2] = {0.0,0.0};
char msg[256];
int comm[2],gcomm[2];
ZOLTAN_ORDER_FN *Order_fn;
struct Zoltan_Order_Options opt;
ZOLTAN_ID_PTR local_gids=NULL, lids=NULL;
int local_num_obj;
int *local_rank = NULL;
struct Zoltan_DD_Struct *dd = NULL;
ZOLTAN_TRACE_ENTER(zz, yo);
if (zz->Proc == zz->Debug_Proc && zz->Debug_Level >= ZOLTAN_DEBUG_PARAMS)
Zoltan_Print_Key_Params(zz);
start_time = Zoltan_Time(zz->Timer);
/*
* Compute Max number of array entries per ID over all processors.
* 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;
MPI_Allreduce(comm, gcomm, 2, MPI_INT, MPI_MAX, zz->Communicator);
zz->Num_GID = gcomm[0];
if (num_gid_entries != zz->Num_GID) {
char msg[253];
sprintf(msg, "num_gid_entries=%d is not equal to parameter setting "
"NUM_GID_ENTRIES=%d\n", num_gid_entries, zz->Num_GID);
ZOLTAN_PRINT_ERROR(zz->Proc, yo, msg);
return (ZOLTAN_FATAL);
}
zz->Order.nbr_objects = num_obj;
zz->Order.start = NULL;
zz->Order.ancestor = NULL;
zz->Order.leaves = NULL;
zz->Order.nbr_leaves = 0;
zz->Order.nbr_blocks = 0;
/*
* 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);
}
/*
* Get ordering options from parameter list.
*/
/* Set default parameter values */
#ifdef HAVE_MPI
strncpy(opt.method, "PARMETIS", MAX_PARAM_STRING_LEN);
strcpy(zz->Order.order_type, "GLOBAL");
#else
strncpy(opt.method, "METIS", MAX_PARAM_STRING_LEN);
strcpy(zz->Order.order_type, "LOCAL");
#endif /* HAVE_MPI */
opt.use_order_info = 0;
opt.start_index = 0;
Zoltan_Bind_Param(Order_params, "ORDER_METHOD", (void *) opt.method);
Zoltan_Bind_Param(Order_params, "USE_ORDER_INFO", (void *) &opt.use_order_info);
Zoltan_Assign_Param_Vals(zz->Params, Order_params, zz->Debug_Level,
zz->Proc, zz->Debug_Proc);
/*
* Check that the user has allocated space for the return args.
*/
if (num_obj && !(gids && permuted_global_ids)) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Input argument is NULL. Please allocate all required arrays before calling this routine.");
ZOLTAN_TRACE_EXIT(zz, yo);
return (ZOLTAN_FATAL);
}
/*
* Find the selected method.
*/
if (!strcmp(opt.method, "NONE")) {
if (zz->Proc == zz->Debug_Proc && zz->Debug_Level >= ZOLTAN_DEBUG_PARAMS)
ZOLTAN_PRINT_WARN(zz->Proc, yo, "Ordering method selected == NONE; no ordering performed\n");
ZOLTAN_TRACE_EXIT(zz, yo);
return (ZOLTAN_WARN);
}
else if (!strcmp(opt.method, "LOCAL_HSFC"))
{
Order_fn = Zoltan_LocalHSFC_Order;
strcpy(zz->Order.order_type, "LOCAL"); /*MMW, not sure about this*/
}
#ifdef ZOLTAN_PARMETIS
else if (!strcmp(opt.method, "METIS")) {
Order_fn = Zoltan_ParMetis_Order;
strcpy(zz->Order.order_type, "LOCAL");
}
else if (!strcmp(opt.method, "PARMETIS")) {
Order_fn = Zoltan_ParMetis_Order;
strcpy(zz->Order.order_type, "GLOBAL");
}
#endif /* ZOLTAN_PARMETIS */
#ifdef ZOLTAN_SCOTCH
else if (!strcmp(opt.method, "SCOTCH")) {
Order_fn = Zoltan_Scotch_Order;
strcpy(zz->Order.order_type, "LOCAL");
}
else if (!strcmp(opt.method, "PTSCOTCH")) {
Order_fn = Zoltan_Scotch_Order;
strcpy(zz->Order.order_type, "GLOBAL");
}
#endif /* ZOLTAN_SCOTCH */
#ifdef ZOLTAN_HUND
else if (!strcasecmp(opt.method, "HUND")) {
ierr = Zoltan_HUND(zz, num_gid_entries, num_obj, gids, permuted_global_ids, NULL);
goto End;
}
#endif /* ZOLTAN_HUND */
else {
fprintf(stderr, "%s\n", opt.method);
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Unknown ordering method");
ZOLTAN_TRACE_EXIT(zz, yo);
return (ZOLTAN_FATAL);
}
/* TODO : Ask why useful ! */
/*
* Construct the heterogenous machine description.
*/
ierr = Zoltan_Build_Machine_Desc(zz);
if (ierr == ZOLTAN_FATAL) {
ZOLTAN_TRACE_EXIT(zz, yo);
return (ierr);
}
ZOLTAN_TRACE_DETAIL(zz, yo, "Done machine description");
/************************************
* Check for required query function
************************************/
if (zz->Get_Num_Obj != NULL) {
local_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.");
return (ierr);
}
}
else {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Must register ZOLTAN_NUM_OBJ_FN.");
return (ZOLTAN_FATAL);
}
/* TODO allocate all this stuff with the graph */
local_gids = ZOLTAN_MALLOC_GID_ARRAY(zz, local_num_obj);
local_rank = (int*) ZOLTAN_MALLOC(local_num_obj*sizeof(int));
lids = ZOLTAN_MALLOC_LID_ARRAY(zz, local_num_obj);
/*
* Call the actual ordering function.
* Compute gid according to the local graph.
*/
ierr = (*Order_fn)(zz, local_num_obj, local_gids, lids, local_rank, NULL, &opt);
ZOLTAN_FREE(&lids);
if (ierr) {
sprintf(msg, "Ordering routine returned error code %d.", ierr);
if (ierr == ZOLTAN_WARN) {
ZOLTAN_PRINT_WARN(zz->Proc, yo, msg);
} else {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, msg);
Zoltan_Multifree(__FILE__, __LINE__, 2,
&local_gids, &local_rank);
ZOLTAN_TRACE_EXIT(zz, yo);
return (ierr);
}
}
ZOLTAN_TRACE_DETAIL(zz, yo, "Done ordering");
/* TODO: Use directly the "graph" structure to avoid to duplicate things. */
/* TODO: At this time, I consider rank == permuted_global_ids */
/* I store : GNO, rank, permuted GID */
/* MMW: perhaps don't ever use graph here since we need to support geometric orderings, otherwise need if/else */
ierr = Zoltan_DD_Create (&dd, zz->Communicator, zz->Num_GID, (local_rank==NULL)?0:1, 0, local_num_obj, 0);
/* Hope a linear assignment will help a little */
if (local_num_obj)
Zoltan_DD_Set_Neighbor_Hash_Fn1(dd, local_num_obj);
/* Associate all the data with our xGNO */
Zoltan_DD_Update (dd, local_gids, (ZOLTAN_ID_PTR)local_rank, NULL, NULL, local_num_obj);
ZOLTAN_FREE(&local_gids);
ZOLTAN_FREE(&local_rank);
Zoltan_DD_Find (dd, gids, (ZOLTAN_ID_PTR)permuted_global_ids, NULL, NULL,
num_obj, NULL);
Zoltan_DD_Destroy(&dd);
ZOLTAN_TRACE_DETAIL(zz, yo, "Done Registering results");
end_time = Zoltan_Time(zz->Timer);
order_time[0] = end_time - start_time;
if (zz->Debug_Level >= ZOLTAN_DEBUG_LIST) {
int i;
Zoltan_Print_Sync_Start(zz->Communicator, TRUE);
printf("ZOLTAN: rank for ordering on Proc %d\n", zz->Proc);
for (i = 0; i < num_obj; i++) {
printf("GID = ");
ZOLTAN_PRINT_GID(zz, &(gids[i*(num_gid_entries)]));
printf(", rank = %3d\n", permuted_global_ids[i]);
}
printf("\n");
Zoltan_Print_Sync_End(zz->Communicator, TRUE);
}
/* 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, order_time[0],
"ZOLTAN Balance: ");
}
#ifdef ZOLTAN_HUND
End:
#endif /*ZOLTAN_HUND*/
ZOLTAN_TRACE_EXIT(zz, yo);
return (ierr);
}
/* This function needs a distribution : rows then cols to work properly */
int
Zoltan_ZG_Build (ZZ* zz, ZG* graph, int local)
{
static char *yo = "Zoltan_ZG_Build";
int ierr = ZOLTAN_OK;
int diag;
int *diagarray=NULL;
Zoltan_matrix_options opt;
char symmetrization[MAX_PARAM_STRING_LEN+1];
char bipartite_type[MAX_PARAM_STRING_LEN+1];
char weigth_type[MAX_PARAM_STRING_LEN+1];
char matrix_build_type[MAX_PARAM_STRING_LEN+1];
int bipartite = 0;
#ifdef CC_TIMERS
double times[9]={0.,0.,0.,0.,0.,0.,0.,0.}; /* Used for timing measurements */
double gtimes[9]={0.,0.,0.,0.,0.,0.,0.,0.}; /* Used for timing measurements */
char *timenames[9]= {"", "setup", "matrix build", "diag", "symmetrize", "dist lin", "2D dist", "complete", "clean up"};
MPI_Barrier(zz->Communicator);
times[0] = Zoltan_Time(zz->Timer);
#endif /* CC_TIMERS */
ZOLTAN_TRACE_ENTER(zz, yo);
memset (graph, 0, sizeof(ZG));
/* Read graph build parameters */
Zoltan_Bind_Param(ZG_params, "GRAPH_SYMMETRIZE", (void *) &symmetrization);
Zoltan_Bind_Param(ZG_params, "GRAPH_SYM_WEIGHT", (void *) &weigth_type);
Zoltan_Bind_Param(ZG_params, "GRAPH_BIPARTITE_TYPE", (void *) &bipartite_type);
Zoltan_Bind_Param(ZG_params, "GRAPH_BUILD_TYPE", (void*) &matrix_build_type);
/* Set default values */
strncpy(symmetrization, "NONE", MAX_PARAM_STRING_LEN);
strncpy(bipartite_type, "OBJ", MAX_PARAM_STRING_LEN);
strncpy(weigth_type, "ADD", MAX_PARAM_STRING_LEN);
strncpy(matrix_build_type, "NORMAL", MAX_PARAM_STRING_LEN);
Zoltan_Assign_Param_Vals(zz->Params, ZG_params, zz->Debug_Level, zz->Proc,
zz->Debug_Proc);
Zoltan_Matrix2d_Init(&graph->mtx);
graph->mtx.comm = (PHGComm*)ZOLTAN_MALLOC (sizeof(PHGComm));
if (graph->mtx.comm == NULL) MEMORY_ERROR;
Zoltan_PHGComm_Init (graph->mtx.comm);
memset(&opt, 0, sizeof(Zoltan_matrix_options));
opt.enforceSquare = 1; /* We want a graph: square matrix */
if (!strcasecmp(weigth_type, "ADD"))
opt.pinwgtop = ADD_WEIGHT;
else if (!strcasecmp(weigth_type, "MAX"))
opt.pinwgtop = MAX_WEIGHT;
else if (!strcasecmp(weigth_type, "CMP"))
opt.pinwgtop = MAX_WEIGHT;
opt.pinwgt = 1;
opt.randomize = 0;
opt.local = local;
opt.keep_distribution = 1;
if (strcasecmp(symmetrization, "NONE")) {
opt.symmetrize = 1;
}
if (!strcasecmp(matrix_build_type, "FAST"))
opt.speed = MATRIX_FAST;
else if (!strcasecmp(matrix_build_type, "FAST_NO_DUP"))
opt.speed = MATRIX_NO_REDIST;
else
opt.speed = MATRIX_FULL_DD;
#ifdef CC_TIMERS
times[1] = Zoltan_Time(zz->Timer);
#endif
ierr = Zoltan_Matrix_Build(zz, &opt, &graph->mtx.mtx);
CHECK_IERR;
#ifdef CC_TIMERS
times[2] = Zoltan_Time(zz->Timer);
#endif
ierr = Zoltan_Matrix_Mark_Diag (zz, &graph->mtx.mtx, &diag, &diagarray);
CHECK_IERR;
if (diag) { /* Some Diagonal Terms have to be removed */
ierr = Zoltan_Matrix_Delete_nnz(zz, &graph->mtx.mtx, diag, diagarray);
ZOLTAN_FREE(&diagarray);
CHECK_IERR;
}
#ifdef CC_TIMERS
times[3] = Zoltan_Time(zz->Timer);
#endif
if (opt.symmetrize) {
if (!strcasecmp(symmetrization, "BIPARTITE"))
bipartite = 1;
ierr = Zoltan_Matrix_Sym(zz, &graph->mtx.mtx, bipartite);
CHECK_IERR;
}
#ifdef CC_TIMERS
times[4] = Zoltan_Time(zz->Timer);
#endif
ierr = Zoltan_Distribute_LinearY(zz, graph->mtx.comm);
CHECK_IERR;
#ifdef CC_TIMERS
times[5] = Zoltan_Time(zz->Timer);
MPI_Barrier(zz->Communicator);
#endif
ierr = Zoltan_Matrix2d_Distribute (zz, graph->mtx.mtx, &graph->mtx, 0);
CHECK_IERR;
#ifdef CC_TIMERS
times[6] = Zoltan_Time(zz->Timer);
#endif
ierr = Zoltan_Matrix_Complete(zz, &graph->mtx.mtx);
#ifdef CC_TIMERS
times[7] = Zoltan_Time(zz->Timer);
#endif
if (bipartite) {
int vertlno;
int limit;
int offset;
graph->bipartite = 1;
graph->fixed_vertices = graph->mtx.mtx.ybipart;
/* graph->fixed_vertices = (int*) ZOLTAN_MALLOC(graph->mtx.mtx.nY*sizeof(int)); */
/* if (graph->mtx.mtx.nY && graph->fixed_vertices == NULL) MEMORY_ERROR; */
/* limit = graph->mtx.mtx.offsetY; */
/* /\* What kind of vertices do we want to keep ? *\/ */
/* graph->fixObj = !strcasecmp(bipartite_type, "OBJ"); /\* Non-zero value means "objects" *\/ */
/* offset = graph->mtx.mtx.offsetY - graph->mtx.dist_y[graph->mtx.comm->myProc_y]; */
/* if (graph->fixObj) /\* What kind of vertices do we want to keep ? *\/ */
/* for (vertlno = 0 ; vertlno < graph->mtx.mtx.nY ; ++ vertlno) */
/* graph->fixed_vertices[vertlno] = (vertlno < offset); */
/* else */
/* for (vertlno = 0 ; vertlno < graph->mtx.mtx.nY ; ++ vertlno) */
/* graph->fixed_vertices[vertlno] = (vertlno >= offset); */
}
#ifdef CC_TIMERS
MPI_Barrier(zz->Communicator);
times[8] = Zoltan_Time(zz->Timer);
MPI_Reduce(times, gtimes, 9, MPI_DOUBLE, MPI_MAX, 0, zz->Communicator);
if (!zz->Proc) {
int i;
printf("Total Build Time in Proc-0: %.2lf Max: %.2lf\n", times[8]-times[0], gtimes[8]-times[0]);
for (i=1; i<9; ++i)
printf("%-13s in Proc-0: %8.2lf Max: %8.2lf\n", timenames[i], times[i]-times[i-1], gtimes[i]-gtimes[i-1]);
}
#endif
End:
ZOLTAN_FREE(&diagarray);
ZOLTAN_TRACE_EXIT(zz, yo);
return (ierr);
}
int Zoltan_Drum_Init(ZZ *zz) {
/* bind DRUM-related Zoltan parameters */
Zoltan_Bind_Param(Drum_params, "USE_DRUM", (void *) &zz->Drum.use_drum);
Zoltan_Bind_Param(Drum_params, "DRUM_HIER", (void *) &zz->Drum.drum_hier);
Zoltan_Bind_Param(Drum_params, "ZOLTAN_BUILD_DRUM_TREE",
(void *) &zz->Drum.build_tree);
Zoltan_Bind_Param(Drum_params, "ZOLTAN_START_DRUM_MONITORS",
(void *) &zz->Drum.start_monitors);
Zoltan_Bind_Param(Drum_params, "DRUM_MONITORING_FREQUENCY",
(void *) &zz->Drum.monitoring_frequency);
Zoltan_Bind_Param(Drum_params, "DRUM_USE_SNMP",
(void *) &zz->Drum.use_snmp);
Zoltan_Bind_Param(Drum_params, "DRUM_USE_KSTAT",
(void *) &zz->Drum.use_kstat);
Zoltan_Bind_Param(Drum_params, "DRUM_USE_NWS",
(void *) &zz->Drum.use_nws);
Zoltan_Bind_Param(Drum_params, "DRUM_NWS_METHOD",
(void *) &zz->Drum.nws_method);
Zoltan_Bind_Param(Drum_params, "DRUM_MONITOR_MEMORY",
(void *) &zz->Drum.monitor_memory);
Zoltan_Bind_Param(Drum_params, "DRUM_USE_FLAT_MODEL",
(void *) &zz->Drum.use_flat_model);
Zoltan_Bind_Param(Drum_params, "DRUM_USE_NETWORK_POWERS",
(void *) &zz->Drum.use_network_powers);
Zoltan_Bind_Param(Drum_params, "DRUM_FIXED_NETWORK_WEIGHT",
(void *) &zz->Drum.fixed_network_weight);
Zoltan_Bind_Param(Drum_params, "DRUM_IGNORE_RPP",
(void *) &zz->Drum.ignore_rpp);
Zoltan_Bind_Param(Drum_params, "DRUM_DEBUG_LEVEL",
(void *) &zz->Drum.debug_level);
Zoltan_Bind_Param(Drum_params, "DRUM_POWER_FILE_LOG",
(void *) zz->Drum.power_filename);
/* set default values */
/* can't do this - this is called on each LB_Balance invocation */
/*zz->Drum.dmm = NULL;*/
zz->Drum.use_drum = 0;
zz->Drum.drum_hier = 0;
zz->Drum.build_tree = 1;
zz->Drum.start_monitors = 1;
zz->Drum.monitoring_frequency = 1;
zz->Drum.use_snmp = 0;
zz->Drum.use_kstat = 1;
zz->Drum.use_nws = 0;
zz->Drum.nws_method = 0;
zz->Drum.monitor_memory = 0;
zz->Drum.use_flat_model = 0;
zz->Drum.use_network_powers = 0;
zz->Drum.fixed_network_weight = 0.0;
zz->Drum.ignore_rpp = 0;
zz->Drum.debug_level = 0;
zz->Drum.power_filename[0] = '\0';
Zoltan_Assign_Param_Vals(zz->Params, Drum_params, zz->Debug_Level, zz->Proc,
zz->Debug_Proc);
return ZOLTAN_OK;
}
