int
Zoltan_Matrix_Construct_CSR(ZZ *zz, int size, Zoltan_Arc *arcs, float* pinwgt,
Zoltan_matrix *outmat, int offset)
{
static char *yo = "Zoltan_Matrix_Remove_DupArcs";
int *tmparray=NULL;
int ierr = ZOLTAN_OK;
int nY, nPin;
int i;
ZOLTAN_TRACE_ENTER(zz, yo);
tmparray = (int*)ZOLTAN_CALLOC(outmat->nY, sizeof(int));
/* Count degree for each vertex */
for (i = 0 ; i < size ; i++) {
int lno = arcs[i].yGNO - offset;
if (arcs[i].pinGNO != -1)
tmparray[lno] ++;
}
outmat->ystart[0] = 0;
outmat->yend = outmat->ystart + 1;
for (i = 0 ; i < outmat->nY ; i++) { /* Assume compact mode */
outmat->yend[i] = outmat->ystart[i] + tmparray[i] ;
}
memset(tmparray, 0, sizeof(int)*outmat->nY);
outmat->nPins = 0;
for(i = 0 ; i <size; i++) {
int lno = arcs[i].yGNO - offset;
if (arcs[i].pinGNO == -1)
continue;
outmat->pinGNO[outmat->ystart[lno] + tmparray[lno]] = arcs[i].pinGNO;
tmparray[lno]++;
outmat->nPins ++;
}
outmat->pinGNO = (int *) ZOLTAN_REALLOC(outmat->pinGNO, outmat->nPins * sizeof(int));
outmat->pinwgt = (float *) ZOLTAN_REALLOC(outmat->pinwgt,
outmat->nPins*outmat->pinwgtdim*sizeof(float));
End:
ZOLTAN_FREE(&tmparray);
ZOLTAN_TRACE_EXIT(zz, yo);
return (ierr);
}
int Zoltan_Timer_Init(
ZTIMER *zt, /* Ptr to Timer object */
int use_barrier, /* Flag indicating whether to perform a
barrier operation before starting the
timer. */
const char *name /* Name of this timer */
)
{
/* Function that returns the index of the next available Timer timer. */
int ret;
static char *yo = "Zoltan_Timer_Init";
TESTTIMER(zt, yo);
ret = zt->NextTimeStruct++;
if (ret >= zt->Length) {
/* Realloc -- need more individual timers */
zt->Length += INITLENGTH;
zt->Times = (ZTIMER_TS *) ZOLTAN_REALLOC(zt->Times, zt->Length * sizeof(ZTIMER_TS));
}
Zoltan_Timer_Reset(zt, ret, use_barrier, name);
#ifdef VAMPIR
if (VT_funcdef(name, VT_NOCLASS, &((zt->Times[ret]).vt_handle)) != VT_OK)
FATALERROR(yo, "VT_funcdef failed.");
#endif
return ret;
}
int Zoltan_DD_GetLocalKeys(Zoltan_DD_Directory *dd,
ZOLTAN_ID_PTR *gid,
int *size)
{
int ierr = ZOLTAN_OK;
int i, k;
DD_Node *ptr;
int gid_alloc_size;
gid_alloc_size = dd->table_length;
(*gid) = (ZOLTAN_ID_PTR)ZOLTAN_MALLOC(
gid_alloc_size*dd->gid_length*sizeof(ZOLTAN_ID_TYPE));
k= 0;
for (i = 0; i < dd->table_length; i++)
for (ptr = dd->table[i]; ptr != NULL; ptr = ptr->next) {
if (k >= gid_alloc_size) {
gid_alloc_size *= 2;
(*gid) = (ZOLTAN_ID_PTR)
ZOLTAN_REALLOC((*gid),
gid_alloc_size*dd->gid_length*sizeof(ZOLTAN_ID_TYPE));
}
ZOLTAN_SET_ID (dd->gid_length, (*gid)+k*dd->gid_length, ptr->gid);
k++;
}
(*size) = k;
return (ierr);
}
int Zoltan_LB_Set_Part_Sizes(ZZ *zz, int global_num,
int len, int *part_ids, int *wgt_idx, float *part_sizes)
{
/*
* Function to set the desired partition sizes. This function
* only sets values locally. Later, Zoltan_LB_Get_Part_Sizes
* collects all the information across processors.
*
* Input:
* zz -- The Zoltan structure to which this method
* applies.
* global_num -- Global partition numbers? (0 for local numbers)
* len -- Length of arrays wgt_idx, part_idx, part_sizes
* part_ids -- Array of partition ids (local or global)
* wgt_idx -- Array of indices between 0 and Obj_Wgt_Dim-1
* part_sizes -- Array of floats that gives the desired partition
* size for each weight and each partition, i.e.,
* part_sizes[i] corresponds to wgt_idx[i] and part_id[i]
*
* Output:
* zz->LB.* -- Appropriate fields set to designated values.
* Return value -- Error code.
*/
char *yo = "Zoltan_LB_Set_Part_Sizes";
int i, j, maxlen=0;
int error = ZOLTAN_OK;
const int INIT_NUM_PART = 64; /* Initial allocation for Part_Info array. */
ZOLTAN_TRACE_ENTER(zz, yo);
/* len = -1 will nullify all partition sizes set on this proc */
if (len == -1){
zz->LB.Part_Info_Len = 0;
goto End;
}
/* Verify input. */
if ((part_ids==NULL) || (part_sizes==NULL)){
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Invalid input argument NULL.");
error = ZOLTAN_FATAL;
goto End;
}
/* Do we need more space? */
if ((!zz->LB.Part_Info) || (zz->LB.Part_Info_Max_Len==0)){
maxlen = INIT_NUM_PART; /* Start with space for INIT_NUM_PART */
zz->LB.Part_Info = (struct Zoltan_part_info *) ZOLTAN_MALLOC(maxlen *
sizeof(struct Zoltan_part_info));
}
if (zz->LB.Part_Info_Len + len > zz->LB.Part_Info_Max_Len){
maxlen = 2*(zz->LB.Part_Info_Len + len); /* Double the length */
zz->LB.Part_Info = (struct Zoltan_part_info *) ZOLTAN_REALLOC(
zz->LB.Part_Info, maxlen * sizeof(struct Zoltan_part_info));
}
if (zz->LB.Part_Info == NULL){
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Memory error.");
error = ZOLTAN_MEMERR;
goto End;
}
/* Add new data to partition info array. */
for (i=0,j=zz->LB.Part_Info_Len; i<len; i++,j++){
zz->LB.Part_Info[j].Size = part_sizes[i];
zz->LB.Part_Info[j].Part_id = part_ids[i];
zz->LB.Part_Info[j].Idx = (wgt_idx ? wgt_idx[i] : 0);
zz->LB.Part_Info[j].Global_num = global_num;
}
/* Update values in LB. */
zz->LB.Part_Info_Len += len;
if (maxlen > zz->LB.Part_Info_Max_Len)
zz->LB.Part_Info_Max_Len = maxlen;
End:
ZOLTAN_TRACE_EXIT(zz, yo);
return error;
}
/* TODO: Add an option to deal with disconnected vertices */
int
Zoltan_Matrix_Remove_DupArcs(ZZ *zz, int size, Zoltan_Arc *arcs, float* pinwgt,
Zoltan_matrix *outmat)
{
static char *yo = "Zoltan_Matrix_Remove_DupArcs";
int ierr = ZOLTAN_OK;
WgtFctPtr wgtfct;
int nY, nPin;
int i;
int prev_pinGNO;
#ifdef CC_TIMERS
double time;
#endif
ZOLTAN_TRACE_ENTER(zz, yo);
#ifdef CC_TIMERS
time = MPI_Wtime();
#endif
switch (outmat->opts.pinwgtop) {
case MAX_WEIGHT:
wgtfct = &wgtFctMax;
break;
case CMP_WEIGHT:
wgtfct = &wgtFctCmp;
break;
case ADD_WEIGHT:
default:
wgtfct = &wgtFctAdd;
}
qsort ((void*)arcs, size, sizeof(Zoltan_Arc),
(int (*)(const void*,const void*))compar_arcs);
#ifdef CC_TIMERS
fprintf(stderr, "(%d) remove arcs (qsort): %g\n", zz->Proc, MPI_Wtime()-time);
#endif
prev_pinGNO = -2;
for (i = 0, nY=-1, nPin=-1; i < size ; ++i) {
int nnew = 0;
int yGNO = arcs[i].yGNO;
int pinGNO = arcs[i].pinGNO;
nnew = ((nY < 0) || (outmat->yGNO[nY] != yGNO));
if (nnew) {
nY++;
outmat->ystart[nY] = nPin + 1;
outmat->yGNO[nY] = yGNO;
prev_pinGNO = -1;
if (pinGNO < 0)
continue;
}
nnew = nnew ||(pinGNO != prev_pinGNO);
if (nnew) { /* New edge */
nPin ++;
outmat->pinGNO[nPin] = pinGNO;
memcpy(outmat->pinwgt + nPin*outmat->pinwgtdim, pinwgt + arcs[i].offset*outmat->pinwgtdim,
outmat->pinwgtdim*sizeof(float));
}
else { /* Duplicate */
wgtfct(outmat->pinwgt + nPin* outmat->pinwgtdim,
pinwgt + arcs[i].offset*outmat->pinwgtdim, outmat->pinwgtdim);
}
prev_pinGNO = outmat->pinGNO[nPin];
}
nY ++;
outmat->ystart[nY] = nPin+1; /* compact mode */
outmat->nPins = nPin+1;
outmat->nY = nY;
/* Try to minimize memory */
/* We reduce memory, thus I don't think these realloc can fail */
if (outmat->yend != outmat->ystart + 1)
ZOLTAN_FREE(&outmat->yend);
outmat->pinGNO = (int *) ZOLTAN_REALLOC(outmat->pinGNO, outmat->nPins * sizeof(int));
outmat->pinwgt = (float *) ZOLTAN_REALLOC(outmat->pinwgt,
outmat->nPins*outmat->pinwgtdim*sizeof(float));
outmat->yend = outmat->ystart + 1;
#ifdef CC_TIMERS
fprintf(stderr, "(%d) remove arcs: %g\n", zz->Proc, MPI_Wtime()-time);
#endif
ZOLTAN_TRACE_EXIT(zz, yo);
return (ierr);
}
int Zoltan_Set_Key_Param(
ZZ *zz, /* Zoltan structure */
const char *name, /* name of variable */
const char *val, /* value of variable */
int idx /* index of vector param, -1 if scalar */
)
{
char *yo = "Zoltan_Set_Key_Param";
char msg[256];
int status; /* return code */
PARAM_UTYPE result; /* value returned from Check_Param */
int index; /* index returned from Check_Param */
int tmp;
int export, import;
status = Zoltan_Check_Param(name, val, Key_params, &result, &index);
if (status == 0) {
switch (index) {
case 0: /* Imbalance_Tol */
if (result.def)
result.fval = ZOLTAN_LB_IMBALANCE_TOL_DEF;
if (result.fval < 1.0) {
sprintf(msg, "Invalid Imbalance_Tol value (%g) "
"being set to %g.", result.fval, ZOLTAN_LB_IMBALANCE_TOL_DEF);
ZOLTAN_PRINT_WARN(zz->Proc, yo, msg);
result.fval = ZOLTAN_LB_IMBALANCE_TOL_DEF;
}
if (idx > zz->Obj_Weight_Dim){
sprintf(msg, "Imbalance_Tol index %d > Obj_Weight_Dim = %d\n",
idx, zz->Obj_Weight_Dim);
ZOLTAN_PRINT_WARN(zz->Proc, yo, msg);
}
else if (idx < -1){
sprintf(msg, "Invalid Imbalance_Tol index %d\n", idx);
ZOLTAN_PRINT_WARN(zz->Proc, yo, msg);
}
else if (idx == -1){
/* Set all entries to the same value. */
for (idx=0; idx<zz->LB.Imb_Tol_Len; idx++)
zz->LB.Imbalance_Tol[idx] = result.fval;
}
else
zz->LB.Imbalance_Tol[idx] = result.fval;
status = 3; /* Don't add to Params field of ZZ */
break;
case 1: /* Help_Migrate */
if (result.def)
result.ival = ZOLTAN_AUTO_MIGRATE_DEF;
zz->Migrate.Auto_Migrate = result.ival;
status = 3; /* Don't add to Params field of ZZ */
break;
case 2: /* Object weight dim. */
if (result.def)
result.ival = ZOLTAN_OBJ_WEIGHT_DEF;
if (result.ival < 0) {
sprintf(msg, "Invalid Obj_Weight_Dim value (%d) "
"being set to %d.", result.ival, ZOLTAN_OBJ_WEIGHT_DEF);
ZOLTAN_PRINT_WARN(zz->Proc, yo, msg);
result.ival = ZOLTAN_OBJ_WEIGHT_DEF;
}
zz->Obj_Weight_Dim = result.ival;
if (zz->Obj_Weight_Dim > zz->LB.Imb_Tol_Len){
/* Resize and reallocate Imb_Tol. */
zz->LB.Imb_Tol_Len += 10;
zz->LB.Imbalance_Tol = (float *) ZOLTAN_REALLOC(zz->LB.Imbalance_Tol, zz->LB.Imb_Tol_Len * sizeof(float));
}
status = 3; /* Don't add to Params field of ZZ */
break;
case 3: /* Edge weight dim. */
case 13:
if (result.def)
result.ival = ZOLTAN_EDGE_WEIGHT_DEF;
if (result.ival < 0) {
sprintf(msg, "Invalid Edge_Weight_Dim value (%d) "
"being set to %d.", result.ival, ZOLTAN_EDGE_WEIGHT_DEF);
ZOLTAN_PRINT_WARN(zz->Proc, yo, msg);
result.ival = ZOLTAN_EDGE_WEIGHT_DEF;
}
zz->Edge_Weight_Dim = result.ival;
status = 3; /* Don't add to Params field of ZZ */
break;
case 4: /* Debug level */
if (result.def)
result.ival = ZOLTAN_DEBUG_LEVEL_DEF;
if (result.ival < 0) {
sprintf(msg, "Invalid Debug_Level value (%d) "
"being set to %d.", result.ival, ZOLTAN_DEBUG_LEVEL_DEF);
ZOLTAN_PRINT_WARN(zz->Proc, yo, msg);
result.ival = ZOLTAN_DEBUG_LEVEL_DEF;
}
zz->Debug_Level = result.ival;
status = 3; /* Don't add to Params field of ZZ */
break;
case 5: /* Debug processor */
if (result.def)
result.ival = ZOLTAN_DEBUG_PROC_DEF;
if (result.ival < 0 || result.ival > zz->Num_Proc) {
sprintf(msg, "Invalid Debug_Processor value (%d) "
"being set to %d.", result.ival, ZOLTAN_DEBUG_PROC_DEF);
ZOLTAN_PRINT_WARN(zz->Proc, yo, msg);
result.ival = ZOLTAN_DEBUG_PROC_DEF;
}
zz->Debug_Proc = result.ival;
status = 3; /* Don't add to Params field of ZZ */
break;
case 6: /* Deterministic flag */
if (result.def)
result.ival = ZOLTAN_DETERMINISTIC_DEF;
if (result.ival < 0) {
sprintf(msg, "Invalid Deterministic value (%d) "
"being set to %d.", result.ival, ZOLTAN_DETERMINISTIC_DEF);
ZOLTAN_PRINT_WARN(zz->Proc, yo, msg);
result.ival = ZOLTAN_DETERMINISTIC_DEF;
}
zz->Deterministic = result.ival;
status = 3; /* Don't add to Params field of ZZ */
break;
case 7: /* Timer */
status = Zoltan_Set_Timer_Param(name, val, &tmp);
zz->Timer = tmp;
Zoltan_Timer_ChangeFlag(zz->ZTime, zz->Timer);
if (status==0) status = 3; /* Don't add to Params field of ZZ */
break;
case 8: /* Num_GID_Entries */
if (result.def)
result.ival = ZOLTAN_NUM_ID_ENTRIES_DEF;
if (result.ival < 1) {
sprintf(msg, "Invalid Num_GID_Entries value (%d); "
"being set to %d.", result.ival, ZOLTAN_NUM_ID_ENTRIES_DEF);
ZOLTAN_PRINT_WARN(zz->Proc, yo, msg);
result.ival = ZOLTAN_NUM_ID_ENTRIES_DEF;
}
zz->Num_GID = result.ival;
status = 3;
break;
case 9: /* Num_LID_Entries */
if (result.def)
result.ival = ZOLTAN_NUM_ID_ENTRIES_DEF;
if (result.ival < 0) {
sprintf(msg, "Invalid Num_LID_Entries value (%d); "
"being set to %d.", result.ival, ZOLTAN_NUM_ID_ENTRIES_DEF);
ZOLTAN_PRINT_WARN(zz->Proc, yo, msg);
result.ival = ZOLTAN_NUM_ID_ENTRIES_DEF;
}
zz->Num_LID = result.ival;
status = 3;
break;
case 10: /* LB.Return_Lists */
export = (strstr(result.sval, "EXPORT") != NULL);
import = (strstr(result.sval, "IMPORT") != NULL);
if ((export && import) || (strcmp(result.sval, "ALL") == 0)) {
tmp = ZOLTAN_LB_ALL_LISTS; /* export AND import lists */
status = 3;
}
else if (import){
tmp = ZOLTAN_LB_IMPORT_LISTS; /* import lists */
status = 3;
}
else if (export){
tmp = ZOLTAN_LB_EXPORT_LISTS; /* export lists */
status = 3;
}
else if (strstr(result.sval, "PART")!=NULL) {
/* list of every object's part assignment */
tmp = ZOLTAN_LB_COMPLETE_EXPORT_LISTS;
status = 3;
}
else if (strcmp(result.sval, "NONE")==0) {
tmp = ZOLTAN_LB_NO_LISTS; /* no lists */
status = 3;
}
else if (strcmp(result.sval, "CANDIDATE_LISTS")==0) {
tmp = ZOLTAN_LB_CANDIDATE_LISTS; /* candidates needed in matching */
status = 3;
}
else{
tmp = ZOLTAN_LB_RETURN_LISTS_DEF;
sprintf(msg, "Unknown return_lists option %s.", result.sval);
ZOLTAN_PRINT_WARN(zz->Proc, yo, msg);
status = 2; /* Illegal parameter */
}
zz->LB.Return_Lists = tmp;
break;
case 11: /* LB_Method */
if (result.def)
strcpy(result.sval, "RCB");
status = Zoltan_LB_Set_LB_Method(zz,result.sval);
if (status == ZOLTAN_OK)
status = 3;
break;
case 12: /* Tflops Special flag */
if (result.def)
result.ival = ZOLTAN_TFLOPS_SPECIAL_DEF;
if (result.ival < 0) {
sprintf(msg, "Invalid Tflops Special value (%d) "
"being set to %d.", result.ival, ZOLTAN_TFLOPS_SPECIAL_DEF);
ZOLTAN_PRINT_WARN(zz->Proc, yo, msg);
result.ival = ZOLTAN_TFLOPS_SPECIAL_DEF;
}
zz->Tflops_Special = result.ival;
status = 3; /* Don't add to Params field of ZZ */
break;
case 14: /* Num_Global_Parts */
case 15:
if (result.def)
result.ival = zz->Num_Proc;
if (result.ival < 1) {
sprintf(msg, "Invalid Num_Global_Parts value (%d); "
"being set to %d.", result.ival,zz->Num_Proc);
ZOLTAN_PRINT_WARN(zz->Proc, yo, msg);
result.ival = zz->Num_Proc;
}
zz->LB.Num_Global_Parts_Param = result.ival;
status = 3;
break;
case 16: /* Num_Local_Parts */
case 17:
if (result.def)
result.ival = -1;
if (result.ival < -1) {
sprintf(msg, "Invalid Num_Local_Parts value (%d); "
"being set to %d.", result.ival,-1);
ZOLTAN_PRINT_WARN(zz->Proc, yo, msg);
result.ival = -1;
}
zz->LB.Num_Local_Parts_Param = result.ival;
status = 3;
break;
case 18: /* Migrate_Only_Proc_Changes */
if (result.def)
result.ival = ZOLTAN_MIGRATE_ONLY_PROC_CHANGES_DEF;
zz->Migrate.Only_Proc_Changes = result.ival;
status = 3; /* Don't add to Params field of ZZ */
break;
case 19: /* LB.Remap */
if (result.def)
result.ival = 0;
zz->LB.Remap_Flag = result.ival;
status = 3; /* Don't add to Params field of ZZ */
break;
case 20: /* Seed */
if (result.def)
result.ival = Zoltan_Seed();
zz->Seed = result.ival;
Zoltan_Srand(result.ival, NULL);
status = 3;
break;
case 21: /* LB_APPROACH */
if (result.def)
strcpy(result.sval, ZOLTAN_LB_APPROACH_DEF);
strcpy(zz->LB.Approach, result.sval);
status = 3;
break;
} /* end switch (index) */
