int chaco_setup_mesh_struct(
int Proc,
int Num_Proc,
PROB_INFO_PTR prob, /* problem description */
MESH_INFO_PTR mesh, /* mesh information for the problem */
int gnvtxs, /* global number of vertices across all procs*/
int nvtxs, /* number of vertices in local graph */
int *start, /* start of edge list for each vertex */
int *adj, /* edge list data */
int vwgt_dim, /* # of weights per vertex */
float *vwgts, /* vertex weight list data */
int ewgt_dim, /* # of weights per edge */
float *ewgts, /* edge weight list data */
int ndim, /* dimension of the geometry */
float *x, /* x-coordinates of the vertices */
float *y, /* y-coordinates of the vertices */
float *z, /* z-coordinates of the vertices */
short *assignments, /* assignments from Chaco file; may be NULL */
int base, /* smallest vertex number to use;
base == 1 for Chaco;
may be 0 or 1 for HG files. */
int no_geom /* flag indicating whether coords are avail. */
)
{
const char *yo = "chaco_setup_mesh_struct";
int i;
DEBUG_TRACE_START(Proc, yo);
/* Initialize mesh structure for Chaco mesh. */
mesh->data_type = ZOLTAN_GRAPH;
mesh->vwgt_dim = vwgt_dim;
mesh->ewgt_dim = ewgt_dim;
mesh->num_elems = nvtxs;
mesh->elem_array_len = mesh->num_elems + 5;
mesh->num_dims = ndim;
mesh->num_el_blks = 1;
mesh->eb_etypes = (int *) malloc (5 * mesh->num_el_blks * sizeof(int));
if (!mesh->eb_etypes) {
Gen_Error(0, "fatal: insufficient memory");
return 0;
}
mesh->eb_ids = mesh->eb_etypes + mesh->num_el_blks;
mesh->eb_cnts = mesh->eb_ids + mesh->num_el_blks;
mesh->eb_nnodes = mesh->eb_cnts + mesh->num_el_blks;
mesh->eb_nattrs = mesh->eb_nnodes + mesh->num_el_blks;
mesh->eb_names = (char **) malloc (mesh->num_el_blks * sizeof(char *));
if (!mesh->eb_names) {
Gen_Error(0, "fatal: insufficient memory");
return 0;
}
mesh->eb_etypes[0] = -1;
mesh->eb_ids[0] = 1;
mesh->eb_cnts[0] = nvtxs;
mesh->eb_nattrs[0] = 0;
mesh->hindex = (int *) malloc(sizeof(int));
mesh->hindex[0] = 0;
/*
* Each element has one set of coordinates (i.e., node) if a coords file
* was provided; zero otherwise.
*/
MPI_Bcast( &no_geom, 1, MPI_INT, 0, MPI_COMM_WORLD);
if (no_geom)
mesh->eb_nnodes[0] = 0;
else
mesh->eb_nnodes[0] = 1;
/* allocate space for name */
mesh->eb_names[0] = (char *) malloc((MAX_STR_LENGTH+1) * sizeof(char));
if (!mesh->eb_names[0]) {
Gen_Error(0, "fatal: insufficient memory");
return 0;
}
strcpy(mesh->eb_names[0], "chaco");
/* allocate the element structure array */
mesh->elements = (ELEM_INFO_PTR) malloc (mesh->elem_array_len
* sizeof(ELEM_INFO));
if (!(mesh->elements)) {
Gen_Error(0, "fatal: insufficient memory");
return 0;
}
/*
* intialize all of the element structs as unused by
* setting the globalID to -1
*/
for (i = 0; i < mesh->elem_array_len; i++)
initialize_element(&(mesh->elements[i]));
/*
* now fill the element structure array with the
* information from the Chaco file
*/
if (!chaco_fill_elements(Proc, Num_Proc, prob, mesh, gnvtxs, nvtxs,
start, adj, vwgt_dim, vwgts, ewgt_dim, ewgts,
ndim, x, y, z, assignments, 1)) {
Gen_Error(0, "fatal: Error returned from chaco_fill_elements");
return 0;
}
DEBUG_TRACE_END(Proc, yo);
return 1;
}
/* Read from file and set up hypergraph. */
int read_hypergraph_file(
int Proc,
int Num_Proc,
PROB_INFO_PTR prob,
PARIO_INFO_PTR pio_info,
MESH_INFO_PTR mesh
)
{
/* Local declarations. */
const char *yo = "read_hypergraph_file";
char cmesg[256];
int i, gnvtxs, distributed_pins = 0, edge, vertex, nextEdge;
int nvtxs = 0, gnhedges = 0, nhedges = 0, npins = 0;
int vwgt_dim=0, hewgt_dim=0, vtx, edgeSize, global_npins;
int *hindex = NULL, *hvertex = NULL, *hvertex_proc = NULL;
int *hgid = NULL;
float *hewgts = NULL, *vwgts = NULL;
ZOLTAN_FILE* fp = NULL;
int base = 0; /* Smallest vertex number; usually zero or one. */
char filename[256];
/* Variables that allow graph-based functions to be reused. */
/* If no chaco.graph or chaco.coords files exist, values are NULL or 0,
* since graph is not being built. If chaco.graph and/or chaco.coords
* exist, these arrays are filled and values stored in mesh.
* Including these files allows for comparison of HG methods with other
* methods, along with visualization of results and comparison of
* LB_Eval results.
*/
int ch_nvtxs = 0; /* Temporary values for chaco_read_graph. */
#ifdef KDDKDD
int ch_vwgt_dim = 0; /* Their values are ignored, as vertex */
#endif
float *ch_vwgts = NULL; /* info is provided by hypergraph file. */
int *ch_start = NULL, *ch_adj = NULL, ch_ewgt_dim = 0;
short *ch_assignments = NULL;
float *ch_ewgts = NULL;
int ch_ndim = 0;
float *ch_x = NULL, *ch_y = NULL, *ch_z = NULL;
int ch_no_geom = TRUE; /* Assume no geometry info is given; reset if
it is provided. */
int file_error = 0;
/***************************** BEGIN EXECUTION ******************************/
DEBUG_TRACE_START(Proc, yo);
if (Proc == 0) {
/* Open and read the hypergraph file. */
if (pio_info->file_type == HYPERGRAPH_FILE)
sprintf(filename, "%s.hg", pio_info->pexo_fname);
else if (pio_info->file_type == MATRIXMARKET_FILE)
sprintf(filename, "%s.mtx", pio_info->pexo_fname);
else {
sprintf(cmesg, "fatal: invalid file type %d", pio_info->file_type);
Gen_Error(0, cmesg);
return 0;
}
fp = ZOLTAN_FILE_open(filename, "r", pio_info->file_comp);
file_error = (fp == NULL);
}
MPI_Bcast(&file_error, 1, MPI_INT, 0, MPI_COMM_WORLD);
if (file_error) {
sprintf(cmesg,
"fatal: Could not open hypergraph file %s",pio_info->pexo_fname);
Gen_Error(0, cmesg);
return 0;
}
if (pio_info->file_type == HYPERGRAPH_FILE) {
/* read the array in on processor 0 */
if (Proc == 0) {
if (HG_readfile(Proc, fp, &nvtxs, &nhedges, &npins,
&hindex, &hvertex, &vwgt_dim, &vwgts,
&hewgt_dim, &hewgts, &base) != 0){
Gen_Error(0, "fatal: Error returned from HG_readfile");
return 0;
}
}
}
else if (pio_info->file_type == MATRIXMARKET_FILE) {
/*
* pio_info->chunk_reader == 0 (the usual case)
* process 0 will read entire file in MM_readfile,
* and will distribute vertices in chaco_dist_graph and pins in
* dist_hyperedges later. (distributed_pins==0)
*
* pio_info->chunk_reader == 1 ("initial read = chunks" in zdrive.inp)
* process 0 will read the file in chunks, and will send vertices
* and pins to other processes before reading the next chunk, all
* in MM_readfile. (distributed_pins==1)
*/
if (MM_readfile(Proc, Num_Proc, fp, pio_info,
&nvtxs, /* global number of vertices */
&nhedges, /* global number of hyperedges */
&npins, /* local number of pins */
&hindex, &hvertex, &vwgt_dim, &vwgts,
&hewgt_dim, &hewgts, &ch_start, &ch_adj,
&ch_ewgt_dim, &ch_ewgts, &base, &global_npins)) {
Gen_Error(0, "fatal: Error returned from MM_readfile");
return 0;
}
if (Proc == 0) ZOLTAN_FILE_close(fp);
if ((Num_Proc > 1) && pio_info->chunk_reader && (global_npins > Num_Proc)){
distributed_pins = 1;
}
else{
distributed_pins = 0;
}
}
#ifdef KDDKDD
{
/* If CHACO graph file is available, read it. */
sprintf(filename, "%s.graph", pio_info->pexo_fname);
fp = ZOLTAN_FILE_open(filename, "r", pio_info->file_comp);
file_error =
#ifndef ZOLTAN_COMPRESS
(fp == NULL);
#else
fp.error;
#endif
if (!file_error) {
/* CHACO graph file is available. */
/* Assuming hypergraph vertices are same as chaco vertices. */
/* Chaco vertices and their weights are ignored in rest of function. */
if (chaco_input_graph(fp, filename, &ch_start, &ch_adj, &ch_nvtxs,
&ch_vwgt_dim, &ch_vwgts, &ch_ewgt_dim, &ch_ewgts) != 0) {
Gen_Error(0, "fatal: Error returned from chaco_input_graph");
return 0;
}
}
else
ch_nvtxs = nvtxs;
/* If coordinate file is available, read it. */
sprintf(filename, "%s.coords", pio_info->pexo_fname);
fp = ZOLTAN_FILE_open(filename, "r", pio_info->file_comp);
file_error =
#ifndef ZOLTAN_COMPRESS
(fp == NULL);
#else
fp.error;
#endif
if (!file_error) {
/* CHACO coordinates file is available. */
ch_no_geom = FALSE;
if (chaco_input_geom(fpkdd, filename, ch_nvtxs, &ch_ndim,
&ch_x, &ch_y, &ch_z) != 0) {
Gen_Error(0, "fatal: Error returned from chaco_input_geom");
return 0;
}
}
}
#else /* KDDKDD */
ch_nvtxs = nvtxs;
#endif /* KDDKDD */
{
/* Read Chaco assignment file, if requested */
if (pio_info->init_dist_type == INITIAL_FILE) {
sprintf(filename, "%s.assign", pio_info->pexo_fname);
fp = ZOLTAN_FILE_open(filename, "r", pio_info->file_comp);
if (fp == NULL) {
sprintf(cmesg, "Error: Could not open Chaco assignment file %s; "
"initial distribution cannot be read",
filename);
Gen_Error(0, cmesg);
return 0;
}
else {
/* read the coordinates in on processor 0 */
ch_assignments = (short *) malloc(nvtxs * sizeof(short));
if (nvtxs && !ch_assignments) {
Gen_Error(0, "fatal: memory error in read_hypergraph_file");
return 0;
}
/* closes fpassign when done */
if (chaco_input_assign(fp, filename, ch_nvtxs, ch_assignments) != 0){
Gen_Error(0, "fatal: Error returned from chaco_input_assign");
return 0;
}
}
}
}
MPI_Bcast(&base, 1, MPI_INT, 0, MPI_COMM_WORLD);
if (distributed_pins){
gnhedges = nhedges;
nhedges = 0;
hewgt_dim = 0;
hewgts = NULL;
for (edge=0; edge<gnhedges; edge++){
edgeSize = hindex[edge+1] - hindex[edge];
if (edgeSize > 0) nhedges++;
}
hgid = (int *)malloc(nhedges * sizeof(int));
hvertex_proc = (int *)malloc(npins * sizeof(int));
nextEdge=0;
vtx=0;
for (edge=0; edge<gnhedges; edge++){
edgeSize = hindex[edge+1] - hindex[edge];
if (edgeSize > 0){
hgid[nextEdge] = edge+1;
if (nextEdge < edge){
hindex[nextEdge+1] = hindex[nextEdge] + edgeSize;
}
for (vertex=0; vertex<edgeSize; vertex++,vtx++){
hvertex_proc[vtx] = ch_dist_proc(hvertex[vtx], NULL, 1);
}
nextEdge++;
}
}
gnvtxs = nvtxs;
nvtxs = ch_dist_num_vtx(Proc, NULL);
if (ch_start){ /* need to include only vertices this process owns */
for (i=0,vertex=0; i<gnvtxs; i++){
if ((ch_start[i+1] > ch_start[vertex]) || /* vtx has adjacencies so it's mine */
(ch_dist_proc(i, NULL, 0) == Proc)) /* my vtx with no adjacencies */
{
if (i > vertex){
ch_start[vertex+1] = ch_start[i+1];
}
vertex++;
}
}
}
#if 0
debug_lists(Proc, Num_Proc, nhedges, hindex, hvertex, hvertex_proc, hgid);
#endif
} else{
/* Distribute hypergraph graph */
/* Use hypergraph vertex information and chaco edge information. */
if (!chaco_dist_graph(MPI_COMM_WORLD, pio_info, 0, &gnvtxs, &nvtxs,
&ch_start, &ch_adj, &vwgt_dim, &vwgts, &ch_ewgt_dim, &ch_ewgts,
&ch_ndim, &ch_x, &ch_y, &ch_z, &ch_assignments) != 0) {
Gen_Error(0, "fatal: Error returned from chaco_dist_graph");
return 0;
}
if (!dist_hyperedges(MPI_COMM_WORLD, pio_info, 0, base, gnvtxs, &gnhedges,
&nhedges, &hgid, &hindex, &hvertex, &hvertex_proc,
&hewgt_dim, &hewgts, ch_assignments)) {
Gen_Error(0, "fatal: Error returned from dist_hyperedges");
return 0;
}
}
/* Initialize mesh structure for Hypergraph. */
mesh->data_type = HYPERGRAPH;
mesh->num_elems = nvtxs;
mesh->vwgt_dim = vwgt_dim;
mesh->ewgt_dim = ch_ewgt_dim;
mesh->elem_array_len = mesh->num_elems + 5;
mesh->num_dims = ch_ndim;
mesh->num_el_blks = 1;
mesh->gnhedges = gnhedges;
mesh->nhedges = nhedges;
mesh->hewgt_dim = hewgt_dim;
mesh->hgid = hgid;
mesh->hindex = hindex;
mesh->hvertex = hvertex;
mesh->hvertex_proc = hvertex_proc;
mesh->heNumWgts = nhedges;
mesh->heWgtId = NULL;
mesh->hewgts = hewgts;
mesh->eb_etypes = (int *) malloc (5 * mesh->num_el_blks * sizeof(int));
if (!mesh->eb_etypes) {
Gen_Error(0, "fatal: insufficient memory");
return 0;
}
mesh->eb_ids = mesh->eb_etypes + mesh->num_el_blks;
mesh->eb_cnts = mesh->eb_ids + mesh->num_el_blks;
mesh->eb_nnodes = mesh->eb_cnts + mesh->num_el_blks;
mesh->eb_nattrs = mesh->eb_nnodes + mesh->num_el_blks;
mesh->eb_names = (char **) malloc (mesh->num_el_blks * sizeof(char *));
if (!mesh->eb_names) {
Gen_Error(0, "fatal: insufficient memory");
return 0;
}
mesh->eb_etypes[0] = -1;
mesh->eb_ids[0] = 1;
mesh->eb_cnts[0] = nvtxs;
mesh->eb_nattrs[0] = 0;
/*
* Each element has one set of coordinates (i.e., node) if a coords file
* was provided; zero otherwise.
*/
MPI_Bcast( &ch_no_geom, 1, MPI_INT, 0, MPI_COMM_WORLD);
if (ch_no_geom)
mesh->eb_nnodes[0] = 0;
else
mesh->eb_nnodes[0] = 1;
/* allocate space for name */
mesh->eb_names[0] = (char *) malloc((MAX_STR_LENGTH+1) * sizeof(char));
if (!mesh->eb_names[0]) {
Gen_Error(0, "fatal: insufficient memory");
return 0;
}
strcpy(mesh->eb_names[0], "hypergraph");
/* allocate the element structure array */
mesh->elements = (ELEM_INFO_PTR) malloc (mesh->elem_array_len
* sizeof(ELEM_INFO));
if (!(mesh->elements)) {
Gen_Error(0, "fatal: insufficient memory");
return 0;
}
/*
* initialize all of the element structs as unused by
* setting the globalID to -1
*/
for (i = 0; i < mesh->elem_array_len; i++)
initialize_element(&(mesh->elements[i]));
/*
* now fill the element structure array with the
* information from the Chaco file
* Use hypergraph vertex information and chaco edge information.
*/
if (!chaco_fill_elements(Proc, Num_Proc, prob, mesh, gnvtxs, nvtxs,
ch_start, ch_adj, vwgt_dim, vwgts, ch_ewgt_dim, ch_ewgts,
ch_ndim, ch_x, ch_y, ch_z, ch_assignments, base)) {
Gen_Error(0, "fatal: Error returned from chaco_fill_elements");
return 0;
}
#if 0
debug_elements(Proc, Num_Proc, mesh->num_elems,mesh->elements);
#endif
safe_free((void **)(void *) &vwgts);
safe_free((void **)(void *) &ch_ewgts);
safe_free((void **)(void *) &ch_vwgts);
safe_free((void **)(void *) &ch_x);
safe_free((void **)(void *) &ch_y);
safe_free((void **)(void *) &ch_z);
safe_free((void **)(void *) &ch_start);
safe_free((void **)(void *) &ch_adj);
safe_free((void **)(void *) &ch_assignments);
if (Debug_Driver > 3)
print_distributed_mesh(Proc, Num_Proc, mesh);
DEBUG_TRACE_END(Proc, yo);
return 1;
}
