void third_test(struct Zoltan_Timer *zt)
{
/* Third test of Timer: This test accrues times through
* separate calls to third_test.
* The time for timer two should be roughly twice that of timer one.
* The time for timer three should be roughly four times that of timer one.
* Intermediate print statements are included (i.e., prints while the timer
* is still running).
*/
int i, j, me;
const int LOOP1=1000,
LOOP2=2000,
LOOP3=4000;
const int MAINLOOP=100;
const int t1=0, t2=1, t3=2;
MPI_Comm_rank(MPI_COMM_WORLD, &me);
for (i = 0; i < MAINLOOP; i++) {
ZOLTAN_TIMER_START(zt, t1, MPI_COMM_WORLD);
for (j = 0; j < LOOP1; j++) {
double a;
a = sqrt((double) (j * LOOP1));
if (!(j%1000)) {
if (me == 0) printf("LOOP1 %d: \n", j);
Zoltan_Timer_Print(zt, t1, 0, MPI_COMM_WORLD, stdout);
}
}
ZOLTAN_TIMER_STOP(zt, t1, MPI_COMM_WORLD);
ZOLTAN_TIMER_START(zt, t2, MPI_COMM_WORLD);
for (j = 0; j < LOOP2; j++) {
double a;
a = sqrt((double) (j * LOOP2));
if (!(j%1000)) {
if (me == 0) printf("LOOP2 %d: \n", j);
Zoltan_Timer_Print(zt, t2, 0, MPI_COMM_WORLD, stdout);
}
}
ZOLTAN_TIMER_STOP(zt, t2, MPI_COMM_WORLD);
ZOLTAN_TIMER_START(zt, t3, MPI_COMM_WORLD);
for (j = 0; j < LOOP3; j++) {
double a;
a = sqrt((double) (j * LOOP3));
if (!(j%1000)) {
if (me == 0) printf("LOOP3 %d: \n", j);
Zoltan_Timer_Print(zt, t3, 0, MPI_COMM_WORLD, stdout);
}
}
ZOLTAN_TIMER_STOP(zt, t3, MPI_COMM_WORLD);
}
Zoltan_Timer_PrintAll(zt, 0, MPI_COMM_WORLD, stdout);
}
void first_test(struct Zoltan_Timer *zt)
{
/* First test of Timer: This test accrues times through
* separate calls to first_test.
* The time for timer two should be roughly twice that of timer one.
* The time for timer three should be roughly four times that of timer one.
*/
int i, j, me;
static int firsttime=1;
const int LOOP1=1000,
LOOP2=2000,
LOOP3=4000;
const int MAINLOOP=100;
const int USE_BARRIER=1;
static int t1=-1, t2=-1, t3=-1;
MPI_Comm_rank(MPI_COMM_WORLD, &me);
for (i = 0; i < MAINLOOP; i++) {
if (firsttime)
t1 = Zoltan_Timer_Init(zt, USE_BARRIER, "Loop 1");
ZOLTAN_TIMER_START(zt, t1, MPI_COMM_WORLD);
for (j = 0; j < LOOP1; j++) {
double a;
a = sqrt((double) (j * LOOP1));
}
ZOLTAN_TIMER_STOP(zt, t1, MPI_COMM_WORLD);
if (firsttime)
t2 = Zoltan_Timer_Init(zt, USE_BARRIER, "Loop 2");
ZOLTAN_TIMER_START(zt, t2, MPI_COMM_WORLD);
for (j = 0; j < LOOP2; j++) {
double a;
a = sqrt((double) (j * LOOP2));
}
ZOLTAN_TIMER_STOP(zt, t2, MPI_COMM_WORLD);
if (firsttime)
t3 = Zoltan_Timer_Init(zt, USE_BARRIER, "Loop 3");
ZOLTAN_TIMER_START(zt, t3, MPI_COMM_WORLD);
for (j = 0; j < LOOP3; j++) {
double a;
a = sqrt((double) (j * LOOP3));
}
ZOLTAN_TIMER_STOP(zt, t3, MPI_COMM_WORLD);
firsttime=0;
}
Zoltan_Timer_PrintAll(zt, 0, MPI_COMM_WORLD, stdout);
}
void second_test(struct Zoltan_Timer *zt)
{
/* Second test of Timer: This test does not accrue times through
* separate function calls. It exercises the REALLOC when more timers
* than INITLENGTH are requested.
* Computation is similar to first test. Timer_flag used is different.
*/
int i, j, me;
const int LOOP1=1000,
LOOP2=2000,
LOOP3=4000;
const int MAINLOOP=100;
const int USE_BARRIER=1;
int t1=-1, t2=-1, t3=-1;
char str[200];
static int cnt = 0;
MPI_Comm_rank(MPI_COMM_WORLD, &me);
sprintf(str, "STLoop 1 %d", cnt);
t1 = Zoltan_Timer_Init(zt, USE_BARRIER, str);
sprintf(str, "STLoop 2 %d", cnt);
t2 = Zoltan_Timer_Init(zt, USE_BARRIER, str);
sprintf(str, "STLoop 3 %d", cnt);
t3 = Zoltan_Timer_Init(zt, USE_BARRIER, str);
cnt++;
for (i = 0; i < MAINLOOP; i++) {
ZOLTAN_TIMER_START(zt, t1, MPI_COMM_WORLD);
for (j = 0; j < LOOP1; j++) {
double a;
a = sqrt((double) (j * LOOP1));
}
ZOLTAN_TIMER_STOP(zt, t1, MPI_COMM_WORLD);
ZOLTAN_TIMER_START(zt, t2, MPI_COMM_WORLD);
for (j = 0; j < LOOP2; j++) {
double a;
a = sqrt((double) (j * LOOP2));
}
ZOLTAN_TIMER_STOP(zt, t2, MPI_COMM_WORLD);
ZOLTAN_TIMER_START(zt, t3, MPI_COMM_WORLD);
for (j = 0; j < LOOP3; j++) {
double a;
a = sqrt((double) (j * LOOP3));
}
ZOLTAN_TIMER_STOP(zt, t3, MPI_COMM_WORLD);
}
Zoltan_Timer_PrintAll(zt, 0, MPI_COMM_WORLD, stdout);
}
/* Main partitioning function for hypergraph partitioning. */
int Zoltan_PHG_Partition (
ZZ *zz, /* Zoltan data structure */
HGraph *hg, /* Input hypergraph to be partitioned */
int p, /* Input: number partitions to be generated */
float *part_sizes, /* Input: array of length p containing percentages
of work to be assigned to each partition */
Partition parts, /* Input: initial partition #s; aligned with vtx
arrays.
Output: computed partition #s */
PHGPartParams *hgp, /* Input: parameters for hgraph partitioning. */
int level)
{
PHGComm *hgc = hg->comm;
VCycle *vcycle=NULL, *del=NULL;
int i, err = ZOLTAN_OK;
int prevVcnt = 2*hg->dist_x[hgc->nProc_x];
int prevVedgecnt = 2*hg->dist_y[hgc->nProc_y];
char *yo = "Zoltan_PHG_Partition";
static int timer_match = -1, /* Timers for various stages */
timer_coarse = -1, /* Declared static so we can accumulate */
timer_refine = -1, /* times over calls to Zoltan_PHG_Partition */
timer_coarsepart = -1,
timer_project = -1,
timer_vcycle = -1; /* times everything in Vcycle not included
in above timers */
int do_timing = (hgp->use_timers > 1);
int vcycle_timing = (hgp->use_timers > 4);
ZOLTAN_TRACE_ENTER(zz, yo);
if (do_timing) {
if (timer_vcycle < 0)
timer_vcycle = Zoltan_Timer_Init(zz->ZTime, 0, "Vcycle");
if (timer_match < 0)
timer_match = Zoltan_Timer_Init(zz->ZTime, 1, "Matching");
if (timer_coarse < 0)
timer_coarse = Zoltan_Timer_Init(zz->ZTime, 1, "Coarsening");
if (timer_coarsepart < 0)
timer_coarsepart = Zoltan_Timer_Init(zz->ZTime, 1,
"Coarse_Partition");
if (timer_refine < 0)
timer_refine = Zoltan_Timer_Init(zz->ZTime, 1, "Refinement");
if (timer_project < 0)
timer_project = Zoltan_Timer_Init(zz->ZTime, 1, "Project_Up");
ZOLTAN_TIMER_START(zz->ZTime, timer_vcycle, hgc->Communicator);
}
if (!(vcycle = newVCycle(zz, hg, parts, NULL, vcycle_timing))) {
ZOLTAN_PRINT_ERROR (zz->Proc, yo, "VCycle is NULL.");
return ZOLTAN_MEMERR;
}
/****** Coarsening ******/
#define COARSEN_FRACTION_LIMIT 0.9 /* Stop if we don't make much progress */
while ((hg->redl>0) && (hg->dist_x[hgc->nProc_x] > hg->redl)
&& ((hg->dist_x[hgc->nProc_x] < (int) (COARSEN_FRACTION_LIMIT * prevVcnt + 0.5))
|| (hg->dist_y[hgc->nProc_y] < (int) (COARSEN_FRACTION_LIMIT * prevVedgecnt + 0.5)))
&& hg->dist_y[hgc->nProc_y] && hgp->matching) {
int *match = NULL;
VCycle *coarser=NULL;
prevVcnt = hg->dist_x[hgc->nProc_x];
prevVedgecnt = hg->dist_y[hgc->nProc_y];
#ifdef _DEBUG
/* UVC: load balance stats */
Zoltan_PHG_LoadBalStat(zz, hg);
#endif
if (hgp->output_level >= PHG_DEBUG_LIST) {
uprintf(hgc,
"START %3d |V|=%6d |E|=%6d #pins=%6d %d/%s/%s/%s p=%d...\n",
hg->info, hg->nVtx, hg->nEdge, hg->nPins, hg->redl,
hgp->redm_str,
hgp->coarsepartition_str, hgp->refinement_str, p);
if (hgp->output_level > PHG_DEBUG_LIST) {
err = Zoltan_HG_Info(zz, hg);
if (err != ZOLTAN_OK && err != ZOLTAN_WARN)
goto End;
}
}
if (hgp->output_level >= PHG_DEBUG_PLOT)
Zoltan_PHG_Plot(zz->Proc, hg->nVtx, p, hg->vindex, hg->vedge, NULL,
"coarsening plot");
if (do_timing) {
ZOLTAN_TIMER_STOP(zz->ZTime, timer_vcycle, hgc->Communicator);
ZOLTAN_TIMER_START(zz->ZTime, timer_match, hgc->Communicator);
}
if (vcycle_timing) {
if (vcycle->timer_match < 0) {
char str[80];
sprintf(str, "VC Matching %d", hg->info);
vcycle->timer_match = Zoltan_Timer_Init(vcycle->timer, 0, str);
}
ZOLTAN_TIMER_START(vcycle->timer, vcycle->timer_match,
hgc->Communicator);
}
/* Allocate and initialize Matching Array */
if (hg->nVtx && !(match = (int*) ZOLTAN_MALLOC (hg->nVtx*sizeof(int)))) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Insufficient memory: Matching array");
return ZOLTAN_MEMERR;
}
for (i = 0; i < hg->nVtx; i++)
match[i] = i;
/* Calculate matching (packing or grouping) */
err = Zoltan_PHG_Matching (zz, hg, match, hgp);
if (err != ZOLTAN_OK && err != ZOLTAN_WARN) {
ZOLTAN_FREE ((void**) &match);
goto End;
}
if (vcycle_timing)
ZOLTAN_TIMER_STOP(vcycle->timer, vcycle->timer_match,
hgc->Communicator);
if (do_timing) {
ZOLTAN_TIMER_STOP(zz->ZTime, timer_match, hgc->Communicator);
ZOLTAN_TIMER_START(zz->ZTime, timer_coarse, hgc->Communicator);
}
if (vcycle_timing) {
if (vcycle->timer_coarse < 0) {
char str[80];
sprintf(str, "VC Coarsening %d", hg->info);
vcycle->timer_coarse = Zoltan_Timer_Init(vcycle->timer, 0, str);
}
ZOLTAN_TIMER_START(vcycle->timer, vcycle->timer_coarse,
hgc->Communicator);
}
if (!(coarser = newVCycle(zz, NULL, NULL, vcycle, vcycle_timing))) {
ZOLTAN_FREE ((void**) &match);
ZOLTAN_PRINT_ERROR (zz->Proc, yo, "coarser is NULL.");
goto End;
}
/* Construct coarse hypergraph and LevelMap */
err = Zoltan_PHG_Coarsening (zz, hg, match, coarser->hg, vcycle->LevelMap,
&vcycle->LevelCnt, &vcycle->LevelSndCnt, &vcycle->LevelData,
&vcycle->comm_plan, hgp);
if (err != ZOLTAN_OK && err != ZOLTAN_WARN)
goto End;
if (vcycle_timing)
ZOLTAN_TIMER_STOP(vcycle->timer, vcycle->timer_coarse,
hgc->Communicator);
if (do_timing) {
ZOLTAN_TIMER_STOP(zz->ZTime, timer_coarse, hgc->Communicator);
ZOLTAN_TIMER_START(zz->ZTime, timer_vcycle, hgc->Communicator);
}
ZOLTAN_FREE ((void**) &match);
if ((err=allocVCycle(coarser))!= ZOLTAN_OK)
goto End;
vcycle = coarser;
hg = vcycle->hg;
}
if (hgp->output_level >= PHG_DEBUG_LIST) {
uprintf(hgc, "START %3d |V|=%6d |E|=%6d #pins=%6d %d/%s/%s/%s p=%d...\n",
hg->info, hg->nVtx, hg->nEdge, hg->nPins, hg->redl,
hgp->redm_str, hgp->coarsepartition_str, hgp->refinement_str, p);
if (hgp->output_level > PHG_DEBUG_LIST) {
err = Zoltan_HG_Info(zz, hg);
if (err != ZOLTAN_OK && err != ZOLTAN_WARN)
goto End;
}
}
if (hgp->output_level >= PHG_DEBUG_PLOT)
Zoltan_PHG_Plot(zz->Proc, hg->nVtx, p, hg->vindex, hg->vedge, NULL,
"coarsening plot");
/* free array that may have been allocated in matching */
if (hgp->vtx_scal) ZOLTAN_FREE(&(hgp->vtx_scal));
if (do_timing) {
ZOLTAN_TIMER_STOP(zz->ZTime, timer_vcycle, hgc->Communicator);
ZOLTAN_TIMER_START(zz->ZTime, timer_coarsepart, hgc->Communicator);
}
/****** Coarse Partitioning ******/
err = Zoltan_PHG_CoarsePartition (zz, hg, p, part_sizes, vcycle->Part, hgp);
if (err != ZOLTAN_OK && err != ZOLTAN_WARN)
goto End;
if (do_timing) {
ZOLTAN_TIMER_STOP(zz->ZTime, timer_coarsepart, hgc->Communicator);
ZOLTAN_TIMER_START(zz->ZTime, timer_vcycle, hgc->Communicator);
}
del = vcycle;
/****** Uncoarsening/Refinement ******/
while (vcycle) {
VCycle *finer = vcycle->finer;
hg = vcycle->hg;
if (do_timing) {
ZOLTAN_TIMER_STOP(zz->ZTime, timer_vcycle, hgc->Communicator);
ZOLTAN_TIMER_START(zz->ZTime, timer_refine, hgc->Communicator);
}
if (vcycle_timing) {
if (vcycle->timer_refine < 0) {
char str[80];
sprintf(str, "VC Refinement %d", hg->info);
vcycle->timer_refine = Zoltan_Timer_Init(vcycle->timer, 0, str);
}
ZOLTAN_TIMER_START(vcycle->timer, vcycle->timer_refine,
hgc->Communicator);
}
err = Zoltan_PHG_Refinement (zz, hg, p, part_sizes, vcycle->Part, hgp);
if (do_timing) {
ZOLTAN_TIMER_STOP(zz->ZTime, timer_refine, hgc->Communicator);
ZOLTAN_TIMER_START(zz->ZTime, timer_vcycle, hgc->Communicator);
}
if (vcycle_timing)
ZOLTAN_TIMER_STOP(vcycle->timer, vcycle->timer_refine,
hgc->Communicator);
if (hgp->output_level >= PHG_DEBUG_LIST)
uprintf(hgc,
"FINAL %3d |V|=%6d |E|=%6d #pins=%6d %d/%s/%s/%s p=%d bal=%.2f cutl=%.2f\n",
hg->info, hg->nVtx, hg->nEdge, hg->nPins, hg->redl,
hgp->redm_str,
hgp->coarsepartition_str, hgp->refinement_str, p,
Zoltan_PHG_Compute_Balance(zz, hg, part_sizes, p, vcycle->Part),
Zoltan_PHG_Compute_ConCut(hgc, hg, vcycle->Part, p, &err));
if (hgp->output_level >= PHG_DEBUG_PLOT)
Zoltan_PHG_Plot(zz->Proc, hg->nVtx, p, hg->vindex, hg->vedge, vcycle->Part,
"partitioned plot");
if (do_timing) {
ZOLTAN_TIMER_STOP(zz->ZTime, timer_vcycle, hgc->Communicator);
ZOLTAN_TIMER_START(zz->ZTime, timer_project, hgc->Communicator);
}
if (vcycle_timing) {
if (vcycle->timer_project < 0) {
char str[80];
sprintf(str, "VC Project Up %d", hg->info);
vcycle->timer_project = Zoltan_Timer_Init(vcycle->timer, 0, str);
}
ZOLTAN_TIMER_START(vcycle->timer, vcycle->timer_project,
hgc->Communicator);
}
/* Project coarse partition to fine partition */
if (finer) {
int *rbuffer;
/* easy to undo internal matches */
for (i = 0; i < finer->hg->nVtx; i++)
if (finer->LevelMap[i] >= 0)
finer->Part[i] = vcycle->Part[finer->LevelMap[i]];
/* fill sendbuffer with part data for external matches I owned */
for (i = 0; i < finer->LevelCnt; i++) {
++i; /* skip return lno */
finer->LevelData[i] = finer->Part[finer->LevelData[i]];
}
/* allocate rec buffer */
rbuffer = NULL;
if (finer->LevelSndCnt > 0) {
rbuffer = (int*) ZOLTAN_MALLOC (2 * finer->LevelSndCnt * sizeof(int));
if (!rbuffer) {
ZOLTAN_PRINT_ERROR (zz->Proc, yo, "Insufficient memory.");
return ZOLTAN_MEMERR;
}
}
/* get partition assignments from owners of externally matchted vtxs */
Zoltan_Comm_Resize (finer->comm_plan, NULL, COMM_TAG, &i);
Zoltan_Comm_Do_Reverse (finer->comm_plan, COMM_TAG+1,
(char*) finer->LevelData, 2 * sizeof(int), NULL, (char*) rbuffer);
/* process data to undo external matches */
for (i = 0; i < 2 * finer->LevelSndCnt;) {
int lno, partition;
lno = rbuffer[i++];
partition = rbuffer[i++];
finer->Part[lno] = partition;
}
ZOLTAN_FREE (&rbuffer);
Zoltan_Comm_Destroy (&finer->comm_plan);
}
if (do_timing) {
ZOLTAN_TIMER_STOP(zz->ZTime, timer_project, hgc->Communicator);
ZOLTAN_TIMER_START(zz->ZTime, timer_vcycle, hgc->Communicator);
}
if (vcycle_timing)
ZOLTAN_TIMER_STOP(vcycle->timer, vcycle->timer_project,
hgc->Communicator);
vcycle = finer;
} /* while (vcycle) */
End:
vcycle = del;
while (vcycle) {
if (vcycle_timing) {
Zoltan_Timer_PrintAll(vcycle->timer, 0, hgc->Communicator, stdout);
Zoltan_Timer_Destroy(&vcycle->timer);
}
if (vcycle->finer) { /* cleanup by level */
Zoltan_HG_HGraph_Free (vcycle->hg);
Zoltan_Multifree (__FILE__, __LINE__, 4, &vcycle->Part, &vcycle->LevelMap,
&vcycle->LevelData, &vcycle->hg);
}
else /* cleanup top level */
Zoltan_Multifree (__FILE__, __LINE__, 2, &vcycle->LevelMap,
&vcycle->LevelData);
del = vcycle;
vcycle = vcycle->finer;
ZOLTAN_FREE(&del);
}
if (do_timing)
ZOLTAN_TIMER_STOP(zz->ZTime, timer_vcycle, hgc->Communicator);
ZOLTAN_TRACE_EXIT(zz, yo) ;
return err;
}
static int refine_fm2 (ZZ *zz,
HGraph *hg,
int p,
float *part_sizes,
Partition part,
PHGPartParams *hgp,
float bal_tol
)
{
int i, j, ierr=ZOLTAN_OK, *pins[2]={NULL,NULL}, *lpins[2]={NULL,NULL};
int *moves=NULL, *mark=NULL, *adj=NULL, passcnt=0;
float *gain=NULL, *lgain=NULL;
int best_cutsizeat, cont, successivefails=0;
double total_weight, weights[2], total_lweight, lweights[2], lwadjust[2],
max_weight[2], lmax_weight[2], avail[2], gavail[2];
int availcnt[2], gavailcnt[2];
double targetw0, ltargetw0, minvw=DBL_MAX;
double cutsize, best_cutsize,
best_limbal, imbal, limbal;
HEAP heap[2];
char *yo="refine_fm2";
int part_dim = (hg->VtxWeightDim ? hg->VtxWeightDim : 1);
#ifdef HANDLE_ISOLATED_VERTICES
int isocnt=hg->nVtx; /* only root uses isocnt, isolated vertices
are kept at the end of moves array */
int *deg=NULL, *ldeg=NULL;
#if 0
double best_imbal;
#endif
#endif
PHGComm *hgc=hg->comm;
int rootRank;
struct phg_timer_indices *timer = Zoltan_PHG_LB_Data_timers(zz);
int do_timing = (hgp->use_timers > 2);
int detail_timing = (hgp->use_timers > 3);
ZOLTAN_TRACE_ENTER(zz, yo);
if (p != 2) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "p!=2 not allowed for refine_fm2.");
ZOLTAN_TRACE_EXIT(zz, yo);
return ZOLTAN_FATAL;
}
/* return only if globally there is no edge or vertex */
if (!hg->dist_y[hgc->nProc_y] || hg->dist_x[hgc->nProc_x] == 0) {
ZOLTAN_TRACE_EXIT(zz, yo);
return ZOLTAN_OK;
}
#ifdef USE_SERIAL_REFINEMENT_ON_ONE_PROC
if (hgc->nProc==1){ /* only one proc? use serial code */
ZOLTAN_TRACE_EXIT(zz, yo);
return serial_fm2 (zz, hg, p, part_sizes, part, hgp, bal_tol);
}
#endif
if (do_timing) {
if (timer->rfrefine < 0)
timer->rfrefine = Zoltan_Timer_Init(zz->ZTime, 1, "Ref_P_Total");
ZOLTAN_TIMER_START(zz->ZTime, timer->rfrefine, hgc->Communicator);
}
if (detail_timing) {
if (timer->rfpins < 0)
timer->rfpins = Zoltan_Timer_Init(zz->ZTime, 0, "Ref_P_Pins");
if (timer->rfiso < 0)
timer->rfiso = Zoltan_Timer_Init(zz->ZTime, 0, "Ref_P_IsolatedVert");
if (timer->rfgain < 0)
timer->rfgain = Zoltan_Timer_Init(zz->ZTime, 0, "Ref_P_Gain");
if (timer->rfheap < 0)
timer->rfheap = Zoltan_Timer_Init(zz->ZTime, 0, "Ref_P_Heap");
if (timer->rfpass < 0)
timer->rfpass = Zoltan_Timer_Init(zz->ZTime, 0, "Ref_P_Pass");
if (timer->rfroll < 0)
timer->rfroll = Zoltan_Timer_Init(zz->ZTime, 0, "Ref_P_Roll");
if (timer->rfnonroot < 0)
timer->rfnonroot = Zoltan_Timer_Init(zz->ZTime, 0, "Ref_P_NonRoot");
}
/* find the index of the proc in column group with
the most #nonzeros; it will be our root
proc for computing moves since it has better
knowedge about global hypergraph.
We ignore returned #pins (i) in root */
Zoltan_PHG_Find_Root(hg->nPins, hgc->myProc_y, hgc->col_comm,
&i, &rootRank);
/* Calculate the weights in each partition and total, then maxima */
weights[0] = weights[1] = 0.0;
lweights[0] = lweights[1] = 0.0;
if (hg->vwgt)
for (i = 0; i < hg->nVtx; i++) {
lweights[part[i]] += hg->vwgt[i*hg->VtxWeightDim];
minvw = (minvw > hg->vwgt[i*hg->VtxWeightDim])
? hg->vwgt[i*hg->VtxWeightDim]
: minvw;
}
else {
minvw = 1.0;
for (i = 0; i < hg->nVtx; i++)
lweights[part[i]] += 1.0;
}
MPI_Allreduce(lweights, weights, 2, MPI_DOUBLE, MPI_SUM, hgc->row_comm);
total_weight = weights[0] + weights[1];
targetw0 = total_weight * part_sizes[0]; /* global target weight for part 0 */
max_weight[0] = total_weight * bal_tol * part_sizes[0];
max_weight[1] = total_weight * bal_tol * part_sizes[part_dim]; /* should be (1 - part_sizes[0]) */
if (weights[0]==0.0) {
ltargetw0 = targetw0 / hgc->nProc_x;
lmax_weight[0] = max_weight[0] / hgc->nProc_x;
} else {
lmax_weight[0] = (weights[0]==0.0) ? 0.0 : lweights[0] +
(max_weight[0] - weights[0]) * ( lweights[0] / weights[0] );
ltargetw0 = targetw0 * ( lweights[0] / weights[0] ); /* local target weight */
}
if (weights[1]==0.0)
lmax_weight[1] = max_weight[1] / hgc->nProc_x;
else
lmax_weight[1] = (weights[1]==0.0) ? 0.0 : lweights[1] +
(max_weight[1] - weights[1]) * ( lweights[1] / weights[1] );
total_lweight = lweights[0]+lweights[1];
avail[0] = MAX(0.0, lmax_weight[0]-total_lweight);
avail[1] = MAX(0.0, lmax_weight[1]-total_lweight);
availcnt[0] = (avail[0] == 0) ? 1 : 0;
availcnt[1] = (avail[1] == 0) ? 1 : 0;
MPI_Allreduce(avail, gavail, 2, MPI_DOUBLE, MPI_SUM, hgc->row_comm);
MPI_Allreduce(availcnt, gavailcnt, 2, MPI_INT, MPI_SUM, hgc->row_comm);
#ifdef _DEBUG
if (gavailcnt[0] || gavailcnt[1])
uprintf(hgc, "before adjustment, LMW[%.1lf, %.1lf]\n", lmax_weight[0], lmax_weight[1]);
#endif
if (gavailcnt[0])
lmax_weight[0] += gavail[0] / (double) gavailcnt[0];
if (gavailcnt[1])
lmax_weight[1] += gavail[1] / (double) gavailcnt[1];
/* Our strategy is to stay close to the current local weight balance.
We do not need the same local balance on each proc, as long as
we achieve approximate global balance. */
#ifdef _DEBUG
imbal = (targetw0==0.0) ? 0.0 : fabs(weights[0]-targetw0)/targetw0;
limbal = (ltargetw0==0.0) ? 0.0 : fabs(lweights[0]-ltargetw0)/ltargetw0;
uprintf(hgc, "H(%d, %d, %d), FM2: W[%.1lf, %.1lf] MW:[%.1lf, %.1lf] I=%.3lf LW[%.1lf, %.1lf] LMW[%.1lf, %.1lf] LI=%.3lf\n", hg->nVtx, hg->nEdge, hg->nPins, weights[0], weights[1], max_weight[0], max_weight[1], imbal, lweights[0], lweights[1], lmax_weight[0], lmax_weight[1], limbal);
#endif
if ((hg->nEdge && (!(pins[0] = (int*) ZOLTAN_MALLOC(2 * hg->nEdge * sizeof(int)))
|| !(lpins[0] = (int*) ZOLTAN_CALLOC(2 * hg->nEdge, sizeof(int))))) ||
(hg->nVtx && (!(moves = (int*) ZOLTAN_MALLOC(hg->nVtx * sizeof(int)))
|| !(lgain = (float*) ZOLTAN_MALLOC(hg->nVtx * sizeof(float))))))
MEMORY_ERROR;
if (hg->nEdge) {
pins[1] = &(pins[0][hg->nEdge]);
lpins[1] = &(lpins[0][hg->nEdge]);
}
if (hgc->myProc_y==rootRank) { /* only root needs mark, adj, gain and heaps*/
Zoltan_Heap_Init(zz, &heap[0], hg->nVtx);
Zoltan_Heap_Init(zz, &heap[1], hg->nVtx);
if (hg->nVtx &&
(!(mark = (int*) ZOLTAN_CALLOC(hg->nVtx, sizeof(int)))
|| !(adj = (int*) ZOLTAN_MALLOC(hg->nVtx * sizeof(int)))
|| !(gain = (float*) ZOLTAN_MALLOC(hg->nVtx * sizeof(float)))))
MEMORY_ERROR;
}
/* Initial calculation of the local pin distribution (sigma in UVC's papers) */
if (detail_timing)
ZOLTAN_TIMER_START(zz->ZTime, timer->rfpins, hgc->Communicator);
for (i = 0; i < hg->nEdge; ++i)
for (j = hg->hindex[i]; j < hg->hindex[i+1]; ++j){
++(lpins[part[hg->hvertex[j]]][i]);
}
if (detail_timing)
ZOLTAN_TIMER_STOP(zz->ZTime, timer->rfpins, hgc->Communicator);
#ifdef HANDLE_ISOLATED_VERTICES
/* first compute vertex degree to find any isolated vertices
we use lgain and gain, as ldeg, deg.*/
if (hg->nVtx) {
if (detail_timing)
ZOLTAN_TIMER_START(zz->ZTime, timer->rfiso, hgc->Communicator);
ldeg = (int *) lgain;
deg = (int *) gain; /* null for non-root but that is fine */
for (i = 0; i < hg->nVtx; ++i)
ldeg[i] = hg->vindex[i+1] - hg->vindex[i];
MPI_Reduce(ldeg, deg, hg->nVtx, MPI_INT, MPI_SUM, rootRank,
hg->comm->col_comm);
if (hgc->myProc_y==rootRank) { /* root marks isolated vertices */
for (i=0; i<hg->nVtx; ++i)
if (!hgp->UseFixedVtx || hg->fixed_part[i]<0) {
if (!deg[i]) {
moves[--isocnt] = i;
part[i] = -(part[i]+1); /* remove those vertices from that part*/
}
}
}
if (detail_timing)
ZOLTAN_TIMER_STOP(zz->ZTime, timer->rfiso, hgc->Communicator);
}
#endif
do {
int v=1, movecnt=0, neggaincnt=0, from, to;
int maxneggain = (hgp->fm_max_neg_move < 0) ? hg->nVtx : hgp->fm_max_neg_move;
int notfeasible=(weights[0]>max_weight[0]) || (weights[1]>max_weight[1]);
/* now compute global pin distribution */
if (hg->nEdge) {
if (detail_timing)
ZOLTAN_TIMER_START(zz->ZTime, timer->rfpins, hgc->Communicator);
MPI_Allreduce(lpins[0], pins[0], 2*hg->nEdge, MPI_INT, MPI_SUM,
hgc->row_comm);
if (detail_timing)
ZOLTAN_TIMER_STOP(zz->ZTime, timer->rfpins, hgc->Communicator);
}
/* now we can compute actual cut */
best_cutsizeat=0;
cutsize = 0.0;
for (i=0; i < hg->nEdge; ++i) {
if (pins[0][i] && pins[1][i])
cutsize += (hg->ewgt ? hg->ewgt[i] : 1.0);
}
MPI_Allreduce(&cutsize, &best_cutsize, 1, MPI_DOUBLE, MPI_SUM, hgc->col_comm);
cutsize = best_cutsize;
imbal = (targetw0==0.0) ? 0.0 : fabs(weights[0]-targetw0)/targetw0;
best_limbal = limbal = (ltargetw0==0.0) ? 0.0
: fabs(lweights[0]-ltargetw0)/ltargetw0;
/* UVCUVC: it looks like instead of moving always from overloaded
part, alternating the 'from' part gives better results.
Hence if the imbal is not really bad (2x worse) we use that approach */
if (imbal > BADBALANCE*(bal_tol-1.0) ) /* decide which way the moves will be in this pass */
from = (weights[0] < targetw0) ? 1 : 0;
else
from = passcnt % 2;
/* we want to be sure that everybody!!! picks the same source */
MPI_Bcast(&from, 1, MPI_INT, 0, hgc->Communicator);
to = 1-from;
#ifdef _DEBUG
/* Just for debugging */
best_cutsize = Zoltan_PHG_Compute_NetCut(hgc, hg, part);
if (best_cutsize!=cutsize) {
errexit("%s: Initial cutsize=%.2lf Verify: total=%.2lf\n", uMe(hgc), cutsize,
best_cutsize);
}
if (hgc->myProc_y==rootRank)
for (i = 0; i< hg->nVtx; ++i)
if (mark[i])
errexit("mark[%d]=%d", i, mark[i]);
/* debuggging code ends here */
#endif
/* compute only the gains of the vertices from 'from' part */
if (detail_timing)
ZOLTAN_TIMER_START(zz->ZTime, timer->rfgain, hgc->Communicator);
for (i = 0; i < hg->nVtx; ++i) {
lgain[i] = 0.0;
if ((part[i]==from) && (!hgp->UseFixedVtx || hg->fixed_part[i]<0))
for (j = hg->vindex[i]; j < hg->vindex[i+1]; j++) {
int edge = hg->vedge[j];
if ((pins[0][edge]+pins[1][edge])>1) { /* if they have at least 2 pins :) */
if (pins[part[i]][edge] == 1)
lgain[i] += (hg->ewgt ? hg->ewgt[edge] : 1.0);
else if (pins[1-part[i]][edge] == 0)
lgain[i] -= (hg->ewgt ? hg->ewgt[edge] : 1.0);
}
}
}
/* now sum up all gains on only root proc */
if (hg->nVtx)
MPI_Reduce(lgain, gain, hg->nVtx, MPI_FLOAT, MPI_SUM, rootRank,
hgc->col_comm);
if (detail_timing)
ZOLTAN_TIMER_STOP(zz->ZTime, timer->rfgain, hgc->Communicator);
if (hgp->output_level >= PHG_DEBUG_ALL) {
imbal = (targetw0==0.0) ? 0.0 : fabs(weights[0]-targetw0)/targetw0;
printf("%s FM Pass %d (%d->%d) Cut=%.2f W[%5.0f, %5.0f] I= %.2f LW[%5.0f, %5.0f] LI= %.2f\n", uMe(hgc), passcnt, from, to, cutsize, weights[0], weights[1], imbal, lweights[0], lweights[1], limbal);
}
if (hgc->myProc_y==rootRank) {
/* those are the lucky ones; each proc in column-group
could have compute the same moves concurrently; but for this
version we'll do it in the root procs and broadcast */
#ifdef HANDLE_ISOLATED_VERTICES
if (detail_timing)
ZOLTAN_TIMER_START(zz->ZTime, timer->rfiso, hgc->Communicator);
lwadjust[0] = lwadjust[1] = 0.0;
for (i=isocnt; i < hg->nVtx; ++i) { /* go over isolated vertices */
int u=moves[i], pno=-part[u]-1;
float w=(hg->vwgt ? hg->vwgt[u*hg->VtxWeightDim] : 1.0);
if (pno<0 || pno>1)
errexit("heeeey pno=%d", pno);
/* let's remove it from its part */
lwadjust[pno] -= w;
}
lweights[0] += lwadjust[0];
lweights[1] += lwadjust[1];
if (detail_timing)
ZOLTAN_TIMER_STOP(zz->ZTime, timer->rfiso, hgc->Communicator);
#endif
if (detail_timing)
ZOLTAN_TIMER_START(zz->ZTime, timer->rfheap, hgc->Communicator);
/* Initialize the heaps and fill them with the gain values */
Zoltan_Heap_Clear(&heap[from]);
for (i = 0; i < hg->nVtx; ++i)
if ((part[i]==from) && (!hgp->UseFixedVtx || hg->fixed_part[i]<0))
Zoltan_Heap_Input(&heap[from], i, gain[i]);
Zoltan_Heap_Make(&heap[from]);
if (detail_timing) {
ZOLTAN_TIMER_STOP(zz->ZTime, timer->rfheap, hgc->Communicator);
ZOLTAN_TIMER_START(zz->ZTime, timer->rfpass, hgc->Communicator);
}
while ((neggaincnt < maxneggain) && ((lweights[to]+minvw) <= lmax_weight[to]) ) {
if (Zoltan_Heap_Empty(&heap[from])) { /* too bad it is empty */
v = -1;
break;
}
v = Zoltan_Heap_Extract_Max(&heap[from]);
#ifdef _DEBUG
if (from != part[v])
errexit("hooop from=%d part[%d]=%d", from, v, part[v]);
#endif
/* Mark vertex we picked from the heap so it is "locked".
For the current strategy, moving only one direction
at a time, the mark information is not critical.
Note that the mark array is also used in the move/update
routine so don't remove it! */
++mark[v];
if (lweights[to]+((hg->vwgt)?hg->vwgt[v*hg->VtxWeightDim]:1.0) > lmax_weight[to]) {
#ifdef _DEBUG2
printf("%s %4d: %6d (g: %5.1lf), p:%2d [%4.0lf, %4.0lf] NF\n", uMe(hgc), movecnt, v, gain[v], from, weights[0], weights[1]);
#endif
/* Negative value in moves array means we have examined
the vertex but couldn't move it. Note offset by one,
otherwise zero would be ambiguous. */
moves[movecnt++] = -(v+1);
continue;
}
moves[movecnt] = v;
++neggaincnt;
cutsize -= gain[v];
fm2_move_vertex_oneway(v, hg, part, gain, heap, pins, lpins, weights, lweights, mark, adj);
imbal = (targetw0==0.0) ? 0.0
: fabs(weights[0]-targetw0)/targetw0;
limbal = (ltargetw0==0.0) ? 0.0
: fabs(lweights[0]-ltargetw0)/ltargetw0;
if (notfeasible || (cutsize<best_cutsize) ||
(cutsize==best_cutsize && limbal < best_limbal)) {
#ifdef _DEBUG2
printf("%s %4d: %6d (g: %5.1lf), p:%2d W[%4.0lf, %4.0lf] I:%.2lf LW[%4.0lf, %4.0lf] LI:%.2lf C:%.1lf<-- Best\n", uMe(hgc), movecnt, v, gain[v], from, weights[0], weights[1], imbal, lweights[0], lweights[1], limbal, cutsize); /* after move gain is -oldgain */
#endif
notfeasible = weights[from]>max_weight[from];
best_cutsize = cutsize;
best_cutsizeat = movecnt+1;
best_limbal = limbal;
neggaincnt = 0;
}
#ifdef _DEBUG2
else
printf("%s %4d: %6d (g: %5.1lf), p:%2d [%4.0lf, %4.0lf] %.1lf\n", uMe(hgc), movecnt, v, gain[v], from, weights[0], weights[1], cutsize);
#endif
++movecnt;
}
if (detail_timing) {
ZOLTAN_TIMER_STOP(zz->ZTime, timer->rfpass, hgc->Communicator);
ZOLTAN_TIMER_START(zz->ZTime, timer->rfroll, hgc->Communicator);
}
#ifdef _DEBUG
if (v<0)
uprintf(hgc, "EOLB @ %d there was no vertex to select: v=%d\n", movecnt, v);
else if (neggaincnt >= maxneggain)
uprintf(hgc, "EOLB @ %d max neg move reached neggaincnt(%d) >= maxneggain\n", movecnt, neggaincnt, maxneggain);
else
uprintf(hgc, "EOLB @ %d balance constraint LW[%.1lf, %.1lf] and MAXW[%.1lf, %.1lf]\n", movecnt, lweights[0], lweights[1], lmax_weight[0], lmax_weight[1]);
#endif
/* roll back the moves without any improvement */
for (i=movecnt-1; i>=best_cutsizeat; --i) {
int vv = moves[i];
if (vv<0)
vv = -vv-1;
else /* we don't need to roll pins, or weights etc; rolling local ones suffices */
fm2_move_vertex_oneway_nonroot(vv, hg, part, lpins, lweights);
mark[vv] = 0;
}
for (i=0; i<best_cutsizeat; ++i){
int vv = (moves[i] < 0 ) ? -moves[i] - 1 : moves[i];
mark[vv] = 0;
}
if (detail_timing)
ZOLTAN_TIMER_STOP(zz->ZTime, timer->rfroll, hgc->Communicator);
}
if (detail_timing)
ZOLTAN_TIMER_START(zz->ZTime, timer->rfnonroot, hgc->Communicator);
/* now root bcast moves to column procs */
MPI_Bcast(&best_cutsizeat, 1, MPI_INT, rootRank, hgc->col_comm);
MPI_Bcast(moves, best_cutsizeat, MPI_INT, rootRank, hgc->col_comm);
if (hgc->myProc_y!=rootRank) { /* now non-root does move simulation */
for (i=0; i<best_cutsizeat; ++i) {
int vv = moves[i];
if (vv>=0)
fm2_move_vertex_oneway_nonroot(vv, hg, part, lpins, lweights);
}
}
if (detail_timing)
ZOLTAN_TIMER_STOP(zz->ZTime, timer->rfnonroot, hgc->Communicator);
#ifdef _DEBUG
for (i = 0; i < hg->nEdge; ++i) {
int lp[2];
lp[0] = lp[1] = 0;
for (j = hg->hindex[i]; j < hg->hindex[i+1]; ++j)
++(lp[part[hg->hvertex[j]]]);
if ((lp[0] != lpins[0][i]) || (lp[1] != lpins[1][i]))
errexit("for net %d -- lp=[%d, %d] lpins[%d, %d]", i, lp[0], lp[1], lpins[0][i], lpins[1][i]);
}
#endif
#ifdef HANDLE_ISOLATED_VERTICES
if (detail_timing)
ZOLTAN_TIMER_START(zz->ZTime, timer->rfiso, hgc->Communicator);
#if 0
MPI_Allreduce(lweights, weights, 2, MPI_DOUBLE, MPI_SUM, hgc->row_comm);
best_imbal = (targetw0==0.0) ? 0.0 : fabs(weights[0]-targetw0)/targetw0;
if (hgc->myProc_y==rootRank)
uprintf(hgc, "BEFORE ISOLATED VERTEX HANDLING WE *THINK* GLOBAL IMBALANCE is %.3lf\n", best_imbal);
#endif
if (hgc->myProc_y==rootRank) {
best_limbal = (ltargetw0==0.0) ? 0.0
: fabs(lweights[0]-ltargetw0)/ltargetw0;
for (i=isocnt; i < hg->nVtx; ++i) { /* go over isolated vertices */
int u = moves[i], npno;
float w=(hg->vwgt ? hg->vwgt[u*hg->VtxWeightDim] : 1.0);
npno = (lweights[0] < ltargetw0) ? 0 : 1;
lweights[npno] += w;
lwadjust[npno] += w;
part[u] = -(npno+1); /* move to npno (might be same as pno;
so it may not be a real move */
}
limbal = (ltargetw0==0.0) ? 0.0
: fabs(lweights[0]-ltargetw0)/ltargetw0;
#if 0
uprintf(hgc, "before binpacking of %d isolated vertices balance was: %.3lf now: %.3lf\n", hg->nVtx-isocnt, best_limbal, limbal);
#endif
}
MPI_Bcast(lwadjust, 2, MPI_DOUBLE, rootRank, hgc->col_comm);
if (hgc->myProc_y!=rootRank) {
lweights[0] += lwadjust[0];
lweights[1] += lwadjust[1];
}
if (detail_timing)
ZOLTAN_TIMER_STOP(zz->ZTime, timer->rfiso, hgc->Communicator);
#endif
MPI_Allreduce(lweights, weights, 2, MPI_DOUBLE, MPI_SUM, hgc->row_comm);
#if 0
best_imbal = (targetw0==0.0) ? 0.0 : fabs(weights[0]-targetw0)/targetw0;
if (hgc->myProc_y==rootRank)
uprintf(hgc, "NEW GLOBAL IMBALANCE is %.3lf\n", best_imbal);
#endif
if (weights[0]==0.0)
ltargetw0 = lmax_weight[0] = 0.0;
else {
lmax_weight[0] = lweights[0] +
(max_weight[0] - weights[0]) * ( lweights[0] / weights[0] );
ltargetw0 = targetw0 * ( lweights[0] / weights[0] ); /* local target weight */
}
lmax_weight[1] = (weights[1]==0.0) ? 0.0 : lweights[1] +
(max_weight[1] - weights[1]) * ( lweights[1] / weights[1] );
cont = 0;
MPI_Allreduce(&best_cutsizeat, &cont, 1, MPI_INT, MPI_LOR, hgc->row_comm);
/* since we're only moving in one direction; make sure two successive
pass didn't produce any improvement before terminating */
if (!cont)
++successivefails;
else
successivefails = 0;
#ifdef _DEBUG
/* Just for debugging */
best_cutsize = Zoltan_PHG_Compute_NetCut(hgc, hg, part);
imbal = (targetw0 == 0.0) ? 0.0 : fabs(weights[0]-targetw0)/targetw0;
printf("%s End of Pass %d Comp.Cut=%.2lf RealCut=%.2lf W[%5.0lf, %5.0lf] Imbal=%.2lf\n", uMe(hgc), passcnt, cutsize, best_cutsize, weights[0], weights[1], imbal);
/* debuggging code ends here */
#endif
} while (successivefails<2 && (++passcnt < hgp->fm_loop_limit));
#ifdef HANDLE_ISOLATED_VERTICES
if (detail_timing)
ZOLTAN_TIMER_START(zz->ZTime, timer->rfiso, hgc->Communicator);
/* now root sneds the final part no's of isolated vertices; if any */
MPI_Bcast(&isocnt, 1, MPI_INT, rootRank, hgc->col_comm);
if (isocnt<hg->nVtx) {
deg = (int *) lgain; /* we'll use for part no's of isolated vertices */
if (hgc->myProc_y==rootRank)
for (i=isocnt; i < hg->nVtx; ++i) { /* go over isolated vertices */
int u = moves[i];
deg[i] = part[u] = -part[u]-1;
}
MPI_Bcast(&moves[isocnt], hg->nVtx-isocnt, MPI_INT, rootRank, hgc->col_comm);
MPI_Bcast(°[isocnt], hg->nVtx-isocnt, MPI_INT, rootRank, hgc->col_comm);
if (hgc->myProc_y!=rootRank)
for (i=isocnt; i < hg->nVtx; ++i) /* go over isolated vertices */
part[moves[i]] = deg[i];
}
if (detail_timing)
ZOLTAN_TIMER_STOP(zz->ZTime, timer->rfiso, hgc->Communicator);
#endif
End:
if (hgc->myProc_y==rootRank) { /* only root needs mark, adj, gain and heaps*/
Zoltan_Multifree(__FILE__,__LINE__, 3, &mark, &adj, &gain);
Zoltan_Heap_Free(&heap[0]);
Zoltan_Heap_Free(&heap[1]);
}
Zoltan_Multifree(__FILE__, __LINE__, 4, &pins[0], &lpins[0], &moves, &lgain);
if (do_timing)
ZOLTAN_TIMER_STOP(zz->ZTime, timer->rfrefine, hgc->Communicator);
ZOLTAN_TRACE_EXIT(zz, yo);
return ierr;
}
int Zoltan_ParMetis_Order(
ZZ *zz, /* Zoltan structure */
int num_obj, /* Number of (local) 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 */
ZOLTAN_ID_PTR rank, /* rank[i] is the rank of gids[i] */
int *iperm,
ZOOS *order_opt /* Ordering options, parsed by Zoltan_Order */
)
{
static char *yo = "Zoltan_ParMetis_Order";
int i, n, ierr;
ZOLTAN_Output_Order ord;
ZOLTAN_Third_Graph gr;
#ifdef ZOLTAN_PARMETIS
MPI_Comm comm = zz->Communicator;/* don't want to risk letting external
packages changing our communicator */
#endif
indextype numflag = 0;
int timer_p = 0;
int get_times = 0;
int use_timers = 0;
double times[5];
ZOLTAN_ID_PTR l_gids = NULL;
ZOLTAN_ID_PTR l_lids = NULL;
indextype options[MAX_PARMETIS_OPTIONS];
char alg[MAX_PARAM_STRING_LEN];
ZOLTAN_TRACE_ENTER(zz, yo);
#ifdef ZOLTAN_PARMETIS
#if TPL_USE_DATATYPE != TPL_METIS_DATATYPES
#ifdef TPL_FLOAT_WEIGHT
i = 1;
#else
i = 0;
#endif
if ((sizeof(indextype) != sizeof(idxtype)) ||
(sizeof(weighttype) != sizeof(idxtype)) || i){
ZOLTAN_THIRD_ERROR(ZOLTAN_FATAL,
"Not supported: Multiple 3rd party libraries with incompatible "
"data types.");
return ZOLTAN_FATAL;
}
#endif
#endif
memset(&gr, 0, sizeof(ZOLTAN_Third_Graph));
memset(&ord, 0, sizeof(ZOLTAN_Output_Order));
memset(times, 0, sizeof(times));
ord.order_opt = order_opt;
if (!order_opt){
/* If for some reason order_opt is NULL, allocate a new ZOOS here. */
/* This should really never happen. */
order_opt = (ZOOS *) ZOLTAN_MALLOC(sizeof(ZOOS));
strcpy(order_opt->method,"PARMETIS");
}
ierr = Zoltan_Parmetis_Parse(zz, options, alg, NULL, NULL, &ord);
/* ParMetis only computes the rank vector */
order_opt->return_args = RETURN_RANK;
/* Check that num_obj equals the number of objects on this proc. */
/* This constraint may be removed in the future. */
n = zz->Get_Num_Obj(zz->Get_Num_Obj_Data, &ierr);
if ((ierr!= ZOLTAN_OK) && (ierr!= ZOLTAN_WARN)){
/* Return error code */
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Get_Num_Obj returned error.");
return(ZOLTAN_FATAL);
}
if (n != num_obj){
/* Currently this is a fatal error. */
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Input num_obj does not equal the "
"number of objects.");
return(ZOLTAN_FATAL);
}
/* Do not use weights for ordering */
gr.obj_wgt_dim = -1;
gr.edge_wgt_dim = -1;
gr.num_obj = num_obj;
/* Check what ordering type is requested */
if (order_opt){
SET_GLOBAL_GRAPH(&gr.graph_type); /* GLOBAL by default */
#ifdef ZOLTAN_PARMETIS
if ((strcmp(order_opt->method, "METIS") == 0))
#endif /* ZOLTAN_PARMETIS */
SET_LOCAL_GRAPH(&gr.graph_type);
}
gr.get_data = 1;
if (IS_LOCAL_GRAPH(gr.graph_type) && zz->Num_Proc > 1) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Serial ordering on more than 1 process: "
"set ParMetis instead.");
return(ZOLTAN_FATAL);
}
timer_p = Zoltan_Preprocess_Timer(zz, &use_timers);
/* Start timer */
get_times = (zz->Debug_Level >= ZOLTAN_DEBUG_ATIME);
if (get_times){
MPI_Barrier(zz->Communicator);
times[0] = Zoltan_Time(zz->Timer);
}
ierr = Zoltan_Preprocess_Graph(zz, &l_gids, &l_lids, &gr, NULL, NULL, NULL);
if ((ierr != ZOLTAN_OK) && (ierr != ZOLTAN_WARN)) {
Zoltan_Third_Exit(&gr, NULL, NULL, NULL, NULL, NULL);
return (ierr);
}
/* Allocate space for separator sizes */
if (IS_GLOBAL_GRAPH(gr.graph_type)) {
if (Zoltan_TPL_Order_Init_Tree(&zz->TPL_Order, 2*zz->Num_Proc, zz->Num_Proc) != ZOLTAN_OK) {
/* Not enough memory */
Zoltan_Third_Exit(&gr, NULL, NULL, NULL, NULL, &ord);
ZOLTAN_THIRD_ERROR(ZOLTAN_MEMERR, "Out of memory.");
}
ord.sep_sizes = (indextype*)ZOLTAN_MALLOC((2*zz->Num_Proc+1)*sizeof(indextype));
if (ord.sep_sizes == NULL) {
Zoltan_Third_Exit(&gr, NULL, NULL, NULL, NULL, &ord);
ZOLTAN_THIRD_ERROR(ZOLTAN_MEMERR, "Out of memory.");
}
memset(ord.sep_sizes, 0, (2*zz->Num_Proc+1)*sizeof(int)); /* It seems parmetis don't initialize correctly */
}
/* Allocate space for direct perm */
ord.rank = (indextype *) ZOLTAN_MALLOC(gr.num_obj*sizeof(indextype));
if (!ord.rank){
/* Not enough memory */
Zoltan_Third_Exit(&gr, NULL, NULL, NULL, NULL, &ord);
ZOLTAN_THIRD_ERROR(ZOLTAN_MEMERR, "Out of memory.");
}
if (IS_LOCAL_GRAPH(gr.graph_type)){
/* Allocate space for inverse perm */
ord.iperm = (indextype *) ZOLTAN_MALLOC(gr.num_obj*sizeof(indextype));
if (!ord.iperm){
/* Not enough memory */
Zoltan_Third_Exit(&gr, NULL, NULL, NULL, NULL, &ord);
ZOLTAN_THIRD_ERROR(ZOLTAN_MEMERR, "Out of memory.");
}
}
else
ord.iperm = NULL;
/* Get a time here */
if (get_times) times[1] = Zoltan_Time(zz->Timer);
#ifdef ZOLTAN_PARMETIS
if (IS_GLOBAL_GRAPH(gr.graph_type)){
ZOLTAN_TRACE_DETAIL(zz, yo, "Calling the ParMETIS library");
ParMETIS_V3_NodeND (gr.vtxdist, gr.xadj, gr.adjncy,
&numflag, options, ord.rank, ord.sep_sizes, &comm);
ZOLTAN_TRACE_DETAIL(zz, yo, "Returned from the ParMETIS library");
}
else
#endif /* ZOLTAN_PARMETIS */
#if defined(ZOLTAN_METIS) || defined(ZOLTAN_PARMETIS)
if (IS_LOCAL_GRAPH(gr.graph_type)) { /* Be careful : permutation parameters are in the opposite order */
indextype numobj = gr.num_obj;
ZOLTAN_TRACE_DETAIL(zz, yo, "Calling the METIS library");
order_opt->return_args = RETURN_RANK|RETURN_IPERM; /* We provide directly all the permutations */
#if !defined(METIS_VER_MAJOR) || METIS_VER_MAJOR < 5
options[0] = 0; /* Use default options for METIS. */
METIS_NodeND(&numobj, gr.xadj, gr.adjncy, &numflag, options,
ord.iperm, ord.rank);
#else
METIS_SetDefaultOptions(options);
METIS_NodeND(&numobj, gr.xadj, gr.adjncy, NULL, options,
ord.iperm, ord.rank); /* NULL is vwgt -- new interface in v4 */
#endif
ZOLTAN_TRACE_DETAIL(zz, yo, "Returned from the METIS library");
}
#endif /* ZOLTAN_METIS */
/* Get a time here */
if (get_times) times[2] = Zoltan_Time(zz->Timer);
if (IS_GLOBAL_GRAPH(gr.graph_type)){ /* Update Elimination tree */
int numbloc;
int start;
int leaf;
int *converttab;
int levelmax;
levelmax = mylog2(zz->Num_Proc) + 1;
converttab = (int*)ZOLTAN_MALLOC(zz->Num_Proc*2*sizeof(int));
memset(converttab, 0, zz->Num_Proc*2*sizeof(int));
/* Determine the first node in each separator, store it in zz->TPL_Order.start */
for (numbloc = 0, start=0, leaf=0; numbloc < zz->Num_Proc /2; numbloc++) {
int father;
father = zz->Num_Proc + numbloc;
converttab[start] = 2*numbloc;
zz->TPL_Order.leaves[leaf++]=start;
zz->TPL_Order.ancestor[start] = start + 2;
converttab[start+1] = 2*numbloc+1;
zz->TPL_Order.leaves[leaf++]=start+1;
zz->TPL_Order.ancestor[start+1] = start + 2;
start+=2;
do {
converttab[start] = father;
if (father %2 == 0) {
int nextoffset;
int level;
level = mylog2(2*zz->Num_Proc - 1 - father);
nextoffset = (1<<(levelmax-level));
zz->TPL_Order.ancestor[start] = start+nextoffset;
start++;
break;
}
else {
zz->TPL_Order.ancestor[start] = start+1;
start++;
father = zz->Num_Proc + father/2;
}
} while (father < 2*zz->Num_Proc - 1);
}
zz->TPL_Order.start[0] = 0;
zz->TPL_Order.ancestor [2*zz->Num_Proc - 2] = -1;
for (numbloc = 1 ; numbloc < 2*zz->Num_Proc ; numbloc++) {
int oldblock=converttab[numbloc-1];
zz->TPL_Order.start[numbloc] = zz->TPL_Order.start[numbloc-1] + ord.sep_sizes[oldblock];
}
ZOLTAN_FREE(&converttab);
ZOLTAN_FREE(&ord.sep_sizes);
zz->TPL_Order.leaves[zz->Num_Proc] = -1;
zz->TPL_Order.nbr_leaves = zz->Num_Proc;
zz->TPL_Order.nbr_blocks = 2*zz->Num_Proc-1;
}
else { /* No tree */
zz->TPL_Order.nbr_blocks = 0;
zz->TPL_Order.start = NULL;
zz->TPL_Order.ancestor = NULL;
zz->TPL_Order.leaves = NULL;
}
/* Correct because no redistribution */
memcpy(gids, l_gids, n*zz->Num_GID*sizeof(ZOLTAN_ID_TYPE));
memcpy(lids, l_lids, n*zz->Num_LID*sizeof(ZOLTAN_ID_TYPE));
ierr = Zoltan_Postprocess_Graph (zz, l_gids, l_lids, &gr, NULL, NULL, NULL, &ord, NULL);
ZOLTAN_FREE(&l_gids);
ZOLTAN_FREE(&l_lids);
/* Get a time here */
if (get_times) times[3] = Zoltan_Time(zz->Timer);
if (get_times) Zoltan_Third_DisplayTime(zz, times);
if (use_timers)
ZOLTAN_TIMER_STOP(zz->ZTime, timer_p, zz->Communicator);
if (sizeof(indextype) == sizeof(ZOLTAN_ID_TYPE)){
memcpy(rank, ord.rank, gr.num_obj*sizeof(indextype));
}
else{
for (i=0; i < gr.num_obj; i++){
rank[i] = (ZOLTAN_ID_TYPE)ord.rank[i];
}
}
if ((ord.iperm != NULL) && (iperm != NULL)){
if (sizeof(indextype) == sizeof(int)){
memcpy(iperm, ord.iperm, gr.num_obj*sizeof(indextype));
}
else{
for (i=0; i < gr.num_obj; i++){
iperm[i] = (int)ord.iperm[i];
}
}
}
if (ord.iperm != NULL) ZOLTAN_FREE(&ord.iperm);
ZOLTAN_FREE(&ord.rank);
/* Free all other "graph" stuff */
Zoltan_Third_Exit(&gr, NULL, NULL, NULL, NULL, NULL);
ZOLTAN_TRACE_EXIT(zz, yo);
return (ZOLTAN_OK);
}
int Zoltan_ParMetis(
ZZ *zz, /* Zoltan structure */
float *part_sizes, /* Input: Array of size zz->Num_Global_Parts
containing the percentage of work to be
assigned to each partition. */
int *num_imp, /* number of objects to be imported */
ZOLTAN_ID_PTR *imp_gids, /* global ids of objects to be imported */
ZOLTAN_ID_PTR *imp_lids, /* local ids of objects to be imported */
int **imp_procs, /* list of processors to import from */
int **imp_to_part, /* list of partitions to which imported objects are
assigned. */
int *num_exp, /* number of objects to be exported */
ZOLTAN_ID_PTR *exp_gids, /* global ids of objects to be exported */
ZOLTAN_ID_PTR *exp_lids, /* local ids of objects to be exported */
int **exp_procs, /* list of processors to export to */
int **exp_to_part /* list of partitions to which exported objects are
assigned. */
)
{
char *yo = "Zoltan_ParMetis";
int ierr;
ZOLTAN_Third_Graph gr;
ZOLTAN_Third_Geom *geo = NULL;
ZOLTAN_Third_Vsize vsp;
ZOLTAN_Third_Part prt;
ZOLTAN_Output_Part part;
ZOLTAN_ID_PTR global_ids = NULL;
ZOLTAN_ID_PTR local_ids = NULL;
int use_timers = 0;
int timer_p = -1;
int get_times = 0;
double times[5];
double pmv3_itr = 0.0;
realtype itr = 0.0;
indextype options[MAX_PARMETIS_OPTIONS];
char alg[MAX_PARAM_STRING_LEN];
#ifdef ZOLTAN_PARMETIS
MPI_Comm comm = zz->Communicator;/* don't risk letting external packages */
/* change our zz struct. */
#endif
indextype i;
realtype *imb_tols;
indextype ncon;
indextype edgecut;
indextype wgtflag;
indextype numflag = 0;
indextype num_part = zz->LB.Num_Global_Parts; /* passed to ParMETIS. */
ZOLTAN_TRACE_ENTER(zz, yo);
Zoltan_Third_Init(&gr, &prt, &vsp, &part,
imp_gids, imp_lids, imp_procs, imp_to_part,
exp_gids, exp_lids, exp_procs, exp_to_part);
if (sizeof(realtype) != sizeof(float)) {
int tmp = zz->LB.Num_Global_Parts * MAX(zz->Obj_Weight_Dim, 1);
prt.input_part_sizes = (realtype *) ZOLTAN_MALLOC(tmp * sizeof(realtype));
for (i = 0; i < tmp; i++)
prt.input_part_sizes[i] = (realtype) part_sizes[i];
/* KDD 2/2014: removed re-scaling part sizes so they sum to one.
* part_sizes are already scaled in Zoltan_LB_Get_Part_Sizes.
* plus, the code here was wrong for multiple object weights.
* similar scaling code did not exist in the Scotch interface.
*/
prt.part_sizes = prt.input_part_sizes;
}
else
prt.input_part_sizes = prt.part_sizes = (realtype *) part_sizes;
ierr = Zoltan_Parmetis_Parse(zz, options, alg, &itr, &pmv3_itr, NULL);
if ((ierr != ZOLTAN_OK) && (ierr != ZOLTAN_WARN)) {
Zoltan_Third_Exit(&gr, geo, &prt, &vsp, &part, NULL);
return (ierr);
}
gr.graph_type = 0;
#ifdef ZOLTAN_PARMETIS
SET_GLOBAL_GRAPH(&gr.graph_type);
/* Select type of graph, negative because we impose them */
/* TODO: add a parameter to select the type, shared with Scotch */
/* if (strcmp (graph_type, "GLOBAL") != 0) { */
/* gr.graph_type = - LOCAL_GRAPH; */
/* if (zz->Num_Proc > 1) { */
/* ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Distributed graph: cannot call METIS, switching to ParMetis"); */
/* gr.graph_type = - GLOBAL_GRAPH; */
/* retval = ZOLTAN_WARN; */
/* } */
/* } */
#else /* graph is local */
SET_LOCAL_GRAPH(&gr.graph_type);
#endif /* ZOLTAN_PARMETIS */
/* Some algorithms use geometry data */
if (strncmp(alg, "PARTGEOM", 8) == 0){ /* PARTGEOM & PARTGEOMKWAY */
geo = (ZOLTAN_Third_Geom*) ZOLTAN_MALLOC(sizeof(ZOLTAN_Third_Geom));
memset (geo, 0, sizeof(ZOLTAN_Third_Geom));
/* ParMETIS will crash if geometric method and some procs have no nodes. */
/* Avoid fatal crash by setting scatter to level 2 or higher. */
gr.scatter_min = 2;
if (geo == NULL) {
ZOLTAN_PRINT_ERROR (zz->Proc, yo, "Out of memory.");
return (ZOLTAN_MEMERR);
}
if (strcmp(alg, "PARTGEOM") == 0) {
gr.get_data = 0;
}
}
timer_p = Zoltan_Preprocess_Timer(zz, &use_timers);
/* Start timer */
get_times = (zz->Debug_Level >= ZOLTAN_DEBUG_ATIME);
if (get_times){
MPI_Barrier(zz->Communicator);
times[0] = Zoltan_Time(zz->Timer);
}
vsp.vsize_malloc = 0;
#ifdef PARMETIS31_ALWAYS_FREES_VSIZE
if (!strcmp(alg, "ADAPTIVEREPART") && (zz->Num_Proc > 1)) {
/* ParMETIS will free this memory; use malloc to allocate so
ZOLTAN_MALLOC counters don't show an error. */
vsp.vsize_malloc = 1 ;
}
#endif /* PARMETIS31_ALWAYS_FREES_VSIZE */
ierr = Zoltan_Preprocess_Graph(zz, &global_ids, &local_ids, &gr,
geo, &prt, &vsp);
if ((ierr != ZOLTAN_OK) && (ierr != ZOLTAN_WARN)) {
Zoltan_Third_Exit(&gr, geo, &prt, &vsp, &part, NULL);
return (ierr);
}
/* Get object sizes if requested */
if (options[PMV3_OPT_USE_OBJ_SIZE] &&
(zz->Get_Obj_Size || zz->Get_Obj_Size_Multi) &&
(!strcmp(alg, "ADAPTIVEREPART") || gr.final_output))
gr.showMoveVol = 1;
/* Get a time here */
if (get_times) times[1] = Zoltan_Time(zz->Timer);
/* Get ready to call ParMETIS */
edgecut = -1;
wgtflag = 2*(gr.obj_wgt_dim>0) + (gr.edge_wgt_dim>0);
numflag = 0;
ncon = (gr.obj_wgt_dim > 0 ? gr.obj_wgt_dim : 1);
if (!prt.part_sizes){
ZOLTAN_THIRD_ERROR(ZOLTAN_FATAL,"Input parameter part_sizes is NULL.");
}
if ((zz->Proc == 0) && (zz->Debug_Level >= ZOLTAN_DEBUG_ALL)) {
for (i=0; i<num_part; i++){
indextype j;
printf("Debug: Size(s) for part " TPL_IDX_SPEC " = ", i);
for (j=0; j<ncon; j++)
printf("%f ", prt.part_sizes[i*ncon+j]);
printf("\n");
}
}
/* if (strcmp(alg, "ADAPTIVEREPART") == 0) */
for (i = 0; i < num_part*ncon; i++)
if (prt.part_sizes[i] == 0)
ZOLTAN_THIRD_ERROR(ZOLTAN_FATAL, "Zero-sized part(s) requested! "
"ParMETIS 3.x will likely fail. Please use a "
"different method, or remove the zero-sized "
"parts from the problem.");
/* Set Imbalance Tolerance for each weight component. */
imb_tols = (realtype *) ZOLTAN_MALLOC(ncon * sizeof(realtype));
if (!imb_tols){
/* Not enough memory */
ZOLTAN_THIRD_ERROR(ZOLTAN_MEMERR, "Out of memory.");
}
for (i=0; i<ncon; i++)
imb_tols[i] = (realtype) (zz->LB.Imbalance_Tol[i]);
/* Now we can call ParMetis */
/* Zoltan_Third_Graph_Print(zz, &gr, "Before calling parmetis"); */
#ifdef ZOLTAN_PARMETIS
if (!IS_LOCAL_GRAPH(gr.graph_type)) { /* May be GLOBAL or NO GRAPH */
/* First check for ParMetis 3 routines */
if (strcmp(alg, "PARTKWAY") == 0){
ZOLTAN_TRACE_DETAIL(zz, yo, "Calling the ParMETIS library "
"ParMETIS_V3_PartKway");
ParMETIS_V3_PartKway(gr.vtxdist, gr.xadj, gr.adjncy, gr.vwgt, gr.ewgts,
&wgtflag, &numflag, &ncon, &num_part, prt.part_sizes,
imb_tols, options, &edgecut, prt.part, &comm);
ZOLTAN_TRACE_DETAIL(zz, yo, "Returned from the ParMETIS library");
}
else if (strcmp(alg, "PARTGEOMKWAY") == 0){
indextype ndims = geo->ndims;
ZOLTAN_TRACE_DETAIL(zz, yo, "Calling the ParMETIS library "
"ParMETIS_V3_PartGeomKway");
ParMETIS_V3_PartGeomKway(gr.vtxdist, gr.xadj, gr.adjncy, gr.vwgt,gr.ewgts,
&wgtflag, &numflag, &ndims, geo->xyz, &ncon,
&num_part, prt.part_sizes,
imb_tols, options, &edgecut, prt.part, &comm);
ZOLTAN_TRACE_DETAIL(zz, yo, "Returned from the ParMETIS library");
}
else if (strcmp(alg, "PARTGEOM") == 0){
indextype ndims = geo->ndims;
ZOLTAN_TRACE_DETAIL(zz, yo, "Calling the ParMETIS library "
"ParMETIS_V3_PartGeom");
ParMETIS_V3_PartGeom(gr.vtxdist, &ndims, geo->xyz, prt.part, &comm);
ZOLTAN_TRACE_DETAIL(zz, yo, "Returned from the ParMETIS library");
}
else if (strcmp(alg, "ADAPTIVEREPART") == 0){
ZOLTAN_TRACE_DETAIL(zz, yo, "Calling the ParMETIS library "
"ParMETIS_V3_AdaptiveRepart");
ParMETIS_V3_AdaptiveRepart(gr.vtxdist, gr.xadj, gr.adjncy, gr.vwgt,
vsp.vsize, gr.ewgts, &wgtflag, &numflag, &ncon,
&num_part, prt.part_sizes, imb_tols,
&itr, options, &edgecut, prt.part, &comm);
ZOLTAN_TRACE_DETAIL(zz, yo, "Returned from the ParMETIS library");
}
else if (strcmp(alg, "REFINEKWAY") == 0){
ZOLTAN_TRACE_DETAIL(zz, yo, "Calling the ParMETIS library "
"ParMETIS_V3_RefineKway");
ParMETIS_V3_RefineKway(gr.vtxdist, gr.xadj, gr.adjncy, gr.vwgt, gr.ewgts,
&wgtflag, &numflag, &ncon, &num_part,
prt.part_sizes, imb_tols,
options, &edgecut, prt.part, &comm);
ZOLTAN_TRACE_DETAIL(zz, yo, "Returned from the ParMETIS library");
}
else {
/* Sanity check: This should never happen! */
char msg[256];
sprintf(msg, "Unknown ParMetis algorithm %s.", alg);
ZOLTAN_THIRD_ERROR(ZOLTAN_FATAL, msg);
}
}
#endif /* ZOLTAN_PARMETIS */
#ifdef ZOLTAN_METIS
/* TODO: I don't know how to set balance ! */
if (IS_LOCAL_GRAPH(gr.graph_type)) {
/* Check for Metis routines */
if (strcmp(alg, "PARTKWAY") == 0){
ZOLTAN_TRACE_DETAIL(zz, yo, "Calling the METIS library ");
/* Use default options for METIS */
#if !defined(METIS_VER_MAJOR) || METIS_VER_MAJOR < 5
options[0] = 0;
METIS_WPartGraphKway (gr.vtxdist+1, gr.xadj, gr.adjncy,
gr.vwgt, gr.ewgts, &wgtflag,
&numflag, &num_part, prt.part_sizes,
options, &edgecut, prt.part);
#else
METIS_SetDefaultOptions(options);
METIS_PartGraphKway (gr.vtxdist+1, &ncon, gr.xadj, gr.adjncy,
gr.vwgt, vsp.vsize, gr.ewgts, &num_part,
prt.part_sizes, imb_tols, options,
&edgecut, prt.part);
#endif
ZOLTAN_TRACE_DETAIL(zz, yo, "Returned from the METIS library");
}
else {
/* Sanity check: This should never happen! */
char msg[256];
sprintf(msg, "Unknown Metis algorithm %s.", alg);
ZOLTAN_THIRD_ERROR(ZOLTAN_FATAL, msg);
}
}
#endif /* ZOLTAN_METIS */
/* Get a time here */
if (get_times) times[2] = Zoltan_Time(zz->Timer);
if (gr.final_output) {
/* Do final output now because after the data will not be coherent:
unscatter only unscatter part data, not graph */
ierr = Zoltan_Postprocess_FinalOutput (zz, &gr, &prt, &vsp, use_timers, itr);
}
/* Ignore the timings of Final Ouput */
if (get_times) times[3] = Zoltan_Time(zz->Timer);
ierr = Zoltan_Postprocess_Graph(zz, global_ids, local_ids, &gr,
geo, &prt, &vsp, NULL, &part);
Zoltan_Third_Export_User(&part,
num_imp, imp_gids, imp_lids, imp_procs, imp_to_part,
num_exp, exp_gids, exp_lids, exp_procs, exp_to_part);
/* Get a time here */
if (get_times) times[4] = Zoltan_Time(zz->Timer);
if (get_times) Zoltan_Third_DisplayTime(zz, times);
if (use_timers && timer_p >= 0)
ZOLTAN_TIMER_STOP(zz->ZTime, timer_p, zz->Communicator);
Zoltan_Third_Exit(&gr, geo, &prt, &vsp, NULL, NULL);
if (imb_tols != NULL) ZOLTAN_FREE(&imb_tols);
if (geo != NULL) ZOLTAN_FREE(&geo);
ZOLTAN_FREE(&global_ids);
ZOLTAN_FREE(&local_ids);
ZOLTAN_TRACE_EXIT(zz, yo);
return (ierr);
}
int Zoltan_PHG(
ZZ *zz, /* The Zoltan structure */
float *part_sizes, /* Input: Array of size zz->Num_Global_Parts
containing the percentage of work assigned
to each partition. */
int *num_imp, /* not computed */
ZOLTAN_ID_PTR *imp_gids, /* not computed */
ZOLTAN_ID_PTR *imp_lids, /* not computed */
int **imp_procs, /* not computed */
int **imp_to_part, /* not computed */
int *num_exp, /* number of objects to be exported */
ZOLTAN_ID_PTR *exp_gids, /* global ids of objects to be exported */
ZOLTAN_ID_PTR *exp_lids, /* local ids of objects to be exported */
int **exp_procs, /* list of processors to export to */
int **exp_to_part ) /* list of partitions to which exported objs
are assigned. */
{
char *yo = "Zoltan_PHG";
ZHG *zoltan_hg = NULL;
PHGPartParams hgp; /* Hypergraph parameters. */
HGraph *hg = NULL; /* Hypergraph itself */
Partition parts = NULL; /* Partition assignments in
2D distribution. */
int err = ZOLTAN_OK, p=0;
struct phg_timer_indices *timer = NULL;
int do_timing = 0;
ZOLTAN_TRACE_ENTER(zz, yo);
/* Initialization of return arguments. */
*num_imp = *num_exp = -1;
*imp_gids = *exp_gids = NULL;
*imp_lids = *exp_lids = NULL;
*imp_procs = *exp_procs = NULL;
/* Initialize HG parameters. */
err = Zoltan_PHG_Initialize_Params(zz, part_sizes, &hgp);
if (err != ZOLTAN_OK)
goto End;
if (hgp.use_timers) {
if (!zz->LB.Data_Structure) {
zz->LB.Data_Structure = (struct phg_timer_indices *)
ZOLTAN_MALLOC(sizeof(struct phg_timer_indices));
initialize_timer_indices((struct phg_timer_indices *)zz->LB.Data_Structure);
}
timer = zz->LB.Data_Structure;
if (timer->all < 0)
timer->all = Zoltan_Timer_Init(zz->ZTime, 1, "Zoltan_PHG");
}
if (hgp.use_timers > 1) {
do_timing = 1;
if (timer->build < 0)
timer->build = Zoltan_Timer_Init(zz->ZTime, 1, "Build");
if (timer->setupvmap < 0)
timer->setupvmap = Zoltan_Timer_Init(zz->ZTime, 0, "Vmaps");
}
if (hgp.use_timers)
ZOLTAN_TIMER_START(zz->ZTime, timer->all, zz->Communicator);
if (do_timing)
ZOLTAN_TIMER_START(zz->ZTime, timer->build, zz->Communicator);
/* build initial Zoltan hypergraph from callback functions. */
err = Zoltan_PHG_Build_Hypergraph (zz, &zoltan_hg, &parts, &hgp);
if (err != ZOLTAN_OK && err != ZOLTAN_WARN) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Error building hypergraph.");
goto End;
}
if (zoltan_hg->GnObj == 0){
/* degenerate case - no objects to partition */
hgp.final_output = 0;
goto End;
}
hg = &zoltan_hg->HG;
p = zz->LB.Num_Global_Parts;
zoltan_hg->HG.redl = MAX(hgp.redl, p); /* redl needs to be dynamic */
/* RTHRTH -- redl may need to be scaled by number of procs */
/* EBEB -- at least make sure redl > #procs */
if (hgp.UseFixedVtx)
hg->bisec_split = 1; /* this will be used only #parts=2
otherwise rdivide will set to appropriate
value */
if (hgp.UsePrefPart || hgp.UseFixedVtx) { /* allocate memory for pref_part */
if (hg->nVtx &&
!(hg->pref_part = (int*) ZOLTAN_MALLOC (sizeof(int) * hg->nVtx))) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Error building hypergraph.");
goto End;
}
}
if (hgp.UsePrefPart) /* copy input parts as pref_part;
UVCUVC: TODO: this code (and alloc of pref_part)
should go to Build_Hypergraph later */
memcpy(hg->pref_part, parts, sizeof(int) * hg->nVtx);
if (hgp.UseFixedVtx) {
int i;
for (i=0; i<hg->nVtx; ++i)
if (hg->fixed_part[i]>=0)
hg->pref_part[i] = hg->fixed_part[i];
else if (!hgp.UsePrefPart)
hg->pref_part[i] = -1;
}
hgp.UsePrefPart |= hgp.UseFixedVtx;
if (do_timing)
ZOLTAN_TIMER_STOP(zz->ZTime, timer->build, zz->Communicator);
/*
UVCUVC DEBUG PRINT
uprintf(hg->comm, "Zoltan_PHG kway=%d #parts=%d\n", hgp.kway, zz->LB.Num_Global_Parts);
*/
if (!strcasecmp(hgp.hgraph_pkg, "PARKWAY")){
if (do_timing) {
if (timer->parkway < 0)
timer->parkway = Zoltan_Timer_Init(zz->ZTime, 0, "PHG_ParKway");
ZOLTAN_TIMER_START(zz->ZTime, timer->parkway, zz->Communicator);
}
err = Zoltan_PHG_ParKway(zz, hg, p,
parts, &hgp);
if (err != ZOLTAN_OK)
goto End;
if (do_timing)
ZOLTAN_TIMER_STOP(zz->ZTime, timer->parkway, zz->Communicator);
} else if (!strcasecmp(hgp.hgraph_pkg, "PATOH")){
if (hgp.use_timers > 1) {
if (timer->patoh < 0)
timer->patoh = Zoltan_Timer_Init(zz->ZTime, 0, "HG_PaToH");
ZOLTAN_TIMER_START(zz->ZTime, timer->patoh, zz->Communicator);
}
err = Zoltan_PHG_PaToH(zz, hg, p,
parts, &hgp);
if (err != ZOLTAN_OK)
goto End;
if (hgp.use_timers > 1)
ZOLTAN_TIMER_STOP(zz->ZTime, timer->patoh, zz->Communicator);
}
else { /* it must be PHG */
/* UVC: if it is bisection anyways; no need to create vmap etc;
rdivide is going to call Zoltan_PHG_Partition anyways... */
if (hgp.globalcomm.Communicator != MPI_COMM_NULL) {
/* This processor is part of the 2D data distribution; it should
participate in partitioning. */
if (hgp.kway || zz->LB.Num_Global_Parts == 2) {
/* call main V cycle routine */
err = Zoltan_PHG_Partition(zz, hg, p,
hgp.part_sizes, parts, &hgp);
if (err != ZOLTAN_OK) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Error partitioning hypergraph.");
goto End;
}
}
else {
int i;
if (do_timing)
ZOLTAN_TIMER_START(zz->ZTime, timer->setupvmap, zz->Communicator);
/* vmap associates original vertices to sub hypergraphs */
if (hg->nVtx &&
!(hg->vmap = (int*) ZOLTAN_MALLOC(hg->nVtx*sizeof (int)))) {
err = ZOLTAN_MEMERR;
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Memory error.");
goto End;
}
for (i = 0; i < hg->nVtx; ++i)
hg->vmap[i] = i;
if (do_timing)
ZOLTAN_TIMER_STOP(zz->ZTime, timer->setupvmap, zz->Communicator);
/* partition hypergraph */
err = Zoltan_PHG_rdivide (0, p-1, parts, zz, hg, &hgp, 0);
if (hgp.output_level >= PHG_DEBUG_LIST)
uprintf(hg->comm, "FINAL %3d |V|=%6d |E|=%6d #pins=%6d %s/%s/%s/%s p=%d "
"bal=%.2f cutl=%.2f\n",
hg->info, hg->nVtx, hg->nEdge, hg->nPins,
hgp.convert_str, hgp.redm_str,
hgp.coarsepartition_str, hgp.refinement_str, p,
Zoltan_PHG_Compute_Balance(zz, hg, hgp.part_sizes, 0,
p, parts),
Zoltan_PHG_Compute_ConCut(hg->comm, hg, parts, p, &err));
if (err != ZOLTAN_OK) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Error partitioning hypergraph.");
goto End;
}
ZOLTAN_FREE (&hg->vmap);
}
#ifdef CHECK_LEFTALONE_VERTICES
findAndSaveLeftAloneVertices(zz, hg, p, parts, &hgp);
#endif
}
}
if (!strcasecmp(hgp.hgraph_method, "REPARTITION")) {
Zoltan_PHG_Remove_Repart_Data(zz, zoltan_hg, hg, &hgp);
}
/* UVC DEBUG PRINT
if (!strcasecmp(hgp->hgraph_method, "REFINE")){
uprintf(hg->comm,
"UVC ATTHEEND |V|=%6d |E|=%6d #pins=%6d p=%d bal=%.2f cutl=%.2f\n",
hg->nVtx, hg->nEdge, hg->nPins, p,
Zoltan_PHG_Compute_Balance(zz, hg, part_sizes, p, parts),
Zoltan_PHG_Compute_ConCut(hg->comm, hg, parts, p, &err));
detailed_balance_info(zz, hg, part_sizes, p, parts);
}
*/
/* Initialize these timers here so their output is near end of printout */
if (do_timing)
if (timer->retlist < 0)
timer->retlist = Zoltan_Timer_Init(zz->ZTime, 1, "Return_Lists");
if (hgp.use_timers)
if (timer->finaloutput < 0)
timer->finaloutput = Zoltan_Timer_Init(zz->ZTime, 1, "Final_Output");
if (do_timing)
ZOLTAN_TIMER_START(zz->ZTime, timer->retlist, zz->Communicator);
/* Build Zoltan's Output_Parts, mapped from 2D distribution
to input distribution. */
Zoltan_PHG_Output_Parts(zz, zoltan_hg, parts);
/* Build Zoltan's return arguments. */
Zoltan_PHG_Return_Lists(zz, zoltan_hg, num_exp, exp_gids,
exp_lids, exp_procs, exp_to_part);
if (do_timing)
ZOLTAN_TIMER_STOP(zz->ZTime, timer->retlist, zz->Communicator);
End:
if (err == ZOLTAN_MEMERR)
ZOLTAN_PRINT_ERROR (zz->Proc, yo, "Memory error.")
else if (err != ZOLTAN_OK)
ZOLTAN_PRINT_ERROR (zz->Proc, yo, "Error partitioning hypergraph.")
/* KDDKDD The following code prints a final quality result even when
* KDDKDD phg_output_level is zero. It is useful for our tests and
* KDDKDD data collection. */
if ((err == ZOLTAN_OK) && hgp.final_output) {
static int nRuns=0;
static double balsum = 0.0, cutlsum = 0.0, cutnsum = 0.0, movesum = 0.0, repartsum = 0.0;
static double balmax = 0.0, cutlmax = 0.0, cutnmax = 0.0, movemax = 0.0, repartmax = 0.0;
static double balmin = 1e100, cutlmin = 1e100, cutnmin = 1e100, movemin = 1e100, repartmin = 1e100;
double bal = 0.;
double cutl = 0.; /* Connnectivity cuts: sum_over_edges((npart-1)*ewgt) */
double cutn = 0.; /* Net cuts: sum_over_edges((nparts>1)*ewgt) */
double rlocal[2]; /* local cut stats for removed edges */
double rglobal[2]; /* global cut stats for removed edges */
int gnremove, i;
double move=0.0, gmove; /* local and global migration costs */
double repart=0.0; /* total repartitioning cost: comcost x multiplier + migration_cost */
if (hgp.use_timers) {
/* Do not include final output time in partitioning time */
ZOLTAN_TIMER_STOP(zz->ZTime, timer->all, zz->Communicator);
ZOLTAN_TIMER_START(zz->ZTime, timer->finaloutput, zz->Communicator);
}
if (hgp.globalcomm.Communicator != MPI_COMM_NULL) {
/* Processor participated in partitioning */
bal = Zoltan_PHG_Compute_Balance(zz, hg, hgp.part_sizes, 0,
zz->LB.Num_Global_Parts, parts);
cutl= Zoltan_PHG_Compute_ConCut(hg->comm, hg, parts,
zz->LB.Num_Global_Parts, &err);
cutn = Zoltan_PHG_Compute_NetCut(hg->comm, hg, parts,
zz->LB.Num_Global_Parts);
for (i = 0; i < zoltan_hg->nObj; ++i) {
/* uprintf(hg->comm, " obj[%d] = %d in=%d out=%d\n", i, zoltan_hg->AppObjSizes[i], zoltan_hg->Input_Parts[i], zoltan_hg->Output_Parts[i]); */
if (zoltan_hg->Input_Parts[i] != zoltan_hg->Output_Parts[i])
move += (double) ((zoltan_hg->AppObjSizes) ? zoltan_hg->AppObjSizes[i] : 1.0);
}
}
if (!err) {
/* Add in cut contributions from removed edges */
MPI_Allreduce(&(zoltan_hg->nRemove), &gnremove, 1, MPI_INT, MPI_SUM,
zz->Communicator);
if (gnremove) {
err = Zoltan_PHG_Removed_Cuts(zz, zoltan_hg, rlocal);
MPI_Allreduce(rlocal, rglobal, 2, MPI_DOUBLE,MPI_SUM,zz->Communicator);
cutl += rglobal[0];
cutn += rglobal[1];
}
MPI_Allreduce(&move, &gmove, 1, MPI_DOUBLE, MPI_SUM, zz->Communicator);
repart = cutl*hgp.RepartMultiplier + gmove;
repartsum += repart;
if (repart > repartmax) repartmax = repart;
if (repart < repartmin) repartmin = repart;
movesum += gmove;
if (gmove > movemax) movemax = gmove;
if (gmove < movemin) movemin = gmove;
cutlsum += cutl;
if (cutl > cutlmax) cutlmax = cutl;
if (cutl < cutlmin) cutlmin = cutl;
cutnsum += cutn;
if (cutn > cutnmax) cutnmax = cutn;
if (cutn < cutnmin) cutnmin = cutn;
balsum += bal;
if (bal > balmax) balmax = bal;
if (bal < balmin) balmin = bal;
nRuns++;
if (zz->Proc == 0) {
uprintf(hg->comm,
"STATS Runs %d bal CURRENT %f MAX %f MIN %f AVG %f\n",
nRuns, bal, balmax, balmin, balsum/nRuns);
uprintf(hg->comm,
"STATS Runs %d cutl CURRENT %f MAX %f MIN %f AVG %f\n",
nRuns, cutl, cutlmax, cutlmin, cutlsum/nRuns);
uprintf(hg->comm,
"STATS Runs %d cutn CURRENT %f MAX %f MIN %f AVG %f\n",
nRuns, cutn, cutnmax, cutnmin, cutnsum/nRuns);
uprintf(hg->comm,
"STATS Runs %d %s CURRENT %f MAX %f MIN %f AVG %f\n",
nRuns, (zoltan_hg->showMoveVol) ? "moveVol" : "moveCnt", gmove, movemax, movemin, movesum/nRuns);
if (zoltan_hg->showMoveVol)
uprintf(hg->comm,
"STATS Runs %d repart CURRENT %f MAX %f MIN %f AVG %f\n",
nRuns, repart, repartmax, repartmin, repartsum/nRuns);
}
}
if (hgp.use_timers) {
ZOLTAN_TIMER_STOP(zz->ZTime, timer->finaloutput, zz->Communicator);
ZOLTAN_TIMER_START(zz->ZTime, timer->all, zz->Communicator);
}
}
/* KDDKDD End of printing section. */
ZOLTAN_FREE(&parts);
if (zoltan_hg != NULL) {
Zoltan_PHG_Free_Hypergraph_Data(zoltan_hg);
ZOLTAN_FREE (&zoltan_hg);
}
if (hgp.use_timers) {
ZOLTAN_TIMER_STOP(zz->ZTime, timer->all, zz->Communicator);
if (hgp.globalcomm.Communicator != MPI_COMM_NULL)
Zoltan_Timer_PrintAll(zz->ZTime, 0, hgp.globalcomm.Communicator, stdout);
}
if (hgp.globalcomm.row_comm != MPI_COMM_NULL)
MPI_Comm_free(&(hgp.globalcomm.row_comm));
if (hgp.globalcomm.col_comm != MPI_COMM_NULL)
MPI_Comm_free(&(hgp.globalcomm.col_comm));
if (hgp.globalcomm.Communicator != MPI_COMM_NULL)
MPI_Comm_free(&(hgp.globalcomm.Communicator));
/* Free part_sizes if created new due to ADD_OBJ_WEIGHT */
if (hgp.part_sizes != part_sizes)
ZOLTAN_FREE(&hgp.part_sizes);
ZOLTAN_TRACE_EXIT(zz, yo);
return err;
}
int
Zoltan_Postprocess_FinalOutput (ZZ* zz, ZOLTAN_Third_Graph *gr,
ZOLTAN_Third_Part *prt, ZOLTAN_Third_Vsize *vsp,
int use_timers, realtype itr)
{
#define FOMAXDIM 10
static char * yo = "Zoltan_Postprocess_FinalOutput";
static int nRuns=0;
static double balsum[FOMAXDIM], cutesum[FOMAXDIM];
static double balmax[FOMAXDIM], cutemax[FOMAXDIM];
static double balmin[FOMAXDIM], cutemin[FOMAXDIM];
/* following variables are defined double to avoid overflow */
static double cutlsum = 0.0, cutnsum = 0.0, movesum = 0.0, repartsum = 0.0;
static float cutlmax = 0, cutnmax = 0;
static double movemax = 0, repartmax = 0;
static float cutlmin = INT_MAX, cutnmin = INT_MAX;
static double movemin = 1e100, repartmin = 1e100;
static int timer_final_output = -1;
double bal[FOMAXDIM]; /* Balance: max / avg */
double cute[FOMAXDIM]; /* Traditional weighted graph edge cuts */
float cutl; /* Connnectivity cuts: sum_over_edges((npart-1)) */
float cutn; /* Net cuts: sum_over_edges((nparts>1)) */
double move = 0.0, gmove =0.0; /* migration cost */
double repart; /* total repartitioning cost; cutl x multiplier + move */
int *adjpart = NULL;
int vdim;
int edim;
indextype *vsizeBACKUP = NULL;
indextype *input_part;
int i,rc;
/* #define UVC_DORUK_COMP_OBJSIZE */
#ifdef UVC_DORUK_COMP_OBJSIZE
double minD, maxD, gminD, gmaxD;
#endif
if (use_timers) {
if (timer_final_output < 0)
timer_final_output = Zoltan_Timer_Init(zz->ZTime, 1, "Final_Output");
ZOLTAN_TIMER_START(zz->ZTime, timer_final_output, zz->Communicator);
}
if (nRuns == 0) {
for (i = 0; i < FOMAXDIM; i++) {
/* Initialize first time */
balsum[i] = cutesum[i] = 0.0;
balmax[i] = cutemax[i] = 0.0;
balmin[i] = cutemin[i] = 1e100;
}
}
if (vsp && vsp->vsizeBACKUP)
vsizeBACKUP = vsp->vsizeBACKUP;
vdim = MAX(gr->obj_wgt_dim,1);
edim = MAX(zz->Edge_Weight_Dim,1);
if (gr->obj_wgt_dim < FOMAXDIM && zz->Edge_Weight_Dim < FOMAXDIM) {
if (gr->xadj[gr->num_obj]){
adjpart = (int *) ZOLTAN_MALLOC(gr->xadj[gr->num_obj] * sizeof(int));
if (!adjpart){
ZOLTAN_THIRD_ERROR(ZOLTAN_MEMERR,
"Error 1 returned from Zoltan_Postprocess_FinalOutput");
}
}
Compute_Bal(zz, gr->num_obj, gr->vwgt, gr->obj_wgt_dim, prt->part, bal);
rc = Compute_Adjpart(zz, gr->num_obj, gr->vtxdist, gr->xadj, gr->adjncy,
gr->adjproc, prt->part, adjpart);
if (rc != ZOLTAN_OK){
ZOLTAN_THIRD_ERROR(ZOLTAN_MEMERR,
"Error 2 returned from Zoltan_Postprocess_FinalOutput");
}
Compute_EdgeCut(zz, gr->num_obj, gr->xadj, gr->float_ewgts,
prt->part, adjpart, cute);
cutl = Compute_ConCut(zz, gr->num_obj, gr->xadj, gr->float_ewgts,
prt->part, adjpart);
cutn = Compute_NetCut(zz, gr->num_obj, gr->xadj, gr->float_ewgts,
prt->part, adjpart);
#ifdef UVC_DORUK_COMP_OBJSIZE
if (vsizeBACKUP) {
minD = vsizeBACKUP[0];
maxD = vsizeBACKUP[0];
}
#endif
if (gr->scatter != 0) { /* Project input part in the scatter graph */
input_part = (indextype*) ZOLTAN_MALLOC(gr->num_obj * sizeof(int));
Zoltan_Comm_Do(gr->comm_plan, TAG1, (char *) prt->input_part, sizeof(indextype),
(char *) input_part);
}
else
input_part = prt->input_part;
for (i=0; i<gr->num_obj; i++) {
/*printf("obj[%d] = %d\n", i, vsize[i]);*/
if (prt->part[i] != input_part[i]) {
move += (double) ((vsizeBACKUP) ? vsizeBACKUP[i] : 1.0);
}
#ifdef UVC_DORUK_COMP_OBJSIZE
if (vsizeBACKUP) {
minD = minD < vsizeBACKUP[i] ? minD : vsizeBACKUP[i];
maxD = maxD > vsizeBACKUP[i] ? maxD : vsizeBACKUP[i];
}
#endif
}
if (gr->scatter != 0)
ZOLTAN_FREE(&input_part);
#ifdef UVC_DORUK_COMP_OBJSIZE
if (gr->showMoveVol) {
MPI_Allreduce(&minD, &gminD, 1, MPI_DOUBLE, MPI_MIN, zz->Communicator);
MPI_Allreduce(&maxD, &gmaxD, 1, MPI_DOUBLE, MPI_MAX, zz->Communicator);
if (zz->Proc == 0)
printf("minD: %f, maxD: %f, gminD: %f, gmaxD: %f\n", minD, maxD, gminD, gmaxD);
}
#endif
MPI_Allreduce(&move, &gmove, 1, MPI_DOUBLE, MPI_SUM, zz->Communicator);
repart = (itr) * (double) cutl + gmove;
repartsum += repart;
if (repart > repartmax) repartmax = repart;
if (repart < repartmin) repartmin = repart;
movesum += gmove;
if (gmove > movemax) movemax = gmove;
if (gmove < movemin) movemin = gmove;
cutlsum += cutl;
if (cutl > cutlmax) cutlmax = cutl;
if (cutl < cutlmin) cutlmin = cutl;
cutnsum += cutn;
if (cutn > cutnmax) cutnmax = cutn;
if (cutn < cutnmin) cutnmin = cutn;
for (i = 0; i < vdim; i++) {
balsum[i] += bal[i];
if (bal[i] > balmax[i]) balmax[i] = bal[i];
if (bal[i] < balmin[i]) balmin[i] = bal[i];
}
for (i = 0; i < edim; i++) {
cutesum[i] += cute[i];
if (cute[i] > cutemax[i]) cutemax[i] = cute[i];
if (cute[i] < cutemin[i]) cutemin[i] = cute[i];
}
nRuns++;
if (zz->Proc == 0) {
for (i = 0; i < vdim; i++)
printf("STATS Runs %d bal[%d] CURRENT %f MAX %f MIN %f AVG %f\n",
nRuns, i, bal[i], balmax[i], balmin[i], balsum[i]/nRuns);
printf("STATS Runs %d cutl CURRENT %f MAX %f MIN %f AVG %f\n",
nRuns, cutl, cutlmax, cutlmin, cutlsum/nRuns);
printf("STATS Runs %d cutn CURRENT %f MAX %f MIN %f AVG %f\n",
nRuns, cutn, cutnmax, cutnmin, cutnsum/nRuns);
for (i = 0; i < edim; i++)
printf("STATS Runs %d cute[%d] CURRENT %f MAX %f MIN %f AVG %f\n",
nRuns, i, cute[i], cutemax[i], cutemin[i], cutesum[i]/nRuns);
printf("STATS Runs %d %s CURRENT %f MAX %f MIN %f AVG %f\n",
nRuns, gr->showMoveVol ? "moveVol" : "moveCnt", gmove,
movemax, movemin, movesum/nRuns);
if (gr->showMoveVol)
printf("STATS Runs %d repart CURRENT %f MAX %f MIN %f AVG %f\n",
nRuns, repart, repartmax, repartmin, repartsum/nRuns);
}
ZOLTAN_FREE(&adjpart);
}
#undef FOMAXDIM
if (use_timers)
ZOLTAN_TIMER_STOP(zz->ZTime, timer_final_output, zz->Communicator);
return (ZOLTAN_OK);
}
/* Main partitioning function for hypergraph partitioning. */
int Zoltan_PHG_Partition (
ZZ *zz, /* Zoltan data structure */
HGraph *hg, /* Input hypergraph to be partitioned */
int p, /* Input: number partitions to be generated */
float *part_sizes, /* Input: array of length p containing percentages
of work to be assigned to each partition */
Partition parts, /* Input: initial partition #s; aligned with vtx
arrays.
Output: computed partition #s */
PHGPartParams *hgp) /* Input: parameters for hgraph partitioning. */
{
PHGComm *hgc = hg->comm;
VCycle *vcycle=NULL, *del=NULL;
int i, err = ZOLTAN_OK, middle;
ZOLTAN_GNO_TYPE origVpincnt; /* for processor reduction test */
ZOLTAN_GNO_TYPE prevVcnt = 2*hg->dist_x[hgc->nProc_x]; /* initialized so that the */
ZOLTAN_GNO_TYPE prevVedgecnt = 2*hg->dist_y[hgc->nProc_y]; /* while loop will be entered
before any coarsening */
ZOLTAN_GNO_TYPE tot_nPins, local_nPins;
MPI_Datatype zoltan_gno_mpi_type;
char *yo = "Zoltan_PHG_Partition";
int do_timing = (hgp->use_timers > 1);
int fine_timing = (hgp->use_timers > 2);
int vcycle_timing = (hgp->use_timers > 4 && hgp->ProRedL == 0);
short refine = 0;
struct phg_timer_indices *timer = Zoltan_PHG_LB_Data_timers(zz);
int reset_geometric_matching = 0;
char reset_geometric_string[4];
ZOLTAN_TRACE_ENTER(zz, yo);
zoltan_gno_mpi_type = Zoltan_mpi_gno_type();
if (do_timing) {
if (timer->vcycle < 0)
timer->vcycle = Zoltan_Timer_Init(zz->ZTime, 0, "Vcycle");
if (timer->procred < 0)
timer->procred = Zoltan_Timer_Init(zz->ZTime, 0, "Processor Reduction");
if (timer->match < 0)
timer->match = Zoltan_Timer_Init(zz->ZTime, 1, "Matching");
if (timer->coarse < 0)
timer->coarse = Zoltan_Timer_Init(zz->ZTime, 1, "Coarsening");
if (timer->coarsepart < 0)
timer->coarsepart = Zoltan_Timer_Init(zz->ZTime, 1,
"Coarse_Partition");
if (timer->refine < 0)
timer->refine = Zoltan_Timer_Init(zz->ZTime, 1, "Refinement");
if (timer->project < 0)
timer->project = Zoltan_Timer_Init(zz->ZTime, 1, "Project_Up");
ZOLTAN_TIMER_START(zz->ZTime, timer->vcycle, hgc->Communicator);
}
local_nPins = (ZOLTAN_GNO_TYPE)hg->nPins;
MPI_Allreduce(&local_nPins,&tot_nPins,1,zoltan_gno_mpi_type,MPI_SUM,hgc->Communicator);
origVpincnt = tot_nPins;
if (!(vcycle = newVCycle(zz, hg, parts, NULL, vcycle_timing))) {
ZOLTAN_PRINT_ERROR (zz->Proc, yo, "VCycle is NULL.");
ZOLTAN_TRACE_EXIT(zz, yo);
return ZOLTAN_MEMERR;
}
/* For geometric coarsening, hgp->matching pointer and string are reset
* after geometric_levels of coarsening. Will need to reset them after
* this vcycle is completed. Capture that fact now! */
if (!strcasecmp(hgp->redm_str, "rcb") || !strcasecmp(hgp->redm_str, "rib")) {
reset_geometric_matching = 1;
strcpy(reset_geometric_string, hgp->redm_str);
}
/****** Coarsening ******/
#define COARSEN_FRACTION_LIMIT 0.9 /* Stop if we don't make much progress */
while ((hg->redl>0) && (hg->dist_x[hgc->nProc_x] > (ZOLTAN_GNO_TYPE)hg->redl)
&& ((hg->dist_x[hgc->nProc_x] < (ZOLTAN_GNO_TYPE) (COARSEN_FRACTION_LIMIT * prevVcnt + 0.5)) /* prevVcnt initialized to 2*hg->dist_x[hgc->nProc_x] */
|| (hg->dist_y[hgc->nProc_y] < (ZOLTAN_GNO_TYPE) (COARSEN_FRACTION_LIMIT * prevVedgecnt + 0.5))) /* prevVedgecnt initialized to 2*hg->dist_y[hgc->nProc_y] */
&& hg->dist_y[hgc->nProc_y] && hgp->matching) {
ZOLTAN_GNO_TYPE *match = NULL;
VCycle *coarser=NULL, *redistributed=NULL;
prevVcnt = hg->dist_x[hgc->nProc_x];
prevVedgecnt = hg->dist_y[hgc->nProc_y];
#ifdef _DEBUG
/* UVC: load balance stats */
Zoltan_PHG_LoadBalStat(zz, hg);
#endif
if (hgp->output_level >= PHG_DEBUG_LIST) {
uprintf(hgc,
"START %3d |V|=%6d |E|=%6d #pins=%6d %d/%s/%s/%s p=%d...\n",
hg->info, hg->nVtx, hg->nEdge, hg->nPins, hg->redl,
hgp->redm_str,
hgp->coarsepartition_str, hgp->refinement_str, p);
if (hgp->output_level > PHG_DEBUG_LIST) {
err = Zoltan_HG_Info(zz, hg);
if (err != ZOLTAN_OK && err != ZOLTAN_WARN)
goto End;
}
}
if (hgp->output_level >= PHG_DEBUG_PLOT)
Zoltan_PHG_Plot(zz->Proc, hg->nVtx, p, hg->vindex, hg->vedge, NULL,
"coarsening plot");
if (do_timing) {
ZOLTAN_TIMER_STOP(zz->ZTime, timer->vcycle, hgc->Communicator);
ZOLTAN_TIMER_START(zz->ZTime, timer->match, hgc->Communicator);
}
if (vcycle_timing) {
if (vcycle->timer_match < 0) {
char str[80];
sprintf(str, "VC Matching %d", hg->info);
vcycle->timer_match = Zoltan_Timer_Init(vcycle->timer, 0, str);
}
ZOLTAN_TIMER_START(vcycle->timer, vcycle->timer_match,
hgc->Communicator);
}
/* Allocate and initialize Matching Array */
if (hg->nVtx && !(match = (ZOLTAN_GNO_TYPE *) ZOLTAN_MALLOC (hg->nVtx*sizeof(ZOLTAN_GNO_TYPE)))) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Insufficient memory: Matching array");
ZOLTAN_TRACE_EXIT(zz, yo);
return ZOLTAN_MEMERR;
}
for (i = 0; i < hg->nVtx; i++)
match[i] = i;
/* Calculate matching (packing or grouping) */
err = Zoltan_PHG_Matching (zz, hg, match, hgp);
if (err != ZOLTAN_OK && err != ZOLTAN_WARN) {
ZOLTAN_FREE (&match);
goto End;
}
if (vcycle_timing)
ZOLTAN_TIMER_STOP(vcycle->timer, vcycle->timer_match,
hgc->Communicator);
if (do_timing) {
ZOLTAN_TIMER_STOP(zz->ZTime, timer->match, hgc->Communicator);
ZOLTAN_TIMER_START(zz->ZTime, timer->coarse, hgc->Communicator);
}
if (vcycle_timing) {
if (vcycle->timer_coarse < 0) {
char str[80];
sprintf(str, "VC Coarsening %d", hg->info);
vcycle->timer_coarse = Zoltan_Timer_Init(vcycle->timer, 0, str);
}
ZOLTAN_TIMER_START(vcycle->timer, vcycle->timer_coarse,
hgc->Communicator);
}
if (!(coarser = newVCycle(zz, NULL, NULL, vcycle, vcycle_timing))) {
ZOLTAN_FREE (&match);
ZOLTAN_PRINT_ERROR (zz->Proc, yo, "coarser is NULL.");
goto End;
}
/* Construct coarse hypergraph and LevelMap */
err = Zoltan_PHG_Coarsening (zz, hg, match, coarser->hg, vcycle->LevelMap,
&vcycle->LevelCnt, &vcycle->LevelSndCnt, &vcycle->LevelData,
&vcycle->comm_plan, hgp);
if (err != ZOLTAN_OK && err != ZOLTAN_WARN)
goto End;
if (vcycle_timing)
ZOLTAN_TIMER_STOP(vcycle->timer, vcycle->timer_coarse,
hgc->Communicator);
if (do_timing) {
ZOLTAN_TIMER_STOP(zz->ZTime, timer->coarse, hgc->Communicator);
ZOLTAN_TIMER_START(zz->ZTime, timer->vcycle, hgc->Communicator);
}
ZOLTAN_FREE (&match);
if ((err=allocVCycle(coarser))!= ZOLTAN_OK)
goto End;
vcycle = coarser;
hg = vcycle->hg;
if (hgc->nProc > 1 && hgp->ProRedL > 0) {
local_nPins = (ZOLTAN_GNO_TYPE)hg->nPins;
MPI_Allreduce(&local_nPins, &tot_nPins, 1, zoltan_gno_mpi_type, MPI_SUM,
hgc->Communicator);
if (tot_nPins < (ZOLTAN_GNO_TYPE)(hgp->ProRedL * origVpincnt + 0.5)) {
if (do_timing) {
ZOLTAN_TIMER_STOP(zz->ZTime, timer->vcycle, hgc->Communicator);
ZOLTAN_TIMER_START(zz->ZTime, timer->procred, hgc->Communicator);
}
/* redistribute to half the processors */
origVpincnt = tot_nPins; /* update for processor reduction test */
if(hg->nVtx&&!(hg->vmap=(int*)ZOLTAN_MALLOC(hg->nVtx*sizeof(int)))) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Insufficient memory: hg->vmap");
ZOLTAN_TRACE_EXIT(zz, yo);
return ZOLTAN_MEMERR;
}
for (i = 0; i < hg->nVtx; i++)
hg->vmap[i] = i;
middle = (int)((float) (hgc->nProc-1) * hgp->ProRedL);
if (hgp->nProc_x_req!=1&&hgp->nProc_y_req!=1) { /* Want 2D decomp */
if ((middle+1) > SMALL_PRIME && Zoltan_PHG_isPrime(middle+1))
--middle; /* if it was prime just use one less #procs (since
it should be bigger than SMALL_PRIME it is safe to
decrement) */
}
if (!(hgc = (PHGComm*) ZOLTAN_MALLOC (sizeof(PHGComm)))) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Insufficient memory: PHGComm");
ZOLTAN_TRACE_EXIT(zz, yo);
return ZOLTAN_MEMERR;
}
if (!(redistributed=newVCycle(zz,NULL,NULL,vcycle,vcycle_timing))) {
ZOLTAN_FREE (&hgc);
ZOLTAN_PRINT_ERROR (zz->Proc, yo, "redistributed is NULL.");
goto End;
}
Zoltan_PHG_Redistribute(zz,hgp,hg,0,middle,hgc, redistributed->hg,
&vcycle->vlno,&vcycle->vdest);
if (hgp->UseFixedVtx || hgp->UsePrefPart)
redistributed->hg->bisec_split = hg->bisec_split;
if ((err=allocVCycle(redistributed))!= ZOLTAN_OK)
goto End;
vcycle = redistributed;
if (hgc->myProc < 0)
/* I'm not in the redistributed part so I should go to uncoarsening
refinement and wait */ {
if (fine_timing) {
if (timer->cpgather < 0)
timer->cpgather = Zoltan_Timer_Init(zz->ZTime, 1, "CP Gather");
if (timer->cprefine < 0)
timer->cprefine =Zoltan_Timer_Init(zz->ZTime, 0, "CP Refine");
if (timer->cpart < 0)
timer->cpart = Zoltan_Timer_Init(zz->ZTime, 0, "CP Part");
}
if (do_timing) {
ZOLTAN_TIMER_STOP(zz->ZTime, timer->procred, hgc->Communicator);
ZOLTAN_TIMER_START(zz->ZTime, timer->vcycle, hgc->Communicator);
}
goto Refine;
}
hg = vcycle->hg;
hg->redl = hgp->redl; /* not set with hg creation */
if (do_timing) {
ZOLTAN_TIMER_STOP(zz->ZTime, timer->procred, hgc->Communicator);
ZOLTAN_TIMER_START(zz->ZTime, timer->vcycle, hgc->Communicator);
}
}
}
}
if (hgp->output_level >= PHG_DEBUG_LIST) {
uprintf(hgc, "START %3d |V|=%6d |E|=%6d #pins=%6d %d/%s/%s/%s p=%d...\n",
hg->info, hg->nVtx, hg->nEdge, hg->nPins, hg->redl,
hgp->redm_str, hgp->coarsepartition_str, hgp->refinement_str, p);
if (hgp->output_level > PHG_DEBUG_LIST) {
err = Zoltan_HG_Info(zz, hg);
if (err != ZOLTAN_OK && err != ZOLTAN_WARN)
goto End;
}
}
if (hgp->output_level >= PHG_DEBUG_PLOT)
Zoltan_PHG_Plot(zz->Proc, hg->nVtx, p, hg->vindex, hg->vedge, NULL,
"coarsening plot");
/* free array that may have been allocated in matching */
if (hgp->vtx_scal) {
hgp->vtx_scal_size = 0;
ZOLTAN_FREE(&(hgp->vtx_scal));
}
if (do_timing) {
ZOLTAN_TIMER_STOP(zz->ZTime, timer->vcycle, hgc->Communicator);
ZOLTAN_TIMER_START(zz->ZTime, timer->coarsepart, hgc->Communicator);
}
/****** Coarse Partitioning ******/
err = Zoltan_PHG_CoarsePartition (zz, hg, p, part_sizes, vcycle->Part, hgp);
if (err != ZOLTAN_OK && err != ZOLTAN_WARN)
goto End;
if (do_timing) {
ZOLTAN_TIMER_STOP(zz->ZTime, timer->coarsepart, hgc->Communicator);
ZOLTAN_TIMER_START(zz->ZTime, timer->vcycle, hgc->Communicator);
}
Refine:
del = vcycle;
refine = 1;
/****** Uncoarsening/Refinement ******/
while (vcycle) {
VCycle *finer = vcycle->finer;
hg = vcycle->hg;
if (refine && hgc->myProc >= 0) {
if (do_timing) {
ZOLTAN_TIMER_STOP(zz->ZTime, timer->vcycle, hgc->Communicator);
ZOLTAN_TIMER_START(zz->ZTime, timer->refine, hgc->Communicator);
}
if (vcycle_timing) {
if (vcycle->timer_refine < 0) {
char str[80];
sprintf(str, "VC Refinement %d", hg->info);
vcycle->timer_refine = Zoltan_Timer_Init(vcycle->timer, 0, str);
}
ZOLTAN_TIMER_START(vcycle->timer, vcycle->timer_refine,
hgc->Communicator);
}
err = Zoltan_PHG_Refinement (zz, hg, p, part_sizes, vcycle->Part, hgp);
if (do_timing) {
ZOLTAN_TIMER_STOP(zz->ZTime, timer->refine, hgc->Communicator);
ZOLTAN_TIMER_START(zz->ZTime, timer->vcycle, hgc->Communicator);
}
if (vcycle_timing)
ZOLTAN_TIMER_STOP(vcycle->timer, vcycle->timer_refine,
hgc->Communicator);
if (hgp->output_level >= PHG_DEBUG_LIST)
uprintf(hgc,
"FINAL %3d |V|=%6d |E|=%6d #pins=%6d %d/%s/%s/%s p=%d bal=%.2f cutl=%.2f\n",
hg->info, hg->nVtx, hg->nEdge, hg->nPins, hg->redl,
hgp->redm_str,
hgp->coarsepartition_str, hgp->refinement_str, p,
Zoltan_PHG_Compute_Balance(zz, hg, part_sizes, 0, p,
vcycle->Part),
Zoltan_PHG_Compute_ConCut(hgc, hg, vcycle->Part, p, &err));
if (hgp->output_level >= PHG_DEBUG_PLOT)
Zoltan_PHG_Plot(zz->Proc, hg->nVtx, p, hg->vindex, hg->vedge, vcycle->Part,
"partitioned plot");
}
if (finer) {
int *rbuffer;
/* Project coarse partition to fine partition */
if (finer->comm_plan) {
refine = 1;
if (do_timing) {
ZOLTAN_TIMER_STOP(zz->ZTime, timer->vcycle, hgc->Communicator);
ZOLTAN_TIMER_START(zz->ZTime, timer->project, hgc->Communicator);
}
if (vcycle_timing) {
if (vcycle->timer_project < 0) {
char str[80];
sprintf(str, "VC Project Up %d", hg->info);
vcycle->timer_project = Zoltan_Timer_Init(vcycle->timer, 0, str);
}
ZOLTAN_TIMER_START(vcycle->timer, vcycle->timer_project,
hgc->Communicator);
}
/* easy to assign partitions to internal matches */
for (i = 0; i < finer->hg->nVtx; i++)
if (finer->LevelMap[i] >= 0) /* if considers only the local vertices */
finer->Part[i] = vcycle->Part[finer->LevelMap[i]];
/* now that the course partition assignments have been propagated */
/* upward to the finer level for the local vertices, we need to */
/* fill the LevelData (matched pairs of a local vertex with a */
/* off processor vertex) with the partition assignment of the */
/* local vertex - can be done totally in the finer level! */
for (i = 0; i < finer->LevelCnt; i++) {
++i; /* skip over off processor lno */
finer->LevelData[i] = finer->Part[finer->LevelData[i]];
}
/* allocate rec buffer to exchange LevelData information */
rbuffer = NULL;
if (finer->LevelSndCnt > 0) {
rbuffer = (int*) ZOLTAN_MALLOC (2 * finer->LevelSndCnt * sizeof(int));
if (!rbuffer) {
ZOLTAN_PRINT_ERROR (zz->Proc, yo, "Insufficient memory.");
ZOLTAN_TRACE_EXIT(zz, yo);
return ZOLTAN_MEMERR;
}
}
/* get partition assignments from owners of externally matched vtxs */
Zoltan_Comm_Resize (finer->comm_plan, NULL, COMM_TAG, &i);
Zoltan_Comm_Do_Reverse (finer->comm_plan, COMM_TAG+1,
(char*) finer->LevelData, 2 * sizeof(int), NULL, (char*) rbuffer);
/* process data to assign partitions to expernal matches */
for (i = 0; i < 2 * finer->LevelSndCnt;) {
int lno, partition;
lno = rbuffer[i++];
partition = rbuffer[i++];
finer->Part[lno] = partition;
}
ZOLTAN_FREE (&rbuffer);
Zoltan_Comm_Destroy (&finer->comm_plan);
if (do_timing) {
ZOLTAN_TIMER_STOP(zz->ZTime, timer->project, hgc->Communicator);
ZOLTAN_TIMER_START(zz->ZTime, timer->vcycle, hgc->Communicator);
}
if (vcycle_timing)
ZOLTAN_TIMER_STOP(vcycle->timer, vcycle->timer_project,
hgc->Communicator);
} else {
int *sendbuf = NULL, size;
refine = 0;
/* ints local and partition numbers */
if (finer->vlno) {
sendbuf = (int*) ZOLTAN_MALLOC (2 * hg->nVtx * sizeof(int));
if (!sendbuf) {
ZOLTAN_PRINT_ERROR (zz->Proc, yo, "Insufficient memory.");
ZOLTAN_TRACE_EXIT(zz, yo);
return ZOLTAN_MEMERR;
}
for (i = 0; i < hg->nVtx; ++i) {
sendbuf[2 * i] = finer->vlno[i]; /* assign local numbers */
sendbuf[2 * i + 1] = vcycle->Part[i];/* assign partition numbers */
}
}
ZOLTAN_FREE (&hgc);
hgc = finer->hg->comm; /* updating hgc is required when the processors
change */
/* Create comm plan to unredistributed processors */
err = Zoltan_Comm_Create(&finer->comm_plan, finer->vlno ? hg->nVtx : 0,
finer->vdest, hgc->Communicator, COMM_TAG+2,
&size);
if (err != ZOLTAN_OK && err != ZOLTAN_WARN) {
ZOLTAN_PRINT_ERROR(hgc->myProc, yo, "Zoltan_Comm_Create failed.");
goto End;
}
/* allocate rec buffer to exchange sendbuf information */
rbuffer = NULL;
if (finer->hg->nVtx) {
rbuffer = (int*) ZOLTAN_MALLOC (2 * finer->hg->nVtx * sizeof(int));
if (!rbuffer) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Insufficient memory.");
ZOLTAN_TRACE_EXIT(zz, yo);
return ZOLTAN_MEMERR;
}
}
/* Use plan to send partitions to the unredistributed processors */
Zoltan_Comm_Do(finer->comm_plan, COMM_TAG+3, (char *) sendbuf,
2*sizeof(int), (char *) rbuffer);
MPI_Bcast(rbuffer, 2*finer->hg->nVtx, MPI_INT, 0, hgc->col_comm);
/* process data to assign partitions to unredistributed processors */
for (i = 0; i < 2 * finer->hg->nVtx;) {
int lno, partition;
lno = rbuffer[i++];
partition = rbuffer[i++];
finer->Part[lno] = partition;
}
if (finer->vlno)
ZOLTAN_FREE (&sendbuf);
ZOLTAN_FREE (&rbuffer);
Zoltan_Comm_Destroy (&finer->comm_plan);
}
}
vcycle = finer;
} /* while (vcycle) */
End:
vcycle = del;
while (vcycle) {
if (vcycle_timing) {
Zoltan_Timer_PrintAll(vcycle->timer, 0, hgc->Communicator, stdout);
Zoltan_Timer_Destroy(&vcycle->timer);
}
if (vcycle->finer) { /* cleanup by level */
Zoltan_HG_HGraph_Free (vcycle->hg);
if (vcycle->LevelData)
Zoltan_Multifree (__FILE__, __LINE__, 4, &vcycle->Part,
&vcycle->LevelMap, &vcycle->LevelData, &vcycle->hg);
else if (vcycle->vlno)
Zoltan_Multifree (__FILE__, __LINE__, 5, &vcycle->Part, &vcycle->vdest,
&vcycle->vlno, &vcycle->LevelMap, &vcycle->hg);
else
Zoltan_Multifree (__FILE__, __LINE__, 3, &vcycle->Part,
&vcycle->LevelMap, &vcycle->hg);
}
else /* cleanup top level */
Zoltan_Multifree (__FILE__, __LINE__, 2, &vcycle->LevelMap,
&vcycle->LevelData);
del = vcycle;
vcycle = vcycle->finer;
ZOLTAN_FREE(&del);
}
if (reset_geometric_matching) {
strcpy(hgp->redm_str, reset_geometric_string);
Zoltan_PHG_Set_Matching_Fn(hgp);
}
if (do_timing)
ZOLTAN_TIMER_STOP(zz->ZTime, timer->vcycle, hgc->Communicator);
ZOLTAN_TRACE_EXIT(zz, yo) ;
return err;
}
int Zoltan_PHG_CoarsePartition(
ZZ *zz,
HGraph *phg, /* Input: coarse hypergraph -- distributed! */
int numPart, /* Input: number of partitions to generate. */
float *part_sizes, /* Input: array of size numPart listing target sizes
(% of work) for the partitions */
Partition part, /* Input: array of initial partition assignments.
Output: array of computed partition assignments. */
PHGPartParams *hgp /* Input: parameters to use. */
)
{
/*
* Zoltan_PHG_CoarsePartition computes a partitioning of a hypergraph.
* Typically, this routine is called at the bottom level in a
* multilevel scheme (V-cycle).
* It gathers the distributed hypergraph to each processor and computes
* a decomposition of the serial hypergraph.
* It computes a different partition on each processor
* using different random numbers (and possibly also
* different algorithms) and selects the best.
*/
char *yo = "Zoltan_PHG_CoarsePartition";
int ierr = ZOLTAN_OK;
int i, si, j;
static PHGComm scomm; /* Serial communicator info */
static int first_time = 1;
HGraph *shg = NULL; /* Serial hypergraph gathered from phg */
int *spart = NULL; /* Partition vectors for shg. */
int *new_part = NULL; /* Ptr to new partition vector. */
float *bestvals = NULL; /* Best cut values found so far */
int worst, new_cand;
float bal, cut, worst_cut;
int fine_timing = (hgp->use_timers > 2);
struct phg_timer_indices *timer = Zoltan_PHG_LB_Data_timers(zz);
int local_coarse_part = hgp->LocalCoarsePartition;
/* Number of iterations to try coarse partitioning on each proc. */
/* 10 when p=1, and 1 when p is large. */
const int num_coarse_iter = 1 + 9/zz->Num_Proc;
ZOLTAN_TRACE_ENTER(zz, yo);
if (fine_timing) {
if (timer->cpgather < 0)
timer->cpgather = Zoltan_Timer_Init(zz->ZTime, 1, "CP Gather");
if (timer->cprefine < 0)
timer->cprefine = Zoltan_Timer_Init(zz->ZTime, 0, "CP Refine");
if (timer->cpart < 0)
timer->cpart = Zoltan_Timer_Init(zz->ZTime, 0, "CP Part");
ZOLTAN_TIMER_START(zz->ZTime, timer->cpart, phg->comm->Communicator);
}
/* Force LocalCoarsePartition if large global graph */
#define LARGE_GRAPH_VTX 64000
#define LARGE_GRAPH_PINS 256000
if (phg->dist_x[phg->comm->nProc_x] > LARGE_GRAPH_VTX){
/* TODO: || (global_nPins > LARGE_GRAPH_PINS) */
local_coarse_part = 1;
}
/* take care of all special cases first */
if (!strcasecmp(hgp->coarsepartition_str, "no")
|| !strcasecmp(hgp->coarsepartition_str, "none")) {
/* Do no coarse partitioning. */
/* Do a sanity test and mapping to parts [0,...,numPart-1] */
int first = 1;
PHGComm *hgc=phg->comm;
Zoltan_Srand_Sync (Zoltan_Rand(NULL), &(hgc->RNGState_col), hgc->col_comm);
if (hgp->UsePrefPart) {
for (i = 0; i < phg->nVtx; i++) {
/* Impose fixed vertex/preferred part constraints. */
if (phg->pref_part[i] < 0) { /* Free vertex in fixedvertex partitioning or repart */
/* randomly assigned to a part */
part[i] = Zoltan_Rand_InRange(&(hgc->RNGState_col), numPart);
} else {
if (phg->bisec_split < 0)
/* direct k-way, use part numbers directly */
part[i] = phg->pref_part[i];
else
/* recursive bisection, map to 0-1 part numbers */
part[i] = (phg->pref_part[i] < phg->bisec_split ? 0 : 1);
}
}
} else {
for (i = 0; i < phg->nVtx; i++) {
if (part[i] >= numPart || part[i]<0) {
if (first) {
ZOLTAN_PRINT_WARN(zz->Proc, yo, "Initial part number > numParts.");
first = 0;
ierr = ZOLTAN_WARN;
}
part[i] = ((part[i]<0) ? -part[i] : part[i]) % numPart;
}
}
}
}
else if (numPart == 1) {
/* everything goes in the one partition */
for (i = 0; i < phg->nVtx; i++)
part[i] = 0;
}
else if (!hgp->UsePrefPart && numPart >= phg->dist_x[phg->comm->nProc_x]) {
/* more partitions than vertices, trivial answer */
for (i = 0; i < phg->nVtx; i++)
part[i] = phg->dist_x[phg->comm->myProc_x]+i;
}
else if (local_coarse_part) {
/* Apply local partitioner to each column */
ierr = local_coarse_partitioner(zz, phg, numPart, part_sizes, part, hgp,
hgp->CoarsePartition);
}
else {
/* Normal case:
* Gather distributed HG to each processor;
* compute different partitioning on each processor;
* select the "best" result.
*/
ZOLTAN_PHG_COARSEPARTITION_FN *CoarsePartition;
/* Select different coarse partitioners for processors here. */
CoarsePartition = hgp->CoarsePartition;
if (CoarsePartition == NULL) { /* auto */
/* Select a coarse partitioner from the array of coarse partitioners */
CoarsePartition = CoarsePartitionFns[phg->comm->myProc %
NUM_COARSEPARTITION_FNS];
}
if (phg->comm->nProc == 1) {
/* Serial and parallel hgraph are the same. */
shg = phg;
}
else {
/* Set up a serial communication struct for gathered HG */
if (first_time) {
scomm.nProc_x = scomm.nProc_y = 1;
scomm.myProc_x = scomm.myProc_y = 0;
scomm.Communicator = MPI_COMM_SELF;
scomm.row_comm = MPI_COMM_SELF;
scomm.col_comm = MPI_COMM_SELF;
scomm.myProc = 0;
scomm.nProc = 1;
first_time = 0;
}
scomm.RNGState = Zoltan_Rand(NULL);
scomm.RNGState_row = Zoltan_Rand(NULL);
scomm.RNGState_col = Zoltan_Rand(NULL);
scomm.zz = zz;
/*
* Gather parallel hypergraph phg to each processor, creating
* serial hypergraph shg.
*/
if (fine_timing) {
ZOLTAN_TIMER_STOP(zz->ZTime, timer->cpart, phg->comm->Communicator);
ZOLTAN_TIMER_START(zz->ZTime, timer->cpgather, phg->comm->Communicator);
}
ierr = Zoltan_PHG_Gather_To_All_Procs(zz, phg, hgp, &scomm, &shg);
if (ierr < 0) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Error returned from gather.");
goto End;
}
if (fine_timing) {
ZOLTAN_TIMER_STOP(zz->ZTime, timer->cpgather, phg->comm->Communicator);
ZOLTAN_TIMER_START(zz->ZTime, timer->cpart, phg->comm->Communicator);
}
}
/*
* Allocate partition array spart for the serial hypergraph shg
* and partition shg.
*/
spart = (int *) ZOLTAN_CALLOC(shg->nVtx * (NUM_PART_KEEP+1),
sizeof(int));
bestvals = (float *) ZOLTAN_MALLOC((NUM_PART_KEEP+1)*sizeof(int));
if ((!spart) || (!bestvals)) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Out of memory.");
ierr = ZOLTAN_MEMERR;
goto End;
}
/* Compute several coarse partitionings. */
/* Keep the NUM_PART_KEEP best ones around. */
/* Currently, only the best one is used. */
/* Set RNG so different procs compute different parts. */
Zoltan_Srand(Zoltan_Rand(NULL) + zz->Proc, NULL);
new_cand = 0;
new_part = spart;
for (i=0; i< num_coarse_iter; i++){
int savefmlooplimit=hgp->fm_loop_limit;
/* Overwrite worst partition with new candidate. */
ierr = CoarsePartition(zz, shg, numPart, part_sizes,
new_part, hgp);
if (ierr < 0) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo,
"Error returned from CoarsePartition.");
goto End;
}
/* time refinement step in coarse partitioner */
if (fine_timing) {
ZOLTAN_TIMER_STOP(zz->ZTime, timer->cpart, phg->comm->Communicator);
ZOLTAN_TIMER_START(zz->ZTime, timer->cprefine, phg->comm->Communicator);
}
/* UVCUVC: Refine new candidate: only one pass is enough. */
hgp->fm_loop_limit = 1;
Zoltan_PHG_Refinement(zz, shg, numPart, part_sizes, new_part, hgp);
hgp->fm_loop_limit = savefmlooplimit;
/* stop refinement timer */
if (fine_timing) {
ZOLTAN_TIMER_STOP(zz->ZTime, timer->cprefine, phg->comm->Communicator);
ZOLTAN_TIMER_START(zz->ZTime, timer->cpart, phg->comm->Communicator);
}
/* Decide if candidate is in the top tier or not. */
/* Our objective is a combination of cuts and balance */
bal = Zoltan_PHG_Compute_Balance(zz, shg, part_sizes, 0,
numPart, new_part);
cut = Zoltan_PHG_Compute_ConCut(shg->comm, shg, new_part, numPart, &ierr);
/* Use ratio-cut as our objective. There are many other options! */
bestvals[new_cand] = cut/(MAX(2.-bal, 0.0001)); /* avoid divide-by-0 */
if (ierr < 0) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo,
"Error returned from Zoltan_PHG_Compute_ConCut.");
goto End;
}
if (i<NUM_PART_KEEP)
new_cand = i+1;
else {
/* find worst partition vector, to overwrite it */
/* future optimization: keep bestvals sorted */
worst = 0;
worst_cut = bestvals[0];
for (j=1; j<NUM_PART_KEEP+1; j++){
if (worst_cut < bestvals[j]){
worst_cut = bestvals[j];
worst = j;
}
}
new_cand = worst;
}
new_part = spart+new_cand*(shg->nVtx);
}
/* Copy last partition vector such that all the best ones
are contiguous starting at spart. */
for (i=0; i<shg->nVtx; i++){
new_part[i] = spart[NUM_PART_KEEP*(shg->nVtx)+i];
}
/* Also update bestvals */
bestvals[new_cand] = bestvals[NUM_PART_KEEP];
/* Evaluate and select the best. */
/* For now, only pick the best one, in the future we pick the k best. */
ierr = pick_best(zz, hgp, phg->comm, shg, numPart,
MIN(NUM_PART_KEEP, num_coarse_iter), spart,
bestvals);
if (ierr < 0) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo,
"Error returned from pick_best.");
goto End;
}
if (phg->comm->nProc > 1) {
/* Map gathered partition back to 2D distribution */
for (i = 0; i < phg->nVtx; i++) {
/* KDDKDD Assume vertices in serial HG are ordered by GNO of phg */
si = VTX_LNO_TO_GNO(phg, i);
part[i] = spart[si];
}
Zoltan_HG_HGraph_Free(shg);
ZOLTAN_FREE(&shg);
}
else { /* single processor */
for (i = 0; i < phg->nVtx; i++)
part[i] = spart[i];
}
ZOLTAN_FREE(&spart);
ZOLTAN_FREE(&bestvals);
}
End:
if (fine_timing)
ZOLTAN_TIMER_STOP(zz->ZTime, timer->cpart, phg->comm->Communicator);
ZOLTAN_TRACE_EXIT(zz, yo);
return ierr;
}
