/**
* Deregister and destroy all window entries and associated buffers.
*
* @pre this function is called once to destroy the internal data structures
* and cannot be called again until reg_win_init() has been called
*
* @see reg_win_init()
*
* @return RR_SUCCESS on success
*/
reg_return_t
reg_win_destroy()
{
int i = 0;
#if DEBUG
printf("[%d] reg_win_destroy()\n", g_state.rank);
#endif
/* preconditions */
COMEX_ASSERT(NULL != reg_win);
COMEX_ASSERT(0 != reg_nprocs);
for (i = 0; i < reg_nprocs; ++i) {
reg_entry_t *runner = reg_win[i];
while (runner) {
reg_entry_t *previous = runner; /* pointer to previous runner */
/* get next runner */
runner = runner->next;
/* destroy the entry */
reg_entry_destroy(i, previous);
}
}
/* free registration window list */
free(reg_win);
reg_win = NULL;
/* reset the number of windows */
reg_nprocs = 0;
return RR_SUCCESS;
}
/**
* Deregister and destroy all cache entries and associated buffers.
*
* @pre this function is called once to destroy the internal data structures
* and cannot be called again until reg_cache_init() has been called
*
* @see reg_cache_init()
*
* @return RR_SUCCESS on success
*/
reg_return_t
reg_cache_destroy()
{
int i = 0;
/* preconditions */
assert(NULL != reg_cache);
assert(0 != reg_nprocs);
for (i = 0; i < reg_nprocs; ++i) {
reg_entry_t *runner = reg_cache[i];
while (runner) {
reg_entry_t *previous = runner; /* pointer to previous runner */
/* get next runner */
runner = runner->next;
/* destroy the entry */
reg_entry_destroy(i, previous);
}
}
/* free registration cache list */
free(reg_cache);
reg_cache = NULL;
/* reset the number of caches */
reg_nprocs = 0;
/* by the time all entries are destroyed, dmapp cache should be empty */
assert(NULL == dmapp_cache);
return RR_SUCCESS;
}
/**
* Removes the reg window entry associated with the given rank and buffer.
*
* If this process owns the buffer, it will unregister the buffer, as well.
*
* @param[in] rank
* @param[in] buf
*
* @pre 0 <= rank && rank < reg_nprocs
* @pre NULL != buf
* @pre reg_win_init() was previously called
* @pre NULL != reg_win_find(rank, buf, 0)
*
* @return RR_SUCCESS on success
* RR_FAILURE otherwise
*/
reg_return_t
reg_win_delete(int rank, void *buf)
{
reg_return_t status = RR_FAILURE;
reg_entry_t *runner = NULL;
reg_entry_t *previous_runner = NULL;
#if DEBUG
printf("[%d] reg_win_delete(rank=%d, buf=%p)\n",
g_state.rank, rank, buf);
#endif
/* preconditions */
COMEX_ASSERT(NULL != reg_win);
COMEX_ASSERT(0 <= rank && rank < reg_nprocs);
COMEX_ASSERT(NULL != buf);
COMEX_ASSERT(NULL != reg_win_find(rank, buf, 0));
/* this is more restrictive than reg_win_find() in that we locate
* exactlty the same region starting address */
runner = reg_win[rank];
while (runner) {
if (runner->buf == buf) {
break;
}
/* no match so match may be next runner */
previous_runner = runner;
runner = runner->next;
}
/* we should have found an entry */
if (NULL == runner) {
COMEX_ASSERT(0);
return RR_FAILURE;
}
/* pop the entry out of the linked list */
if (previous_runner) {
/* runner is a match and it is not the first entry in list */
previous_runner->next = runner->next;
}
else {
/* buf corresponds to first entry in list */
reg_win[rank] = reg_win[rank]->next;
}
status = reg_entry_destroy(rank, runner);
return status;
}
/**
* Removes the reg cache entry associated with the given rank and buffer.
*
* If this process owns the buffer, it will unregister the buffer, as well.
*
* @param[in] rank
* @param[in] buf
*
* @pre 0 <= rank && rank < reg_nprocs
* @pre NULL != buf
* @pre reg_cache_init() was previously called
* @pre NULL != reg_cache_find(rank, buf, 0)
*
* @return RR_SUCCESS on success
* RR_FAILURE otherwise
*/
reg_return_t
reg_cache_delete(int rank, void *buf)
{
reg_return_t status = RR_FAILURE;
reg_entry_t *runner = NULL;
reg_entry_t *previous_runner = NULL;
/* preconditions */
assert(NULL != reg_cache);
assert(0 <= rank && rank < reg_nprocs);
assert(NULL != buf);
assert(NULL != reg_cache_find(rank, buf, 0));
/* this is more restrictive than reg_cache_find() in that we locate
* exactlty the same region starting address */
runner = reg_cache[rank];
while (runner) {
if (runner->buf == buf) {
break;
}
previous_runner = runner;
runner = runner->next;
}
/* we should have found an entry */
if (NULL == runner) {
assert(0);
return RR_FAILURE;
}
/* pop the entry out of the linked list */
if (previous_runner) {
previous_runner->next = runner->next;
}
else {
reg_cache[rank] = reg_cache[rank]->next;
}
status = reg_entry_destroy(rank, runner);
return status;
}
