/*
* void Zoltan_Oct_addRegion(pOctant octant, pRegion region)
* add a region to oct's list
*/
int Zoltan_Oct_addRegion(ZZ *zz, pOctant oct, pRegion region) {
char *yo = "Zoltan_Oct_addRegion";
pRegion entry; /* pointer to new entry in region list */
if(oct == NULL)
return ZOLTAN_WARN;
entry = (pRegion) ZOLTAN_MALLOC(sizeof(Region)); /* malloc space for region */
if(entry == NULL) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Cannot allocated memory for region.");
return ZOLTAN_MEMERR;
}
entry->Global_ID = ZOLTAN_MALLOC_GID(zz);
entry->Local_ID = ZOLTAN_MALLOC_LID(zz);
/* copy region information into the entry */
vector_set(entry->Coord, region->Coord);
entry->Weight = region->Weight;
ZOLTAN_SET_GID(zz, entry->Global_ID, region->Global_ID);
ZOLTAN_SET_LID(zz, entry->Local_ID, region->Local_ID);
entry->Proc = region->Proc;
/* attach region to region list */
entry->next = oct->list;
oct->list = entry;
return ZOLTAN_OK;
}
/*
* Function that initializes the region data structure. It uses the
* global ID, coordinates and weight provided by the application.
*/
static void initialize_region(ZZ *zz, pRegion *ret, ZOLTAN_ID_PTR global_id,
ZOLTAN_ID_PTR local_id, int wgtflag, float wgt,
int num_dim, double *geom_vec)
{
pRegion reg;
int i;
reg = (pRegion) ZOLTAN_MALLOC(sizeof(Region));
*ret = reg;
reg->Global_ID = ZOLTAN_MALLOC_GID(zz);
reg->Local_ID = ZOLTAN_MALLOC_LID(zz);
ZOLTAN_SET_GID(zz, reg->Global_ID, global_id);
ZOLTAN_SET_LID(zz, reg->Local_ID, local_id);
reg->Proc = zz->Proc;
/* reg->Proc = 0; */
reg->Coord[0] = reg->Coord[1] = reg->Coord[2] = 0.0;
for (i = 0; i < num_dim; i++)
reg->Coord[i] = geom_vec[i];
#if 0
Zoltan_Print_Sync_Start(zz->Communicator, TRUE);
fprintf(stderr, "Result info on %d: %d %d %d %lf %lf %lf\n", zz->Proc,
reg->Local_ID, reg->Global_ID, reg->Proc,
reg->Coord[0], reg->Coord[1], reg->Coord[2]);
Zoltan_Print_Sync_End(zz->Communicator, TRUE);
#endif
if (wgtflag)
reg->Weight = wgt;
else
reg->Weight = 1;
reg->next = NULL;
}
/*
* int Zoltan_Oct_copy_info(pRegion *destination, pRegion source)
*
* Copies region information from the source to the destination
*/
static int Zoltan_Oct_copy_info(ZZ *zz, pRegion src, pRegion *dest) {
pRegion copy;
char *yo = "Zoltan_Oct_copy_info";
int ierr = ZOLTAN_OK;
/* mallloc space for destination */
copy = (pRegion) ZOLTAN_MALLOC(sizeof(Region));
if(copy == NULL) {
ZOLTAN_TRACE_EXIT(zz, yo);
return ZOLTAN_MEMERR;
}
copy->Global_ID = ZOLTAN_MALLOC_GID(zz);
copy->Local_ID = ZOLTAN_MALLOC_LID(zz);
if (copy->Global_ID == NULL || (zz->Num_LID && copy->Local_ID == NULL)) {
ZOLTAN_TRACE_EXIT(zz, yo);
return ZOLTAN_MEMERR;
}
/* set up return pointer */
*dest = copy;
/* copy all important information */
vector_set(copy->Coord, src->Coord);
copy->Weight = src->Weight;
ZOLTAN_SET_GID(zz, copy->Global_ID, src->Global_ID);
ZOLTAN_SET_LID(zz, copy->Local_ID, src->Local_ID);
copy->Proc = src->Proc;
copy->attached = 0;
return ierr;
}
/*
* void malloc_new_objects();
*
* gets the tags being imported into this processor, and sets up the
* import_tags array, and the nrectags array.
*/
static int malloc_new_objects(ZZ *zz, int nsentags, pRegion exported_tags,
ZOLTAN_ID_PTR exported_gids,
ZOLTAN_ID_PTR exported_lids, int *tag_pids,
int *nstags, pRegion *ex_tags,
pRegion prev_tags, ZOLTAN_ID_PTR prev_gids,
ZOLTAN_ID_PTR prev_lids, int npimtags,
float *c3)
{
char *yo = "malloc_new_objects";
int i; /* index counter */
int nreceives; /* number of messages received */
pRegion t_b_exp; /* array of tags to be exported */
pRegion tmp = NULL;
ZOLTAN_ID_PTR tmp_gids = NULL;
ZOLTAN_ID_PTR tmp_lids = NULL;
int msgtag, msgtag2;
int j;
int ierr = ZOLTAN_OK;
int num_gid_entries = zz->Num_GID;
int num_lid_entries = zz->Num_LID;
float im_load;
ZOLTAN_COMM_OBJ *comm_plan; /* Object returned by communication routines */
im_load = 0;
msgtag = 32767;
ierr = Zoltan_Comm_Create(&comm_plan, nsentags, tag_pids, zz->Communicator,
msgtag, &nreceives);
if(ierr != ZOLTAN_OK && ierr != ZOLTAN_WARN) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo,
"Error returned from Zoltan_Comm_Create.");
ZOLTAN_TRACE_EXIT(zz, yo);
return(ierr);
}
if (nreceives > 0) {
tmp = (pRegion) ZOLTAN_MALLOC(nreceives * sizeof(Region));
tmp_gids = ZOLTAN_MALLOC_GID_ARRAY(zz, nreceives);
tmp_lids = ZOLTAN_MALLOC_LID_ARRAY(zz, nreceives);
if(tmp == NULL || !tmp_gids || (num_lid_entries && !tmp_lids)) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Insufficient memory.");
ZOLTAN_FREE(&tmp);
ZOLTAN_FREE(&tmp_gids);
ZOLTAN_FREE(&tmp_lids);
ZOLTAN_TRACE_EXIT(zz, yo);
return ZOLTAN_MEMERR;
}
}
msgtag2 = 32766;
ierr = Zoltan_Comm_Do(comm_plan, msgtag2, (char *) exported_tags,
sizeof(Region), (char *) tmp);
if(ierr != ZOLTAN_OK && ierr != ZOLTAN_WARN) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Error returned from Zoltan_Comm_Do.");
ZOLTAN_TRACE_EXIT(zz, yo);
ZOLTAN_FREE(&tmp);
ZOLTAN_FREE(&tmp_gids);
ZOLTAN_FREE(&tmp_lids);
return(ierr);
}
msgtag2--;
ierr = Zoltan_Comm_Do(comm_plan, msgtag2, (char *) exported_gids,
sizeof(ZOLTAN_ID_TYPE)*num_gid_entries,
(char *) tmp_gids);
if (ierr != ZOLTAN_OK && ierr != ZOLTAN_WARN) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Error returned from Zoltan_Comm_Do.");
fprintf(stderr, "OCT %s Error %s returned from Zoltan_Comm_Do\n", yo,
(ierr == ZOLTAN_MEMERR ? "ZOLTAN_MEMERR" : "ZOLTAN_FATAL"));
ZOLTAN_FREE(&tmp);
ZOLTAN_FREE(&tmp_gids);
ZOLTAN_FREE(&tmp_lids);
return(ierr);
}
if (num_lid_entries > 0) {
msgtag2--;
ierr = Zoltan_Comm_Do(comm_plan, msgtag2, (char *) exported_lids,
sizeof(ZOLTAN_ID_TYPE)*num_lid_entries,
(char *) tmp_lids);
if (ierr != ZOLTAN_OK && ierr != ZOLTAN_WARN) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Error returned from Zoltan_Comm_Do.");
ZOLTAN_FREE(&tmp);
ZOLTAN_FREE(&tmp_gids);
ZOLTAN_FREE(&tmp_lids);
return(ierr);
}
}
ierr = Zoltan_Comm_Destroy(&comm_plan);
if(ierr != ZOLTAN_OK && ierr != ZOLTAN_WARN) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo,
"Error returned from Zoltan_Comm_Destroy.");
ZOLTAN_TRACE_EXIT(zz, yo);
ZOLTAN_FREE(&tmp);
return(ierr);
}
/* get each message sent, and store region in import array */
j=0;
for (i=0; i<nreceives; i++) {
im_load += tmp[i].Weight;
if(tmp[i].newProc != zz->Proc) {
j++;
}
}
if((j + npimtags) != 0) { /* malloc import array */
if((t_b_exp = (pRegion)ZOLTAN_MALLOC((j+npimtags)*sizeof(Region)))==NULL){
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Insufficient memory.");
ZOLTAN_TRACE_EXIT(zz, yo);
ZOLTAN_FREE(&tmp);
ZOLTAN_FREE(&tmp_gids);
ZOLTAN_FREE(&tmp_lids);
return ZOLTAN_MEMERR;
}
}
else
t_b_exp = NULL;
/* setup return pointer */
(*ex_tags) = t_b_exp;
j=0;
for (i=0; i<nreceives; i++) {
if(tmp[i].newProc != zz->Proc) {
t_b_exp[j] = tmp[i];
t_b_exp[j].Global_ID = ZOLTAN_MALLOC_GID(zz);
t_b_exp[j].Local_ID = ZOLTAN_MALLOC_LID(zz);
if (!(t_b_exp[j].Global_ID) ||
(num_lid_entries && !(t_b_exp[j].Local_ID))) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Insufficient memory.");
ZOLTAN_TRACE_EXIT(zz, yo);
ZOLTAN_FREE(&tmp);
ZOLTAN_FREE(&tmp_gids);
ZOLTAN_FREE(&tmp_lids);
return ZOLTAN_MEMERR;
}
ZOLTAN_SET_GID(zz, t_b_exp[j].Global_ID,
&(tmp_gids[i*num_gid_entries]));
ZOLTAN_SET_LID(zz, t_b_exp[j].Local_ID, &(tmp_lids[i*num_lid_entries]));
j++;
}
}
if(npimtags > 0) {
for(i=0; i<npimtags; i++) {
t_b_exp[j] = prev_tags[i];
t_b_exp[j].Global_ID = ZOLTAN_MALLOC_GID(zz);
t_b_exp[j].Local_ID = ZOLTAN_MALLOC_LID(zz);
if (!(t_b_exp[j].Global_ID) ||
(num_lid_entries && !(t_b_exp[j].Local_ID))) {
ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Insufficient memory.");
ZOLTAN_TRACE_EXIT(zz, yo);
ZOLTAN_FREE(&tmp);
ZOLTAN_FREE(&tmp_gids);
ZOLTAN_FREE(&tmp_lids);
return ZOLTAN_MEMERR;
}
ZOLTAN_SET_GID(zz, t_b_exp[j].Global_ID,
&(prev_gids[i*num_gid_entries]));
ZOLTAN_SET_LID(zz, t_b_exp[j].Local_ID,
&(prev_lids[i*num_lid_entries]));
j++;
}
}
*nstags = j;
ZOLTAN_FREE(&tmp);
ZOLTAN_FREE(&tmp_gids);
ZOLTAN_FREE(&tmp_lids);
if((*nstags == 0) && (*ex_tags != NULL)) {
ZOLTAN_TRACE_DETAIL(zz, yo,
"Fatal error, import tags not empty but no tags received\n");
return ZOLTAN_FATAL;
}
*c3 = im_load;
return ierr;
}
