/** Destroy/free ARMCI mutexes. Collective.
*/
int ARMCI_Destroy_mutexes(void) {
int err;
if (armci_mutex_hdl == NULL)
ARMCII_Error("attempted to free unallocated ARMCI mutexes");
err = ARMCIX_Destroy_mutexes_hdl(armci_mutex_hdl);
armci_mutex_hdl = NULL;
return err;
}
/** Destroy/free a shared memory region.
*
* @param[in] ptr Pointer within range of the segment (e.g. base pointer).
* @param[in] group Group on which to perform the free.
*/
void gmr_destroy(gmr_t *mreg, ARMCI_Group *group) {
int search_proc_in, search_proc_out, search_proc_out_grp;
void *search_base;
int alloc_me, alloc_nproc;
int world_me, world_nproc;
MPI_Comm_rank(group->comm, &alloc_me);
MPI_Comm_size(group->comm, &alloc_nproc);
MPI_Comm_rank(ARMCI_GROUP_WORLD.comm, &world_me);
MPI_Comm_size(ARMCI_GROUP_WORLD.comm, &world_nproc);
/* All-to-all exchange of a <base address, proc> pair. This is so that we
* can support passing NULL into ARMCI_Free() which is permitted when a
* process allocates 0 bytes. Unfortunately, in this case we still need to
* identify the mem region and free it.
*/
if (mreg == NULL)
search_proc_in = -1;
else {
search_proc_in = world_me;
search_base = mreg->slices[world_me].base;
}
/* Collectively decide on who will provide the base address */
MPI_Allreduce(&search_proc_in, &search_proc_out, 1, MPI_INT, MPI_MAX, group->comm);
/* Everyone passed NULL. Nothing to free. */
if (search_proc_out < 0)
return;
/* Translate world rank to group rank */
search_proc_out_grp = ARMCII_Translate_absolute_to_group(group, search_proc_out);
/* Broadcast the base address */
MPI_Bcast(&search_base, sizeof(void*), MPI_BYTE, search_proc_out_grp, group->comm);
/* If we were passed NULL, look up the mem region using the <base, proc> pair */
if (mreg == NULL)
mreg = gmr_lookup(search_base, search_proc_out);
/* If it's still not found, the user may have passed the wrong group */
ARMCII_Assert_msg(mreg != NULL, "Could not locate the desired allocation");
switch (mreg->lock_state) {
case GMR_LOCK_UNLOCKED:
break;
case GMR_LOCK_DLA:
ARMCII_Warning("Releasing direct local access before freeing shared allocation\n");
gmr_dla_unlock(mreg);
break;
default:
ARMCII_Error("Unable to free locked memory region (%d)\n", mreg->lock_state);
}
/* Remove from the list of mem regions */
if (mreg->prev == NULL) {
ARMCII_Assert(gmr_list == mreg);
gmr_list = mreg->next;
if (mreg->next != NULL)
mreg->next->prev = NULL;
} else {
mreg->prev->next = mreg->next;
if (mreg->next != NULL)
mreg->next->prev = mreg->prev;
}
/* Destroy the window and free all buffers */
MPI_Win_free(&mreg->window);
if (mreg->slices[world_me].base != NULL)
MPI_Free_mem(mreg->slices[world_me].base);
free(mreg->slices);
ARMCIX_Destroy_mutexes_hdl(mreg->rmw_mutex);
free(mreg);
}
