C++ (Cpp) NNTI_fini示例

示例#1

/**
 * @brief Finalize the RPC mechanism.
 *
 * The \b nssi_rpc_finalize method performs any cleanup
 * required by the underlying communication protocol
 * before exiting the client application.
 */
int nssi_rpc_fini(const nssi_rpc_transport rpc_transport)
{
    int rc;

    if (nssi_config.use_buffer_queue) {
        trios_buffer_queue_fini(
                &send_bq);
        trios_buffer_queue_fini(
                &recv_bq);
    }

    /* initialize the transport mechanism */
    rc = NNTI_fini(&transports[rpc_transport]);
    if (rc != NNTI_OK) {
        log_fatal(rpc_debug_level,"failed");
        return rc;
    }

    /* initialize the xdr-encoding mechanism */
    switch (encoding) {
        case NSSI_RPC_XDR:
            rc = nssi_xdr_fini();
            if (rc != NSSI_OK) {
                log_fatal(rpc_debug_level,"failed, %d", rc);
                return rc;
            }
            break;

        default:
            rc = NSSI_ENOENT;
            log_error(rpc_debug_level, "the transport scheme "
                    "does not exist");
            return rc;
    }

    rpc_initialized=false;

    return NSSI_OK;
}

示例#2

文件： NntiPackUnpackLocalTest.cpp 项目： 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 );
}

示例#3

文件： NntiPerfTest.cpp 项目： eisenhauer/nnti1

int main(int argc, char *argv[])
{
    char logname[1024];

    bool success=true;


    MPI_Init(&argc, &argv);

    MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);

    nservers=1;
    nclients=nprocs-nservers;
    client_rank=rank-1;

    if (argc != 6) {
    	if (rank == 0) {
        	fprintf(stderr, "Usage: %s <num sends> <num_gets> <get_size> <num_puts> <put_size>\n", argv[0]);
            MPI_Barrier(MPI_COMM_WORLD);
    	} else {
    	    MPI_Barrier(MPI_COMM_WORLD);
    	}
    	MPI_Abort(MPI_COMM_WORLD, -1);
    }

    if (nprocs != 2) {
    	if (rank == 0) {
        	fprintf(stderr, "%s only supports 2 ranks.\n", argv[0]);
            MPI_Barrier(MPI_COMM_WORLD);
    	} else {
    	    MPI_Barrier(MPI_COMM_WORLD);
    	}
    	MPI_Abort(MPI_COMM_WORLD, -1);
    }

    parse_args(argc, argv);

    sprintf(logname, "nntiperf.%03d.log", rank);
    logger_init(LOG_ERROR, NULL);

    NNTI_init(NNTI_DEFAULT_TRANSPORT, NULL, &trans_hdl);

    if (rank==0) {
        NNTI_get_url(&trans_hdl, url, NNTI_URL_LEN);
    }

    MPI_Bcast(&url[0], NNTI_URL_LEN, MPI_CHAR, 0, MPI_COMM_WORLD);

    log_debug(nntiperf_debug_level, "NNTI perfermance server url is %s", url);

    if (rank==0) {
        server();
    } else {
        client();
    }

    NNTI_fini(&trans_hdl);

    MPI_Finalize();

    logger_fini();

    //    Teuchos::oblackholestream blackhole;
    //    std::ostream &out = ( rank == 1 ? std::cout : blackhole );
    std::ostream &out = std::cout;
    if (success)
        out << "\nEnd Result: TEST PASSED" << std::endl;
    else
        out << "\nEnd Result: TEST FAILED" << std::endl;

    return (success ? 0 : 1 );
//    return 0;
}