bool wxSymbolListCtrl::Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos,
const wxSize& size,
long style,
const wxString& name)
{
style |= wxWANTS_CHARS | wxFULL_REPAINT_ON_RESIZE;
if ((style & wxBORDER_MASK) == wxBORDER_DEFAULT)
style |= wxBORDER_THEME;
if ( !wxVScrolledWindow::Create(parent, id, pos, size, style, name) )
return false;
// make sure the native widget has the right colour since we do
// transparent drawing by default
SetBackgroundColour(GetBackgroundColour());
m_colBgSel = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT);
// flicker-free drawing requires this
SetBackgroundStyle(wxBG_STYLE_CUSTOM);
SetFont(*wxNORMAL_FONT);
SetupCtrl();
SetInitialSize(size);
return true;
}
/******************************************************************************
* This function takes a graph and its partition vector and creates a new
* graph corresponding to the one after the movement
*******************************************************************************/
void TestMoveGraph(graph_t *ograph, graph_t *omgraph, idx_t *part, MPI_Comm comm)
{
idx_t npes, mype;
ctrl_t *ctrl;
graph_t *graph, *mgraph;
idx_t options[5] = {0, 0, 1, 0, 0};
gkMPI_Comm_size(comm, &npes);
ctrl = SetupCtrl(PARMETIS_OP_KMETIS, NULL, 1, npes, NULL, NULL, comm);
mype = ctrl->mype;
ctrl->CoarsenTo = 1; /* Needed by SetUpGraph, otherwise we can FP errors */
graph = TestSetUpGraph(ctrl, ograph->vtxdist, ograph->xadj, NULL, ograph->adjncy, NULL, 0);
AllocateWSpace(ctrl, 0);
CommSetup(ctrl, graph);
graph->where = part;
graph->ncon = 1;
mgraph = MoveGraph(ctrl, graph);
omgraph->gnvtxs = mgraph->gnvtxs;
omgraph->nvtxs = mgraph->nvtxs;
omgraph->nedges = mgraph->nedges;
omgraph->vtxdist = mgraph->vtxdist;
omgraph->xadj = mgraph->xadj;
omgraph->adjncy = mgraph->adjncy;
mgraph->vtxdist = NULL;
mgraph->xadj = NULL;
mgraph->adjncy = NULL;
FreeGraph(mgraph);
graph->where = NULL;
FreeInitialGraphAndRemap(graph);
FreeCtrl(&ctrl);
}
// set the current font
bool wxSymbolListCtrl::SetFont(const wxFont& font)
{
wxVScrolledWindow::SetFont(font);
SetupCtrl();
return true;
}
// set Unicode/ASCII mode
void wxSymbolListCtrl::SetUnicodeMode(bool unicodeMode)
{
bool changed = false;
if (unicodeMode && !m_unicodeMode)
{
changed = true;
m_minSymbolValue = 0;
m_maxSymbolValue = 65535;
}
else if (!unicodeMode && m_unicodeMode)
{
changed = true;
m_minSymbolValue = 0;
m_maxSymbolValue = 255;
}
m_unicodeMode = unicodeMode;
if (changed)
SetupCtrl();
}
int METIS_PartGraphKway(idx_t *nvtxs, idx_t *ncon, idx_t *xadj, idx_t *adjncy,
idx_t *vwgt, idx_t *vsize, idx_t *adjwgt, idx_t *nparts,
real_t *tpwgts, real_t *ubvec, idx_t *options, idx_t *objval,
idx_t *part)
{
int sigrval=0, renumber=0;
graph_t *graph;
ctrl_t *ctrl;
/* set up malloc cleaning code and signal catchers */
if (!gk_malloc_init())
return METIS_ERROR_MEMORY;
gk_sigtrap();
if ((sigrval = gk_sigcatch()) != 0)
goto SIGTHROW;
/* set up the run parameters */
ctrl = SetupCtrl(METIS_OP_KMETIS, options, *ncon, *nparts, tpwgts, ubvec);
if (!ctrl) {
gk_siguntrap();
return METIS_ERROR_INPUT;
}
/* if required, change the numbering to 0 */
if (ctrl->numflag == 1) {
Change2CNumbering(*nvtxs, xadj, adjncy);
renumber = 1;
}
/* set up the graph */
graph = SetupGraph(ctrl, *nvtxs, *ncon, xadj, adjncy, vwgt, vsize, adjwgt);
/* set up multipliers for making balance computations easier */
SetupKWayBalMultipliers(ctrl, graph);
/* set various run parameters that depend on the graph */
if (ctrl->iptype == METIS_IPTYPE_METISRB) {
ctrl->CoarsenTo = gk_max((*nvtxs)/(40*gk_log2(*nparts)), 30*(*nparts));
ctrl->CoarsenTo = 10*(*nparts);
ctrl->nIparts = (ctrl->CoarsenTo == 30*(*nparts) ? 4 : 5);
}
else {
ctrl->CoarsenTo = 10*(*nparts);
ctrl->nIparts = 10;
}
/* take care contiguity requests for disconnected graphs */
if (ctrl->contig && !IsConnected(graph, 0))
gk_errexit(SIGERR, "METIS Error: A contiguous partition is requested for a non-contiguous input graph.\n");
/* allocate workspace memory */
AllocateWorkSpace(ctrl, graph);
/* start the partitioning */
IFSET(ctrl->dbglvl, METIS_DBG_TIME, InitTimers(ctrl));
IFSET(ctrl->dbglvl, METIS_DBG_TIME, gk_startwctimer(ctrl->TotalTmr));
*objval = MlevelKWayPartitioning(ctrl, graph, part);
IFSET(ctrl->dbglvl, METIS_DBG_TIME, gk_stopwctimer(ctrl->TotalTmr));
IFSET(ctrl->dbglvl, METIS_DBG_TIME, PrintTimers(ctrl));
/* clean up */
FreeCtrl(&ctrl);
SIGTHROW:
/* if required, change the numbering back to 1 */
if (renumber)
Change2FNumbering(*nvtxs, xadj, adjncy, part);
gk_siguntrap();
gk_malloc_cleanup(0);
return metis_rcode(sigrval);
}
int METIS_NodeND(idx_t *nvtxs, idx_t *xadj, idx_t *adjncy, idx_t *vwgt,
idx_t *options, idx_t *perm, idx_t *iperm)
{
int sigrval=0, renumber=0;
idx_t i, ii, j, l, nnvtxs=0;
graph_t *graph=NULL;
ctrl_t *ctrl;
idx_t *cptr, *cind, *piperm;
int numflag = 0;
/* set up malloc cleaning code and signal catchers */
if (!gk_malloc_init())
return METIS_ERROR_MEMORY;
gk_sigtrap();
if ((sigrval = gk_sigcatch()) != 0)
goto SIGTHROW;
/* set up the run time parameters */
ctrl = SetupCtrl(METIS_OP_OMETIS, options, 1, 3, NULL, NULL);
if (!ctrl) {
gk_siguntrap();
return METIS_ERROR_INPUT;
}
/* if required, change the numbering to 0 */
if (ctrl->numflag == 1) {
Change2CNumbering(*nvtxs, xadj, adjncy);
renumber = 1;
}
IFSET(ctrl->dbglvl, METIS_DBG_TIME, InitTimers(ctrl));
IFSET(ctrl->dbglvl, METIS_DBG_TIME, gk_startcputimer(ctrl->TotalTmr));
/* prune the dense columns */
if (ctrl->pfactor > 0.0) {
piperm = imalloc(*nvtxs, "OMETIS: piperm");
graph = PruneGraph(ctrl, *nvtxs, xadj, adjncy, vwgt, piperm, ctrl->pfactor);
if (graph == NULL) {
/* if there was no prunning, cleanup the pfactor */
gk_free((void **)&piperm, LTERM);
ctrl->pfactor = 0.0;
}
else {
nnvtxs = graph->nvtxs;
ctrl->compress = 0; /* disable compression if prunning took place */
}
}
/* compress the graph; note that compression only happens if not prunning
has taken place. */
if (ctrl->compress) {
cptr = imalloc(*nvtxs+1, "OMETIS: cptr");
cind = imalloc(*nvtxs, "OMETIS: cind");
graph = CompressGraph(ctrl, *nvtxs, xadj, adjncy, vwgt, cptr, cind);
if (graph == NULL) {
/* if there was no compression, cleanup the compress flag */
gk_free((void **)&cptr, &cind, LTERM);
ctrl->compress = 0;
}
else {
nnvtxs = graph->nvtxs;
ctrl->cfactor = 1.0*(*nvtxs)/nnvtxs;
if (ctrl->cfactor > 1.5 && ctrl->nseps == 1)
ctrl->nseps = 2;
//ctrl->nseps = (idx_t)(ctrl->cfactor*ctrl->nseps);
}
}
/* if no prunning and no compression, setup the graph in the normal way. */
if (ctrl->pfactor == 0.0 && ctrl->compress == 0)
graph = SetupGraph(ctrl, *nvtxs, 1, xadj, adjncy, vwgt, NULL, NULL);
ASSERT(CheckGraph(graph, ctrl->numflag, 1));
/* allocate workspace memory */
AllocateWorkSpace(ctrl, graph);
/* do the nested dissection ordering */
if (ctrl->ccorder)
MlevelNestedDissectionCC(ctrl, graph, iperm, graph->nvtxs);
else
MlevelNestedDissection(ctrl, graph, iperm, graph->nvtxs);
if (ctrl->pfactor > 0.0) { /* Order any prunned vertices */
icopy(nnvtxs, iperm, perm); /* Use perm as an auxiliary array */
for (i=0; i<nnvtxs; i++)
iperm[piperm[i]] = perm[i];
for (i=nnvtxs; i<*nvtxs; i++)
iperm[piperm[i]] = i;
gk_free((void **)&piperm, LTERM);
}
else if (ctrl->compress) { /* Uncompress the ordering */
/* construct perm from iperm */
for (i=0; i<nnvtxs; i++)
perm[iperm[i]] = i;
for (l=ii=0; ii<nnvtxs; ii++) {
i = perm[ii];
for (j=cptr[i]; j<cptr[i+1]; j++)
iperm[cind[j]] = l++;
}
gk_free((void **)&cptr, &cind, LTERM);
}
for (i=0; i<*nvtxs; i++)
perm[iperm[i]] = i;
IFSET(ctrl->dbglvl, METIS_DBG_TIME, gk_stopcputimer(ctrl->TotalTmr));
IFSET(ctrl->dbglvl, METIS_DBG_TIME, PrintTimers(ctrl));
/* clean up */
FreeCtrl(&ctrl);
SIGTHROW:
/* if required, change the numbering back to 1 */
if (renumber)
Change2FNumberingOrder(*nvtxs, xadj, adjncy, perm, iperm);
gk_siguntrap();
gk_malloc_cleanup(0);
return metis_rcode(sigrval);
}
// Respond to size change
void wxSymbolListCtrl::OnSize(wxSizeEvent& event)
{
SetupCtrl();
event.Skip();
}
/***********************************************************************************
* This function is the entry point of the parallel multilevel local diffusion
* algorithm. It uses parallel undirected diffusion followed by adaptive k-way
* refinement. This function utilizes local coarsening.
************************************************************************************/
int ParMETIS_V3_RefineKway(idx_t *vtxdist, idx_t *xadj, idx_t *adjncy, idx_t *vwgt,
idx_t *adjwgt, idx_t *wgtflag, idx_t *numflag, idx_t *ncon, idx_t *nparts,
real_t *tpwgts, real_t *ubvec, idx_t *options, idx_t *edgecut, idx_t *part,
MPI_Comm *comm)
{
idx_t npes, mype, status;
ctrl_t *ctrl=NULL;
graph_t *graph=NULL;
size_t curmem;
/* Check the input parameters and return if an error */
status = CheckInputsPartKway(vtxdist, xadj, adjncy, vwgt, adjwgt, wgtflag,
numflag, ncon, nparts, tpwgts, ubvec, options, edgecut, part, comm);
if (GlobalSEMinComm(*comm, status) == 0)
return METIS_ERROR;
status = METIS_OK;
gk_malloc_init();
curmem = gk_GetCurMemoryUsed();
/* Setup ctrl */
ctrl = SetupCtrl(PARMETIS_OP_RMETIS, options, *ncon, *nparts, tpwgts, ubvec, *comm);
npes = ctrl->npes;
mype = ctrl->mype;
/* Take care the nparts == 1 case */
if (*nparts == 1) {
iset(vtxdist[mype+1]-vtxdist[mype], (*numflag == 0 ? 0 : 1), part);
*edgecut = 0;
goto DONE;
}
/* setup the graph */
if (*numflag > 0)
ChangeNumbering(vtxdist, xadj, adjncy, part, npes, mype, 1);
graph = SetupGraph(ctrl, *ncon, vtxdist, xadj, vwgt, NULL, adjncy, adjwgt, *wgtflag);
if (ctrl->ps_relation == PARMETIS_PSR_COUPLED)
iset(graph->nvtxs, mype, graph->home);
else
icopy(graph->nvtxs, part, graph->home);
/* Allocate workspace */
AllocateWSpace(ctrl, 10*graph->nvtxs);
/* Partition and Remap */
STARTTIMER(ctrl, ctrl->TotalTmr);
ctrl->CoarsenTo = gk_min(vtxdist[npes]+1, 50*(*ncon)*gk_max(npes, *nparts));
Adaptive_Partition(ctrl, graph);
ParallelReMapGraph(ctrl, graph);
icopy(graph->nvtxs, graph->where, part);
*edgecut = graph->mincut;
STOPTIMER(ctrl, ctrl->TotalTmr);
/* Take care of output */
IFSET(ctrl->dbglvl, DBG_TIME, PrintTimingInfo(ctrl));
IFSET(ctrl->dbglvl, DBG_TIME, gkMPI_Barrier(ctrl->gcomm));
IFSET(ctrl->dbglvl, DBG_INFO, PrintPostPartInfo(ctrl, graph, 1));
FreeInitialGraphAndRemap(graph);
if (*numflag > 0)
ChangeNumbering(vtxdist, xadj, adjncy, part, npes, mype, 0);
DONE:
FreeCtrl(&ctrl);
if (gk_GetCurMemoryUsed() - curmem > 0) {
printf("ParMETIS appears to have a memory leak of %zdbytes. Report this.\n",
(ssize_t)(gk_GetCurMemoryUsed() - curmem));
}
gk_malloc_cleanup(0);
return (int)status;
}
/***********************************************************************************
* This function is the entry point of the parallel kmetis algorithm that uses
* coordinates to compute an initial graph distribution.
************************************************************************************/
int ParMETIS_V3_PartGeomKway(idx_t *vtxdist, idx_t *xadj, idx_t *adjncy,
idx_t *vwgt, idx_t *adjwgt, idx_t *wgtflag, idx_t *numflag, idx_t *ndims,
real_t *xyz, idx_t *ncon, idx_t *nparts, real_t *tpwgts, real_t *ubvec,
idx_t *options, idx_t *edgecut, idx_t *part, MPI_Comm *comm)
{
idx_t h, i, j, npes, mype, status, nvtxs, seed, dbglvl;
idx_t cut, gcut, maxnvtxs;
idx_t moptions[METIS_NOPTIONS];
ctrl_t *ctrl;
graph_t *graph, *mgraph;
real_t balance;
size_t curmem;
/* Check the input parameters and return if an error */
status = CheckInputsPartGeomKway(vtxdist, xadj, adjncy, vwgt, adjwgt, wgtflag,
numflag, ndims, xyz, ncon, nparts, tpwgts, ubvec, options,
edgecut, part, comm);
if (GlobalSEMinComm(*comm, status) == 0)
return METIS_ERROR;
status = METIS_OK;
gk_malloc_init();
curmem = gk_GetCurMemoryUsed();
/* Setup the ctrl */
ctrl = SetupCtrl(PARMETIS_OP_GKMETIS, options, *ncon, *nparts, tpwgts, ubvec, *comm);
npes = ctrl->npes;
mype = ctrl->mype;
/* Take care the nparts == 1 case */
if (*nparts == 1) {
iset(vtxdist[mype+1]-vtxdist[mype], (*numflag == 0 ? 0 : 1), part);
*edgecut = 0;
goto DONE;
}
/* Take care of npes == 1 case */
if (npes == 1) {
nvtxs = vtxdist[1] - vtxdist[0]; /* subtraction is required when numflag==1 */
METIS_SetDefaultOptions(moptions);
moptions[METIS_OPTION_NUMBERING] = *numflag;
status = METIS_PartGraphKway(&nvtxs, ncon, xadj, adjncy, vwgt, NULL, adjwgt,
nparts, tpwgts, ubvec, moptions, edgecut, part);
goto DONE;
}
/* Setup the graph */
if (*numflag > 0)
ChangeNumbering(vtxdist, xadj, adjncy, part, npes, mype, 1);
graph = SetupGraph(ctrl, *ncon, vtxdist, xadj, vwgt, NULL, adjncy, adjwgt, *wgtflag);
gk_free((void **)&graph->nvwgt, LTERM);
/* Allocate the workspace */
AllocateWSpace(ctrl, 10*graph->nvtxs);
/* Compute the initial npes-way partitioning geometric partitioning */
STARTTIMER(ctrl, ctrl->TotalTmr);
Coordinate_Partition(ctrl, graph, *ndims, xyz, 1);
STOPTIMER(ctrl, ctrl->TotalTmr);
/* Move the graph according to the partitioning */
STARTTIMER(ctrl, ctrl->MoveTmr);
ctrl->nparts = npes;
mgraph = MoveGraph(ctrl, graph);
ctrl->nparts = *nparts;
SetupGraph_nvwgts(ctrl, mgraph); /* compute nvwgts for the moved graph */
if (ctrl->dbglvl&DBG_INFO) {
CommInterfaceData(ctrl, graph, graph->where, graph->where+graph->nvtxs);
for (cut=0, i=0; i<graph->nvtxs; i++) {
for (j=graph->xadj[i]; j<graph->xadj[i+1]; j++) {
if (graph->where[i] != graph->where[graph->adjncy[j]])
cut += graph->adjwgt[j];
}
}
gcut = GlobalSESum(ctrl, cut)/2;
maxnvtxs = GlobalSEMax(ctrl, mgraph->nvtxs);
balance = (real_t)(maxnvtxs)/((real_t)(graph->gnvtxs)/(real_t)(npes));
rprintf(ctrl, "XYZ Cut: %6"PRIDX" \tBalance: %6.3"PRREAL" [%"PRIDX" %"PRIDX" %"PRIDX"]\n",
gcut, balance, maxnvtxs, graph->gnvtxs, npes);
}
STOPTIMER(ctrl, ctrl->MoveTmr);
/* Compute the partition of the moved graph */
STARTTIMER(ctrl, ctrl->TotalTmr);
ctrl->CoarsenTo = gk_min(vtxdist[npes]+1, 25*(*ncon)*gk_max(npes, *nparts));
if (vtxdist[npes] < SMALLGRAPH
|| vtxdist[npes] < npes*20
|| GlobalSESum(ctrl, mgraph->nedges) == 0) { /* serially */
IFSET(ctrl->dbglvl, DBG_INFO,
rprintf(ctrl, "Partitioning a graph of size %"PRIDX" serially\n", vtxdist[npes]));
PartitionSmallGraph(ctrl, mgraph);
}
else { /* in parallel */
Global_Partition(ctrl, mgraph);
}
ParallelReMapGraph(ctrl, mgraph);
/* Invert the ordering back to the original graph */
ctrl->nparts = npes;
ProjectInfoBack(ctrl, graph, part, mgraph->where);
ctrl->nparts = *nparts;
*edgecut = mgraph->mincut;
STOPTIMER(ctrl, ctrl->TotalTmr);
/* Print some stats */
IFSET(ctrl->dbglvl, DBG_TIME, PrintTimingInfo(ctrl));
IFSET(ctrl->dbglvl, DBG_TIME, gkMPI_Barrier(ctrl->gcomm));
IFSET(ctrl->dbglvl, DBG_INFO, PrintPostPartInfo(ctrl, mgraph, 0));
FreeGraph(mgraph);
FreeInitialGraphAndRemap(graph);
if (*numflag > 0)
ChangeNumbering(vtxdist, xadj, adjncy, part, npes, mype, 0);
DONE:
FreeCtrl(&ctrl);
if (gk_GetCurMemoryUsed() - curmem > 0) {
printf("ParMETIS appears to have a memory leak of %zdbytes. Report this.\n",
(ssize_t)(gk_GetCurMemoryUsed() - curmem));
}
gk_malloc_cleanup(0);
return (int)status;
}
/***********************************************************************************
* This function is the entry point of the parallel ordering algorithm.
* This function assumes that the graph is already nice partitioned among the
* processors and then proceeds to perform recursive bisection.
************************************************************************************/
int ParMETIS_V3_PartGeom(idx_t *vtxdist, idx_t *ndims, real_t *xyz, idx_t *part,
MPI_Comm *comm)
{
idx_t i, nvtxs, firstvtx, npes, mype, status;
idx_t *xadj, *adjncy;
ctrl_t *ctrl=NULL;
graph_t *graph=NULL;
size_t curmem;
/* Check the input parameters and return if an error */
status = CheckInputsPartGeom(vtxdist, ndims, xyz, part, comm);
if (GlobalSEMinComm(*comm, status) == 0)
return METIS_ERROR;
status = METIS_OK;
gk_malloc_init();
curmem = gk_GetCurMemoryUsed();
/* Setup the ctrl */
ctrl = SetupCtrl(PARMETIS_OP_GMETIS, NULL, 1, 1, NULL, NULL, *comm);
/*ctrl->dbglvl=15;*/
npes = ctrl->npes;
mype = ctrl->mype;
/* Trivial case when npes == 1 */
if (npes == 1) {
iset(vtxdist[mype+1]-vtxdist[mype], 0, part);
goto DONE;
}
/* Setup a fake graph to allow the rest of the code to work unchanged */
nvtxs = vtxdist[mype+1]-vtxdist[mype];
firstvtx = vtxdist[mype];
xadj = imalloc(nvtxs+1, "ParMETIS_PartGeom: xadj");
adjncy = imalloc(nvtxs, "ParMETIS_PartGeom: adjncy");
for (i=0; i<nvtxs; i++) {
xadj[i] = i;
adjncy[i] = firstvtx + (i+1)%nvtxs;
}
xadj[nvtxs] = nvtxs;
graph = SetupGraph(ctrl, 1, vtxdist, xadj, NULL, NULL, adjncy, NULL, 0);
/* Allocate workspace memory */
AllocateWSpace(ctrl, 5*graph->nvtxs);
/* Compute the initial geometric partitioning */
STARTTIMER(ctrl, ctrl->TotalTmr);
Coordinate_Partition(ctrl, graph, *ndims, xyz, 0);
icopy(graph->nvtxs, graph->where, part);
STOPTIMER(ctrl, ctrl->TotalTmr);
IFSET(ctrl->dbglvl, DBG_TIME, PrintTimingInfo(ctrl));
gk_free((void **)&xadj, (void **)&adjncy, LTERM);
FreeInitialGraphAndRemap(graph);
DONE:
FreeCtrl(&ctrl);
if (gk_GetCurMemoryUsed() - curmem > 0) {
printf("ParMETIS appears to have a memory leak of %zdbytes. Report this.\n",
(ssize_t)(gk_GetCurMemoryUsed() - curmem));
}
gk_malloc_cleanup(0);
return (int)status;
}
/**************************************************************************
* mexFunction: gateway routine for MATLAB interface.
***************************************************************************/
void mexFunction
(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
// Argument checking
if (nrhs != 5)
mexErrMsgIdAndTxt(FUNC_NAME, "Wrong input.");
if (nlhs != 3)
mexErrMsgIdAndTxt(FUNC_NAME, "Wrong output.");
// Input and output variables
idx_t nvtxs = (idx_t) mxGetScalar(nvtxs_in);
idx_t *xadj; GetIdxArray(xadj_in,&xadj);
idx_t *adjncy; GetIdxArray(adjncy_in,&adjncy);
idx_t *vwgt; GetIdxArray(vwgt_in,&vwgt);
idx_t options[METIS_NOPTIONS];
GetOptions(options_in, options);
idx_t *sepidx;
idx_t *lgraphidx;
idx_t *rgraphidx;
// Metis main function
idx_t i, nnvtxs=0;
idx_t ptlgraph, ptrgraph, ptsep;
graph_t *graph=NULL;
ctrl_t *ctrl;
idx_t *piperm;
idx_t snvtxs[3];
idx_t *where;
/* set up malloc cleaning code and signal catchers */
if (!gk_malloc_init())
CheckReturn( METIS_ERROR_MEMORY, FUNC_NAME );
// set up the run time parameters
ctrl = SetupCtrl(METIS_OP_OMETIS, options, 1, 3, NULL, NULL);
// prune the dense columns
if (ctrl->pfactor > 0.0)
{
piperm = imalloc(nvtxs, "OMETIS: piperm");
graph = PruneGraph(ctrl, nvtxs, xadj, adjncy, vwgt,
piperm, ctrl->pfactor);
if (graph == NULL)
{
// if there was no prunning, cleanup the pfactor
gk_free((void **)&piperm, LTERM);
ctrl->pfactor = 0.0;
}
else
{
nnvtxs = graph->nvtxs;
// disable compression if prunning took place
ctrl->compress = 0;
}
}
// compress the graph
if (ctrl->compress)
ctrl->compress = 0;
// if no prunning and no compression, setup the graph in the normal way.
if (ctrl->pfactor == 0.0 && ctrl->compress == 0)
graph = SetupGraph(ctrl, nvtxs, 1, xadj, adjncy, vwgt, NULL, NULL);
ASSERT(CheckGraph(graph, ctrl->numflag, 1));
/* allocate workspace memory */
AllocateWorkSpace(ctrl, graph);
MlevelNodeBisectionMultiple(ctrl, graph);
snvtxs[0] = 0;
snvtxs[1] = 0;
snvtxs[2] = 0;
if (ctrl->pfactor > 0.0)
snvtxs[2] += nvtxs-nnvtxs;
where = graph->where;
for (i=0; i<graph->nvtxs; i++)
snvtxs[where[i]]++;
lgraphidx = (idx_t*) mxCalloc (snvtxs[0], sizeof(idx_t));
rgraphidx = (idx_t*) mxCalloc (snvtxs[1], sizeof(idx_t));
sepidx = (idx_t*) mxCalloc (snvtxs[2], sizeof(idx_t));
ptlgraph = 0;
ptrgraph = 0;
ptsep = 0;
if (ctrl->pfactor > 0.0)
{
for (i=0; i<graph->nvtxs; i++)
if (where[i] == 0)
lgraphidx[ptlgraph++] = piperm[i];
else if (where[i] == 1)
rgraphidx[ptrgraph++] = piperm[i];
else
sepidx[ptsep++] = piperm[i];
for (i=nnvtxs; i<nvtxs; i++)
sepidx[ptsep++] = piperm[i];
gk_free((void **)&piperm, LTERM);
}
else
{
for (i=0; i<graph->nvtxs; i++)
if (where[i] == 0)
lgraphidx[ptlgraph++] = i;
else if (where[i] == 1)
rgraphidx[ptrgraph++] = i;
else
sepidx[ptsep++] = i;
}
/* clean up */
FreeCtrl(&ctrl);
// Output
lgraphidx_out = mxCreateDoubleMatrix(1,ptlgraph,mxREAL);
mxSetData(lgraphidx_out,mxMalloc(sizeof(double)*ptlgraph));
double *lgraphidx_out_pr = mxGetPr(lgraphidx_out);
for(idx_t i=0; i<ptlgraph; i++)
lgraphidx_out_pr[i] = (double) lgraphidx[i];
rgraphidx_out = mxCreateDoubleMatrix(1,ptrgraph,mxREAL);
mxSetData(rgraphidx_out,mxMalloc(sizeof(double)*ptrgraph));
double *rgraphidx_out_pr = mxGetPr(rgraphidx_out);
for(idx_t i=0; i<ptrgraph; i++)
rgraphidx_out_pr[i] = (double) rgraphidx[i];
sepidx_out = mxCreateDoubleMatrix(1,ptsep,mxREAL);
mxSetData(sepidx_out,mxMalloc(sizeof(double)*ptsep));
double *sepidx_out_pr = mxGetPr(sepidx_out);
for(idx_t i=0; i<ptsep; i++)
sepidx_out_pr[i] = (double) sepidx[i];
}
/***********************************************************************************
* This function is the entry point of the serial ordering algorithm.
************************************************************************************/
int ParMETIS_SerialNodeND(idx_t *vtxdist, idx_t *xadj, idx_t *adjncy,
idx_t *numflag, idx_t *options, idx_t *order, idx_t *sizes,
MPI_Comm *comm)
{
idx_t i, npes, mype;
ctrl_t *ctrl=NULL;
graph_t *agraph=NULL;
idx_t *perm=NULL, *iperm=NULL;
idx_t *sendcount, *displs;
/* Setup the ctrl */
ctrl = SetupCtrl(PARMETIS_OP_OMETIS, options, 1, 1, NULL, NULL, *comm);
npes = ctrl->npes;
mype = ctrl->mype;
if (!ispow2(npes)) {
if (mype == 0)
printf("Error: The number of processors must be a power of 2!\n");
FreeCtrl(&ctrl);
return METIS_ERROR;
}
if (*numflag > 0)
ChangeNumbering(vtxdist, xadj, adjncy, order, npes, mype, 1);
STARTTIMER(ctrl, ctrl->TotalTmr);
STARTTIMER(ctrl, ctrl->MoveTmr);
agraph = AssembleEntireGraph(ctrl, vtxdist, xadj, adjncy);
STOPTIMER(ctrl, ctrl->MoveTmr);
if (mype == 0) {
perm = imalloc(agraph->nvtxs, "PAROMETISS: perm");
iperm = imalloc(agraph->nvtxs, "PAROMETISS: iperm");
METIS_NodeNDP(agraph->nvtxs, agraph->xadj, agraph->adjncy,
agraph->vwgt, npes, NULL, perm, iperm, sizes);
}
STARTTIMER(ctrl, ctrl->MoveTmr);
/* Broadcast the sizes array */
gkMPI_Bcast((void *)sizes, 2*npes, IDX_T, 0, ctrl->gcomm);
/* Scatter the iperm */
sendcount = imalloc(npes, "PAROMETISS: sendcount");
displs = imalloc(npes, "PAROMETISS: displs");
for (i=0; i<npes; i++) {
sendcount[i] = vtxdist[i+1]-vtxdist[i];
displs[i] = vtxdist[i];
}
gkMPI_Scatterv((void *)iperm, sendcount, displs, IDX_T, (void *)order,
vtxdist[mype+1]-vtxdist[mype], IDX_T, 0, ctrl->gcomm);
STOPTIMER(ctrl, ctrl->MoveTmr);
STOPTIMER(ctrl, ctrl->TotalTmr);
IFSET(ctrl->dbglvl, DBG_TIME, PrintTimingInfo(ctrl));
IFSET(ctrl->dbglvl, DBG_TIME, gkMPI_Barrier(ctrl->gcomm));
gk_free((void **)&agraph->xadj, &agraph->adjncy, &perm, &iperm,
&sendcount, &displs, &agraph, LTERM);
if (*numflag > 0)
ChangeNumbering(vtxdist, xadj, adjncy, order, npes, mype, 0);
goto DONE;
DONE:
FreeCtrl(&ctrl);
return METIS_OK;
}