static pmix_status_t pmix_ptl_close(void)
{
if (!pmix_ptl_globals.initialized) {
return PMIX_SUCCESS;
}
pmix_ptl_globals.initialized = false;
/* ensure the listen thread has been shut down */
pmix_ptl_base_stop_listening();
if (NULL != pmix_client_globals.myserver) {
if (0 <= pmix_client_globals.myserver->sd) {
CLOSE_THE_SOCKET(pmix_client_globals.myserver->sd);
pmix_client_globals.myserver->sd = -1;
}
}
/* the components will cleanup when closed */
PMIX_LIST_DESTRUCT(&pmix_ptl_globals.actives);
PMIX_LIST_DESTRUCT(&pmix_ptl_globals.posted_recvs);
PMIX_LIST_DESTRUCT(&pmix_ptl_globals.unexpected_msgs);
PMIX_LIST_DESTRUCT(&pmix_ptl_globals.listeners);
return pmix_mca_base_framework_components_close(&pmix_ptl_base_framework, NULL);
}
static void tcp_finalize(void)
{
pmix_output_verbose(2, pmix_pnet_base_framework.framework_output,
"pnet: tcp finalize");
if (PMIX_PROC_IS_GATEWAY(pmix_globals.mypeer)) {
PMIX_LIST_DESTRUCT(&allocations);
PMIX_LIST_DESTRUCT(&available);
}
}
void cli_disconnect(cli_info_t *cli)
{
if( CLI_DISCONN != cli->next_state[cli->state] ){
TEST_ERROR(("rank %d: bad client next state: expect %d have %d!",
cli_rank(cli), CLI_DISCONN, cli->next_state[cli->state]));
test_abort = true;
}
if( 0 > cli->sd ){
TEST_ERROR(("Bad sd = %d of rank = %d ", cli->sd, cli_rank(cli)));
test_abort = true;
} else {
TEST_VERBOSE(("close sd = %d for rank = %d", cli->sd, cli_rank(cli)));
close(cli->sd);
cli->sd = -1;
}
if( NULL == cli->ev ){
TEST_ERROR(("Bad ev = NULL of rank = %d ", cli->sd, cli_rank(cli)));
test_abort = true;
} else {
TEST_VERBOSE(("remove event of rank %d from event queue", cli_rank(cli)));
event_del(cli->ev);
event_free(cli->ev);
cli->ev = NULL;
}
TEST_VERBOSE(("Destruct modex list for the rank %d", cli_rank(cli)));
PMIX_LIST_DESTRUCT(&(cli->modex));
cli->state = CLI_DISCONN;
}
static void sndes(pmix_server_nspace_t *p)
{
PMIX_DESTRUCT(&p->job_info);
PMIX_LIST_DESTRUCT(&p->ranks);
PMIX_DESTRUCT(&p->mylocal);
PMIX_DESTRUCT(&p->myremote);
PMIX_DESTRUCT(&p->remote);
}
static void nsdes(pmix_nspace_t *p)
{
PMIX_LIST_DESTRUCT(&p->nodes);
PMIX_DESTRUCT(&p->internal);
PMIX_DESTRUCT(&p->modex);
if (NULL != p->server) {
PMIX_RELEASE(p->server);
}
}
static void rvdes(pmix_regex_value_t *p)
{
if (NULL != p->prefix) {
free(p->prefix);
}
if (NULL != p->suffix) {
free(p->suffix);
}
PMIX_LIST_DESTRUCT(&p->ranges);
}
void pmix_globals_finalize(void)
{
PMIX_LIST_DESTRUCT(&pmix_globals.nspaces);
if (NULL != pmix_globals.cache_local) {
PMIX_RELEASE(pmix_globals.cache_local);
}
if (NULL != pmix_globals.cache_remote) {
PMIX_RELEASE(pmix_globals.cache_remote);
}
}
static void cbdes(pmix_cb_t *p)
{
if (p->timer_running) {
pmix_event_del(&p->ev);
}
if (NULL != p->pname.nspace) {
free(p->pname.nspace);
}
PMIX_DESTRUCT(&p->data);
PMIX_LIST_DESTRUCT(&p->kvs);
}
static void tades(tcp_available_ports_t *p)
{
PMIX_LIST_DESTRUCT(&p->devices);
if (NULL != p->type) {
free(p->type);
}
if (NULL != p->plane) {
free(p->plane);
}
if (NULL != p->ports) {
pmix_argv_free(p->ports);
}
}
static void nsdes(pmix_nspace_t *p)
{
if (NULL != p->nspace) {
free(p->nspace);
}
if (NULL != p->jobinfo) {
PMIX_INFO_FREE(p->jobinfo, p->njobinfo);
}
if (NULL != p->jobbkt) {
PMIX_RELEASE(p->jobbkt);
}
PMIX_LIST_DESTRUCT(&p->ranks);
}
static void pdes(pmix_peer_t *p)
{
if (0 <= p->sd) {
CLOSE_THE_SOCKET(p->sd);
}
if (p->send_ev_active) {
pmix_event_del(&p->send_event);
}
if (p->recv_ev_active) {
pmix_event_del(&p->recv_event);
}
if (NULL != p->info) {
PMIX_RELEASE(p->info);
}
PMIX_LIST_DESTRUCT(&p->send_queue);
if (NULL != p->send_msg) {
PMIX_RELEASE(p->send_msg);
}
if (NULL != p->recv_msg) {
PMIX_RELEASE(p->recv_msg);
}
}
void pmix_usock_finalize(void)
{
PMIX_LIST_DESTRUCT(&pmix_usock_globals.posted_recvs);
}
void pmix_rte_finalize(void)
{
if( --pmix_initialized != 0 ) {
if( pmix_initialized < 0 ) {
fprintf(stderr, "PMIx Finalize called too many times\n");
return;
}
return;
}
if (!pmix_globals.external_evbase) {
/* stop the progress thread */
(void)pmix_progress_thread_finalize(NULL);
}
/* cleanup communications */
pmix_usock_finalize();
if (PMIX_PROC_SERVER != pmix_globals.proc_type &&
0 <= pmix_client_globals.myserver.sd) {
CLOSE_THE_SOCKET(pmix_client_globals.myserver.sd);
}
#if defined(PMIX_ENABLE_DSTORE) && (PMIX_ENABLE_DSTORE == 1)
pmix_dstore_finalize();
#endif /* PMIX_ENABLE_DSTORE */
/* close the security framework */
(void)pmix_mca_base_framework_close(&pmix_psec_base_framework);
/* Clear out all the registered MCA params */
pmix_deregister_params();
pmix_mca_base_var_finalize();
/* keyval lex-based parser */
pmix_util_keyval_parse_finalize();
(void)pmix_mca_base_framework_close(&pmix_pinstalldirs_base_framework);
/* finalize the show_help system */
pmix_show_help_finalize();
/* finalize the output system. This has to come *after* the
malloc code, as the malloc code needs to call into this, but
the malloc code turning off doesn't affect pmix_output that
much */
pmix_output_finalize();
#if 0
/* close the bfrops */
(void)pmix_mca_base_framework_close(&pmix_bfrops_base_framework);
#endif
/* clean out the globals */
PMIX_RELEASE(pmix_globals.mypeer);
PMIX_LIST_DESTRUCT(&pmix_globals.nspaces);
if (NULL != pmix_globals.cache_local) {
PMIX_RELEASE(pmix_globals.cache_local);
}
if (NULL != pmix_globals.cache_remote) {
PMIX_RELEASE(pmix_globals.cache_remote);
}
PMIX_DESTRUCT(&pmix_globals.events);
#if PMIX_NO_LIB_DESTRUCTOR
pmix_cleanup();
#endif
}
