int
Zoltan_Matrix_Build (ZZ* zz, Zoltan_matrix_options *opt, Zoltan_matrix* matrix,
int request_GNOs, /* Input: Flag indicating calling code
needs translation of extra GIDs
to GNOs; partial 2D coloring
needs this feature. */
int num_requested, /* Input: Local # of GIDs needing
translation to GNOs. */
ZOLTAN_ID_PTR requested_GIDs, /* Input: Calling code requests the
GNOs for these GIDs */
ZOLTAN_GNO_TYPE *requested_GNOs /* Output: Return GNOs of
the requested GIDs. */
)
{
static char *yo = "Zoltan_Matrix_Build";
int ierr = ZOLTAN_OK;
int nX;
ZOLTAN_GNO_TYPE tmp;
ZOLTAN_GNO_TYPE *xGNO = NULL;
ZOLTAN_ID_PTR xLID=NULL;
ZOLTAN_ID_PTR xGID=NULL;
ZOLTAN_ID_PTR yGID=NULL;
ZOLTAN_ID_PTR pinID=NULL;
float *xwgt = NULL;
int * Input_Parts=NULL;
struct Zoltan_DD_Struct *dd = NULL;
int *proclist = NULL;
int *xpid = NULL;
int i;
int gno_size_for_dd;
MPI_Datatype zoltan_gno_mpi_type;
int use_full_dd = (opt->speed == MATRIX_FULL_DD);
int fast_build_base = opt->fast_build_base;
matrix->opts.speed = opt->speed;
matrix->opts.fast_build_base = opt->fast_build_base;
ZOLTAN_TRACE_ENTER(zz, yo);
if (num_requested && (!requested_GIDs || !requested_GNOs)) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo,
"Error in requested input; needed arrays are NULL.\n");
}
/* ZOLTAN_GNO_TYPE is >= ZOLTAN_ID_TYPE */
gno_size_for_dd = sizeof(ZOLTAN_GNO_TYPE) / sizeof(ZOLTAN_ID_TYPE);
zoltan_gno_mpi_type = Zoltan_mpi_gno_type();
memset (matrix, 0, sizeof(Zoltan_matrix)); /* Set all fields to 0 */
memcpy (&matrix->opts, opt, sizeof(Zoltan_matrix_options));
/**************************************************/
/* Obtain vertex information from the application */
/**************************************************/
ierr = Zoltan_Get_Obj_List(zz, &nX, &xGID, &xLID,
zz->Obj_Weight_Dim, &xwgt,
&Input_Parts);
if (ierr != ZOLTAN_OK && ierr != ZOLTAN_WARN) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Error getting object data");
goto End;
}
ZOLTAN_FREE(&Input_Parts);
ZOLTAN_FREE(&xwgt);
/*******************************************************************/
/* Assign vertex consecutive numbers (gnos) */
/*******************************************************************/
if (use_full_dd) {
/* Zoltan computes a translation */
/* Have to use Data Directory if request_GNOs is true. */
if (nX) {
xGNO = (ZOLTAN_GNO_TYPE*) ZOLTAN_MALLOC(nX*sizeof(ZOLTAN_GNO_TYPE));
if (xGNO == NULL)
MEMORY_ERROR;
}
ierr = Zoltan_PHG_GIDs_to_global_numbers(zz, xGNO, nX, matrix->opts.randomize, &matrix->globalX);
if (ierr != ZOLTAN_OK && ierr != ZOLTAN_WARN) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Error assigning global numbers to vertices");
goto End;
}
ierr = Zoltan_DD_Create (&dd, zz->Communicator, zz->Num_GID, gno_size_for_dd, 0, nX, 0);
CHECK_IERR;
/* Make our new numbering public */
Zoltan_DD_Update (dd, xGID, (ZOLTAN_ID_PTR) xGNO, NULL, NULL, nX);
if (request_GNOs) {
Zoltan_DD_Find(dd, requested_GIDs, (ZOLTAN_ID_PTR) requested_GNOs,
NULL, NULL, num_requested, NULL);
}
}
else { /* We don't want to use the DD */
/*
* KDDKDD 2/10/11 This code cannot work when NUM_GID_ENTRIES>1.
* KDDKDD 2/10/11 The assumption is that, if a user sets the
* KDDKDD 2/10/11 appropriate parameter to enable this code, the user
* KDDKDD 2/10/11 knows that his GIDs are compatible with integers.
*/
if (sizeof(ZOLTAN_GNO_TYPE) != sizeof(ZOLTAN_ID_TYPE)){
xGNO = (ZOLTAN_GNO_TYPE*) ZOLTAN_MALLOC(nX*sizeof(ZOLTAN_GNO_TYPE));
if (nX && xGNO == NULL)
MEMORY_ERROR;
for (i=0; i < nX; i++)
xGNO[i] = (ZOLTAN_GNO_TYPE)xGID[i] - fast_build_base;
}
else {
xGNO = (ZOLTAN_GNO_TYPE *)xGID;
if (fast_build_base)
for (i = 0; i < nX; i++)
xGNO[i] -= fast_build_base;
}
for (i = 0; i < num_requested; i++)
requested_GNOs[i] = (ZOLTAN_GNO_TYPE)requested_GIDs[i]
- fast_build_base;
tmp = (ZOLTAN_GNO_TYPE)nX;
MPI_Allreduce(&tmp, &matrix->globalX, 1, zoltan_gno_mpi_type, MPI_SUM, zz->Communicator);
}
/* I store : xGNO, xGID, xpid, */
ierr = Zoltan_DD_Create (&matrix->ddX, zz->Communicator, gno_size_for_dd, zz->Num_GID,
sizeof(int), matrix->globalX/zz->Num_Proc, 0);
CHECK_IERR;
/* Hope a linear assignment will help a little */
if (matrix->globalX/zz->Num_Proc)
Zoltan_DD_Set_Neighbor_Hash_Fn1(matrix->ddX, matrix->globalX/zz->Num_Proc);
/* Associate all the data with our xGNO */
xpid = (int*)ZOLTAN_MALLOC(nX*sizeof(int));
if (nX >0 && xpid == NULL) MEMORY_ERROR;
for (i = 0 ; i < nX ; ++i)
xpid[i] = zz->Proc;
Zoltan_DD_Update (matrix->ddX, (ZOLTAN_ID_PTR)xGNO, xGID, (char *)xpid, NULL, nX);
ZOLTAN_FREE(&xpid);
if (matrix->opts.pinwgt)
matrix->pinwgtdim = zz->Edge_Weight_Dim;
else
matrix->pinwgtdim = 0;
ierr = matrix_get_edges(zz, matrix, &yGID, &pinID, nX, &xGID, &xLID, &xGNO, &xwgt, use_full_dd);
CHECK_IERR;
matrix->nY_ori = matrix->nY;
if ((ierr != ZOLTAN_OK) && (ierr != ZOLTAN_WARN)){
goto End;
}
if (matrix->opts.enforceSquare && matrix->redist) {
/* Convert yGID to yGNO using the same translation as x */
/* Needed for graph : rowID = colID */
/* y and x may have different distributions */
matrix->yGNO = (ZOLTAN_GNO_TYPE*)ZOLTAN_MALLOC(matrix->nY * sizeof(ZOLTAN_GNO_TYPE));
if (matrix->nY && matrix->yGNO == NULL) {
ZOLTAN_FREE(&pinID);
MEMORY_ERROR;
}
ierr = Zoltan_DD_Find (dd, yGID, (ZOLTAN_ID_PTR)(matrix->yGNO), NULL, NULL,
matrix->nY, NULL);
if (ierr != ZOLTAN_OK) {
ZOLTAN_PRINT_ERROR(zz->Proc,yo,"Hyperedge GIDs don't match.\n");
ierr = ZOLTAN_FATAL;
ZOLTAN_FREE(&pinID);
goto End;
}
}
if (matrix->opts.local) { /* keep only local edges */
proclist = (int*) ZOLTAN_MALLOC(matrix->nPins*sizeof(int));
if (matrix->nPins && proclist == NULL) {
ZOLTAN_FREE(&pinID);
MEMORY_ERROR;
}
}
else
proclist = NULL;
/* Convert pinID to pinGNO using the same translation as x */
if (use_full_dd) {
matrix->pinGNO = (ZOLTAN_GNO_TYPE*)ZOLTAN_MALLOC(matrix->nPins* sizeof(ZOLTAN_GNO_TYPE));
if ((matrix->nPins > 0) && (matrix->pinGNO == NULL)) {
ZOLTAN_FREE(&pinID);
MEMORY_ERROR;
}
ierr = Zoltan_DD_Find (dd, pinID, (ZOLTAN_ID_PTR)(matrix->pinGNO), NULL, NULL,
matrix->nPins, proclist);
if (ierr != ZOLTAN_OK) {
ZOLTAN_PRINT_ERROR(zz->Proc,yo,"Undefined GID found.\n");
ierr = ZOLTAN_FATAL;
goto End;
}
ZOLTAN_FREE(&pinID);
Zoltan_DD_Destroy(&dd);
dd = NULL;
}
else {
if (sizeof(ZOLTAN_GNO_TYPE) != sizeof(ZOLTAN_ID_TYPE)){
matrix->pinGNO = (ZOLTAN_GNO_TYPE *)ZOLTAN_MALLOC(matrix->nPins * sizeof(ZOLTAN_GNO_TYPE));
if (matrix->nPins && !matrix->pinGNO){
ZOLTAN_FREE(&pinID);
MEMORY_ERROR;
}
for (i=0; i < matrix->nPins; i++)
matrix->pinGNO[i] = (ZOLTAN_GNO_TYPE)pinID[i] - fast_build_base;
ZOLTAN_FREE(&pinID);
}
else{
matrix->pinGNO = (ZOLTAN_GNO_TYPE *) pinID;
if (fast_build_base)
for (i=0; i < matrix->nPins; i++)
matrix->pinGNO[i] -= fast_build_base;
pinID = NULL;
}
}
/* if (matrix->opts.local) { /\* keep only local edges *\/ */
/* int *nnz_list; /\* nnz offset to delete *\/ */
/* int nnz; /\* number of nnz to delete *\/ */
/* int i; */
/* nnz_list = (int*) ZOLTAN_MALLOC(matrix->nPins*sizeof(int)); */
/* if (matrix->nPins && nnz_list == NULL) MEMORY_ERROR; */
/* for (i = 0, nnz=0 ; i < matrix->nPins ; ++i) { */
/* if (proclist[i] == zz->Proc) continue; */
/* nnz_list[nnz++] = i; */
/* } */
/* ZOLTAN_FREE(&proclist); */
/* Zoltan_Matrix_Delete_nnz(zz, matrix, nnz, nnz_list); */
/* } */
if (!matrix->opts.enforceSquare) {
/* Hyperedges name translation is different from the one of vertices */
matrix->yGNO = (ZOLTAN_GNO_TYPE*)ZOLTAN_CALLOC(matrix->nY, sizeof(ZOLTAN_GNO_TYPE));
if (matrix->nY && matrix->yGNO == NULL) MEMORY_ERROR;
/* int nGlobalEdges = 0; */
ierr = Zoltan_PHG_GIDs_to_global_numbers(zz, matrix->yGNO, matrix->nY,
matrix->opts.randomize, &matrix->globalY);
CHECK_IERR;
/* /\**************************************************************************************** */
/* * If it is desired to remove dense edges, divide the list of edges into */
/* * two lists. The ZHG structure will contain the removed edges (if final_output is true), */
/* * and the kept edges will be returned. */
/* ****************************************************************************************\/ */
/* totalNumEdges = zhg->globalHedges; */
/* ierr = remove_dense_edges_matrix(zz, zhg, edgeSizeThreshold, final_output, */
/* &nLocalEdges, &nGlobalEdges, &nPins, */
/* &edgeGNO, &edgeSize, &edgeWeight, &pinGNO, &pinProcs); */
/* if (nGlobalEdges < totalNumEdges){ */
/* /\* re-assign edge global numbers if any edges were removed *\/ */
/* ierr = Zoltan_PHG_GIDs_to_global_numbers(zz, edgeGNO, nLocalEdges, */
/* randomizeInitDist, &totalNumEdges); */
/* if (ierr != ZOLTAN_OK && ierr != ZOLTAN_WARN) { */
/* ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Error reassigning global numbers to edges"); */
/* goto End; */
/* } */
/* } */
/* We have to define ddY : yGNO, yGID, ywgt */
ierr = Zoltan_DD_Create (&matrix->ddY, zz->Communicator, gno_size_for_dd, zz->Num_GID,
0, matrix->globalY/zz->Num_Proc, 0);
/* Hope a linear assignment will help a little */
if (matrix->globalY/zz->Num_Proc)
Zoltan_DD_Set_Neighbor_Hash_Fn1(matrix->ddY, matrix->globalY/zz->Num_Proc);
/* Associate all the data with our yGNO */
Zoltan_DD_Update (matrix->ddY, (ZOLTAN_ID_PTR)matrix->yGNO, yGID, NULL, NULL, matrix->nY);
}
End:
ZOLTAN_FREE(&xpid);
ZOLTAN_FREE(&xLID);
ZOLTAN_FREE(&xGNO);
ZOLTAN_FREE(&xGID);
ZOLTAN_FREE(&xwgt);
ZOLTAN_FREE(&Input_Parts);
ZOLTAN_FREE(&proclist);
if (dd != NULL)
Zoltan_DD_Destroy(&dd);
/* Already stored in the DD */
ZOLTAN_FREE(&yGID);
ZOLTAN_TRACE_EXIT(zz, yo);
return (ierr);
}
int Zoltan_Verify_Graph(MPI_Comm comm, indextype *vtxdist, indextype *xadj,
indextype *adjncy, weighttype *vwgt, weighttype *adjwgt,
int vwgt_dim, int ewgt_dim,
int graph_type, int check_graph, int output_level)
{
int ierr, flag, cross_edges = 0, mesg_size, sum;
int nprocs, proc, *proclist, errors, global_errors;
int *perm=NULL;
int free_adjncy_sort=0;
ZOLTAN_COMM_OBJ *comm_plan;
static char *yo = "Zoltan_Verify_Graph";
char msg[256];
ZOLTAN_GNO_TYPE num_obj;
int nrecv;
indextype *ptr, *ptr1, *ptr2;
indextype global_i, global_j;
indextype *sendgno=NULL, *recvgno=NULL, *adjncy_sort=NULL;
weighttype *sendwgt, *recvwgt;
ZOLTAN_GNO_TYPE num_duplicates, num_singletons;
ZOLTAN_GNO_TYPE num_selfs, nedges, global_sum, num_zeros;
ZOLTAN_GNO_TYPE i, j, ii, k;
MPI_Datatype zoltan_gno_mpi_type;
ierr = ZOLTAN_OK;
zoltan_gno_mpi_type = Zoltan_mpi_gno_type();
/* Make sure all procs have same value of check_graph. */
MPI_Allreduce(&check_graph, &i, 1, MPI_INT, MPI_MAX, comm);
check_graph = i;
if (check_graph == 0) /* perform no error checking at all */
return ierr;
/* Get number of procs and my rank */
MPI_Comm_size(comm, &nprocs);
MPI_Comm_rank(comm, &proc);
/* Check number of vertices (objects) */
num_obj = (ZOLTAN_GNO_TYPE)(vtxdist[proc+1] - vtxdist[proc]);
MPI_Reduce(&num_obj, &global_sum, 1, zoltan_gno_mpi_type, MPI_SUM, 0, comm);
if ((proc==0) && (global_sum==0)){
if (ierr == ZOLTAN_OK) ierr = ZOLTAN_WARN;
if (output_level>0)
ZOLTAN_PRINT_WARN(proc, yo, "No vertices in graph.");
}
/* Verify that vertex weights are non-negative */
num_zeros = 0;
if (vwgt_dim){
for (i=0; i<num_obj; i++){
sum = 0;
for (k=0; k<vwgt_dim; k++){
if (vwgt[i*vwgt_dim+k] < 0) {
sprintf(msg, "Negative object weight of " TPL_WGT_SPEC " for object " ZOLTAN_GNO_SPEC ".",
vwgt[i*vwgt_dim+k], i);
ZOLTAN_PRINT_ERROR(proc, yo, msg);
ierr = ZOLTAN_FATAL;
}
sum += vwgt[i*vwgt_dim+k];
}
if (sum == 0){
num_zeros++;
if (output_level>1) {
sprintf(msg, "Zero vertex (object) weights for object " ZOLTAN_GNO_SPEC ".", i);
ZOLTAN_PRINT_WARN(proc, yo, msg);
}
if (ierr == ZOLTAN_OK) ierr = ZOLTAN_WARN;
}
}
MPI_Reduce(&num_zeros, &global_sum, 1, zoltan_gno_mpi_type, MPI_SUM, 0, comm);
if ((proc==0) && (global_sum>0)){
if (ierr == ZOLTAN_OK) ierr = ZOLTAN_WARN;
if (output_level>0){
sprintf(msg, ZOLTAN_GNO_SPEC " objects have zero weights.", global_sum);
ZOLTAN_PRINT_WARN(proc, yo, msg);
}
}
}
/* Check number of edges */
nedges = (ZOLTAN_GNO_TYPE)xadj[num_obj];
MPI_Reduce(&nedges, &global_sum, 1, zoltan_gno_mpi_type, MPI_SUM, 0, comm);
if ((proc==0) && (global_sum==0)){
if (ierr == ZOLTAN_OK) ierr = ZOLTAN_WARN;
if (output_level>0)
ZOLTAN_PRINT_WARN(proc, yo, "No edges in graph.");
}
/* Verify that edge weights are non-negative */
num_zeros = 0;
if (ewgt_dim){
for (j=0; j<nedges; j++){
sum = 0;
for (k=0; k<ewgt_dim; k++){
if (adjwgt[j*ewgt_dim+k] < 0) {
sprintf(msg, "Negative edge weight of " TPL_WGT_SPEC " in edge " ZOLTAN_GNO_SPEC ".",
adjwgt[j*ewgt_dim+k], j);
ZOLTAN_PRINT_ERROR(proc, yo, msg);
ierr = ZOLTAN_FATAL;
}
sum += adjwgt[j*ewgt_dim+k];
}
if (sum == 0){
num_zeros++;
if (output_level>1) {
sprintf(msg, "Zero edge (communication) weights for edge " ZOLTAN_GNO_SPEC ".", j);
ZOLTAN_PRINT_WARN(proc, yo, msg);
}
if (ierr == ZOLTAN_OK) ierr = ZOLTAN_WARN;
}
}
MPI_Reduce(&num_zeros, &global_sum, 1, zoltan_gno_mpi_type, MPI_SUM, 0, comm);
if ((proc==0) && (global_sum>0)){
if (ierr == ZOLTAN_OK) ierr = ZOLTAN_WARN;
if (output_level>0){
sprintf(msg, ZOLTAN_GNO_SPEC " edges have zero weights.", global_sum);
ZOLTAN_PRINT_WARN(proc, yo, msg);
}
}
}
/* Verify that the graph is symmetric (edge weights, too) */
/* Also check for self-edges and multi-edges */
/* Pre-processing: Check if edge lists are sorted. If not, */
/* make a copy and sort so we can save time in the lookups. */
flag = 0; /* Assume sorted. */
for (i=0; (i<num_obj) && (flag==0); i++){
for (ii=xadj[i]; ii<xadj[i+1]-1; ii++){
if (adjncy[ii] > adjncy[ii+1]){
flag = 1; /* Not sorted. */
break;
}
}
}
if (flag){ /* Need to sort. */
adjncy_sort = (indextype *) ZOLTAN_MALLOC(nedges*sizeof(indextype));
perm = (int *) ZOLTAN_MALLOC(nedges*sizeof(int));
free_adjncy_sort = 1;
if (nedges && (!adjncy_sort || !perm)){
/* Out of memory. */
ZOLTAN_PRINT_ERROR(proc, yo, "Out of memory.");
ierr = ZOLTAN_MEMERR;
}
for (k=0; k<nedges; k++){
adjncy_sort[k] = adjncy[k];
perm[k] = k;
}
if (sizeof(indextype) == sizeof(short)){
for (i=0; i<num_obj; i++)
Zoltan_quicksort_list_inc_short((short *)adjncy_sort, perm, (int)xadj[i], (int)xadj[i+1]-1);
}
else if (sizeof(indextype) == sizeof(int)){
for (i=0; i<num_obj; i++)
Zoltan_quicksort_list_inc_int((int *)adjncy_sort, perm, (int)xadj[i], (int)xadj[i+1]-1);
}
else if (sizeof(indextype) == sizeof(long)){
for (i=0; i<num_obj; i++)
Zoltan_quicksort_list_inc_long((long *)adjncy_sort, perm, (int)xadj[i], (int)xadj[i+1]-1);
}
else if (sizeof(indextype) == sizeof(int64_t)){
for (i=0; i<num_obj; i++)
Zoltan_quicksort_list_inc_long_long((int64_t*)adjncy_sort, perm, (int)xadj[i], (int)xadj[i+1]-1);
}
else{
ZOLTAN_PRINT_ERROR(proc, yo, "Error in third party library data type support.");
ierr = ZOLTAN_MEMERR;
}
}
else { /* Already sorted. */
adjncy_sort = adjncy;
}
/* First pass: Check on-processor edges and count # off-proc edges */
cross_edges = 0;
num_selfs = 0;
num_duplicates = 0;
num_singletons = 0;
for (i=0; i<num_obj; i++){
if (IS_GLOBAL_GRAPH(graph_type)){
global_i = vtxdist[proc]+i;
}
else{ /* graph_type == LOCAL_GRAPH */
global_i = i; /* A bit confusingly, global_i = i for local graphs */
}
/* Singleton? */
if (xadj[i] == xadj[i+1]){
num_singletons++;
if (output_level>1){
sprintf(msg, "Vertex " TPL_IDX_SPEC " has no edges.", global_i);
ZOLTAN_PRINT_WARN(proc, yo, msg);
}
}
for (ii=xadj[i]; ii<xadj[i+1]; ii++){
global_j = adjncy_sort[ii];
/* Valid vertex number? */
if ((IS_GLOBAL_GRAPH(graph_type) &&
((global_j < vtxdist[0]) || (global_j >= vtxdist[nprocs])))
|| (IS_LOCAL_GRAPH(graph_type) &&
((global_j < 0) || (global_j >= num_obj)))){
sprintf(msg, "Edge to invalid vertex " TPL_IDX_SPEC " detected.", global_j);
ZOLTAN_PRINT_ERROR(proc, yo, msg);
ierr = ZOLTAN_FATAL;
}
/* Self edge? */
if (global_j == global_i){
num_selfs++;
if (output_level>1){
sprintf(msg, "Self edge for vertex " TPL_IDX_SPEC " detected.", global_i);
ZOLTAN_PRINT_WARN(proc, yo, msg);
}
}
/* Duplicate edge? */
if ((ii+1<xadj[i+1]) && (adjncy_sort[ii]==adjncy_sort[ii+1])){
num_duplicates++;
if (output_level>1){
sprintf(msg, "Duplicate edge (" TPL_IDX_SPEC "," TPL_IDX_SPEC ") detected.", global_i, global_j);
ZOLTAN_PRINT_WARN(proc, yo, msg);
}
}
/* Is global_j a local vertex? */
if (IS_LOCAL_GRAPH(graph_type) || (IS_GLOBAL_GRAPH(graph_type) &&
(global_j >= vtxdist[proc]) && (global_j < vtxdist[proc+1]))){
/* Check if (global_j, global_i) is an edge */
if (IS_GLOBAL_GRAPH(graph_type))
j = global_j - vtxdist[proc];
else /* graph_type == LOCAL_GRAPH */
j = global_j;
/* Binary search for edge (global_j, global_i) */
ptr = (indextype *)bsearch(&global_i, &adjncy_sort[xadj[j]], (int)(xadj[j+1]-xadj[j]),
sizeof(indextype), Zoltan_Compare_Indextypes);
if (ptr){
/* OK, found edge (global_j, global_i) */
if ((adjncy_sort==adjncy) && ewgt_dim){
/* Compare weights */
/* EBEB For now, don't compare weights if we sorted edge lists. */
flag = 0;
for (k=0; k<ewgt_dim; k++){
if (adjwgt[(ptr-adjncy_sort)*ewgt_dim+k] !=
adjwgt[ii*ewgt_dim+k]){
/* Numerically nonsymmetric */
flag = -1;
if (ierr == ZOLTAN_OK) ierr = ZOLTAN_WARN;
}
}
if (flag<0 && output_level>0){
sprintf(msg, "Graph is numerically nonsymmetric "
"in edge (" TPL_IDX_SPEC "," TPL_IDX_SPEC ")", global_i, global_j);
ZOLTAN_PRINT_WARN(proc, yo, msg);
}
}
}
else { /* bsearch failed */
sprintf(msg, "Graph is not symmetric. "
"Edge (" TPL_IDX_SPEC "," TPL_IDX_SPEC ") exists, but no edge (" TPL_IDX_SPEC "," TPL_IDX_SPEC ").",
global_i, global_j, global_j, global_i);
ZOLTAN_PRINT_ERROR(proc, yo, msg);
ierr = ZOLTAN_FATAL;
}
}
else {
cross_edges++;
}
}
}
/* Sum up warnings so far. */
MPI_Reduce(&num_selfs, &global_sum, 1, zoltan_gno_mpi_type, MPI_SUM, 0, comm);
if ((proc==0) && (global_sum>0)){
ierr = ZOLTAN_WARN;
if (output_level>0){
sprintf(msg, ZOLTAN_GNO_SPEC " self-edges in graph.", global_sum);
ZOLTAN_PRINT_WARN(proc, yo, msg);
}
}
MPI_Reduce(&num_duplicates, &global_sum, 1, zoltan_gno_mpi_type, MPI_SUM, 0, comm);
if ((proc==0) && (global_sum>0)){
ierr = ZOLTAN_WARN;
if (output_level>0){
sprintf(msg, ZOLTAN_GNO_SPEC " duplicate edges in graph.", global_sum);
ZOLTAN_PRINT_WARN(proc, yo, msg);
}
}
MPI_Reduce(&num_singletons, &global_sum, 1, zoltan_gno_mpi_type, MPI_SUM, 0, comm);
if ((proc==0) && (global_sum>0)){
ierr = ZOLTAN_WARN;
if (output_level>0){
sprintf(msg, ZOLTAN_GNO_SPEC " vertices in the graph are singletons (have no edges).", global_sum);
ZOLTAN_PRINT_WARN(proc, yo, msg);
}
}
/* Check if any processor has encountered an error so far */
errors = 0;
if (ierr == ZOLTAN_WARN)
errors |= 1;
if (ierr == ZOLTAN_MEMERR)
errors |= 2;
if (ierr == ZOLTAN_FATAL)
errors |= 4;
MPI_Allreduce(&errors, &global_errors, 1, MPI_INT, MPI_BOR, comm);
if (global_errors & 4){
/* Fatal error: return now */
if (free_adjncy_sort) ZOLTAN_FREE(&adjncy_sort);
if (free_adjncy_sort) ZOLTAN_FREE(&perm);
return ZOLTAN_FATAL;
}
if ((IS_GLOBAL_GRAPH(graph_type)) && (check_graph >= 2)) {
/* Test for consistency across processors. */
/* Allocate space for off-proc data */
mesg_size = (2*sizeof(indextype)) + (ewgt_dim * sizeof(weighttype));
sendgno = (indextype *) ZOLTAN_MALLOC(cross_edges*mesg_size);
recvgno = (indextype *) ZOLTAN_MALLOC(cross_edges*mesg_size);
proclist = (int *) ZOLTAN_MALLOC(cross_edges*sizeof(int));
if (cross_edges && !(sendgno && recvgno && proclist)){
ZOLTAN_PRINT_ERROR(proc, yo, "Out of memory.");
ierr = ZOLTAN_MEMERR;
}
/* Second pass: Copy data to send buffer */
nedges = 0;
ptr1 = (indextype *) sendgno;
for (i=0; i<num_obj; i++){
global_i = vtxdist[proc]+i;
for (ii=xadj[i]; ii<xadj[i+1]; ii++){
global_j = adjncy[ii];
/* Is global_j off-proc? */
if ((global_j < vtxdist[proc]) || (global_j >= vtxdist[proc+1])){
/* Add to list */
k=0;
while (global_j >= vtxdist[k+1]) k++;
proclist[nedges++] = k;
/* Copy (global_i, global_j) and corresponding weights to sendgno */
*ptr1++ = global_i;
*ptr1++ = global_j;
for (k=0; k<ewgt_dim; k++){
*ptr1++ = adjwgt[ii*ewgt_dim+k];
}
}
}
}
/* Do the irregular communication */
ierr = Zoltan_Comm_Create(&comm_plan, cross_edges, proclist, comm, TAG1, &nrecv);
if (ierr != ZOLTAN_OK && ierr != ZOLTAN_WARN) {
sprintf(msg, "Error %s returned from Zoltan_Comm_Create.",
(ierr == ZOLTAN_MEMERR ? "ZOLTAN_MEMERR" : "ZOLTAN_FATAL"));
ZOLTAN_PRINT_ERROR(proc, yo, msg);
}
else {
if (nrecv != cross_edges){
sprintf(msg, "Incorrect number of edges to/from proc %d.", proc);
ZOLTAN_PRINT_ERROR(proc, yo, msg);
ierr = ZOLTAN_FATAL;
}
ierr = Zoltan_Comm_Do(comm_plan, TAG2, (char *)sendgno, mesg_size, (char *)recvgno);
Zoltan_Comm_Destroy(&comm_plan);
if (ierr != ZOLTAN_OK && ierr != ZOLTAN_WARN) {
sprintf(msg, "Error %s returned from Zoltan_Comm_Do.",
(ierr == ZOLTAN_MEMERR ? "ZOLTAN_MEMERR" : "ZOLTAN_FATAL"));
ZOLTAN_PRINT_ERROR(proc, yo, msg);
}
else {
/* Third pass: Compare on-proc data to the off-proc data we received */
/* sendgno and recvgno should contain the same data except (i,j) is */
/* (j,i) */
for (i=0, ptr1=sendgno; i<cross_edges; i++){
flag = 0;
sendwgt = (weighttype *)(ptr1 + 2);
for (j=0, ptr2=recvgno; j<cross_edges; j++){
recvwgt = (weighttype *)(ptr2 + 2);
if ((ptr2[0] == ptr1[1]) && (ptr2[1] == ptr1[0])){
/* Found matching edge */
flag = 1;
/* Check weights */
for (k=0; k<ewgt_dim; k++){
if (sendwgt[k] != recvwgt[k]){
flag = -1;
ierr = ZOLTAN_WARN;
}
}
if (flag<0 && output_level>0){
sprintf(msg, "Edge weight (" TPL_IDX_SPEC "," TPL_IDX_SPEC ") is not symmetric",
ptr1[0], ptr1[1]);
ZOLTAN_PRINT_WARN(proc, yo, msg);
}
}
ptr2 = (indextype *)(recvwgt + ewgt_dim);
}
if (!flag){
sprintf(msg, "Graph is not symmetric. "
"Edge (" TPL_IDX_SPEC "," TPL_IDX_SPEC ") exists, but not (" TPL_IDX_SPEC "," TPL_IDX_SPEC ").",
ptr1[0], ptr1[1], ptr1[1], ptr1[0]);
ZOLTAN_PRINT_ERROR(proc, yo, msg);
ierr = ZOLTAN_FATAL;
}
ptr1 = (indextype *)(sendwgt + ewgt_dim);
}
}
}
/* Free memory */
ZOLTAN_FREE(&sendgno);
ZOLTAN_FREE(&recvgno);
ZOLTAN_FREE(&proclist);
}
if (free_adjncy_sort) ZOLTAN_FREE(&adjncy_sort);
if (free_adjncy_sort) ZOLTAN_FREE(&perm);
/* Compute global error code */
errors = 0;
if (ierr == ZOLTAN_WARN)
errors |= 1;
if (ierr == ZOLTAN_MEMERR)
errors |= 2;
if (ierr == ZOLTAN_FATAL)
errors |= 4;
MPI_Allreduce(&errors, &global_errors, 1, MPI_INT, MPI_BOR, comm);
if (global_errors & 4){
return ZOLTAN_FATAL;
}
else if (global_errors & 2){
return ZOLTAN_MEMERR;
}
else if (global_errors & 1){
return ZOLTAN_WARN;
}
else {
if (proc==0 && output_level>0){
printf("ZOLTAN %s: The graph is valid with check_graph = %1d\n",
yo, check_graph);
}
return ZOLTAN_OK;
}
}
static int Zoltan_PHG_Redistribute_Hypergraph(
ZZ *zz,
PHGPartParams *hgp, /* Input: parameters; used only for UseFixedVtx */
HGraph *ohg, /* Input: Local part of distributed hypergraph */
int firstproc, /* Input: rank (in ocomm) of the first proc of
the ncomm*/
int *v2Col, /* Input: Vertex to processor Column Mapping */
int *n2Row, /* Input: Net to processor Row Mapping */
PHGComm *ncomm, /* Input: communicators of new distribution */
HGraph *nhg, /* Output: Newly redistributed hypergraph */
int **vmap, /* Output: allocated with the size nhg->nVtx and
vertex map from nhg to ohg's local vertex number*/
int **vdest /* Output: allocated with the size nhg->nVtx and
stores dest proc in ocomm */
)
{
char * yo = "Zoltan_PHG_Redistribute_Hypergraph";
PHGComm *ocomm = ohg->comm;
int ierr=ZOLTAN_OK;
int i, v, n, nPins, nsend, elemsz, nVtx, nEdge;
int msg_tag = 9999;
int *proclist=NULL, *cnt=NULL;
int *intbuf;
ZOLTAN_GNO_TYPE *sendbuf=NULL;
ZOLTAN_GNO_TYPE *vno=NULL, *nno=NULL, *dist_x=NULL, *dist_y=NULL,
*vsn=NULL, *nsn=NULL, *pins=NULL;
ZOLTAN_COMM_OBJ *plan;
MPI_Datatype zoltan_gno_mpi_type;
zoltan_gno_mpi_type = Zoltan_mpi_gno_type();
Zoltan_HG_HGraph_Init (nhg);
nhg->comm = ncomm;
nhg->dist_x = (ZOLTAN_GNO_TYPE *) ZOLTAN_CALLOC(ncomm->nProc_x+1, sizeof(ZOLTAN_GNO_TYPE));
nhg->dist_y = (ZOLTAN_GNO_TYPE *) ZOLTAN_CALLOC(ncomm->nProc_y+1, sizeof(ZOLTAN_GNO_TYPE));
dist_x = (ZOLTAN_GNO_TYPE *) ZOLTAN_CALLOC(ncomm->nProc_x+1, sizeof(ZOLTAN_GNO_TYPE));
dist_y = (ZOLTAN_GNO_TYPE *) ZOLTAN_CALLOC(ncomm->nProc_y+1, sizeof(ZOLTAN_GNO_TYPE));
vsn = (ZOLTAN_GNO_TYPE *) ZOLTAN_CALLOC(ncomm->nProc_x+1, sizeof(ZOLTAN_GNO_TYPE));
nsn = (ZOLTAN_GNO_TYPE *) ZOLTAN_CALLOC(ncomm->nProc_y+1, sizeof(ZOLTAN_GNO_TYPE));
vno = (ZOLTAN_GNO_TYPE *) ZOLTAN_MALLOC(ohg->nVtx * sizeof(ZOLTAN_GNO_TYPE));
nno = (ZOLTAN_GNO_TYPE *) ZOLTAN_MALLOC(ohg->nEdge * sizeof(ZOLTAN_GNO_TYPE));
if (!nhg->dist_x || !nhg->dist_y || !dist_x || !dist_y ||
!vsn || !nsn || (ohg->nVtx && !vno) || (ohg->nEdge && !nno) ) {
uprintf(ocomm, " new comm nProcx=%d nProcy=%d nvtx=%d nedge=%d", ncomm->nProc_x, ncomm->nProc_y, ohg->nVtx, ohg->nEdge);
MEMORY_ERROR;
}
for (v = 0; v < ohg->nVtx; ++v)
++dist_x[v2Col[v]];
for (n = 0; n < ohg->nEdge; ++n)
++dist_y[n2Row[n]];
/* UVCUVC: CHECK ASSUMPTION
This code assumes that the objects in the receive buffer of
Zoltan_Comm_Do function are
1- in the increasing processor order,
2- order of the items send by a processor is preserved.
*/
/* compute prefix sum to find new vertex start numbers; for each processor */
MPI_Scan(dist_x, vsn, ncomm->nProc_x, zoltan_gno_mpi_type, MPI_SUM, ocomm->row_comm);
/* All reduce to compute how many each processor will have */
MPI_Allreduce(dist_x, &(nhg->dist_x[1]), ncomm->nProc_x, zoltan_gno_mpi_type, MPI_SUM,
ocomm->row_comm);
nhg->dist_x[0] = 0;
for (i=1; i<=ncomm->nProc_x; ++i)
nhg->dist_x[i] += nhg->dist_x[i-1];
MPI_Scan(dist_y, nsn, ncomm->nProc_y, zoltan_gno_mpi_type, MPI_SUM, ocomm->col_comm);
MPI_Allreduce(dist_y, &(nhg->dist_y[1]), ncomm->nProc_y, zoltan_gno_mpi_type, MPI_SUM, ocomm->col_comm);
nhg->dist_y[0] = 0;
for (i=1; i<=ncomm->nProc_y; ++i)
nhg->dist_y[i] += nhg->dist_y[i-1];
#ifdef _DEBUG1
PrintArr(ocomm, "vsn", vsn, ncomm->nProc_x);
PrintArr(ocomm, "nsn", nsn, ncomm->nProc_y);
#endif
/* find mapping of current LOCAL vertex no (in my node)
to "new" vertex no LOCAL to dest node*/
for (v = ohg->nVtx-1; v>=0; --v)
vno[v] = --vsn[v2Col[v]];
for (n = ohg->nEdge-1; n>=0; --n)
nno[n] = --nsn[n2Row[n]];
nsend = MAX(MAX(ohg->nPins, ohg->nVtx), ohg->nEdge);
elemsz = MAX(MAX(2, ohg->VtxWeightDim), ohg->EdgeWeightDim);
elemsz = (sizeof(float)>sizeof(ZOLTAN_GNO_TYPE)) ? sizeof(float)*elemsz : sizeof(ZOLTAN_GNO_TYPE)*elemsz;
proclist = (int *) ZOLTAN_MALLOC(nsend * sizeof(int));
sendbuf = (ZOLTAN_GNO_TYPE *) ZOLTAN_MALLOC(nsend * elemsz);
if (nsend && (!proclist || !sendbuf)) MEMORY_ERROR;
/* first communicate pins */
nPins = 0;
for (v = 0; v < ohg->nVtx; ++v) {
for (i = ohg->vindex[v]; i < ohg->vindex[v+1]; ++i) {
#ifdef _DEBUG1
if ((n2Row[ohg->vedge[i]] * ncomm->nProc_x + v2Col[v])<0 ||
(n2Row[ohg->vedge[i]] * ncomm->nProc_x + v2Col[v])>=ocomm->nProc)
errexit("vertex %d vedge[%d]=%d n2Row=%d #Proc_x=%d v2Col=%d", i, ohg->vedge[i], n2Row[ohg->vedge[i]], ncomm->nProc_x , v2Col[v]);
#endif
proclist[nPins] = firstproc + n2Row[ohg->vedge[i]] * ncomm->nProc_x + v2Col[v];
sendbuf[2*nPins] = vno[v];
sendbuf[2*nPins+1]= nno[ohg->vedge[i]];
++nPins;
}
}
#ifdef _DEBUG1
if (nPins!=ohg->nPins) {
uprintf(ocomm, "sanity check failed nPins(%d)!=hg->nPins(%d)\n", nPins, ohg->nPins);
errexit("terminating");
}
#endif
--msg_tag;
ierr |= Zoltan_Comm_Create(&plan, ohg->nPins, proclist, ocomm->Communicator, msg_tag, &nPins);
#ifdef _DEBUG1
if (ncomm->myProc==-1 && nPins>1) { /* this processor is not in new comm but receiving data?*/
uprintf(ocomm, "Something wrong; why I'm receiving data nPins=%d\n", nPins);
errexit("terminating");
}
#endif
if (nPins && (pins = (ZOLTAN_GNO_TYPE *) ZOLTAN_MALLOC(nPins * 2 * sizeof(ZOLTAN_GNO_TYPE)))==NULL)
MEMORY_ERROR;
--msg_tag;
Zoltan_Comm_Do(plan, msg_tag, (char *) sendbuf, 2*sizeof(ZOLTAN_GNO_TYPE), (char *) pins);
Zoltan_Comm_Destroy(&plan);
/* now communicate vertex map */
nsend = 0;
intbuf = (int *)sendbuf;
if (!ocomm->myProc_y) { /* only first row sends to the first row of ncomm */
for (v = 0; v < ohg->nVtx; ++v) {
proclist[nsend] = firstproc+v2Col[v];
intbuf[nsend++] = ohg->vmap[v];
}
}
--msg_tag;
ierr |= Zoltan_Comm_Create(&plan, nsend, proclist, ocomm->Communicator, msg_tag, &nVtx);
#ifdef _DEBUG1
if (ncomm->myProc==-1 && nVtx>1) { /* this processor is not in new comm but receiving data?*/
uprintf(ocomm, "Something wrong; why I'm receiving data nVtx=%d\n", nVtx);
errexit("terminating");
}
#endif
/* those are only needed in the first row of ncomm */
*vmap = *vdest = NULL;
if (!ncomm->myProc_y && nVtx &&
(!(*vmap = (int *) ZOLTAN_MALLOC(nVtx * sizeof(int))) ||
!(*vdest = (int *) ZOLTAN_MALLOC(nVtx * sizeof(int)))))
MEMORY_ERROR;
--msg_tag;
Zoltan_Comm_Do(plan, msg_tag, (char *) sendbuf, sizeof(int), (char *) *vmap);
intbuf = (int *)sendbuf;
if (!ocomm->myProc_y) { /* only first row sends to the first row of ncomm */
for (v = 0; v < ohg->nVtx; ++v)
intbuf[v] = ocomm->myProc;
}
--msg_tag;
Zoltan_Comm_Do(plan, msg_tag, (char *) sendbuf, sizeof(int), (char *) *vdest);
if (ncomm->myProc!=-1) { /* I'm in the new comm */
/* ncomm's first row now bcast to other rows */
MPI_Bcast(&nVtx, 1, MPI_INT, 0, ncomm->col_comm);
#ifdef _DEBUG1
if (nVtx!=(int)(nhg->dist_x[ncomm->myProc_x+1] - nhg->dist_x[ncomm->myProc_x]))
errexit("nVtx(%d)!= nhg->dist_x[ncomm->myProc_x+1] - nhg->dist_x[ncomm->myProc_x](%d)", nVtx, nhg->dist_x[ncomm->myProc_x+1] - nhg->dist_x[ncomm->myProc_x]);
#endif
if (nVtx && (nhg->vmap = (int *) ZOLTAN_MALLOC(nVtx * sizeof(int)))==NULL)
MEMORY_ERROR;
for (i=0; i<nVtx; ++i)
nhg->vmap[i] = i;
}
/* now communicate vertex weights */
if (ohg->VtxWeightDim) {
if (nVtx){
nhg->vwgt = (float*) ZOLTAN_MALLOC(nVtx*ohg->VtxWeightDim*sizeof(float));
if (!nhg->vwgt) MEMORY_ERROR;
}
--msg_tag;
Zoltan_Comm_Do(plan, msg_tag, (char *) ohg->vwgt,
ohg->VtxWeightDim*sizeof(float), (char *) nhg->vwgt);
if (ncomm->myProc!=-1) /* ncomm's first row now bcast to other rows */
MPI_Bcast(nhg->vwgt, nVtx*ohg->VtxWeightDim, MPI_FLOAT, 0, ncomm->col_comm);
}
/* communicate coordinates */
if (ohg->nDim) {
if (nVtx) {
nhg->coor = (double *) ZOLTAN_MALLOC(nVtx * ohg->nDim * sizeof(double));
if (!nhg->coor) MEMORY_ERROR;
}
--msg_tag;
Zoltan_Comm_Do(plan, msg_tag, (char *) ohg->coor, ohg->nDim * sizeof(double),
(char *) nhg->coor);
if (ncomm->myProc != -1) /* ncomm's first row bcast to other rows */
MPI_Bcast(nhg->coor, nVtx * ohg->nDim, MPI_DOUBLE, 0, ncomm->col_comm);
}
/* communicate fixed vertices, if any */
if (hgp->UseFixedVtx) {
if (nVtx){
nhg->fixed_part = (int *) ZOLTAN_MALLOC(nVtx*sizeof(int));
if (!nhg->fixed_part) MEMORY_ERROR;
}
--msg_tag;
Zoltan_Comm_Do(plan, msg_tag, (char *) ohg->fixed_part,
sizeof(int), (char *) nhg->fixed_part);
if (ncomm->myProc!=-1) /* ncomm's first row now bcast to other rows */
MPI_Bcast(nhg->fixed_part, nVtx, MPI_INT, 0, ncomm->col_comm);
}
/* communicate pref parts, if any */
if (hgp->UsePrefPart) {
if (nVtx){
nhg->pref_part = (int *) ZOLTAN_MALLOC(nVtx*sizeof(int));
if (!nhg->pref_part) MEMORY_ERROR;
}
--msg_tag;
Zoltan_Comm_Do(plan, msg_tag, (char *) ohg->pref_part,
sizeof(int), (char *) nhg->pref_part);
if (ncomm->myProc!=-1) /* ncomm's first row now bcast to other rows */
MPI_Bcast(nhg->pref_part, nVtx, MPI_INT, 0, ncomm->col_comm);
}
/* this comm plan is no longer needed. */
Zoltan_Comm_Destroy(&plan);
if (ohg->EdgeWeightDim) { /* now communicate edge weights */
nsend = 0;
if (!ocomm->myProc_x) /* only first column sends to first column of ncomm */
for (n = 0; n < ohg->nEdge; ++n)
proclist[nsend++] = firstproc + n2Row[n]*ncomm->nProc_x;
--msg_tag;
ierr |= Zoltan_Comm_Create(&plan, nsend, proclist, ocomm->Communicator,
msg_tag, &nEdge);
#ifdef _DEBUG1
if (ncomm->myProc==-1 && nEdge>1) { /* this processor is not in new comm but receiving data?*/
uprintf(ocomm, "Something wrong; why I'm receiving data nEdge=%d\n", nEdge);
errexit("terminating");
}
#endif
if (ncomm->myProc!=-1) { /* if we're in the new comm */
/* ncomm's first column now bcast to other columns */
MPI_Bcast(&nEdge, 1, MPI_INT, 0, ncomm->row_comm);
#ifdef _DEBUG1
if (nEdge != (nhg->dist_y[ncomm->myProc_y+1] - nhg->dist_y[ncomm->myProc_y]))
errexit("nEdge(%d)!=nhg->dist_y[ncomm->myProc_y+1] - nhg->dist_y[ncomm->myProc_y](%d)", nEdge, nhg->dist_y[ncomm->myProc_y+1] - nhg->dist_y[ncomm->myProc_y]);
#endif
}
if (nEdge){
nhg->ewgt = (float*) ZOLTAN_MALLOC(nEdge*ohg->EdgeWeightDim*sizeof(float));
if (!nhg->ewgt) MEMORY_ERROR;
}
--msg_tag;
Zoltan_Comm_Do(plan, msg_tag, (char *) ohg->ewgt,
ohg->EdgeWeightDim*sizeof(float), (char *) nhg->ewgt);
if (ncomm->myProc!=-1) { /* if we're in the new comm */
/* ncomm's first column now bcast to other columns */
if (nEdge)
MPI_Bcast(nhg->ewgt, nEdge*ohg->EdgeWeightDim, MPI_FLOAT, 0,
ncomm->row_comm);
}
Zoltan_Comm_Destroy(&plan);
} else
nEdge = (ncomm->myProc==-1)
? 0
: (int)(nhg->dist_y[ncomm->myProc_y+1] - nhg->dist_y[ncomm->myProc_y]);
if (ncomm->myProc==-1) {
#ifdef _DEBUG1
if (nPins || nVtx || nEdge)
errexit("I should not have any data: hey nPins=%d nVtx=%d nEdge=%d\n", nPins, nVtx, nEdge);
#endif
nhg->nEdge = nhg->nVtx = nhg->nPins = 0;
} else {
nhg->nEdge = (int)(nhg->dist_y[ncomm->myProc_y+1] - nhg->dist_y[ncomm->myProc_y]);
nhg->nVtx = (int)(nhg->dist_x[ncomm->myProc_x+1] - nhg->dist_x[ncomm->myProc_x]);
nhg->nPins = nPins;
/* Unpack the pins received. */
cnt = (int *) ZOLTAN_CALLOC(nhg->nVtx + 1, sizeof(int));
nhg->vindex = (int *) ZOLTAN_CALLOC(nhg->nVtx + 1, sizeof(int));
nhg->vedge = (int *) ZOLTAN_MALLOC(nhg->nPins * sizeof(int));
if (!cnt || !nhg->vindex || (nPins && !nhg->vedge))
MEMORY_ERROR;
/* Count the number of pins per vertex */
for (i = 0; i < nPins; ++i)
++cnt[pins[2*i]];
/* Compute prefix sum to represent hindex correctly. */
for (i = 0; i < nhg->nVtx; ++i) {
nhg->vindex[i+1] = nhg->vindex[i] + cnt[i];
cnt[i] = nhg->vindex[i];
}
for (i = 0; i < nPins; ++i)
nhg->vedge[cnt[pins[2*i]]++] = pins[2*i+1];
nhg->info = ohg->info;
nhg->nDim = ohg->nDim;
nhg->VtxWeightDim = ohg->VtxWeightDim;
nhg->EdgeWeightDim = ohg->EdgeWeightDim;
ierr = Zoltan_HG_Create_Mirror(zz, nhg);
if (ierr != ZOLTAN_OK && ierr != ZOLTAN_WARN)
MEMORY_ERROR;
}
End:
Zoltan_Comm_Destroy(&plan); /* Needed if goto End on error condition */
Zoltan_Multifree(__FILE__, __LINE__, 10,
&proclist, &sendbuf, &pins, &cnt,
&vno, &nno, &dist_x, &dist_y, &vsn, &nsn
);
return ierr;
}
/* Main partitioning function for hypergraph partitioning. */
int Zoltan_PHG_Partition (
ZZ *zz, /* Zoltan data structure */
HGraph *hg, /* Input hypergraph to be partitioned */
int p, /* Input: number partitions to be generated */
float *part_sizes, /* Input: array of length p containing percentages
of work to be assigned to each partition */
Partition parts, /* Input: initial partition #s; aligned with vtx
arrays.
Output: computed partition #s */
PHGPartParams *hgp) /* Input: parameters for hgraph partitioning. */
{
PHGComm *hgc = hg->comm;
VCycle *vcycle=NULL, *del=NULL;
int i, err = ZOLTAN_OK, middle;
ZOLTAN_GNO_TYPE origVpincnt; /* for processor reduction test */
ZOLTAN_GNO_TYPE prevVcnt = 2*hg->dist_x[hgc->nProc_x]; /* initialized so that the */
ZOLTAN_GNO_TYPE prevVedgecnt = 2*hg->dist_y[hgc->nProc_y]; /* while loop will be entered
before any coarsening */
ZOLTAN_GNO_TYPE tot_nPins, local_nPins;
MPI_Datatype zoltan_gno_mpi_type;
char *yo = "Zoltan_PHG_Partition";
int do_timing = (hgp->use_timers > 1);
int fine_timing = (hgp->use_timers > 2);
int vcycle_timing = (hgp->use_timers > 4 && hgp->ProRedL == 0);
short refine = 0;
struct phg_timer_indices *timer = Zoltan_PHG_LB_Data_timers(zz);
int reset_geometric_matching = 0;
char reset_geometric_string[4];
ZOLTAN_TRACE_ENTER(zz, yo);
zoltan_gno_mpi_type = Zoltan_mpi_gno_type();
if (do_timing) {
if (timer->vcycle < 0)
timer->vcycle = Zoltan_Timer_Init(zz->ZTime, 0, "Vcycle");
if (timer->procred < 0)
timer->procred = Zoltan_Timer_Init(zz->ZTime, 0, "Processor Reduction");
if (timer->match < 0)
timer->match = Zoltan_Timer_Init(zz->ZTime, 1, "Matching");
if (timer->coarse < 0)
timer->coarse = Zoltan_Timer_Init(zz->ZTime, 1, "Coarsening");
if (timer->coarsepart < 0)
timer->coarsepart = Zoltan_Timer_Init(zz->ZTime, 1,
"Coarse_Partition");
if (timer->refine < 0)
timer->refine = Zoltan_Timer_Init(zz->ZTime, 1, "Refinement");
if (timer->project < 0)
timer->project = Zoltan_Timer_Init(zz->ZTime, 1, "Project_Up");
ZOLTAN_TIMER_START(zz->ZTime, timer->vcycle, hgc->Communicator);
}
local_nPins = (ZOLTAN_GNO_TYPE)hg->nPins;
MPI_Allreduce(&local_nPins,&tot_nPins,1,zoltan_gno_mpi_type,MPI_SUM,hgc->Communicator);
origVpincnt = tot_nPins;
if (!(vcycle = newVCycle(zz, hg, parts, NULL, vcycle_timing))) {
ZOLTAN_PRINT_ERROR (zz->Proc, yo, "VCycle is NULL.");
ZOLTAN_TRACE_EXIT(zz, yo);
return ZOLTAN_MEMERR;
}
/* For geometric coarsening, hgp->matching pointer and string are reset
* after geometric_levels of coarsening. Will need to reset them after
* this vcycle is completed. Capture that fact now! */
if (!strcasecmp(hgp->redm_str, "rcb") || !strcasecmp(hgp->redm_str, "rib")) {
reset_geometric_matching = 1;
strcpy(reset_geometric_string, hgp->redm_str);
}
/****** Coarsening ******/
#define COARSEN_FRACTION_LIMIT 0.9 /* Stop if we don't make much progress */
while ((hg->redl>0) && (hg->dist_x[hgc->nProc_x] > (ZOLTAN_GNO_TYPE)hg->redl)
&& ((hg->dist_x[hgc->nProc_x] < (ZOLTAN_GNO_TYPE) (COARSEN_FRACTION_LIMIT * prevVcnt + 0.5)) /* prevVcnt initialized to 2*hg->dist_x[hgc->nProc_x] */
|| (hg->dist_y[hgc->nProc_y] < (ZOLTAN_GNO_TYPE) (COARSEN_FRACTION_LIMIT * prevVedgecnt + 0.5))) /* prevVedgecnt initialized to 2*hg->dist_y[hgc->nProc_y] */
&& hg->dist_y[hgc->nProc_y] && hgp->matching) {
ZOLTAN_GNO_TYPE *match = NULL;
VCycle *coarser=NULL, *redistributed=NULL;
prevVcnt = hg->dist_x[hgc->nProc_x];
prevVedgecnt = hg->dist_y[hgc->nProc_y];
#ifdef _DEBUG
/* UVC: load balance stats */
Zoltan_PHG_LoadBalStat(zz, hg);
#endif
if (hgp->output_level >= PHG_DEBUG_LIST) {
uprintf(hgc,
"START %3d |V|=%6d |E|=%6d #pins=%6d %d/%s/%s/%s p=%d...\n",
hg->info, hg->nVtx, hg->nEdge, hg->nPins, hg->redl,
hgp->redm_str,
hgp->coarsepartition_str, hgp->refinement_str, p);
if (hgp->output_level > PHG_DEBUG_LIST) {
err = Zoltan_HG_Info(zz, hg);
if (err != ZOLTAN_OK && err != ZOLTAN_WARN)
goto End;
}
}
if (hgp->output_level >= PHG_DEBUG_PLOT)
Zoltan_PHG_Plot(zz->Proc, hg->nVtx, p, hg->vindex, hg->vedge, NULL,
"coarsening plot");
if (do_timing) {
ZOLTAN_TIMER_STOP(zz->ZTime, timer->vcycle, hgc->Communicator);
ZOLTAN_TIMER_START(zz->ZTime, timer->match, hgc->Communicator);
}
if (vcycle_timing) {
if (vcycle->timer_match < 0) {
char str[80];
sprintf(str, "VC Matching %d", hg->info);
vcycle->timer_match = Zoltan_Timer_Init(vcycle->timer, 0, str);
}
ZOLTAN_TIMER_START(vcycle->timer, vcycle->timer_match,
hgc->Communicator);
}
/* Allocate and initialize Matching Array */
if (hg->nVtx && !(match = (ZOLTAN_GNO_TYPE *) ZOLTAN_MALLOC (hg->nVtx*sizeof(ZOLTAN_GNO_TYPE)))) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Insufficient memory: Matching array");
ZOLTAN_TRACE_EXIT(zz, yo);
return ZOLTAN_MEMERR;
}
for (i = 0; i < hg->nVtx; i++)
match[i] = i;
/* Calculate matching (packing or grouping) */
err = Zoltan_PHG_Matching (zz, hg, match, hgp);
if (err != ZOLTAN_OK && err != ZOLTAN_WARN) {
ZOLTAN_FREE (&match);
goto End;
}
if (vcycle_timing)
ZOLTAN_TIMER_STOP(vcycle->timer, vcycle->timer_match,
hgc->Communicator);
if (do_timing) {
ZOLTAN_TIMER_STOP(zz->ZTime, timer->match, hgc->Communicator);
ZOLTAN_TIMER_START(zz->ZTime, timer->coarse, hgc->Communicator);
}
if (vcycle_timing) {
if (vcycle->timer_coarse < 0) {
char str[80];
sprintf(str, "VC Coarsening %d", hg->info);
vcycle->timer_coarse = Zoltan_Timer_Init(vcycle->timer, 0, str);
}
ZOLTAN_TIMER_START(vcycle->timer, vcycle->timer_coarse,
hgc->Communicator);
}
if (!(coarser = newVCycle(zz, NULL, NULL, vcycle, vcycle_timing))) {
ZOLTAN_FREE (&match);
ZOLTAN_PRINT_ERROR (zz->Proc, yo, "coarser is NULL.");
goto End;
}
/* Construct coarse hypergraph and LevelMap */
err = Zoltan_PHG_Coarsening (zz, hg, match, coarser->hg, vcycle->LevelMap,
&vcycle->LevelCnt, &vcycle->LevelSndCnt, &vcycle->LevelData,
&vcycle->comm_plan, hgp);
if (err != ZOLTAN_OK && err != ZOLTAN_WARN)
goto End;
if (vcycle_timing)
ZOLTAN_TIMER_STOP(vcycle->timer, vcycle->timer_coarse,
hgc->Communicator);
if (do_timing) {
ZOLTAN_TIMER_STOP(zz->ZTime, timer->coarse, hgc->Communicator);
ZOLTAN_TIMER_START(zz->ZTime, timer->vcycle, hgc->Communicator);
}
ZOLTAN_FREE (&match);
if ((err=allocVCycle(coarser))!= ZOLTAN_OK)
goto End;
vcycle = coarser;
hg = vcycle->hg;
if (hgc->nProc > 1 && hgp->ProRedL > 0) {
local_nPins = (ZOLTAN_GNO_TYPE)hg->nPins;
MPI_Allreduce(&local_nPins, &tot_nPins, 1, zoltan_gno_mpi_type, MPI_SUM,
hgc->Communicator);
if (tot_nPins < (ZOLTAN_GNO_TYPE)(hgp->ProRedL * origVpincnt + 0.5)) {
if (do_timing) {
ZOLTAN_TIMER_STOP(zz->ZTime, timer->vcycle, hgc->Communicator);
ZOLTAN_TIMER_START(zz->ZTime, timer->procred, hgc->Communicator);
}
/* redistribute to half the processors */
origVpincnt = tot_nPins; /* update for processor reduction test */
if(hg->nVtx&&!(hg->vmap=(int*)ZOLTAN_MALLOC(hg->nVtx*sizeof(int)))) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Insufficient memory: hg->vmap");
ZOLTAN_TRACE_EXIT(zz, yo);
return ZOLTAN_MEMERR;
}
for (i = 0; i < hg->nVtx; i++)
hg->vmap[i] = i;
middle = (int)((float) (hgc->nProc-1) * hgp->ProRedL);
if (hgp->nProc_x_req!=1&&hgp->nProc_y_req!=1) { /* Want 2D decomp */
if ((middle+1) > SMALL_PRIME && Zoltan_PHG_isPrime(middle+1))
--middle; /* if it was prime just use one less #procs (since
it should be bigger than SMALL_PRIME it is safe to
decrement) */
}
if (!(hgc = (PHGComm*) ZOLTAN_MALLOC (sizeof(PHGComm)))) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Insufficient memory: PHGComm");
ZOLTAN_TRACE_EXIT(zz, yo);
return ZOLTAN_MEMERR;
}
if (!(redistributed=newVCycle(zz,NULL,NULL,vcycle,vcycle_timing))) {
ZOLTAN_FREE (&hgc);
ZOLTAN_PRINT_ERROR (zz->Proc, yo, "redistributed is NULL.");
goto End;
}
Zoltan_PHG_Redistribute(zz,hgp,hg,0,middle,hgc, redistributed->hg,
&vcycle->vlno,&vcycle->vdest);
if (hgp->UseFixedVtx || hgp->UsePrefPart)
redistributed->hg->bisec_split = hg->bisec_split;
if ((err=allocVCycle(redistributed))!= ZOLTAN_OK)
goto End;
vcycle = redistributed;
if (hgc->myProc < 0)
/* I'm not in the redistributed part so I should go to uncoarsening
refinement and wait */ {
if (fine_timing) {
if (timer->cpgather < 0)
timer->cpgather = Zoltan_Timer_Init(zz->ZTime, 1, "CP Gather");
if (timer->cprefine < 0)
timer->cprefine =Zoltan_Timer_Init(zz->ZTime, 0, "CP Refine");
if (timer->cpart < 0)
timer->cpart = Zoltan_Timer_Init(zz->ZTime, 0, "CP Part");
}
if (do_timing) {
ZOLTAN_TIMER_STOP(zz->ZTime, timer->procred, hgc->Communicator);
ZOLTAN_TIMER_START(zz->ZTime, timer->vcycle, hgc->Communicator);
}
goto Refine;
}
hg = vcycle->hg;
hg->redl = hgp->redl; /* not set with hg creation */
if (do_timing) {
ZOLTAN_TIMER_STOP(zz->ZTime, timer->procred, hgc->Communicator);
ZOLTAN_TIMER_START(zz->ZTime, timer->vcycle, hgc->Communicator);
}
}
}
}
if (hgp->output_level >= PHG_DEBUG_LIST) {
uprintf(hgc, "START %3d |V|=%6d |E|=%6d #pins=%6d %d/%s/%s/%s p=%d...\n",
hg->info, hg->nVtx, hg->nEdge, hg->nPins, hg->redl,
hgp->redm_str, hgp->coarsepartition_str, hgp->refinement_str, p);
if (hgp->output_level > PHG_DEBUG_LIST) {
err = Zoltan_HG_Info(zz, hg);
if (err != ZOLTAN_OK && err != ZOLTAN_WARN)
goto End;
}
}
if (hgp->output_level >= PHG_DEBUG_PLOT)
Zoltan_PHG_Plot(zz->Proc, hg->nVtx, p, hg->vindex, hg->vedge, NULL,
"coarsening plot");
/* free array that may have been allocated in matching */
if (hgp->vtx_scal) {
hgp->vtx_scal_size = 0;
ZOLTAN_FREE(&(hgp->vtx_scal));
}
if (do_timing) {
ZOLTAN_TIMER_STOP(zz->ZTime, timer->vcycle, hgc->Communicator);
ZOLTAN_TIMER_START(zz->ZTime, timer->coarsepart, hgc->Communicator);
}
/****** Coarse Partitioning ******/
err = Zoltan_PHG_CoarsePartition (zz, hg, p, part_sizes, vcycle->Part, hgp);
if (err != ZOLTAN_OK && err != ZOLTAN_WARN)
goto End;
if (do_timing) {
ZOLTAN_TIMER_STOP(zz->ZTime, timer->coarsepart, hgc->Communicator);
ZOLTAN_TIMER_START(zz->ZTime, timer->vcycle, hgc->Communicator);
}
Refine:
del = vcycle;
refine = 1;
/****** Uncoarsening/Refinement ******/
while (vcycle) {
VCycle *finer = vcycle->finer;
hg = vcycle->hg;
if (refine && hgc->myProc >= 0) {
if (do_timing) {
ZOLTAN_TIMER_STOP(zz->ZTime, timer->vcycle, hgc->Communicator);
ZOLTAN_TIMER_START(zz->ZTime, timer->refine, hgc->Communicator);
}
if (vcycle_timing) {
if (vcycle->timer_refine < 0) {
char str[80];
sprintf(str, "VC Refinement %d", hg->info);
vcycle->timer_refine = Zoltan_Timer_Init(vcycle->timer, 0, str);
}
ZOLTAN_TIMER_START(vcycle->timer, vcycle->timer_refine,
hgc->Communicator);
}
err = Zoltan_PHG_Refinement (zz, hg, p, part_sizes, vcycle->Part, hgp);
if (do_timing) {
ZOLTAN_TIMER_STOP(zz->ZTime, timer->refine, hgc->Communicator);
ZOLTAN_TIMER_START(zz->ZTime, timer->vcycle, hgc->Communicator);
}
if (vcycle_timing)
ZOLTAN_TIMER_STOP(vcycle->timer, vcycle->timer_refine,
hgc->Communicator);
if (hgp->output_level >= PHG_DEBUG_LIST)
uprintf(hgc,
"FINAL %3d |V|=%6d |E|=%6d #pins=%6d %d/%s/%s/%s p=%d bal=%.2f cutl=%.2f\n",
hg->info, hg->nVtx, hg->nEdge, hg->nPins, hg->redl,
hgp->redm_str,
hgp->coarsepartition_str, hgp->refinement_str, p,
Zoltan_PHG_Compute_Balance(zz, hg, part_sizes, 0, p,
vcycle->Part),
Zoltan_PHG_Compute_ConCut(hgc, hg, vcycle->Part, p, &err));
if (hgp->output_level >= PHG_DEBUG_PLOT)
Zoltan_PHG_Plot(zz->Proc, hg->nVtx, p, hg->vindex, hg->vedge, vcycle->Part,
"partitioned plot");
}
if (finer) {
int *rbuffer;
/* Project coarse partition to fine partition */
if (finer->comm_plan) {
refine = 1;
if (do_timing) {
ZOLTAN_TIMER_STOP(zz->ZTime, timer->vcycle, hgc->Communicator);
ZOLTAN_TIMER_START(zz->ZTime, timer->project, hgc->Communicator);
}
if (vcycle_timing) {
if (vcycle->timer_project < 0) {
char str[80];
sprintf(str, "VC Project Up %d", hg->info);
vcycle->timer_project = Zoltan_Timer_Init(vcycle->timer, 0, str);
}
ZOLTAN_TIMER_START(vcycle->timer, vcycle->timer_project,
hgc->Communicator);
}
/* easy to assign partitions to internal matches */
for (i = 0; i < finer->hg->nVtx; i++)
if (finer->LevelMap[i] >= 0) /* if considers only the local vertices */
finer->Part[i] = vcycle->Part[finer->LevelMap[i]];
/* now that the course partition assignments have been propagated */
/* upward to the finer level for the local vertices, we need to */
/* fill the LevelData (matched pairs of a local vertex with a */
/* off processor vertex) with the partition assignment of the */
/* local vertex - can be done totally in the finer level! */
for (i = 0; i < finer->LevelCnt; i++) {
++i; /* skip over off processor lno */
finer->LevelData[i] = finer->Part[finer->LevelData[i]];
}
/* allocate rec buffer to exchange LevelData information */
rbuffer = NULL;
if (finer->LevelSndCnt > 0) {
rbuffer = (int*) ZOLTAN_MALLOC (2 * finer->LevelSndCnt * sizeof(int));
if (!rbuffer) {
ZOLTAN_PRINT_ERROR (zz->Proc, yo, "Insufficient memory.");
ZOLTAN_TRACE_EXIT(zz, yo);
return ZOLTAN_MEMERR;
}
}
/* get partition assignments from owners of externally matched vtxs */
Zoltan_Comm_Resize (finer->comm_plan, NULL, COMM_TAG, &i);
Zoltan_Comm_Do_Reverse (finer->comm_plan, COMM_TAG+1,
(char*) finer->LevelData, 2 * sizeof(int), NULL, (char*) rbuffer);
/* process data to assign partitions to expernal matches */
for (i = 0; i < 2 * finer->LevelSndCnt;) {
int lno, partition;
lno = rbuffer[i++];
partition = rbuffer[i++];
finer->Part[lno] = partition;
}
ZOLTAN_FREE (&rbuffer);
Zoltan_Comm_Destroy (&finer->comm_plan);
if (do_timing) {
ZOLTAN_TIMER_STOP(zz->ZTime, timer->project, hgc->Communicator);
ZOLTAN_TIMER_START(zz->ZTime, timer->vcycle, hgc->Communicator);
}
if (vcycle_timing)
ZOLTAN_TIMER_STOP(vcycle->timer, vcycle->timer_project,
hgc->Communicator);
} else {
int *sendbuf = NULL, size;
refine = 0;
/* ints local and partition numbers */
if (finer->vlno) {
sendbuf = (int*) ZOLTAN_MALLOC (2 * hg->nVtx * sizeof(int));
if (!sendbuf) {
ZOLTAN_PRINT_ERROR (zz->Proc, yo, "Insufficient memory.");
ZOLTAN_TRACE_EXIT(zz, yo);
return ZOLTAN_MEMERR;
}
for (i = 0; i < hg->nVtx; ++i) {
sendbuf[2 * i] = finer->vlno[i]; /* assign local numbers */
sendbuf[2 * i + 1] = vcycle->Part[i];/* assign partition numbers */
}
}
ZOLTAN_FREE (&hgc);
hgc = finer->hg->comm; /* updating hgc is required when the processors
change */
/* Create comm plan to unredistributed processors */
err = Zoltan_Comm_Create(&finer->comm_plan, finer->vlno ? hg->nVtx : 0,
finer->vdest, hgc->Communicator, COMM_TAG+2,
&size);
if (err != ZOLTAN_OK && err != ZOLTAN_WARN) {
ZOLTAN_PRINT_ERROR(hgc->myProc, yo, "Zoltan_Comm_Create failed.");
goto End;
}
/* allocate rec buffer to exchange sendbuf information */
rbuffer = NULL;
if (finer->hg->nVtx) {
rbuffer = (int*) ZOLTAN_MALLOC (2 * finer->hg->nVtx * sizeof(int));
if (!rbuffer) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Insufficient memory.");
ZOLTAN_TRACE_EXIT(zz, yo);
return ZOLTAN_MEMERR;
}
}
/* Use plan to send partitions to the unredistributed processors */
Zoltan_Comm_Do(finer->comm_plan, COMM_TAG+3, (char *) sendbuf,
2*sizeof(int), (char *) rbuffer);
MPI_Bcast(rbuffer, 2*finer->hg->nVtx, MPI_INT, 0, hgc->col_comm);
/* process data to assign partitions to unredistributed processors */
for (i = 0; i < 2 * finer->hg->nVtx;) {
int lno, partition;
lno = rbuffer[i++];
partition = rbuffer[i++];
finer->Part[lno] = partition;
}
if (finer->vlno)
ZOLTAN_FREE (&sendbuf);
ZOLTAN_FREE (&rbuffer);
Zoltan_Comm_Destroy (&finer->comm_plan);
}
}
vcycle = finer;
} /* while (vcycle) */
End:
vcycle = del;
while (vcycle) {
if (vcycle_timing) {
Zoltan_Timer_PrintAll(vcycle->timer, 0, hgc->Communicator, stdout);
Zoltan_Timer_Destroy(&vcycle->timer);
}
if (vcycle->finer) { /* cleanup by level */
Zoltan_HG_HGraph_Free (vcycle->hg);
if (vcycle->LevelData)
Zoltan_Multifree (__FILE__, __LINE__, 4, &vcycle->Part,
&vcycle->LevelMap, &vcycle->LevelData, &vcycle->hg);
else if (vcycle->vlno)
Zoltan_Multifree (__FILE__, __LINE__, 5, &vcycle->Part, &vcycle->vdest,
&vcycle->vlno, &vcycle->LevelMap, &vcycle->hg);
else
Zoltan_Multifree (__FILE__, __LINE__, 3, &vcycle->Part,
&vcycle->LevelMap, &vcycle->hg);
}
else /* cleanup top level */
Zoltan_Multifree (__FILE__, __LINE__, 2, &vcycle->LevelMap,
&vcycle->LevelData);
del = vcycle;
vcycle = vcycle->finer;
ZOLTAN_FREE(&del);
}
if (reset_geometric_matching) {
strcpy(hgp->redm_str, reset_geometric_string);
Zoltan_PHG_Set_Matching_Fn(hgp);
}
if (do_timing)
ZOLTAN_TIMER_STOP(zz->ZTime, timer->vcycle, hgc->Communicator);
ZOLTAN_TRACE_EXIT(zz, yo) ;
return err;
}
/* if !copy, inmat is not usable after this call */
int
Zoltan_Matrix2d_Distribute (ZZ* zz, Zoltan_matrix inmat, /* Cannot be const as we can share it inside outmat */
Zoltan_matrix_2d *outmat, int copy)
{
static char *yo = "Zoltan_Matrix2d_Distribute";
int ierr = ZOLTAN_OK;
int nProc_x, nProc_y;
int myProc_x, myProc_y;
int i, j, cnt;
int *proclist = NULL;
Zoltan_Arc *nonzeros= NULL, *sendbuf= NULL;
ZOLTAN_GNO_TYPE *perm_y = NULL;
float *wgtarray = NULL;
float *tmpwgtarray = NULL;
int msg_tag = 1021982;
ZOLTAN_COMM_OBJ *plan;
MPI_Comm communicator = MPI_COMM_NULL;
int nProc;
ZOLTAN_GNO_TYPE *yGNO = NULL;
ZOLTAN_GNO_TYPE *pinGNO = NULL;
ZOLTAN_GNO_TYPE tmp_gno;
void *partdata = NULL;
MPI_Datatype zoltan_gno_mpi_type;
ZOLTAN_TRACE_ENTER(zz, yo);
zoltan_gno_mpi_type = Zoltan_mpi_gno_type();
memcpy(&outmat->mtx, &inmat, sizeof(Zoltan_matrix));
if(copy) {
/* TODO: We need to copy the arrays also */
Zoltan_Matrix_Reset (&outmat->mtx);
/* Copy also directories */
outmat->mtx.ddX = Zoltan_DD_Copy (inmat.ddX);
if (inmat.ddY == inmat.ddX)
outmat->mtx.ddY = outmat->mtx.ddX;
else
outmat->mtx.ddY = Zoltan_DD_Copy (inmat.ddY);
}
communicator = outmat->comm->Communicator;
nProc = outmat->comm->nProc;
nProc_x = outmat->comm->nProc_x;
nProc_y = outmat->comm->nProc_y;
myProc_x = outmat->comm->myProc_x;
myProc_y = outmat->comm->myProc_y;
KDDKDDKDD(zz->Proc, " Zoltan_Matrix_Remove_Duplicates");
ierr = Zoltan_Matrix_Remove_Duplicates(zz, outmat->mtx, &outmat->mtx);
/* KDDKDDKDD FIX INDENTATION OF THIS BLOCK */
if (inmat.opts.speed != MATRIX_NO_REDIST) {
if (outmat->hashDistFct == (distFnct *)&Zoltan_Distribute_Origin) {
/* I need to know the original distribution */
if (outmat->mtx.ddX != outmat->mtx.ddY) { /* No initial distribution */
outmat->hashDistFct = (distFnct *)&Zoltan_Distribute_Linear;
}
else {
int *cmember = NULL;
cmember = (int*)ZOLTAN_MALLOC(outmat->mtx.nY*sizeof(int));
if (outmat->mtx.nY > 0 && cmember == NULL) MEMORY_ERROR;
Zoltan_DD_Find (outmat->mtx.ddY, (ZOLTAN_ID_PTR)outmat->mtx.yGNO, NULL, (char *)cmember, NULL,
outmat->mtx.nY, NULL);
KDDKDDKDD(zz->Proc, " Zoltan_Distribute_Partition_Register");
partdata = Zoltan_Distribute_Partition_Register(zz, outmat->mtx.nY, outmat->mtx.yGNO,
cmember, zz->Num_Proc, zz->Num_Proc);
ZOLTAN_FREE(&cmember);
Zoltan_Distribute_Set(outmat, (distFnct *)&Zoltan_Distribute_Origin, partdata);
}
}
/*
* Build comm plan for sending non-zeros to their target processors in
* 2D data distribution.
*/
/* TRICK: create fake arc (edgeno, -1) for empty Y. Upper bound for size might be nPins + nY */
proclist = (int *)ZOLTAN_MALLOC((outmat->mtx.nPins+outmat->mtx.nY) *sizeof(int));
sendbuf = (Zoltan_Arc*) ZOLTAN_MALLOC((outmat->mtx.nPins +outmat->mtx.nY)* sizeof(Zoltan_Arc));
if ((outmat->mtx.nPins + outmat->mtx.nY >0) && (proclist == NULL || sendbuf == NULL)) MEMORY_ERROR;
wgtarray = (float*) ZOLTAN_MALLOC((outmat->mtx.nPins+outmat->mtx.nY)*outmat->mtx.pinwgtdim*sizeof(float));
if (outmat->mtx.nPins*outmat->mtx.pinwgtdim && !wgtarray) MEMORY_ERROR;
yGNO = outmat->mtx.yGNO;
pinGNO = outmat->mtx.pinGNO;
KDDKDDKDD(zz->Proc, " CommPlan Hash");
cnt = 0;
for (i = 0; i < outmat->mtx.nY; i++) {
ZOLTAN_GNO_TYPE edge_gno=-1;
/* processor row for the edge */
edge_gno = yGNO[i];
for (j = outmat->mtx.ystart[i]; j < outmat->mtx.yend[i]; j++) {
ZOLTAN_GNO_TYPE vtx_gno=-1;
/* processor column for the vertex */
vtx_gno = pinGNO[j];
proclist[cnt] = (*outmat->hashDistFct)(edge_gno, vtx_gno, outmat->hashDistData,
&sendbuf[cnt].part_y);
if (proclist[cnt] < 0) /* Discard this nnz */
continue;
sendbuf[cnt].GNO[0] = edge_gno;
sendbuf[cnt].GNO[1] = vtx_gno;
memcpy(wgtarray+cnt*outmat->mtx.pinwgtdim, outmat->mtx.pinwgt+j*outmat->mtx.pinwgtdim,
outmat->mtx.pinwgtdim*sizeof(float));
cnt++;
}
if(outmat->mtx.ystart[i] == outmat->mtx.yend[i]) {
proclist[cnt] = (*outmat->hashDistFct)(edge_gno, -1, outmat->hashDistData,
&sendbuf[cnt].part_y);
if (proclist[cnt] < 0) /* Discard this nnz */
continue;
sendbuf[cnt].GNO[0] = edge_gno;
sendbuf[cnt].GNO[1] = -1;
memset(wgtarray+cnt*outmat->mtx.pinwgtdim, 0,outmat->mtx.pinwgtdim*sizeof(float));
cnt++;
}
}
if (outmat->hashDistFct == (distFnct *)&Zoltan_Distribute_Origin)
Zoltan_Distribute_Partition_Free(&outmat->hashDistData);
if (outmat->mtx.yend != outmat->mtx.ystart + 1)
ZOLTAN_FREE(&outmat->mtx.yend);
outmat->mtx.yend = NULL;
ZOLTAN_FREE(&outmat->mtx.ystart);
ZOLTAN_FREE(&outmat->mtx.yGNO);
ZOLTAN_FREE(&outmat->mtx.pinGNO);
ZOLTAN_FREE(&outmat->mtx.pinwgt);
ZOLTAN_FREE(&outmat->mtx.yGID);
/*
* Send pins to their target processors.
* They become non-zeros in the 2D data distribution.
*/
KDDKDDKDD(zz->Proc, " CommPlan Create");
msg_tag--;
ierr = Zoltan_Comm_Create(&plan, cnt, proclist, communicator, msg_tag, &outmat->mtx.nPins);
ZOLTAN_FREE(&proclist);
nonzeros = (Zoltan_Arc *) ZOLTAN_MALLOC((outmat->mtx.nPins) * sizeof(Zoltan_Arc));
if (outmat->mtx.nPins && nonzeros == NULL) MEMORY_ERROR;
msg_tag--;
Zoltan_Comm_Do(plan, msg_tag, (char *) sendbuf, sizeof(Zoltan_Arc), (char *) nonzeros);
ZOLTAN_FREE(&sendbuf);
if (outmat->mtx.pinwgtdim) { /* We have to take care about weights */
tmpwgtarray = (float*) ZOLTAN_MALLOC(outmat->mtx.nPins*outmat->mtx.pinwgtdim*sizeof(float));
if (outmat->mtx.nPins && tmpwgtarray == NULL) MEMORY_ERROR;
msg_tag--;
Zoltan_Comm_Do(plan, msg_tag, (char *) wgtarray, outmat->mtx.pinwgtdim*sizeof(float),
(char *) tmpwgtarray);
ZOLTAN_FREE(&wgtarray);
}
Zoltan_Comm_Destroy(&plan);
/* Unpack the non-zeros received. */
KDDKDDKDD(zz->Proc, " Zoltan_Matrix_Remove_DupArcs");
/* TODO: do take care about singletons */
Zoltan_Matrix_Remove_DupArcs(zz, outmat->mtx.nPins, (Zoltan_Arc*)nonzeros, tmpwgtarray,
&outmat->mtx);
}
/* Now we just have to change numbering */
outmat->dist_y = (ZOLTAN_GNO_TYPE *) ZOLTAN_CALLOC((nProc_y+1), sizeof(ZOLTAN_GNO_TYPE));
outmat->dist_x = (ZOLTAN_GNO_TYPE *) ZOLTAN_CALLOC((nProc_x+1), sizeof(ZOLTAN_GNO_TYPE));
if (outmat->dist_y == NULL || outmat->dist_x == NULL) MEMORY_ERROR;
/* FIXME: Work only in 1D */
tmp_gno = (ZOLTAN_GNO_TYPE)outmat->mtx.nY;
MPI_Allgather(&tmp_gno, 1, zoltan_gno_mpi_type, outmat->dist_y+1, 1, zoltan_gno_mpi_type, communicator);
for (i = 1 ; i <= nProc_y ; i ++) {
outmat->dist_y[i] += outmat->dist_y[i-1];
}
outmat->dist_x[1] = outmat->mtx.globalX;
perm_y = (ZOLTAN_GNO_TYPE *) ZOLTAN_MALLOC(outmat->mtx.nY * sizeof(ZOLTAN_GNO_TYPE));
if (outmat->mtx.nY > 0 && perm_y == NULL) MEMORY_ERROR;
for (i = 0 ; i < outmat->mtx.nY ; ++i){
perm_y[i] = i + outmat->dist_y[myProc_y];
}
KDDKDDKDD(zz->Proc, " Zoltan_Matrix_Permute");
Zoltan_Matrix_Permute(zz, &outmat->mtx, perm_y);
KDDKDDKDD(zz->Proc, " Zoltan_Matrix_Permute done");
End:
ZOLTAN_FREE(&perm_y);
ZOLTAN_FREE(&proclist);
ZOLTAN_FREE(&sendbuf);
ZOLTAN_FREE(&nonzeros);
ZOLTAN_FREE(&tmpwgtarray);
ZOLTAN_TRACE_EXIT(zz, yo);
return (ierr);
}
int Zoltan_RB_Create_Proc_List(
ZZ *zz, /* Load-balancing structure. */
int set, /* set that processor is in */
int dotnum, /* number of dots that my processor has */
int outgoing, /* number of dots that my processor is sending */
int *proclist, /* processor list for my outgoing dots */
MPI_Comm comm, /* communicator for partition */
int proclower, /* smallest processor for Tflops_Special */
int numprocs /* number of processors for Tflops_Special */
)
{
/* This routine calculates a communication pattern for the situation where
there are two groups of processors and each processor has a number of
items which need to be communicated to the other group. This routine
calculates a communication pattern which seeks to minimize the number
of items that any one processor has after communication. */
int nprocs; /* number of processors in partition */
int rank; /* my processor number in partition */
int np_other = 0; /* number of processors in other group */
int i, k; /* loop indexes */
int err = ZOLTAN_OK; /* error code */
MPI_Datatype zoltan_gno_mpi_type;
ZOLTAN_GNO_TYPE *send; /* array of number of dots outgoing */
ZOLTAN_GNO_TYPE *rem; /* array of number of dots that remain */
ZOLTAN_GNO_TYPE *sets; /* set for each of the processors */
ZOLTAN_GNO_TYPE a; /* number of dots that will be on each proc */
ZOLTAN_GNO_TYPE sum_send; /* total number sent from my group */
ZOLTAN_GNO_TYPE sum_rem; /* total number remaining in other group */
ZOLTAN_GNO_TYPE s, sp; /* temporary sums */
ZOLTAN_GNO_TYPE num_to; /* number of dots to send to a processor */
ZOLTAN_GNO_TYPE *tmp_send; /* Work vector */
zoltan_gno_mpi_type = Zoltan_mpi_gno_type();
/* allocate memory for arrays */
MPI_Comm_rank(comm, &rank);
if (zz->Tflops_Special) {
nprocs = numprocs;
rank -= proclower;
}
else
MPI_Comm_size(comm, &nprocs);
if ((send = (ZOLTAN_GNO_TYPE *) ZOLTAN_MALLOC(3*nprocs*sizeof(ZOLTAN_GNO_TYPE))) == NULL)
return ZOLTAN_MEMERR;
if ((tmp_send = (ZOLTAN_GNO_TYPE *) ZOLTAN_MALLOC(3*nprocs*sizeof(ZOLTAN_GNO_TYPE))) == NULL) {
ZOLTAN_FREE(&send);
return ZOLTAN_MEMERR;
}
rem = &send[nprocs];
sets = &send[2*nprocs];
/* gather number of outgoing and remaining dots across processors */
if (zz->Tflops_Special) {
for (i = 3*nprocs-1; i >= 0; i--)
send[i] = 0;
send[rank] = outgoing;
send[rank+nprocs] = dotnum - outgoing;
send[rank+2*nprocs] = set;
Zoltan_RB_Gather(send, tmp_send, proclower, rank, nprocs, comm);
}
else {
for (i = 3*nprocs-1; i >= 0; i--)
tmp_send[i] = 0;
tmp_send[rank] = outgoing;
tmp_send[rank+nprocs] = dotnum - outgoing;
tmp_send[rank+2*nprocs] = set;
i = 3*nprocs;
MPI_Allreduce(tmp_send, send, i, zoltan_gno_mpi_type, MPI_SUM, comm);
}
ZOLTAN_FREE(&tmp_send);
/* Convert processor numbers to local (for this communicator) numbering
and determine which subset of processors a processor is in. */
/* to determine the number of dots (a) that will be on each of the
processors in the other group, start with the average */
sum_send = sum_rem = 0;
for (i = 0; i < nprocs; i++)
if (sets[i] == set)
sum_send += send[i];
else {
sum_rem += rem[i];
np_other++;
}
/* Modify the value of a, which is now the number of dots that a processor
will have after communication if the number of dots that it keeps is
not greater than a. Set a so there is a non-negative number left. */
if (sum_send) {
if (np_other == 0){
/* This should never happen. Prevent divide-by-zero to be safe. */
err = ZOLTAN_FATAL;
goto End;
}
a = (sum_send + sum_rem)/np_other;
sp = -1;
k = 0;
while (!k) {
s = 0;
for (i = 0; i < nprocs; i++)
if (sets[i] != set && rem[i] < a)
s += a - rem[i];
if (s == sum_send)
k = 1;
else if (s < sum_send) {
if (sp > sum_send)
k = 1;
else
a++;
}
else {
a--;
if (sp < sum_send && sp > 0)
k = 1;
}
sp = s;
}
} else
a = 0;
/* Allocate who recieves how much and if necessary give out remainder.
The variable send is now the number that will be received by each
processor only in the other part */
s = 0;
for (i = 0; i < nprocs; i++)
if (sets[i] != set && rem[i] < a)
s += send[i] = a - rem[i];
while (s < sum_send)
for (i = 0; i < nprocs && s < sum_send; i++)
if (sets[i] != set && (send[i] || !s)) {
send[i]++;
s++;
}
/* Create list of which processor to send dots to. Only the other half
of send has been overwritten above. s is the number of dots that will
be sent by processors in my part of the partition which are less then
my processor. sp is the sum of what processors in the other part are
recieving. The processor which causes sp > s is the first processor
that we send dots to. We continue to send dots to processors beyond
that one until we run out of dots to send. */
if (outgoing) {
if (zz->Tflops_Special) a = (ZOLTAN_GNO_TYPE)outgoing; /* keep outgoing around in a */
s = sp = 0;
for (i = 0; i < rank; i++)
if (sets[i] == set) /* only overwrote other half */
s += send[i];
for (i = 0; sp <= s; i++)
if (sets[i] != set)
sp += send[i];
i--;
num_to = (outgoing < (sp - s)) ? outgoing : (sp - s);
for (sp = 0; sp < num_to; sp++)
proclist[sp] = i;
outgoing -= num_to;
while (outgoing > 0) {
i++;
while (sets[i] == set)
i++;
num_to = (outgoing < send[i]) ? outgoing : send[i];
outgoing -= num_to;
for (s = 0; s < num_to; s++, sp++)
proclist[sp] = i;
}
if (zz->Tflops_Special)
for (s = 0; s < a; s++)
proclist[s] += proclower;
}
End:
/* free memory and return */
ZOLTAN_FREE(&send);
return err;
}
static void Zoltan_RB_Gather(
ZOLTAN_GNO_TYPE *send, /* input/output array */
ZOLTAN_GNO_TYPE *tmp_send, /* temporary array */
int proclower, /* smallest numbered processor in partition */
int rank, /* processor number within partition */
int nprocs, /* number of processors in this partition */
MPI_Comm comm /* MPI Communicator */
)
{
int tag = 32100; /* message tag */
int partner; /* message partner in binary exchange */
int to; /* message partner not in binary exchange */
int mask; /* mask to determine communication partner */
int nprocs_small; /* largest power of 2 contained in nprocs */
int hbit; /* 2^hbit = nproc_small */
int len; /* message length */
int i; /* loop counter */
MPI_Status status;
MPI_Datatype zoltan_gno_mpi_type;
zoltan_gno_mpi_type = Zoltan_mpi_gno_type();
/* This routine sums a vector of integers on a subset of processors */
len = 3*nprocs;
/* Find next lower power of 2. */
for (hbit = 0; (nprocs >> hbit) != 1; hbit++);
nprocs_small = 1 << hbit;
if (nprocs_small * 2 == nprocs) {
nprocs_small *= 2;
hbit++;
}
to = proclower + (rank ^ nprocs_small);
if (rank & nprocs_small) { /* processors greater than largest power of 2 */
MPI_Send(send, len, zoltan_gno_mpi_type, to, tag, comm);
tag += hbit + 1;
MPI_Recv(send, len, zoltan_gno_mpi_type, to, tag, comm, &status);
}
else { /* processors within greatest power of 2 */
if (rank + nprocs_small < nprocs) {
MPI_Recv(tmp_send, len, zoltan_gno_mpi_type, to, tag, comm, &status);
for (i = 0; i < len; i++)
send[i] += tmp_send[i];
}
for (mask = nprocs_small >> 1; mask; mask >>= 1) { /* binary exchange */
tag++;
partner = proclower + (rank ^ mask);
/* Change requested by Qingyu Meng <*****@*****.**> to */
/* support mvapich 1.0 on TACC Ranger. */
/* MPI_Send(send, len, zoltan_gno_mpi_type, partner, tag, comm); */
/* MPI_Recv(tmp_send, len, zoltan_gno_mpi_type, partner, tag, comm, &status); */
MPI_Sendrecv(send, len, zoltan_gno_mpi_type, partner, tag,
tmp_send, len, zoltan_gno_mpi_type, partner, tag, comm, &status);
for (i = 0; i < len; i++)
send[i] += tmp_send[i];
}
tag++;
if (rank + nprocs_small < nprocs)
MPI_Send(send, len, zoltan_gno_mpi_type, to, tag, comm);
}
}
