C++ (Cpp) hg_thread_mutex_destroy Examples

Example #1

File: na.c Project: scottatchley/mercury

/*---------------------------------------------------------------------------*/
na_return_t
NA_Context_destroy(na_class_t *na_class, na_context_t *context)
{
    struct na_private_context *na_private_context =
            (struct na_private_context *) context;
    na_return_t ret = NA_SUCCESS;

    if (!na_class) {
        NA_LOG_ERROR("NULL NA class");
        ret = NA_INVALID_PARAM;
        goto done;
    }
    if (!context) goto done;

    /* Check that completion queue is empty now */
    hg_thread_mutex_lock(&na_private_context->completion_queue_mutex);

    if (!hg_queue_is_empty(na_private_context->completion_queue)) {
        NA_LOG_ERROR("Completion queue should be empty");
        ret = NA_PROTOCOL_ERROR;
        hg_thread_mutex_unlock(&na_private_context->completion_queue_mutex);
        goto done;
    }

    if (na_class->context_destroy) {
        ret = na_class->context_destroy(na_class,
                na_private_context->context.plugin_context);
        if (ret != NA_SUCCESS) {
            goto done;
        }
    }

    /* Destroy completion queue */
    hg_queue_free(na_private_context->completion_queue);
    na_private_context->completion_queue = NULL;

    hg_thread_mutex_unlock(&na_private_context->completion_queue_mutex);

    /* Destroy completion queue mutex/cond */
    hg_thread_mutex_destroy(&na_private_context->completion_queue_mutex);
    hg_thread_cond_destroy(&na_private_context->completion_queue_cond);

    /* Destroy progress mutex/cond */
    hg_thread_mutex_destroy(&na_private_context->progress_mutex);
    hg_thread_cond_destroy(&na_private_context->progress_cond);

    free(na_private_context);

done:
    return ret;
}

Example #2

File: na.c Project: scottatchley/mercury-cci

/*---------------------------------------------------------------------------*/
na_return_t
NA_Finalize(na_class_t *na_class)
{
    na_return_t ret = NA_SUCCESS;

    assert(na_class);

    ret = na_class->finalize(na_class);

    /* Destroy lookup mutex */
    hg_thread_mutex_destroy(&na_addr_lookup_mutex_g);

    return ret;
}

Example #3

File: mercury_test.c Project: chuckcranor/mercury

/*---------------------------------------------------------------------------*/
hg_return_t
HG_Test_finalize(hg_class_t *hg_class)
{
    hg_return_t ret = HG_SUCCESS;
    na_return_t na_ret;

    NA_Test_barrier();

    (void)hg_class;
    if (hg_test_is_client_g) {
        /* Terminate server */
        if (hg_test_rank_g == 0) hg_test_finalize_rpc();

        /* Free addr id */
        ret = HG_Addr_free(HG_CLASS_DEFAULT, hg_test_addr_g);
        if (ret != HG_SUCCESS) {
            fprintf(stderr, "Could not free addr\n");
            goto done;
        }
        hg_test_addr_g = HG_ADDR_NULL;
    } else if (hg_test_addr_table_g) {
        unsigned int i;

        for (i = 0; i < hg_test_addr_table_size_g; i++)
            HG_Addr_free(HG_CLASS_DEFAULT, hg_test_addr_table_g[i]);
        free(hg_test_addr_table_g);
        hg_test_addr_table_g = NULL;
    }

    /* Destroy bulk handle */
    HG_Bulk_free(hg_test_local_bulk_handle_g);
    hg_test_local_bulk_handle_g = HG_BULK_NULL;

#ifdef MERCURY_TESTING_HAS_THREAD_POOL
    hg_thread_pool_destroy(hg_test_thread_pool_g);
    hg_thread_mutex_destroy(&hg_test_local_bulk_handle_mutex_g);
#endif

    /* Finalize interface */
    ret = HG_Hl_finalize();
    if (ret != HG_SUCCESS) {
        fprintf(stderr, "Could not finalize HG\n");
        goto done;
    }

    na_ret = NA_Context_destroy(hg_test_na_class_g, hg_test_na_context_g);
    if (na_ret != NA_SUCCESS) {
        fprintf(stderr, "Could not destroy NA context\n");
        goto done;
    }
    hg_test_na_context_g = NULL;

    na_ret = NA_Test_finalize(hg_test_na_class_g);
    if (na_ret != NA_SUCCESS) {
        fprintf(stderr, "Could not finalize NA interface\n");
        goto done;
    }

done:
     return ret;
}