OSStatus CAPlayThrough::Init(AudioDeviceID input, AudioDeviceID output)
{
OSStatus err = noErr;
//Note: You can interface to input and output devices with "output" audio units.
//Please keep in mind that you are only allowed to have one output audio unit per graph (AUGraph).
//As you will see, this sample code splits up the two output units. The "output" unit that will
//be used for device input will not be contained in a AUGraph, while the "output" unit that will
//interface the default output device will be in a graph.
//Setup AUHAL for an input device
err = SetupAUHAL(input);
checkErr(err);
//Setup Graph containing Varispeed Unit & Default Output Unit
err = SetupGraph(output);
checkErr(err);
err = SetupBuffers();
checkErr(err);
// the varispeed unit should only be conected after the input and output formats have been set
err = AUGraphConnectNodeInput(mGraph, mVarispeedNode, 0, mOutputNode, 0);
checkErr(err);
err = AUGraphInitialize(mGraph);
checkErr(err);
//Add latency between the two devices
ComputeThruOffset();
return err;
}
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);
}
/***********************************************************************************
* 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 sets up a graph data structure for partitioning
*****************************************************************************/
graph_t *TestSetUpGraph(ctrl_t *ctrl, idx_t *vtxdist, idx_t *xadj,
idx_t *vwgt, idx_t *adjncy, idx_t *adjwgt, idx_t wgtflag)
{
return SetupGraph(ctrl, 1, vtxdist, xadj, vwgt, NULL, adjncy, adjwgt, wgtflag);
}
int main( int argc, char *argv[])
{
double (* f)();
void *MsgCtx = 0; /* This is the context of the message-passing operation */
void *outctx;
int reps,len,error_flag;
double t;
int first,last,incr, svals[3];
char units[32]; /* Name of units of length */
MPI_Init( &argc, &argv );
MPI_Comm_size( MPI_COMM_WORLD, &__NUMNODES );
MPI_Comm_rank( MPI_COMM_WORLD, &__MYPROCID );
;
strcpy( units, "" );
if (SYArgHasName( &argc, argv, 1, "-help" )) {
return PrintHelp( argv );
}
if (__NUMNODES < 2) {
fprintf( stderr, "Must run goptest with at least 2 nodes\n" );
return 1;
}
/* Get the output context */
outctx = SetupGraph( &argc, argv );
if (SYArgHasName( &argc, argv, 1, "-noinfo" )) doinfo = 0;
if (SYArgHasName( &argc, argv, 1, "-nohead" )) doheader = 0;
if (SYArgHasName( &argc, argv, 1, "-notail" )) dotail = 0;
reps = DEFAULT_REPS;
error_flag = 0;
if (SYArgHasName( &argc, argv, 0, "-sync") ) {
svals[0] = svals[1] = svals[2] = 0;
}
else {
/* We use fewer values because we are generating them on the same line. */
svals[0] = 0;
svals[1] = 1024;
svals[2] = 256;
}
SYArgGetIntVec( &argc, argv, 1, "-size", 3, svals );
nsizes = SYArgGetIntList( &argc, argv, 1, "-sizelist", MAX_SIZE_LIST,
sizelist );
/* We ALWAYS use sizelist */
if (nsizes == 0) {
/* Generate the size list from the svals list */
sizelist[0] = svals[0];
for (nsizes=1; sizelist[nsizes-1] < svals[1] && nsizes<MAX_SIZE_LIST;
nsizes++) {
sizelist[nsizes] = sizelist[nsizes-1] + svals[2];
}
if (sizelist[nsizes] > svals[1]) nsizes--;
}
SYArgGetInt( &argc, argv, 1, "-reps", &reps );
if (SYArgHasName( &argc, argv, 1, "-autoreps" )) AutoReps = 1;
if (SYArgGetDouble( &argc, argv, 1, "-tgoal", &Tgoal )) {
AutoReps = 1;
if (TgoalMin > 0.1 * Tgoal) TgoalMin = 0.1 * Tgoal;
}
SYArgGetDouble( &argc, argv, 1, "-rthresh", &repsThresh );
f = GetGOPFunction( &argc, argv, test_name, units );
MsgCtx = GOPInit( &argc, argv );
first = svals[0];
last = svals[1];
incr = svals[2];
if (incr == 0) incr = 1;
/*
Finally, we are ready to run the tests. We want to report times as
the times for a single link, and rates as the aggregate rate.
To do this, we need to know how to scale both the times and the rates.
Times: scaled by the number of one-way trips measured by the base testing
code. This is often 2 trips, or a scaling of 1/2.
Rates: scaled by the number of simultaneous participants (as well as
the scaling in times). Compute the rates based on the updated time,
then multiply by the number of participants. Note that, for a single
sender, time and rate are inversely proportional (that is, if TimeScale
is 0.5, RateScale is 2.0).
*/
if (doinfo && doheader &&__MYPROCID == 0) {
HeaderForGopGraph( outctx, test_name, (char *)0, units );
}
time_function(reps,first,last,incr,f,outctx,MsgCtx);
/*
Generate the "end of page". This allows multiple graphs on the
same plot
*/
if (doinfo && dotail && __MYPROCID == 0)
EndPageGraph( outctx );
MPI_Finalize();
return 0;
}
/***********************************************************************************
* 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];
}
