/*--------------------------------------------------------------------*/
int
main ( int argc, char *argv[] )
/*
--------------------------------------------------------------------
this program tests the Graph_MPI_Bcast() method
(1) process root generates a random Graph object
and computes its checksum
(2) process root broadcasts the Graph object to the other processors
(3) each process computes the checksum of its Graph object
(4) the checksums are compared on root
created -- 98sep10, cca
--------------------------------------------------------------------
*/
{
char *buffer ;
double chksum, t1, t2 ;
double *sums ;
Drand drand ;
int iproc, length, loc, msglvl, myid, nitem, nproc,
nvtx, root, seed, size, type, v ;
int *list ;
FILE *msgFile ;
Graph *graph ;
/*
---------------------------------------------------------------
find out the identity of this process and the number of process
---------------------------------------------------------------
*/
MPI_Init(&argc, &argv) ;
MPI_Comm_rank(MPI_COMM_WORLD, &myid) ;
MPI_Comm_size(MPI_COMM_WORLD, &nproc) ;
fprintf(stdout, "\n process %d of %d, argc = %d", myid, nproc, argc) ;
fflush(stdout) ;
if ( argc != 8 ) {
fprintf(stdout,
"\n\n usage : %s msglvl msgFile type nvtx nitem root seed "
"\n msglvl -- message level"
"\n msgFile -- message file"
"\n type -- type of graph"
"\n nvtx -- # of vertices"
"\n nitem -- # of items used to generate graph"
"\n root -- root processor for broadcast"
"\n seed -- random number seed"
"\n", argv[0]) ;
return(0) ;
}
msglvl = atoi(argv[1]) ;
if ( strcmp(argv[2], "stdout") == 0 ) {
msgFile = stdout ;
} else {
length = strlen(argv[2]) + 1 + 4 ;
buffer = CVinit(length, '\0') ;
sprintf(buffer, "%s.%d", argv[2], myid) ;
if ( (msgFile = fopen(buffer, "w")) == NULL ) {
fprintf(stderr, "\n fatal error in %s"
"\n unable to open file %s\n",
argv[0], argv[2]) ;
return(-1) ;
}
CVfree(buffer) ;
}
type = atoi(argv[3]) ;
nvtx = atoi(argv[4]) ;
nitem = atoi(argv[5]) ;
root = atoi(argv[6]) ;
seed = atoi(argv[7]) ;
fprintf(msgFile,
"\n %s "
"\n msglvl -- %d"
"\n msgFile -- %s"
"\n type -- %d"
"\n nvtx -- %d"
"\n nitem -- %d"
"\n root -- %d"
"\n seed -- %d"
"\n",
argv[0], msglvl, argv[2], type, nvtx, nitem, root, seed) ;
fflush(msgFile) ;
/*
-----------------------
set up the Graph object
-----------------------
*/
MARKTIME(t1) ;
graph = Graph_new() ;
if ( myid == root ) {
InpMtx *inpmtx ;
int nedges, totewght, totvwght, v ;
int *adj, *vwghts ;
IVL *adjIVL, *ewghtIVL ;
/*
-----------------------
generate a random graph
-----------------------
*/
inpmtx = InpMtx_new() ;
InpMtx_init(inpmtx, INPMTX_BY_ROWS, INPMTX_INDICES_ONLY, nitem, 0) ;
Drand_setDefaultFields(&drand) ;
Drand_setSeed(&drand, seed) ;
Drand_setUniform(&drand, 0, nvtx) ;
Drand_fillIvector(&drand, nitem, InpMtx_ivec1(inpmtx)) ;
Drand_fillIvector(&drand, nitem, InpMtx_ivec2(inpmtx)) ;
InpMtx_setNent(inpmtx, nitem) ;
InpMtx_changeStorageMode(inpmtx, INPMTX_BY_VECTORS) ;
if ( msglvl > 2 ) {
fprintf(msgFile, "\n\n inpmtx mtx filled with raw entries") ;
InpMtx_writeForHumanEye(inpmtx, msgFile) ;
fflush(msgFile) ;
}
adjIVL = InpMtx_fullAdjacency(inpmtx) ;
if ( msglvl > 2 ) {
fprintf(msgFile, "\n\n full adjacency structure") ;
IVL_writeForHumanEye(adjIVL, msgFile) ;
fflush(msgFile) ;
}
nedges = adjIVL->tsize ;
if ( type == 1 || type == 3 ) {
Drand_setUniform(&drand, 1, 10) ;
vwghts = IVinit(nvtx, 0) ;
Drand_fillIvector(&drand, nvtx, vwghts) ;
totvwght = IVsum(nvtx, vwghts) ;
if ( msglvl > 2 ) {
fprintf(msgFile, "\n\n vertex weights") ;
IVfprintf(msgFile, nvtx, vwghts) ;
fflush(msgFile) ;
}
} else {
vwghts = NULL ;
totvwght = nvtx ;
}
if ( msglvl > 2 ) {
fprintf(msgFile, "\n\n totvwght %d", totvwght) ;
fflush(msgFile) ;
}
if ( type == 2 || type == 3 ) {
ewghtIVL = IVL_new() ;
IVL_init1(ewghtIVL, IVL_CHUNKED, nvtx) ;
Drand_setUniform(&drand, 1, 100) ;
totewght = 0 ;
for ( v = 0 ; v < nvtx ; v++ ) {
IVL_listAndSize(adjIVL, v, &size, &adj) ;
IVL_setList(ewghtIVL, v, size, NULL) ;
IVL_listAndSize(ewghtIVL, v, &size, &adj) ;
Drand_fillIvector(&drand, size, adj) ;
totewght += IVsum(size, adj) ;
}
if ( msglvl > 2 ) {
fprintf(msgFile, "\n\n ewghtIVL") ;
IVL_writeForHumanEye(ewghtIVL, msgFile) ;
fflush(msgFile) ;
}
} else {
ewghtIVL = NULL ;
totewght = nedges ;
}
if ( msglvl > 2 ) {
fprintf(msgFile, "\n\n totewght %d", totewght) ;
fflush(msgFile) ;
}
Graph_init2(graph, type, nvtx, 0, nedges, totvwght, totewght,
adjIVL, vwghts, ewghtIVL) ;
InpMtx_free(inpmtx) ;
}
MARKTIME(t2) ;
fprintf(msgFile,
"\n CPU %8.3f : initialize the Graph object", t2 - t1) ;
fflush(msgFile) ;
if ( msglvl > 2 ) {
Graph_writeForHumanEye(graph, msgFile) ;
} else {
Graph_writeStats(graph, msgFile) ;
}
fflush(msgFile) ;
if ( myid == root ) {
/*
----------------------------------------
compute the checksum of the Graph object
----------------------------------------
*/
chksum = graph->type + graph->nvtx + graph->nvbnd
+ graph->nedges + graph->totvwght + graph->totewght ;
for ( v = 0 ; v < nvtx ; v++ ) {
IVL_listAndSize(graph->adjIVL, v, &size, &list) ;
chksum += 1 + v + size + IVsum(size, list) ;
}
if ( graph->vwghts != NULL ) {
chksum += IVsum(nvtx, graph->vwghts) ;
}
if ( graph->ewghtIVL != NULL ) {
for ( v = 0 ; v < nvtx ; v++ ) {
IVL_listAndSize(graph->ewghtIVL, v, &size, &list) ;
chksum += 1 + v + size + IVsum(size, list) ;
}
}
fprintf(msgFile, "\n\n local chksum = %12.4e", chksum) ;
fflush(msgFile) ;
}
/*
--------------------------
broadcast the Graph object
--------------------------
*/
MARKTIME(t1) ;
graph = Graph_MPI_Bcast(graph, root, msglvl, msgFile, MPI_COMM_WORLD) ;
MARKTIME(t2) ;
fprintf(msgFile, "\n CPU %8.3f : broadcast the Graph object", t2 - t1) ;
if ( msglvl > 2 ) {
Graph_writeForHumanEye(graph, msgFile) ;
} else {
Graph_writeStats(graph, msgFile) ;
}
/*
----------------------------------------
compute the checksum of the Graph object
----------------------------------------
*/
chksum = graph->type + graph->nvtx + graph->nvbnd
+ graph->nedges + graph->totvwght + graph->totewght ;
for ( v = 0 ; v < nvtx ; v++ ) {
IVL_listAndSize(graph->adjIVL, v, &size, &list) ;
chksum += 1 + v + size + IVsum(size, list) ;
}
if ( graph->vwghts != NULL ) {
chksum += IVsum(nvtx, graph->vwghts) ;
}
if ( graph->ewghtIVL != NULL ) {
for ( v = 0 ; v < nvtx ; v++ ) {
IVL_listAndSize(graph->ewghtIVL, v, &size, &list) ;
chksum += 1 + v + size + IVsum(size, list) ;
}
}
fprintf(msgFile, "\n\n local chksum = %12.4e", chksum) ;
fflush(msgFile) ;
/*
---------------------------------------
gather the checksums from the processes
---------------------------------------
*/
sums = DVinit(nproc, 0.0) ;
MPI_Gather((void *) &chksum, 1, MPI_DOUBLE,
(void *) sums, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD) ;
if ( myid == 0 ) {
fprintf(msgFile, "\n\n sums") ;
DVfprintf(msgFile, nproc, sums) ;
for ( iproc = 0 ; iproc < nproc ; iproc++ ) {
sums[iproc] -= chksum ;
}
fprintf(msgFile, "\n\n errors") ;
DVfprintf(msgFile, nproc, sums) ;
fprintf(msgFile, "\n\n maxerror = %12.4e", DVmax(nproc, sums, &loc));
}
/*
----------------
free the objects
----------------
*/
DVfree(sums) ;
Graph_free(graph) ;
/*
------------------------
exit the MPI environment
------------------------
*/
MPI_Finalize() ;
fprintf(msgFile, "\n") ;
fclose(msgFile) ;
return(0) ; }
/*
-------------------------------------------------
purpose -- to write a Graph object for a human eye
return value -- 1 if success, 0 otherwise
created -- 95sep29, cca
-------------------------------------------------
*/
int
Graph_writeForHumanEye (
Graph *graph,
FILE *fp
) {
int ierr, rc ;
if ( graph == NULL || fp == NULL ) {
fprintf(stderr, "\n fatal error in Graph_writeForHumanEye(%p,%p)"
"\n bad input\n", graph, fp) ;
spoolesFatal();
}
/*
------------------------
write out the statistics
------------------------
*/
if ( (rc = Graph_writeStats(graph, fp)) == 0 ) {
fprintf(stderr, "\n fatal error in Graph_writeForHumanEye(%p,%p)"
"\n rc = %d, return from Graph_writeStats(%p,%p)\n",
graph, fp, rc, graph, fp) ;
return(0) ;
}
if ( graph->adjIVL != NULL ) {
/*
----------------------------------
write out the adjacency IVL object
----------------------------------
*/
fprintf(fp, "\n\n adjacency IVL object") ;
rc = IVL_writeForHumanEye(graph->adjIVL, fp) ;
if ( rc < 0 ) {
fprintf(stderr, "\n fatal error in Graph_writeForHumanEye(%p,%p)"
"\n rc = %d, return from IVL_writeForHumanEye(%p,%p)"
"\n while attempting to write out adjIVL\n",
graph, fp, rc, graph->adjIVL, fp) ;
return(0) ;
}
}
/*
----------------------------------------------
write out the vertex weights vector if present
----------------------------------------------
*/
if ( graph->type % 2 == 1 ) {
if ( graph->vwghts == NULL ) {
fprintf(stderr,
"\n fatal error in Graph_writeForHumanEye(%p,%p)"
"\n graph->type = %d, graph->vwghts == NULL\n",
graph, fp, graph->type) ;
return(0) ;
}
fprintf(fp, "\n\n vertex weights ") ;
IVfp80(fp, graph->nvtx + graph->nvbnd, graph->vwghts, 80, &ierr) ;
if ( ierr < 0 ) {
fprintf(stderr,
"\n fatal error in Graph_writeForHumanEye(%p,%p)"
"\n ierr = %d, return from vwghts[] IVfp80\n",
graph, fp, ierr) ;
return(0) ;
}
}
/*
------------------------------------------------
write out the edge weight IVL object, if present
------------------------------------------------
*/
if ( graph->type >= 2 ) {
if ( graph->ewghtIVL == NULL ) {
fprintf(stderr,
"\n fatal error in Graph_writeForHumanEye(%p,%p)"
"\n graph->type = %d, graph->ewghtIVL == NULL\n",
graph, fp, graph->type) ;
return(0) ;
}
fprintf(fp, "\n\n edge weights IVL object") ;
rc = IVL_writeForHumanEye(graph->ewghtIVL, fp) ;
if ( rc < 0 ) {
fprintf(stderr,
"\n fatal error in Graph_writeForHumanEye(%p,%p)"
"\n rc = %d, return from IVL_writeForHumanEye(%p,%p)"
"\n while attempting to write out ewghtIVL\n",
graph, fp, rc, graph->ewghtIVL, fp) ;
return(0) ;
}
}
return(1) ; }
/*--------------------------------------------------------------------*/
int
main ( int argc, char *argv[] )
/*
------------------------------------------------------
(1) read in an ETree object.
(2) read in an Graph object.
(3) find the optimal domain/schur complement partition
for a semi-implicit factorization
created -- 96oct03, cca
------------------------------------------------------
*/
{
char *inETreeFileName, *inGraphFileName, *outIVfileName ;
double alpha, nA21, nfent1, nfops1, nL11, nL22, nPhi, nV, t1, t2 ;
Graph *graph ;
int ii, inside, J, K, msglvl, nfind1, nfront, nJ, nleaves1,
nnode1, nvtx, rc, sizeJ, totalgain, vsize, v, w ;
int *adjJ, *compids, *nodwghts, *vadj, *vtxToFront, *vwghts ;
IV *compidsIV ;
IVL *symbfacIVL ;
ETree *etree ;
FILE *msgFile ;
Tree *tree ;
if ( argc != 7 ) {
fprintf(stdout,
"\n\n usage : %s msglvl msgFile inETreeFile inGraphFile alpha"
"\n outIVfile "
"\n msglvl -- message level"
"\n msgFile -- message file"
"\n inETreeFile -- input file, must be *.etreef or *.etreeb"
"\n inGraphFile -- input file, must be *.graphf or *.graphb"
"\n alpha -- weight parameter"
"\n alpha = 0 --> minimize storage"
"\n alpha = 1 --> minimize solve ops"
"\n outIVfile -- output file for oldToNew vector,"
"\n must be *.ivf or *.ivb"
"\n", argv[0]) ;
return(0) ;
}
msglvl = atoi(argv[1]) ;
if ( strcmp(argv[2], "stdout") == 0 ) {
msgFile = stdout ;
} else if ( (msgFile = fopen(argv[2], "a")) == NULL ) {
fprintf(stderr, "\n fatal error in %s"
"\n unable to open file %s\n",
argv[0], argv[2]) ;
return(-1) ;
}
inETreeFileName = argv[3] ;
inGraphFileName = argv[4] ;
alpha = atof(argv[5]) ;
outIVfileName = argv[6] ;
fprintf(msgFile,
"\n %s "
"\n msglvl -- %d"
"\n msgFile -- %s"
"\n inETreeFile -- %s"
"\n inGraphFile -- %s"
"\n alpha -- %f"
"\n outIVfile -- %s"
"\n",
argv[0], msglvl, argv[2],
inETreeFileName, inGraphFileName, alpha, outIVfileName) ;
fflush(msgFile) ;
/*
------------------------
read in the ETree object
------------------------
*/
if ( strcmp(inETreeFileName, "none") == 0 ) {
fprintf(msgFile, "\n no file to read from") ;
spoolesFatal();
}
etree = ETree_new() ;
MARKTIME(t1) ;
rc = ETree_readFromFile(etree, inETreeFileName) ;
MARKTIME(t2) ;
fprintf(msgFile, "\n CPU %9.5f : read in etree from file %s",
t2 - t1, inETreeFileName) ;
if ( rc != 1 ) {
fprintf(msgFile, "\n return value %d from ETree_readFromFile(%p,%s)",
rc, etree, inETreeFileName) ;
spoolesFatal();
}
ETree_leftJustify(etree) ;
fprintf(msgFile, "\n\n after reading ETree object from file %s",
inETreeFileName) ;
if ( msglvl > 2 ) {
ETree_writeForHumanEye(etree, msgFile) ;
} else {
ETree_writeStats(etree, msgFile) ;
}
fflush(msgFile) ;
nfront = ETree_nfront(etree) ;
tree = ETree_tree(etree) ;
nodwghts = ETree_nodwghts(etree) ;
vtxToFront = ETree_vtxToFront(etree) ;
/*
------------------------
read in the Graph object
------------------------
*/
if ( strcmp(inGraphFileName, "none") == 0 ) {
fprintf(msgFile, "\n no file to read from") ;
spoolesFatal();
}
graph = Graph_new() ;
MARKTIME(t1) ;
rc = Graph_readFromFile(graph, inGraphFileName) ;
nvtx = graph->nvtx ;
vwghts = graph->vwghts ;
MARKTIME(t2) ;
fprintf(msgFile, "\n CPU %9.5f : read in graph from file %s",
t2 - t1, inGraphFileName) ;
if ( rc != 1 ) {
fprintf(msgFile, "\n return value %d from Graph_readFromFile(%p,%s)",
rc, graph, inGraphFileName) ;
spoolesFatal();
}
fprintf(msgFile, "\n\n after reading Graph object from file %s",
inGraphFileName) ;
if ( msglvl > 2 ) {
Graph_writeForHumanEye(graph, msgFile) ;
} else {
Graph_writeStats(graph, msgFile) ;
}
fflush(msgFile) ;
/*
----------------------
compute the statistics
----------------------
*/
nnode1 = etree->tree->n ;
nfind1 = ETree_nFactorIndices(etree) ;
nfent1 = ETree_nFactorEntries(etree, SPOOLES_SYMMETRIC) ;
nfops1 = ETree_nFactorOps(etree, SPOOLES_REAL, SPOOLES_SYMMETRIC) ;
nleaves1 = Tree_nleaves(etree->tree) ;
fprintf(stdout, "\n root front %d has %d vertices",
etree->tree->root,
etree->nodwghtsIV->vec[etree->tree->root]) ;
/*
---------------------------------
create the symbolic factorization
---------------------------------
*/
symbfacIVL = SymbFac_initFromGraph(etree, graph) ;
if ( msglvl > 2 ) {
IVL_writeForHumanEye(symbfacIVL, msgFile) ;
} else {
IVL_writeStats(symbfacIVL, msgFile) ;
}
fflush(msgFile) ;
/*
--------------------------
find the optimal partition
--------------------------
*/
compidsIV = ETree_optPart(etree, graph, symbfacIVL, alpha,
&totalgain, msglvl, msgFile) ;
if ( msglvl > 2 ) {
IV_writeForHumanEye(compidsIV, msgFile) ;
} else {
IV_writeStats(compidsIV, msgFile) ;
}
fflush(msgFile) ;
compids = IV_entries(compidsIV) ;
/*
------------------------------------------------------
compute the number of vertices in the schur complement
------------------------------------------------------
*/
for ( J = 0, nPhi = nV = 0. ; J < nfront ; J++ ) {
if ( compids[J] == 0 ) {
nPhi += nodwghts[J] ;
}
nV += nodwghts[J] ;
}
/*
--------------------------------------------
compute the number of entries in L11 and L22
--------------------------------------------
*/
nL11 = nL22 = 0 ;
for ( J = Tree_postOTfirst(tree) ;
J != -1 ;
J = Tree_postOTnext(tree, J) ) {
nJ = nodwghts[J] ;
if ( msglvl > 3 ) {
fprintf(msgFile, "\n\n front %d, nJ = %d", J, nJ) ;
}
IVL_listAndSize(symbfacIVL, J, &sizeJ, &adjJ) ;
for ( ii = 0, inside = 0 ; ii < sizeJ ; ii++ ) {
w = adjJ[ii] ;
K = vtxToFront[w] ;
if ( msglvl > 3 ) {
fprintf(msgFile, "\n w = %d, K = %d", w, K) ;
}
if ( K > J && compids[K] == compids[J] ) {
inside += (vwghts == NULL) ? 1 : vwghts[w] ;
if ( msglvl > 3 ) {
fprintf(msgFile, ", inside") ;
}
}
}
if ( compids[J] != 0 ) {
if ( msglvl > 3 ) {
fprintf(msgFile, "\n inside = %d, adding %d to L11",
inside, nJ*nJ + 2*nJ*inside) ;
}
nL11 += (nJ*(nJ+1))/2 + nJ*inside ;
} else {
if ( msglvl > 3 ) {
fprintf(msgFile, "\n inside = %d, adding %d to L22",
inside, (nJ*(nJ+1))/2 + nJ*inside) ;
}
nL22 += (nJ*(nJ+1))/2 + nJ*inside ;
}
}
if ( msglvl > 0 ) {
fprintf(msgFile, "\n |L| = %.0f, |L11| = %.0f, |L22| = %.0f",
nfent1, nL11, nL22) ;
}
/*
------------------------------------
compute the number of entries in A21
------------------------------------
*/
nA21 = 0 ;
if ( vwghts != NULL ) {
for ( v = 0 ; v < nvtx ; v++ ) {
J = vtxToFront[v] ;
if ( compids[J] != 0 ) {
Graph_adjAndSize(graph, v, &vsize, &vadj) ;
for ( ii = 0 ; ii < vsize ; ii++ ) {
w = vadj[ii] ;
K = vtxToFront[w] ;
if ( compids[K] == 0 ) {
if ( msglvl > 3 ) {
fprintf(msgFile, "\n A21 : v = %d, w = %d", v, w) ;
}
nA21 += vwghts[v] * vwghts[w] ;
}
}
}
}
} else {
for ( v = 0 ; v < nvtx ; v++ ) {
J = vtxToFront[v] ;
if ( compids[J] != 0 ) {
Graph_adjAndSize(graph, v, &vsize, &vadj) ;
for ( ii = 0 ; ii < vsize ; ii++ ) {
w = vadj[ii] ;
K = vtxToFront[w] ;
if ( compids[K] == 0 ) {
if ( msglvl > 3 ) {
fprintf(msgFile, "\n A21 : v = %d, w = %d", v, w) ;
}
nA21++ ;
}
}
}
}
}
if ( msglvl > 0 ) {
fprintf(msgFile,
"\n |L| = %.0f, |L11| = %.0f, |L22| = %.0f, |A21| = %.0f",
nfent1, nL11, nL22, nA21) ;
fprintf(msgFile,
"\n storage: explicit = %.0f, semi-implicit = %.0f, ratio = %.3f"
"\n opcount: explicit = %.0f, semi-implicit = %.0f, ratio = %.3f",
nfent1, nL11 + nA21 + nL22,
nfent1/(nL11 + nA21 + nL22),
2*nfent1, 4*nL11 + 2*nA21 + 2*nL22,
2*nfent1/(4*nL11 + 2*nA21 + 2*nL22)) ;
fprintf(msgFile, "\n ratios %8.3f %8.3f %8.3f",
nPhi/nV,
nfent1/(nL11 + nA21 + nL22),
2*nfent1/(4*nL11 + 2*nA21 + 2*nL22)) ;
}
/*
----------------
free the objects
----------------
*/
ETree_free(etree) ;
Graph_free(graph) ;
IVL_free(symbfacIVL) ;
fprintf(msgFile, "\n") ;
fclose(msgFile) ;
return(1) ; }
/*--------------------------------------------------------------------*/
int
main ( int argc, char *argv[] )
/*
---------------------------------------------------
read in a DSTree object, read in a Graph file,
read in a DV cutoffs file, get the stages IV object
based on domain weight and write it to a file.
created -- 97jun12, cca
---------------------------------------------------
*/
{
char *inCutoffDVfileName, *inDSTreeFileName,
*inGraphFileName, *outIVfileName ;
double t1, t2 ;
DV *cutoffDV ;
Graph *graph ;
int msglvl, rc ;
IV *stagesIV ;
DSTree *dstree ;
FILE *msgFile ;
if ( argc != 7 ) {
fprintf(stdout,
"\n\n usage : %s msglvl msgFile inDSTreeFile inGraphFile "
"\n inCutoffDVfile outFile"
"\n msglvl -- message level"
"\n msgFile -- message file"
"\n inDSTreeFile -- input file, must be *.dstreef or *.dstreeb"
"\n inGraphFile -- input file, must be *.graphf or *.graphb"
"\n inCutoffDVfile -- input file, must be *.dvf or *.dvb"
"\n outFile -- output file, must be *.ivf or *.ivb"
"\n", argv[0]) ;
return(0) ;
}
msglvl = atoi(argv[1]) ;
if ( strcmp(argv[2], "stdout") == 0 ) {
msgFile = stdout ;
} else if ( (msgFile = fopen(argv[2], "a")) == NULL ) {
fprintf(stderr, "\n fatal error in %s"
"\n unable to open file %s\n",
argv[0], argv[2]) ;
return(-1) ;
}
inDSTreeFileName = argv[3] ;
inGraphFileName = argv[4] ;
inCutoffDVfileName = argv[5] ;
outIVfileName = argv[6] ;
fprintf(msgFile,
"\n %s "
"\n msglvl -- %d"
"\n msgFile -- %s"
"\n inDSTreeFileName -- %s"
"\n inGraphFileName -- %s"
"\n inCutoffDVfileName -- %s"
"\n outFile -- %s"
"\n",
argv[0], msglvl, argv[2], inDSTreeFileName,
inGraphFileName, inCutoffDVfileName, outIVfileName) ;
fflush(msgFile) ;
/*
-------------------------
read in the DSTree object
-------------------------
*/
if ( strcmp(inDSTreeFileName, "none") == 0 ) {
fprintf(msgFile, "\n no file to read from") ;
spoolesFatal();
}
dstree = DSTree_new() ;
MARKTIME(t1) ;
rc = DSTree_readFromFile(dstree, inDSTreeFileName) ;
MARKTIME(t2) ;
fprintf(msgFile, "\n CPU %9.5f : read in dstree from file %s",
t2 - t1, inDSTreeFileName) ;
if ( rc != 1 ) {
fprintf(msgFile, "\n return value %d from DSTree_readFromFile(%p,%s)",
rc, dstree, inDSTreeFileName) ;
spoolesFatal();
}
fprintf(msgFile, "\n\n after reading DSTree object from file %s",
inDSTreeFileName) ;
if ( msglvl > 2 ) {
DSTree_writeForHumanEye(dstree, msgFile) ;
} else {
DSTree_writeStats(dstree, msgFile) ;
}
fflush(msgFile) ;
/*
-------------------------
read in the Graph object
-------------------------
*/
if ( strcmp(inGraphFileName, "none") == 0 ) {
fprintf(msgFile, "\n no file to read from") ;
spoolesFatal();
}
graph = Graph_new() ;
MARKTIME(t1) ;
rc = Graph_readFromFile(graph, inGraphFileName) ;
MARKTIME(t2) ;
fprintf(msgFile, "\n CPU %9.5f : read in graph from file %s",
t2 - t1, inGraphFileName) ;
if ( rc != 1 ) {
fprintf(msgFile, "\n return value %d from Graph_readFromFile(%p,%s)",
rc, graph, inGraphFileName) ;
spoolesFatal();
}
fprintf(msgFile, "\n\n after reading Graph object from file %s",
inGraphFileName) ;
if ( msglvl > 2 ) {
Graph_writeForHumanEye(graph, msgFile) ;
} else {
Graph_writeStats(graph, msgFile) ;
}
fflush(msgFile) ;
/*
-----------------------------
read in the cutoffs DV object
-----------------------------
*/
if ( strcmp(inCutoffDVfileName, "none") == 0 ) {
fprintf(msgFile, "\n no file to read from") ;
spoolesFatal();
}
cutoffDV = DV_new() ;
MARKTIME(t1) ;
rc = DV_readFromFile(cutoffDV, inCutoffDVfileName) ;
MARKTIME(t2) ;
fprintf(msgFile, "\n CPU %9.5f : read in graph from file %s",
t2 - t1, inCutoffDVfileName) ;
if ( rc != 1 ) {
fprintf(msgFile, "\n return value %d from DV_readFromFile(%p,%s)",
rc, cutoffDV, inCutoffDVfileName) ;
spoolesFatal();
}
fprintf(msgFile, "\n\n after reading DV object from file %s",
inCutoffDVfileName) ;
if ( msglvl > 0 ) {
DV_writeForHumanEye(cutoffDV, msgFile) ;
} else {
DV_writeStats(cutoffDV, msgFile) ;
}
fflush(msgFile) ;
/*
---------------------
get the stages vector
---------------------
*/
stagesIV = DSTree_stagesViaDomainWeight(dstree,
graph->vwghts, cutoffDV) ;
if ( msglvl > 2 ) {
IV_writeForHumanEye(stagesIV, msgFile) ;
} else {
IV_writeStats(stagesIV, msgFile) ;
}
fflush(msgFile) ;
/*
---------------------------
write out the DSTree object
---------------------------
*/
if ( stagesIV != NULL && strcmp(outIVfileName, "none") != 0 ) {
MARKTIME(t1) ;
rc = IV_writeToFile(stagesIV, outIVfileName) ;
MARKTIME(t2) ;
fprintf(msgFile, "\n CPU %9.5f : write dstree to file %s",
t2 - t1, outIVfileName) ;
if ( rc != 1 ) {
fprintf(msgFile,
"\n return value %d from IV_writeToFile(%p,%s)",
rc, stagesIV, outIVfileName) ;
}
}
/*
----------------------
free the DSTree object
----------------------
*/
DSTree_free(dstree) ;
if ( stagesIV != NULL ) {
IV_free(stagesIV) ;
}
fprintf(msgFile, "\n") ;
fclose(msgFile) ;
return(1) ; }
/*--------------------------------------------------------------------*/
int
main ( int argc, char *argv[] )
/*
-----------------------------------------
check to see whether a graph is symmetric
created -- 96oct31, cca
-----------------------------------------
*/
{
char *inGraphFileName ;
double t1, t2 ;
int msglvl, rc ;
Graph *graph ;
FILE *msgFile ;
if ( argc != 4 ) {
fprintf(stdout,
"\n\n usage : %s msglvl msgFile inFile "
"\n msglvl -- message level"
"\n msgFile -- message file"
"\n inFile -- input file, must be *.graphf or *.graphb"
"\n", argv[0]) ;
return(0) ;
}
msglvl = atoi(argv[1]) ;
if ( strcmp(argv[2], "stdout") == 0 ) {
msgFile = stdout ;
} else if ( (msgFile = fopen(argv[2], "a")) == NULL ) {
fprintf(stderr, "\n fatal error in %s"
"\n unable to open file %s\n",
argv[0], argv[2]) ;
return(-1) ;
}
inGraphFileName = argv[3] ;
fprintf(msgFile,
"\n %s "
"\n msglvl -- %d"
"\n msgFile -- %s"
"\n inFile -- %s"
"\n",
argv[0], msglvl, argv[2], inGraphFileName) ;
fflush(msgFile) ;
/*
----------------------
read in the Graph object
----------------------
*/
if ( strcmp(inGraphFileName, "none") == 0 ) {
fprintf(msgFile, "\n no file to read from") ;
exit(0) ;
}
graph = Graph_new() ;
MARKTIME(t1) ;
rc = Graph_readFromFile(graph, inGraphFileName) ;
MARKTIME(t2) ;
fprintf(msgFile, "\n CPU %9.5f : read in graph from file %s",
t2 - t1, inGraphFileName) ;
if ( rc != 1 ) {
fprintf(msgFile, "\n return value %d from Graph_readFromFile(%p,%s)",
rc, graph, inGraphFileName) ;
exit(-1) ;
}
fprintf(msgFile, "\n\n after reading Graph object from file %s",
inGraphFileName) ;
if ( msglvl > 2 ) {
Graph_writeForHumanEye(graph, msgFile) ;
} else {
Graph_writeStats(graph, msgFile) ;
}
fflush(msgFile) ;
/*
-------------------------------------------
check to see whether the graph is symmetric
-------------------------------------------
*/
rc = Graph_isSymmetric(graph) ;
if ( rc == 1 ) {
fprintf(msgFile, "\n graph is symmetric") ;
} else {
fprintf(msgFile, "\n graph is not symmetric") ;
}
/*
---------------------
free the Graph object
---------------------
*/
Graph_free(graph) ;
fprintf(msgFile, "\n") ;
fclose(msgFile) ;
return(1) ; }
/*--------------------------------------------------------------------*/
int
main ( int argc, char *argv[] )
/*
---------------------------------------------------
read in a Graph and a stages id IV object,
replace the stages IV object with wirebasket stages
created -- 97jul30, cca
---------------------------------------------------
*/
{
char *inCompidsFileName, *inGraphFileName, *outStagesIVfileName ;
double t1, t2 ;
Graph *graph ;
int msglvl, nvtx, radius, rc, v ;
int *compids, *stages ;
IV *compidsIV, *stagesIV ;
FILE *msgFile ;
if ( argc != 7 ) {
fprintf(stdout,
"\n\n usage : %s msglvl msgFile inGraphFile inStagesFile "
"\n outStagesFile radius"
"\n msglvl -- message level"
"\n msgFile -- message file"
"\n inGraphFile -- input file, must be *.graphf or *.graphb"
"\n inStagesFile -- output file, must be *.ivf or *.ivb"
"\n outStagesFile -- output file, must be *.ivf or *.ivb"
"\n radius -- radius to set the stage "
"\n of a separator vertex"
"\n", argv[0]) ;
return(0) ;
}
msglvl = atoi(argv[1]) ;
if ( strcmp(argv[2], "stdout") == 0 ) {
msgFile = stdout ;
} else if ( (msgFile = fopen(argv[2], "a")) == NULL ) {
fprintf(stderr, "\n fatal error in %s"
"\n unable to open file %s\n",
argv[0], argv[2]) ;
return(-1) ;
}
inGraphFileName = argv[3] ;
inCompidsFileName = argv[4] ;
outStagesIVfileName = argv[5] ;
radius = atoi(argv[6]) ;
fprintf(msgFile,
"\n %s "
"\n msglvl -- %d"
"\n msgFile -- %s"
"\n inGraphFile -- %s"
"\n inStagesFile -- %s"
"\n outStagesFile -- %s"
"\n radius -- %d"
"\n",
argv[0], msglvl, argv[2], inGraphFileName, inCompidsFileName,
outStagesIVfileName, radius) ;
fflush(msgFile) ;
/*
------------------------
read in the Graph object
------------------------
*/
if ( strcmp(inGraphFileName, "none") == 0 ) {
fprintf(msgFile, "\n no file to read from") ;
exit(0) ;
}
graph = Graph_new() ;
MARKTIME(t1) ;
rc = Graph_readFromFile(graph, inGraphFileName) ;
MARKTIME(t2) ;
fprintf(msgFile, "\n CPU %9.5f : read in graph from file %s",
t2 - t1, inGraphFileName) ;
if ( rc != 1 ) {
fprintf(msgFile, "\n return value %d from Graph_readFromFile(%p,%s)",
rc, graph, inGraphFileName) ;
exit(-1) ;
}
fprintf(msgFile, "\n\n after reading Graph object from file %s",
inGraphFileName) ;
if ( msglvl > 2 ) {
Graph_writeForHumanEye(graph, msgFile) ;
} else {
Graph_writeStats(graph, msgFile) ;
}
fflush(msgFile) ;
/*
---------------------
read in the IV object
---------------------
*/
if ( strcmp(inCompidsFileName, "none") == 0 ) {
fprintf(msgFile, "\n no file to read from") ;
exit(0) ;
}
compidsIV = IV_new() ;
MARKTIME(t1) ;
rc = IV_readFromFile(compidsIV, inCompidsFileName) ;
MARKTIME(t2) ;
fprintf(msgFile, "\n CPU %9.5f : read in compidsIV from file %s",
t2 - t1, inCompidsFileName) ;
if ( rc != 1 ) {
fprintf(msgFile, "\n return value %d from IV_readFromFile(%p,%s)",
rc, compidsIV, inCompidsFileName) ;
exit(-1) ;
}
fprintf(msgFile, "\n\n after reading IV object from file %s",
inCompidsFileName) ;
if ( msglvl > 2 ) {
IV_writeForHumanEye(compidsIV, msgFile) ;
} else {
IV_writeStats(compidsIV, msgFile) ;
}
fflush(msgFile) ;
IV_sizeAndEntries(compidsIV, &nvtx, &compids) ;
/*
----------------------------
convert to the stages vector
----------------------------
*/
stagesIV = IV_new() ;
IV_init(stagesIV, nvtx, NULL) ;
stages = IV_entries(stagesIV) ;
for ( v = 0 ; v < nvtx ; v++ ) {
if ( compids[v] == 0 ) {
stages[v] = 1 ;
} else {
stages[v] = 0 ;
}
}
/*
for ( v = 0 ; v < nvtx ; v++ ) {
if ( compids[v] == 0 ) {
stages[v] = 0 ;
} else {
stages[v] = 1 ;
}
}
*/
/*
-------------------------
get the wirebasket stages
-------------------------
*/
Graph_wirebasketStages(graph, stagesIV, radius) ;
IV_sizeAndEntries(stagesIV, &nvtx, &stages) ;
for ( v = 0 ; v < nvtx ; v++ ) {
if ( stages[v] == 2 ) {
stages[v] = 1 ;
} else if ( stages[v] > 2 ) {
stages[v] = 2 ;
}
}
fprintf(msgFile, "\n\n new stages IV object") ;
if ( msglvl > 2 ) {
IV_writeForHumanEye(stagesIV, msgFile) ;
} else {
IV_writeStats(stagesIV, msgFile) ;
}
fflush(msgFile) ;
/*
---------------------------
write out the stages object
---------------------------
*/
if ( strcmp(outStagesIVfileName, "none") != 0 ) {
MARKTIME(t1) ;
IV_writeToFile(stagesIV, outStagesIVfileName) ;
MARKTIME(t2) ;
fprintf(msgFile, "\n CPU %9.5f : write stagesIV to file %s",
t2 - t1, outStagesIVfileName) ;
if ( rc != 1 ) {
fprintf(msgFile,
"\n return value %d from IV_writeToFile(%p,%s)",
rc, stagesIV, outStagesIVfileName) ;
}
}
/*
------------------------
free the working storage
------------------------
*/
Graph_free(graph) ;
IV_free(stagesIV) ;
IV_free(compidsIV) ;
fprintf(msgFile, "\n") ;
fclose(msgFile) ;
return(1) ; }
/*--------------------------------------------------------------------*/
int
main ( int argc, char *argv[] )
/*
-------------------------------------------------
1) read in graph
2) get the equivalence map
3) optionally write out equivalence map
4) get compressed graph
5) optionally write out compressed graph map
created -- 95mar02, cca
-------------------------------------------------
*/
{
char *inGraphFileName, *outIVfileName, *outGraphFileName ;
double t1, t2 ;
int coarseType, msglvl, rc ;
Graph *gc, *gf ;
FILE *msgFile ;
IV *mapIV ;
if ( argc != 7 ) {
fprintf(stdout,
"\n\n usage : %s msglvl msgFile inGraphFile "
"\n coarseType outMapFile outGraphFile"
"\n msglvl -- message level"
"\n msgFile -- message file"
"\n inGraphFile -- input file for graph"
"\n must be *.graphf or *.graphb"
"\n coarseType -- type for compressed graph"
"\n outMapFile -- output file for map vector"
"\n must be *.ivf or *.ivb"
"\n outGraphFile -- output file for compressed graph"
"\n must be *.graphf or *.graphb"
"\n", argv[0]) ;
return(0) ;
}
msglvl = atoi(argv[1]) ;
if ( strcmp(argv[2], "stdout") == 0 ) {
msgFile = stdout ;
} else if ( (msgFile = fopen(argv[2], "a")) == NULL ) {
fprintf(stderr, "\n fatal error in %s"
"\n unable to open file %s\n",
argv[0], argv[2]) ;
return(-1) ;
}
inGraphFileName = argv[3] ;
coarseType = atoi(argv[4]) ;
outIVfileName = argv[5] ;
outGraphFileName = argv[6] ;
fprintf(msgFile,
"\n %s "
"\n msglvl -- %d"
"\n msgFile -- %s"
"\n inGraphFile -- %s"
"\n coarseType -- %d"
"\n outMapFile -- %s"
"\n outGraphFile -- %s"
"\n",
argv[0], msglvl, argv[2], inGraphFileName,
coarseType, outIVfileName, outGraphFileName) ;
fflush(msgFile) ;
/*
------------------------
read in the Graph object
------------------------
*/
if ( strcmp(inGraphFileName, "none") == 0 ) {
fprintf(msgFile, "\n no file to read from") ;
exit(0) ;
}
MARKTIME(t1) ;
gf = Graph_new() ;
rc = Graph_readFromFile(gf, inGraphFileName) ;
MARKTIME(t2) ;
fprintf(msgFile, "\n CPU %9.5f : read in graph from file %s",
t2 - t1, inGraphFileName) ;
if ( rc != 1 ) {
fprintf(msgFile, "\n return value %d from Graph_readFromFile(%p,%s)",
rc, gf, inGraphFileName) ;
exit(-1) ;
}
if ( msglvl > 2 ) {
fprintf(msgFile, "\n\n after reading Graph object from file %s",
inGraphFileName) ;
Graph_writeForHumanEye(gf, msgFile) ;
fflush(msgFile) ;
} else {
Graph_writeStats(gf, msgFile) ;
fflush(msgFile) ;
}
/*
-----------------------
get the equivalence map
-----------------------
*/
MARKTIME(t1) ;
mapIV = Graph_equivMap(gf) ;
MARKTIME(t2) ;
fprintf(msgFile, "\n CPU %9.5f : create equivalence map", t2 - t1) ;
if ( msglvl > 1 ) {
fprintf(msgFile, "\n\n equivalence map IV object") ;
IV_writeForHumanEye(mapIV, msgFile) ;
fflush(msgFile) ;
}
/*
---------------------------
write out the map IV object
---------------------------
*/
if ( strcmp(outIVfileName, "none") != 0 ) {
MARKTIME(t1) ;
rc = IV_writeToFile(mapIV, outIVfileName) ;
MARKTIME(t2) ;
fprintf(msgFile, "\n CPU %9.5f : write map IV to file %s",
t2 - t1, outIVfileName) ;
if ( rc != 1 ) {
fprintf(msgFile, "\n return value %d from IV_writeToFile(%p,%s)",
rc, mapIV, outIVfileName) ;
}
}
/*
------------------------
get the compressed graph
------------------------
*/
MARKTIME(t1) ;
gc = Graph_compress(gf, IV_entries(mapIV), coarseType) ;
MARKTIME(t2) ;
fprintf(msgFile, "\n CPU %9.5f : compress the graph", t2 - t1) ;
fprintf(msgFile, "\n\n compressed graph") ;
if ( msglvl > 2 ) {
Graph_writeForHumanEye(gc, msgFile) ;
fflush(msgFile) ;
} else {
Graph_writeStats(gc, msgFile) ;
fflush(msgFile) ;
}
/*
--------------------------
write out the Graph object
--------------------------
*/
if ( strcmp(outGraphFileName, "none") != 0 ) {
MARKTIME(t1) ;
rc = Graph_writeToFile(gc, outGraphFileName) ;
MARKTIME(t2) ;
fprintf(msgFile, "\n CPU %9.5f : write compressed graph to file %s",
t2 - t1, outGraphFileName) ;
if ( rc != 1 ) {
fprintf(msgFile,
"\n return value %d from Graph_writeToFile(%p,%s)",
rc, gc, outGraphFileName) ;
exit(-1) ;
}
}
/*
----------------
free the objects
----------------
*/
Graph_free(gf) ;
Graph_free(gc) ;
IV_free(mapIV) ;
fprintf(msgFile, "\n") ;
fclose(msgFile) ;
return(1) ; }
