int CHOLMOD(metis)
(
/* ---- input ---- */
cholmod_sparse *A, /* matrix to order */
Int *fset, /* subset of 0:(A->ncol)-1 */
size_t fsize, /* size of fset */
int postorder, /* if TRUE, follow with etree or coletree postorder */
/* ---- output --- */
Int *Perm, /* size A->nrow, output permutation */
/* --------------- */
cholmod_common *Common
)
{
double d ;
Int *Iperm, *Iwork, *Bp, *Bi ;
idxtype *Mp, *Mi, *Mperm, *Miperm ;
cholmod_sparse *B ;
Int i, j, n, nz, p, identity, uncol ;
int Opt [8], nn, zero = 0 ;
size_t n1, s ;
int ok = TRUE ;
/* ---------------------------------------------------------------------- */
/* get inputs */
/* ---------------------------------------------------------------------- */
RETURN_IF_NULL_COMMON (FALSE) ;
RETURN_IF_NULL (A, FALSE) ;
RETURN_IF_NULL (Perm, FALSE) ;
RETURN_IF_XTYPE_INVALID (A, CHOLMOD_PATTERN, CHOLMOD_ZOMPLEX, FALSE) ;
Common->status = CHOLMOD_OK ;
/* ---------------------------------------------------------------------- */
/* quick return */
/* ---------------------------------------------------------------------- */
n = A->nrow ;
if (n == 0)
{
return (TRUE) ;
}
n1 = ((size_t) n) + 1 ;
/* ---------------------------------------------------------------------- */
/* allocate workspace */
/* ---------------------------------------------------------------------- */
/* s = 4*n + uncol */
uncol = (A->stype == 0) ? A->ncol : 0 ;
s = CHOLMOD(mult_size_t) (n, 4, &ok) ;
s = CHOLMOD(add_size_t) (s, uncol, &ok) ;
if (!ok)
{
ERROR (CHOLMOD_TOO_LARGE, "problem too large") ;
return (FALSE) ;
}
CHOLMOD(allocate_work) (n, s, 0, Common) ;
if (Common->status < CHOLMOD_OK)
{
return (FALSE) ;
}
ASSERT (CHOLMOD(dump_work) (TRUE, TRUE, 0, Common)) ;
/* ---------------------------------------------------------------------- */
/* convert the matrix to adjacency list form */
/* ---------------------------------------------------------------------- */
/* The input graph for METIS must be symmetric, with both upper and lower
* parts present, and with no diagonal entries. The columns need not be
* sorted.
* B = A+A', A*A', or A(:,f)*A(:,f)', upper and lower parts present */
if (A->stype)
{
/* Add the upper/lower part to a symmetric lower/upper matrix by
* converting to unsymmetric mode */
/* workspace: Iwork (nrow) */
B = CHOLMOD(copy) (A, 0, -1, Common) ;
}
else
{
/* B = A*A' or A(:,f)*A(:,f)', no diagonal */
/* workspace: Flag (nrow), Iwork (max (nrow,ncol)) */
B = CHOLMOD(aat) (A, fset, fsize, -1, Common) ;
}
ASSERT (CHOLMOD(dump_sparse) (B, "B for NodeND", Common) >= 0) ;
if (Common->status < CHOLMOD_OK)
{
return (FALSE) ;
}
ASSERT (B->nrow == A->nrow) ;
/* ---------------------------------------------------------------------- */
/* get inputs */
/* ---------------------------------------------------------------------- */
Iwork = Common->Iwork ;
Iperm = Iwork ; /* size n (i/i/l) */
Bp = B->p ;
Bi = B->i ;
nz = Bp [n] ;
/* ---------------------------------------------------------------------- */
/* METIS does not have a SuiteSparse_long integer version */
/* ---------------------------------------------------------------------- */
#ifdef LONG
if (sizeof (Int) > sizeof (idxtype) && MAX (n,nz) > INT_MAX / sizeof (int))
{
/* CHOLMOD's matrix is too large for METIS */
CHOLMOD(free_sparse) (&B, Common) ;
return (FALSE) ;
}
#endif
/* B does not include the diagonal, and both upper and lower parts.
* Common->anz includes the diagonal, and just the lower part of B */
Common->anz = nz / 2 + n ;
/* ---------------------------------------------------------------------- */
/* set control parameters for METIS_NodeND */
/* ---------------------------------------------------------------------- */
Opt [0] = 0 ; /* use defaults */
Opt [1] = 3 ; /* matching type */
Opt [2] = 1 ; /* init. partitioning algo*/
Opt [3] = 2 ; /* refinement algorithm */
Opt [4] = 0 ; /* no debug */
Opt [5] = 1 ; /* initial compression */
Opt [6] = 0 ; /* no dense node removal */
Opt [7] = 1 ; /* number of separators @ each step */
/* ---------------------------------------------------------------------- */
/* allocate the METIS input arrays, if needed */
/* ---------------------------------------------------------------------- */
if (sizeof (Int) == sizeof (idxtype))
{
/* This is the typical case. */
Miperm = (idxtype *) Iperm ;
Mperm = (idxtype *) Perm ;
Mp = (idxtype *) Bp ;
Mi = (idxtype *) Bi ;
}
else
{
/* allocate graph for METIS only if Int and idxtype differ */
Miperm = CHOLMOD(malloc) (n, sizeof (idxtype), Common) ;
Mperm = CHOLMOD(malloc) (n, sizeof (idxtype), Common) ;
Mp = CHOLMOD(malloc) (n1, sizeof (idxtype), Common) ;
Mi = CHOLMOD(malloc) (nz, sizeof (idxtype), Common) ;
if (Common->status < CHOLMOD_OK)
{
/* out of memory */
CHOLMOD(free_sparse) (&B, Common) ;
CHOLMOD(free) (n, sizeof (idxtype), Miperm, Common) ;
CHOLMOD(free) (n, sizeof (idxtype), Mperm, Common) ;
CHOLMOD(free) (n1, sizeof (idxtype), Mp, Common) ;
CHOLMOD(free) (nz, sizeof (idxtype), Mi, Common) ;
return (FALSE) ;
}
for (j = 0 ; j <= n ; j++)
{
Mp [j] = Bp [j] ;
}
for (p = 0 ; p < nz ; p++)
{
Mi [p] = Bi [p] ;
}
}
/* ---------------------------------------------------------------------- */
/* METIS workarounds */
/* ---------------------------------------------------------------------- */
identity = FALSE ;
if (nz == 0)
{
/* The matrix has no off-diagonal entries. METIS_NodeND fails in this
* case, so avoid using it. The best permutation is identity anyway,
* so this is an easy fix. */
identity = TRUE ;
PRINT1 (("METIS:: no nz\n")) ;
}
else if (Common->metis_nswitch > 0)
{
/* METIS_NodeND in METIS 4.0.1 gives a seg fault with one matrix of
* order n = 3005 and nz = 6,036,025, including the diagonal entries.
* The workaround is to return the identity permutation instead of using
* METIS for matrices of dimension 3000 or more and with density of 66%
* or more - admittedly an uncertain fix, but such matrices are so dense
* that any reasonable ordering will do, even identity (n^2 is only 50%
* higher than nz in this case). CHOLMOD's nested dissection method
* (cholmod_nested_dissection) has no problems with the same matrix,
* even though it too uses METIS_NodeComputeSeparator. The matrix is
* derived from LPnetlib/lpi_cplex1 in the UF sparse matrix collection.
* If C is the lpi_cplex matrix (of order 3005-by-5224), A = (C*C')^2
* results in the seg fault. The seg fault also occurs in the stand-
* alone onmetis program that comes with METIS. If a future version of
* METIS fixes this problem, then set Common->metis_nswitch to zero.
*/
d = ((double) nz) / (((double) n) * ((double) n)) ;
if (n > (Int) (Common->metis_nswitch) && d > Common->metis_dswitch)
{
identity = TRUE ;
PRINT1 (("METIS:: nswitch/dswitch activated\n")) ;
}
}
if (!identity && !metis_memory_ok (n, nz, Common))
{
/* METIS might ask for too much memory and thus terminate the program */
identity = TRUE ;
}
/* ---------------------------------------------------------------------- */
/* find the permutation */
/* ---------------------------------------------------------------------- */
if (identity)
{
/* no need to do the postorder */
postorder = FALSE ;
for (i = 0 ; i < n ; i++)
{
Mperm [i] = i ;
}
}
else
{
#ifdef DUMP_GRAPH
/* DUMP_GRAPH */ printf ("Calling METIS_NodeND n "ID" nz "ID""
"density %g\n", n, nz, ((double) nz) / (((double) n) * ((double) n)));
dumpgraph (Mp, Mi, n, Common) ;
#endif
nn = n ;
METIS_NodeND (&nn, Mp, Mi, &zero, Opt, Mperm, Miperm) ;
n = nn ;
PRINT0 (("METIS_NodeND done\n")) ;
}
/* ---------------------------------------------------------------------- */
/* free the METIS input arrays */
/* ---------------------------------------------------------------------- */
if (sizeof (Int) != sizeof (idxtype))
{
for (i = 0 ; i < n ; i++)
{
Perm [i] = (Int) (Mperm [i]) ;
}
CHOLMOD(free) (n, sizeof (idxtype), Miperm, Common) ;
CHOLMOD(free) (n, sizeof (idxtype), Mperm, Common) ;
CHOLMOD(free) (n+1, sizeof (idxtype), Mp, Common) ;
CHOLMOD(free) (nz, sizeof (idxtype), Mi, Common) ;
}
CHOLMOD(free_sparse) (&B, Common) ;
/* ---------------------------------------------------------------------- */
/* etree or column-etree postordering, using the Cholesky Module */
/* ---------------------------------------------------------------------- */
if (postorder)
{
Int *Parent, *Post, *NewPerm ;
Int k ;
Parent = Iwork + 2*((size_t) n) + uncol ; /* size n = nrow */
Post = Parent + n ; /* size n */
/* workspace: Iwork (2*nrow+uncol), Flag (nrow), Head (nrow+1) */
CHOLMOD(analyze_ordering) (A, CHOLMOD_METIS, Perm, fset, fsize,
Parent, Post, NULL, NULL, NULL, Common) ;
if (Common->status == CHOLMOD_OK)
{
/* combine the METIS permutation with its postordering */
NewPerm = Parent ; /* use Parent as workspace */
for (k = 0 ; k < n ; k++)
{
NewPerm [k] = Perm [Post [k]] ;
}
for (k = 0 ; k < n ; k++)
{
Perm [k] = NewPerm [k] ;
}
}
}
ASSERT (CHOLMOD(dump_work) (TRUE, TRUE, 0, Common)) ;
PRINT1 (("cholmod_metis done\n")) ;
return (Common->status == CHOLMOD_OK) ;
}
/* transform the graph to a shortest-path tree by marking tree edges */
void
mapit()
{ register p_node n;
register p_link l;
p_link lparent;
static int firsttime = 0;
vprintf(stderr, "*** mapping\n");
Tflag = Tflag && Vflag; /* tracing here only if verbose */
/* re-use the hash table space for the heap */
Heap = (p_link *) Table;
Hashpart = pack(0L, Tabsize - 1);
/* expunge penalties from -a option and make circular copy lists */
resetnodes();
if (firsttime++) {
if (Linkout && *Linkout) /* dump cheapest links */
showlinks();
if (Graphout && *Graphout) /* dump the edge list */
dumpgraph();
}
/* insert Home to get things started */
l = newlink(); /* link to get things started */
getlink(l)->l_to = Home;
(void) dehash(Home);
insert(l);
/* main mapping loop */
remap:
Heaphighwater = Nheap;
while ((lparent = min_node()) != 0) {
chkheap(1);
getlink(lparent)->l_flag |= LTREE;
n = getlink(lparent)->l_to;
if (Tflag && maptrace(n, n))
fprintf(stderr, "%s -> %s mapped\n",
getnode(getnode(n)->n_parent)->n_name,
getnode(n)->n_name);
if (getnode(n)->n_flag & MAPPED)
die("mapped node in heap");
getnode(n)->n_flag |= MAPPED;
/* add children to heap */
heapchildren(n);
}
vprintf(stderr, "heap high water mark was %ld\n", Heaphighwater);
/* sanity check on implementation */
if (Nheap != 0)
die("null entry in heap");
if (Hashpart < Tabsize) {
/*
* add back links from unreachable hosts to
* reachable neighbors, then remap.
*
* asymptotically, this is quadratic; in
* practice, this is done once or twice.
*/
backlinks();
if (Nheap)
goto remap;
}
if (Hashpart < Tabsize) {
fputs("You can't get there from here:\n", stderr);
for ( ; Hashpart < Tabsize; Hashpart++) {
fprintf(stderr, "\t%s", getnode(Table[Hashpart])->n_name);
if (getnode(Table[Hashpart])->n_flag & ISPRIVATE)
fputs(" (private)", stderr);
putc('\n', stderr);
}
}
}
