C++ (Cpp) join_wait_thread Examples

Example #1

File: NssiSelfSendTest.cpp Project: 00liujj/trilinos

int main(int argc, char *argv[])
{
    int rc;
    nssi_service svc;

    logger_init(LOG_ERROR, "nssiselfsend.log");

    pthread_barrier_init(&barrier, NULL, 2);

    // common init
    nssi_rpc_init(NSSI_DEFAULT_TRANSPORT, NSSI_DEFAULT_ENCODE, NULL);

    launch_wait_thread();

    // wait for the service to initialize
    pthread_barrier_wait(&barrier);

    // client init
    nssi_init(NSSI_DEFAULT_TRANSPORT);

    for (int i=0; i < 3; i++) {
        log_debug(selfsend_debug_level, "Try to connect to server: attempt #%d", i);
        rc=nssi_get_service(NSSI_DEFAULT_TRANSPORT, my_url.c_str(), 5000, &svc);
        if (rc == NSSI_OK)
            break;
        else if (rc != NSSI_ETIMEDOUT) {
            log_error(selfsend_debug_level, "could not get svc description: %s",
                      nssi_err_str(rc));
            break;
        }
    }

    sleep(1);

    // shutdown the service
    rc = nssi_kill(&svc, 0, 5000);
    // finalize the client
    nssi_fini(NSSI_DEFAULT_TRANSPORT);

    join_wait_thread();

    // finalize the NSSI library
    rc = nssi_rpc_fini(NSSI_DEFAULT_TRANSPORT);
    if (rc != NSSI_OK)
        log_error(selfsend_debug_level, "Error in nssi_rpc_fini");

    logger_fini();

    return 0;
}

Example #2

File: NntiPackUnpackLocalTest.cpp Project: agrippa/Trilinos

int main(int argc, char *argv[])
{
    NNTI_result_t rc;
    selfsend_args *ssa;
    char server_url[NNTI_URL_LEN];

    logger_init(LOG_ERROR, NULL);

    pthread_barrier_init(&barrier, NULL, 2);

    rc=NNTI_init(NNTI_DEFAULT_TRANSPORT, NULL, &trans_hdl);

    NNTI_dt_sizeof(&trans_hdl, &trans_hdl, &packed_size);
    NNTI_dt_pack(&trans_hdl, &trans_hdl, packed_buf, packed_size);
    NNTI_dt_unpack(&trans_hdl, &copy_trans_hdl, packed_buf, packed_size);

    rc=NNTI_get_url(&copy_trans_hdl, server_url, NNTI_URL_LEN);

    launch_wait_thread();

    pthread_barrier_wait(&barrier);

    rc=NNTI_connect(
            &copy_trans_hdl,
            server_url,
            5000,
            &server_hdl);

    NNTI_dt_sizeof(&copy_trans_hdl, &server_hdl, &packed_size);
    NNTI_dt_pack(&copy_trans_hdl, &server_hdl, packed_buf, packed_size);
    NNTI_dt_unpack(&copy_trans_hdl, &copy_server_hdl, packed_buf, packed_size);

    rc=NNTI_alloc(&copy_trans_hdl, NNTI_REQUEST_BUFFER_SIZE, 1, NNTI_SEND_SRC, &send_mr);

    NNTI_dt_sizeof(&copy_trans_hdl, &send_mr, &packed_size);
    NNTI_dt_pack(&copy_trans_hdl, &send_mr, packed_buf, packed_size);
    NNTI_dt_unpack(&copy_trans_hdl, &copy_send_mr, packed_buf, packed_size);

    ssa=(selfsend_args *)NNTI_BUFFER_C_POINTER(&send_mr);
    ssa->data.int_val   =10;
    ssa->data.float_val =10.0;
    ssa->data.double_val=10.0;
    ssa->chksum=calc_checksum((const char *)&ssa->data, sizeof(data_t));

    rc=NNTI_send(&copy_server_hdl, &copy_send_mr, NULL, &send_wr);

    NNTI_dt_sizeof(&copy_trans_hdl, &send_wr, &packed_size);
    NNTI_dt_pack(&copy_trans_hdl, &send_wr, packed_buf, packed_size);
    NNTI_dt_unpack(&copy_trans_hdl, &copy_send_wr, packed_buf, packed_size);

    rc=NNTI_wait(&copy_send_wr, 5000, &send_status);

    NNTI_dt_free(&copy_trans_hdl, &copy_send_wr);

    pthread_barrier_wait(&barrier);

    NNTI_dt_free(&copy_trans_hdl, &copy_send_mr);
    NNTI_free(&send_mr);

    NNTI_dt_free(&copy_trans_hdl, &copy_server_hdl);
    rc=NNTI_disconnect(
            &copy_trans_hdl,
            &server_hdl);

    join_wait_thread();

    NNTI_dt_free(&trans_hdl, &copy_trans_hdl);
    NNTI_fini(&trans_hdl);

    if (success)
        std::cout << "\nEnd Result: TEST PASSED" << std::endl;
    else
        std::cout << "\nEnd Result: TEST FAILED" << std::endl;

    return (success ? 0 : 1 );
}