1
1
openmpi/ompi/mca/btl/mx/btl_mx.c
George Bosilca 3078be40aa First stable version of the MX BTL (at least we pass NetPipe). The perfs are not amazing
but are not that bad either.

On a 2 procs Intel(R) Xeon(TM) CPU 3.20GHz with MYRICOM Inc. Myrinet 2000 Scalable Cluster Interconnect (rev 04) I get:

  0:       1 bytes  13096 times -->      1.10 Mbps in       6.94 usec
  1:       2 bytes  14408 times -->      2.17 Mbps in       7.02 usec
  2:       3 bytes  14243 times -->      3.24 Mbps in       7.07 usec
  3:       4 bytes   9428 times -->      4.27 Mbps in       7.15 usec
  4:       6 bytes  10493 times -->      6.26 Mbps in       7.32 usec
  5:       8 bytes   6834 times -->      8.18 Mbps in       7.47 usec
  6:      12 bytes   8371 times -->     11.89 Mbps in       7.70 usec
  7:      13 bytes   5411 times -->     12.72 Mbps in       7.80 usec
  8:      16 bytes   5919 times -->     15.35 Mbps in       7.95 usec
  9:      19 bytes   7074 times -->     17.66 Mbps in       8.21 usec
 10:      21 bytes   7696 times -->     19.00 Mbps in       8.43 usec
 11:      24 bytes   7906 times -->     20.87 Mbps in       8.77 usec
 12:      27 bytes   8073 times -->     23.05 Mbps in       8.94 usec
 13:      29 bytes   4972 times -->     24.32 Mbps in       9.10 usec
 14:      32 bytes   5307 times -->     26.29 Mbps in       9.29 usec
 15:      35 bytes   5720 times -->     33.61 Mbps in       7.95 usec
 16:      45 bytes   7191 times -->     39.50 Mbps in       8.69 usec
 17:      48 bytes   7670 times -->     41.33 Mbps in       8.86 usec
 18:      51 bytes   7759 times -->     42.80 Mbps in       9.09 usec
 19:      61 bytes   4313 times -->     47.44 Mbps in       9.81 usec
 20:      64 bytes   5012 times -->     57.61 Mbps in       8.48 usec
 21:      67 bytes   6083 times -->     59.31 Mbps in       8.62 usec
 22:      93 bytes   6234 times -->     68.08 Mbps in      10.42 usec
 23:      96 bytes   6396 times -->     80.65 Mbps in       9.08 usec
 24:      99 bytes   7455 times -->     81.56 Mbps in       9.26 usec
 25:     125 bytes   3926 times -->    112.46 Mbps in       8.48 usec
 26:     128 bytes   5848 times -->    116.87 Mbps in       8.36 usec
 27:     131 bytes   6077 times -->    119.22 Mbps in       8.38 usec
 28:     189 bytes   6192 times -->    163.79 Mbps in       8.80 usec
 29:     192 bytes   7572 times -->    168.01 Mbps in       8.72 usec
 30:     195 bytes   7705 times -->    171.13 Mbps in       8.69 usec
 31:     253 bytes   4011 times -->    210.21 Mbps in       9.18 usec
 32:     256 bytes   5423 times -->    214.55 Mbps in       9.10 usec
 33:     259 bytes   5535 times -->    217.64 Mbps in       9.08 usec
 34:     381 bytes   5613 times -->    290.55 Mbps in      10.00 usec
 35:     384 bytes   6663 times -->    296.11 Mbps in       9.89 usec
 36:     387 bytes   6764 times -->    298.74 Mbps in       9.88 usec
 37:     509 bytes   3451 times -->    353.78 Mbps in      10.98 usec
 38:     512 bytes   4546 times -->    359.36 Mbps in      10.87 usec
 39:     515 bytes   4617 times -->    361.53 Mbps in      10.87 usec
 40:     765 bytes   4645 times -->    461.41 Mbps in      12.65 usec
 41:     768 bytes   5270 times -->    468.59 Mbps in      12.50 usec
 42:     771 bytes   5341 times -->    470.16 Mbps in      12.51 usec
 43:    1021 bytes   2695 times -->    508.42 Mbps in      15.32 usec
 44:    1024 bytes   3260 times -->    514.44 Mbps in      15.19 usec
 45:    1027 bytes   3298 times -->    515.72 Mbps in      15.19 usec
 46:    1533 bytes   3307 times -->    707.12 Mbps in      16.54 usec
 47:    1536 bytes   4030 times -->    714.93 Mbps in      16.39 usec
 48:    1539 bytes   4071 times -->    714.41 Mbps in      16.44 usec
 49:    2045 bytes   2040 times -->    761.38 Mbps in      20.49 usec
 50:    2048 bytes   2438 times -->    769.78 Mbps in      20.30 usec
 51:    2051 bytes   2465 times -->    769.78 Mbps in      20.33 usec
 52:    3069 bytes   2465 times -->    923.43 Mbps in      25.36 usec
 53:    3072 bytes   2629 times -->    928.48 Mbps in      25.24 usec
 54:    3075 bytes   2642 times -->    929.07 Mbps in      25.25 usec
 55:    4093 bytes   1323 times -->   1012.38 Mbps in      30.85 usec
 56:    4096 bytes   1620 times -->   1016.69 Mbps in      30.74 usec
 57:    4099 bytes   1627 times -->   1015.16 Mbps in      30.81 usec
 58:    6141 bytes   1625 times -->   1171.82 Mbps in      39.98 usec
 59:    6144 bytes   1667 times -->   1173.85 Mbps in      39.93 usec
 60:    6147 bytes   1669 times -->   1174.44 Mbps in      39.93 usec
 61:    8189 bytes    835 times -->   1232.43 Mbps in      50.69 usec
 62:    8192 bytes    986 times -->   1234.87 Mbps in      50.61 usec
 63:    8195 bytes    988 times -->   1234.85 Mbps in      50.63 usec
 64:   12285 bytes    988 times -->   1360.73 Mbps in      68.88 usec
 65:   12288 bytes    967 times -->   1364.20 Mbps in      68.72 usec
 66:   12291 bytes    970 times -->   1364.56 Mbps in      68.72 usec
 67:   16381 bytes    485 times -->   1385.48 Mbps in      90.21 usec
 68:   16384 bytes    554 times -->   1388.76 Mbps in      90.01 usec
 69:   16387 bytes    555 times -->   1388.41 Mbps in      90.05 usec
 70:   24573 bytes    555 times -->   1499.72 Mbps in     125.01 usec
 71:   24576 bytes    533 times -->   1499.36 Mbps in     125.05 usec
 72:   24579 bytes    533 times -->   1500.44 Mbps in     124.98 usec
 73:   32765 bytes    266 times -->   1499.31 Mbps in     166.73 usec
 74:   32768 bytes    299 times -->   1497.10 Mbps in     166.99 usec
 75:   32771 bytes    299 times -->   1495.29 Mbps in     167.21 usec
 76:   49149 bytes    299 times -->   1528.78 Mbps in     245.28 usec
 77:   49152 bytes    271 times -->   1527.97 Mbps in     245.42 usec
 78:   49155 bytes    271 times -->   1529.35 Mbps in     245.22 usec
 79:   65533 bytes    135 times -->   1586.19 Mbps in     315.21 usec
 80:   65536 bytes    158 times -->   1591.11 Mbps in     314.25 usec
 81:   65539 bytes    159 times -->   1586.50 Mbps in     315.17 usec
 82:   98301 bytes    158 times -->   1668.05 Mbps in     449.61 usec
 83:   98304 bytes    148 times -->   1667.40 Mbps in     449.80 usec
 84:   98307 bytes    148 times -->   1667.29 Mbps in     449.84 usec
 85:  131069 bytes     74 times -->   1709.11 Mbps in     585.09 usec
 86:  131072 bytes     85 times -->   1711.09 Mbps in     584.42 usec
 87:  131075 bytes     85 times -->   1710.92 Mbps in     584.49 usec
 88:  196605 bytes     85 times -->   1727.93 Mbps in     868.08 usec
 89:  196608 bytes     76 times -->   1726.28 Mbps in     868.92 usec
 90:  196611 bytes     76 times -->   1727.06 Mbps in     868.54 usec
 91:  262141 bytes     38 times -->   1757.65 Mbps in    1137.87 usec
 92:  262144 bytes     43 times -->   1758.69 Mbps in    1137.21 usec
 93:  262147 bytes     43 times -->   1759.38 Mbps in    1136.78 usec
 94:  393213 bytes     43 times -->   1801.51 Mbps in    1665.25 usec
 95:  393216 bytes     40 times -->   1803.26 Mbps in    1663.65 usec
 96:  393219 bytes     40 times -->   1800.73 Mbps in    1666.00 usec
 97:  524285 bytes     20 times -->   1805.33 Mbps in    2215.65 usec
 98:  524288 bytes     22 times -->   1806.80 Mbps in    2213.86 usec
 99:  524291 bytes     22 times -->   1805.77 Mbps in    2215.14 usec
100:  786429 bytes     22 times -->   1827.24 Mbps in    3283.64 usec
101:  786432 bytes     20 times -->   1827.03 Mbps in    3284.03 usec
102:  786435 bytes     20 times -->   1827.20 Mbps in    3283.73 usec
103: 1048573 bytes     10 times -->   1840.05 Mbps in    4347.71 usec
104: 1048576 bytes     11 times -->   1839.68 Mbps in    4348.58 usec
105: 1048579 bytes     11 times -->   1840.13 Mbps in    4347.54 usec
106: 1572861 bytes     11 times -->   1853.99 Mbps in    6472.50 usec
107: 1572864 bytes     10 times -->   1854.11 Mbps in    6472.10 usec
108: 1572867 bytes     10 times -->   1854.12 Mbps in    6472.10 usec
109: 2097149 bytes      5 times -->   1861.41 Mbps in    8595.61 usec
110: 2097152 bytes      5 times -->   1861.25 Mbps in    8596.40 usec
111: 2097155 bytes      5 times -->   1860.99 Mbps in    8597.59 usec
112: 3145725 bytes      5 times -->   1868.34 Mbps in   12845.59 usec
113: 3145728 bytes      5 times -->   1868.30 Mbps in   12845.90 usec
114: 3145731 bytes      5 times -->   1868.59 Mbps in   12843.89 usec
115: 4194301 bytes      3 times -->   1872.16 Mbps in   17092.51 usec
116: 4194304 bytes      3 times -->   1872.31 Mbps in   17091.19 usec
117: 4194307 bytes      3 times -->   1872.13 Mbps in   17092.82 usec
118: 6291453 bytes      3 times -->   1875.88 Mbps in   25588.00 usec
119: 6291456 bytes      3 times -->   1875.98 Mbps in   25586.68 usec
120: 6291459 bytes      3 times -->   1875.93 Mbps in   25587.36 usec
121: 8388605 bytes      3 times -->   1877.79 Mbps in   34082.69 usec
122: 8388608 bytes      3 times -->   1877.72 Mbps in   34083.84 usec
123: 8388611 bytes      3 times -->   1877.66 Mbps in   34085.00 usec

This commit was SVN r7180.
2005-09-04 22:08:13 +00:00

679 строки
21 KiB
C

/*
* Copyright (c) 2004-2005 The Trustees of Indiana University.
* All rights reserved.
* Copyright (c) 2004-2005 The Trustees of the University of Tennessee.
* All rights reserved.
* Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
* University of Stuttgart. All rights reserved.
* Copyright (c) 2004-2005 The Regents of the University of California.
* All rights reserved.
* $COPYRIGHT$
*
* Additional copyrights may follow
*
* $HEADER$
*/
#include "ompi_config.h"
#include <string.h>
#include "opal/util/output.h"
#include "opal/util/if.h"
#include "mca/pml/pml.h"
#include "mca/btl/btl.h"
#include "btl_mx.h"
#include "btl_mx_frag.h"
#include "btl_mx_proc.h"
#include "btl_mx_endpoint.h"
#include "datatype/convertor.h"
#include "mca/mpool/base/base.h"
#include "mca/mpool/mpool.h"
mca_btl_mx_module_t mca_btl_mx_module = {
{
&mca_btl_mx_component.super,
0, /* max size of first fragment */
0, /* min send fragment size */
0, /* max send fragment size */
0, /* min rdma fragment size */
0, /* max rdma fragment size */
0, /* exclusivity */
0, /* latency */
0, /* bandwidth */
MCA_BTL_FLAGS_SEND_INPLACE | MCA_BTL_FLAGS_PUT, /* flags */
mca_btl_mx_add_procs,
mca_btl_mx_del_procs,
mca_btl_mx_register,
mca_btl_mx_finalize,
mca_btl_mx_alloc,
mca_btl_mx_free,
mca_btl_mx_prepare_src,
mca_btl_mx_prepare_dst,
mca_btl_mx_send,
mca_btl_mx_put,
NULL /* get */
}
};
/**
*
*/
int mca_btl_mx_add_procs(
struct mca_btl_base_module_t* btl,
size_t nprocs,
struct ompi_proc_t **ompi_procs,
struct mca_btl_base_endpoint_t** peers,
ompi_bitmap_t* reachable)
{
mca_btl_mx_module_t* mx_btl = (mca_btl_mx_module_t*)btl;
int i, rc;
for(i = 0; i < (int) nprocs; i++) {
struct ompi_proc_t* ompi_proc = ompi_procs[i];
mca_btl_mx_proc_t* mx_proc;
mca_btl_base_endpoint_t* mx_endpoint;
if( ompi_procs[i] == ompi_proc_local_proc ) {
/* Do not alllow to connect to ourselfs ... */
continue;
}
if(NULL == (mx_proc = mca_btl_mx_proc_create(ompi_proc))) {
return OMPI_ERR_OUT_OF_RESOURCE;
}
/*
* Check to make sure that the peer has at least as many interface
* addresses exported as we are trying to use. If not, then
* don't bind this PTL instance to the proc.
*/
OPAL_THREAD_LOCK(&module_proc->proc_lock);
/* The btl_proc datastructure is shared by all MX BTL
* instances that are trying to reach this destination.
* Cache the peer instance on the btl_proc.
*/
mx_endpoint = OBJ_NEW(mca_btl_mx_endpoint_t);
if(NULL == mx_endpoint) {
OPAL_THREAD_UNLOCK(&module_proc->proc_lock);
return OMPI_ERR_OUT_OF_RESOURCE;
}
mx_endpoint->endpoint_btl = mx_btl;
rc = mca_btl_mx_proc_insert(mx_proc, mx_endpoint);
if(rc != OMPI_SUCCESS) {
OBJ_RELEASE(mx_endpoint);
OBJ_RELEASE(mx_proc);
OPAL_THREAD_UNLOCK(&module_proc->proc_lock);
continue;
}
ompi_bitmap_set_bit(reachable, i);
OPAL_THREAD_UNLOCK(&module_proc->proc_lock);
peers[i] = mx_endpoint;
}
return OMPI_SUCCESS;
}
int mca_btl_mx_del_procs(struct mca_btl_base_module_t* btl,
size_t nprocs,
struct ompi_proc_t **procs,
struct mca_btl_base_endpoint_t ** peers)
{
/* TODO */
return OMPI_SUCCESS;
}
/**
* Register callback function to support send/recv semantics
*/
int mca_btl_mx_register( struct mca_btl_base_module_t* btl,
mca_btl_base_tag_t tag,
mca_btl_base_module_recv_cb_fn_t cbfunc,
void* cbdata )
{
mca_btl_mx_module_t* mx_btl = (mca_btl_mx_module_t*) btl;
mca_btl_mx_frag_t* frag;
mx_return_t mx_return;
mx_segment_t mx_segment;
int i, rc;
mx_btl->mx_reg[tag].cbfunc = cbfunc;
mx_btl->mx_reg[tag].cbdata = cbdata;
/*
* Post the receives
*/
for( i = 0; i < mca_btl_mx_component.mx_max_posted_recv; i++ ) {
MCA_BTL_MX_FRAG_ALLOC_EAGER( mx_btl, frag, rc );
if( NULL == frag ) {
if( 0 == i ) {
return OMPI_ERROR;
}
}
frag->base.des_dst = frag->segment;
frag->base.des_dst_cnt = 1;
frag->base.des_src = NULL;
frag->base.des_src_cnt = 0;
frag->mx_frag_list = NULL;
frag->tag = tag;
mx_segment.segment_ptr = frag->base.des_dst->seg_addr.pval;
mx_segment.segment_length = frag->base.des_dst->seg_len;
mx_return = mx_irecv( mx_btl->mx_endpoint, &mx_segment, 1, (uint64_t)tag, 0xffffffffffffffff,
frag, &(frag->mx_request) );
if( MX_SUCCESS != mx_return ) {
return OMPI_ERROR;
}
}
extern int mx_debug;
if( mx_debug ) {
#include <unistd.h>
sleep(20);
}
return OMPI_SUCCESS;
}
/**
* Allocate a segment.
*
* @param btl (IN) BTL module
* @param size (IN) Request segment size.
*/
mca_btl_base_descriptor_t* mca_btl_mx_alloc(
struct mca_btl_base_module_t* btl,
size_t size)
{
mca_btl_mx_module_t* mx_btl = (mca_btl_mx_module_t*) btl;
mca_btl_mx_frag_t* frag;
int rc;
#if 0
if(size <= mx_btl->super.btl_eager_limit) {
MCA_BTL_MX_FRAG_ALLOC_EAGER(mx_btl, frag, rc);
frag->segment[0].seg_len =
size <= mx_btl->super.btl_eager_limit ?
size : mx_btl->super.btl_eager_limit ;
} else {
MCA_BTL_MX_FRAG_ALLOC_USER(mx_btl, frag, rc);
frag->segment[0].seg_len =
size <= mx_btl->super.btl_max_send_size ?
size : mx_btl->super.btl_max_send_size ;
}
#endif
MCA_BTL_MX_FRAG_ALLOC_EAGER(mx_btl, frag, rc);
frag->segment[0].seg_len =
size <= mx_btl->super.btl_eager_limit ?
size : mx_btl->super.btl_eager_limit ;
frag->base.des_src = frag->segment;
frag->base.des_src_cnt = 1;
frag->base.des_dst = NULL;
frag->base.des_dst_cnt = 0;
frag->base.des_flags = 0;
return (mca_btl_base_descriptor_t*)frag;
}
/**
* Return a segment
xo */
int mca_btl_mx_free(
struct mca_btl_base_module_t* btl,
mca_btl_base_descriptor_t* des)
{
mca_btl_mx_frag_t* frag = (mca_btl_mx_frag_t*)des;
#if MCA_BTL_HAS_MPOOL
if(frag->size == 0) {
OBJ_RELEASE(frag->registration);
}
#endif
if( 0 == frag->base.des_dst_cnt ) { /* send fragment */
MCA_BTL_MX_FRAG_RETURN(btl, frag);
} else { /* receive fragment */
opal_output( 0, "BARFFFFFFF return send frag\n" );
}
return OMPI_SUCCESS;
}
/**
* Pack data and return a descriptor that can be
* used for send/put.
*
* @param btl (IN) BTL module
* @param peer (IN) BTL peer addressing
*/
mca_btl_base_descriptor_t* mca_btl_mx_prepare_src(
struct mca_btl_base_module_t* btl,
struct mca_btl_base_endpoint_t* endpoint,
struct mca_mpool_base_registration_t* registration,
struct ompi_convertor_t* convertor,
size_t reserve,
size_t* size
)
{
mca_btl_mx_module_t* mx_btl = (mca_btl_mx_module_t*)btl;
mca_btl_mx_frag_t* frag;
struct iovec iov;
uint32_t iov_count = 1;
size_t max_data = *size;
int32_t free_after;
int rc;
#if MCA_BTL_HAS_MPOOL
/*
* If the data has already been pinned and is contigous than we can
* use it in place.
*/
if (NULL != registration && 0 == ompi_convertor_need_buffers(convertor)) {
size_t reg_len;
MCA_BTL_MX_FRAG_ALLOC_USER(mx_btl, frag, rc);
if(NULL == frag){
return NULL;
}
iov.iov_len = max_data;
iov.iov_base = NULL;
ompi_convertor_pack(convertor, &iov, &iov_count, &max_data, &free_after);
frag->segment.seg_len = max_data;
frag->segment.seg_addr.pval = iov.iov_base;
reg_len = (unsigned char*)registration->bound - (unsigned char*)iov.iov_base + 1;
if(frag->segment.seg_len > reg_len) {
mca_mpool_base_module_t* mpool = mx_btl->mx_mpool;
size_t new_len = (unsigned char*)iov.iov_base -
(unsigned char *) registration->base + max_data;
void* base_addr = registration->base;
/* remove old registration from tree and decrement reference count */
mca_mpool_base_remove(base_addr);
OBJ_RELEASE(registration);
/* re-register at new size */
rc = mpool->mpool_register(
mpool,
base_addr,
new_len,
&registration);
if(rc != OMPI_SUCCESS) {
MCA_BTL_MX_FRAG_RETURN_USER(btl,frag);
return NULL;
}
/* re-insert into tree with new registration */
rc = mca_mpool_base_insert(
base_addr,
new_len,
mpool,
btl,
registration);
if(rc != OMPI_SUCCESS) {
MCA_BTL_MX_FRAG_RETURN_USER(btl,frag);
OBJ_RELEASE(registration);
return NULL;
}
}
/* bump reference count as so that the registration
* doesn't go away when the operation completes
*/
OBJ_RETAIN(registration);
frag->registration = registration;
/*
* if the data is not already pinned - but the leave pinned option is set,
* then go ahead and pin contigous data. however, if a reserve is required
* then we must allocated a fragment w/ buffer space
*/
} else if ((mca_btl_mx_component.leave_pinned || max_data > btl->btl_max_send_size) &&
ompi_convertor_need_buffers(convertor) == 0 &&
reserve == 0) {
mca_mpool_base_module_t* mpool = mx_btl->mx_mpool;
MCA_BTL_MX_FRAG_ALLOC_USER(mx_btl, frag, rc);
if(NULL == frag){
return NULL;
}
iov.iov_len = max_data;
iov.iov_base = NULL;
ompi_convertor_pack(convertor, &iov, &iov_count, &max_data, &free_after);
frag->segment.seg_len = max_data;
frag->segment.seg_addr.pval = iov.iov_base;
rc = mpool->mpool_register(
mpool,
iov.iov_base,
max_data,
&registration);
if(rc != OMPI_SUCCESS) {
MCA_BTL_MX_FRAG_RETURN_USER(btl,frag);
return NULL;
}
if(mca_btl_mx_component.leave_pinned) {
/*
* insert the registration into the tree and bump the reference
* count so that it doesn't go away on completion.
*/
rc = mca_mpool_base_insert(
iov.iov_base,
iov.iov_len,
mpool,
btl,
registration);
if(rc != OMPI_SUCCESS) {
MCA_BTL_MX_FRAG_RETURN_USER(btl,frag);
OBJ_RELEASE(registration);
return NULL;
}
OBJ_RETAIN(registration);
}
frag->registration = registration;
} else
#endif
/* If the data is contiguous we can user directly the pointer
* to the user memory.
*/
if( 0 == ompi_convertor_need_buffers(convertor) ) {
MCA_BTL_MX_FRAG_ALLOC_USER(btl, frag, rc);
if( NULL == frag ) {
return NULL;
}
if( (max_data + reserve) > btl->btl_eager_limit ) {
max_data = btl->btl_eager_limit - reserve;
}
/* let the convertor figure out the correct pointer depending on the data layout */
iov.iov_base = NULL;
iov.iov_len = max_data;
frag->base.des_src_cnt = 2;
frag->segment[0].seg_len = reserve;
} else {
MCA_BTL_MX_FRAG_ALLOC_EAGER( mx_btl, frag, rc );
if( NULL == frag ) {
return NULL;
}
if( (max_data + reserve) <= btl->btl_eager_limit ) {
iov.iov_len = max_data;
} else {
iov.iov_len = mca_btl_mx_module.super.btl_eager_limit - reserve;
max_data = iov.iov_len; /* let the PML establish the pipeline */
}
iov.iov_base = (unsigned char*)frag->segment[0].seg_addr.pval + reserve;
frag->segment[0].seg_len = reserve;
frag->base.des_src_cnt = 1;
}
rc = ompi_convertor_pack(convertor, &iov, &iov_count, &max_data, &free_after);
*size = max_data;
if( rc < 0 ) {
MCA_BTL_MX_FRAG_RETURN( mx_btl, frag );
return NULL;
}
if( 1 == frag->base.des_src_cnt ) {
frag->segment[0].seg_len += max_data;
} else {
frag->segment[1].seg_addr.pval = iov.iov_base;
frag->segment[1].seg_len = max_data;
}
frag->base.des_src = frag->segment;
frag->base.des_dst = NULL;
frag->base.des_dst_cnt = 0;
frag->base.des_flags = 0;
return &frag->base;
}
/**
* Prepare a descriptor for send/rdma using the supplied
* convertor. If the convertor references data that is contigous,
* the descriptor may simply point to the user buffer. Otherwise,
* this routine is responsible for allocating buffer space and
* packing if required.
*
* @param btl (IN) BTL module
* @param endpoint (IN) BTL peer addressing
* @param convertor (IN) Data type convertor
* @param reserve (IN) Additional bytes requested by upper layer to precede user data
* @param size (IN/OUT) Number of bytes to prepare (IN), number of bytes actually prepared (OUT)
*/
mca_btl_base_descriptor_t* mca_btl_mx_prepare_dst(
struct mca_btl_base_module_t* btl,
struct mca_btl_base_endpoint_t* endpoint,
struct mca_mpool_base_registration_t* registration,
struct ompi_convertor_t* convertor,
size_t reserve,
size_t* size)
{
mca_btl_mx_module_t* mx_btl = (mca_btl_mx_module_t*) btl;
mca_btl_mx_frag_t* frag;
int rc;
MCA_BTL_MX_FRAG_ALLOC_USER(btl, frag, rc);
if(NULL == frag) {
return NULL;
}
frag->segment[0].seg_len = *size;
frag->segment[0].seg_addr.pval = convertor->pBaseBuf + convertor->bConverted;
frag->base.des_src = NULL;
frag->base.des_src_cnt = 0;
frag->base.des_dst = frag->segment;
frag->base.des_dst_cnt = 1;
frag->base.des_flags = 0;
#if MCA_BTL_HAS_MPOOL
if(NULL != registration) {
size_t reg_len = (unsigned char*)registration->bound - (unsigned char*)frag->segment.seg_addr.pval + 1;
if(frag->segment.seg_len > reg_len) {
mca_mpool_base_module_t* mpool = mx_btl->mx_mpool;
size_t new_len = (unsigned char*)frag->segment.seg_addr.pval -
(unsigned char*) registration->base +
frag->segment.seg_len;
void* base_addr = registration->base;
/* remove old registration from tree and decrement reference count */
mca_mpool_base_remove(base_addr);
OBJ_RELEASE(registration);
/* re-register at new size */
rc = mpool->mpool_register(
mpool,
base_addr,
new_len,
&registration);
if(rc != OMPI_SUCCESS) {
MCA_BTL_MX_FRAG_RETURN_USER(btl,frag);
return NULL;
}
/* re-insert into tree with new registration */
rc = mca_mpool_base_insert(
base_addr,
new_len,
mpool,
btl,
registration);
if(rc != OMPI_SUCCESS) {
MCA_BTL_MX_FRAG_RETURN_USER(btl,frag);
OBJ_RELEASE(registration);
return NULL;
}
}
/* bump reference count as so that the registration
* doesn't go away when the operation completes
*/
OBJ_RETAIN(registration);
frag->registration = registration;
} else {
mca_mpool_base_module_t* mpool = mx_btl->mx_mpool;
rc = mpool->mpool_register(
mpool,
frag->segment.seg_addr.pval,
frag->segment.seg_len,
&registration);
if(rc != OMPI_SUCCESS) {
MCA_BTL_MX_FRAG_RETURN_USER(btl,frag);
return NULL;
}
if(mca_btl_mx_component.leave_pinned) {
/*
* insert the registration into the tree and bump the reference
* count so that it doesn't go away on completion.
*/
rc = mca_mpool_base_insert(
frag->segment.seg_addr.pval,
frag->segment.seg_len,
mpool,
btl,
registration);
if(rc != OMPI_SUCCESS) {
MCA_BTL_MX_FRAG_RETURN_USER(btl,frag);
OBJ_RELEASE(registration);
return NULL;
}
OBJ_RETAIN(registration);
}
frag->registration = registration;
}
#endif
return &frag->base;
}
/**
* Initiate an asynchronous send.
*
* @param btl (IN) BTL module
* @param endpoint (IN) BTL addressing information
* @param descriptor (IN) Description of the data to be transfered
* @param tag (IN) The tag value used to notify the peer.
*/
int mca_btl_mx_send(
struct mca_btl_base_module_t* btl,
struct mca_btl_base_endpoint_t* endpoint,
struct mca_btl_base_descriptor_t* descriptor,
mca_btl_base_tag_t tag)
{
mca_btl_mx_module_t* mx_btl = (mca_btl_mx_module_t*) btl;
mca_btl_mx_frag_t* frag = (mca_btl_mx_frag_t*)descriptor;
mx_segment_t mx_segment[2];
mx_return_t mx_return;
uint64_t total_length;
frag->endpoint = endpoint;
frag->tag = tag;
mx_segment[0].segment_ptr = descriptor->des_src[0].seg_addr.pval;
mx_segment[0].segment_length = descriptor->des_src[0].seg_len;
total_length = mx_segment[0].segment_length;
if( 2 == descriptor->des_src_cnt ) {
mx_segment[1].segment_ptr = descriptor->des_src[1].seg_addr.pval;
mx_segment[1].segment_length = descriptor->des_src[1].seg_len;
total_length += mx_segment[1].segment_length;
}
mx_return = mx_isend( mx_btl->mx_endpoint, mx_segment, descriptor->des_src_cnt, endpoint->mx_peer_addr,
(uint64_t)tag, frag, &frag->mx_request );
if( MX_SUCCESS != mx_return ) {
opal_output( 0, "mx_isend fails with error %s\n", mx_strerror(mx_return) );
return OMPI_ERROR;
}
#if 0
if( 4096 > total_length ) {
mx_status_t mx_status;
uint32_t mx_result;
/* let's check for completness */
mx_return = mx_test( mx_btl->mx_endpoint, &(frag->mx_request), &mx_status, &mx_result );
if( MX_SUCCESS != mx_return )
return OMPI_SUCCESS;
/* call the completion callback */
frag->base.des_cbfunc( &(mx_btl->super), frag->endpoint, &(frag->base), OMPI_SUCCESS);
}
#endif
return OMPI_SUCCESS;
}
/**
* Initiate an asynchronous put.
*
* @param btl (IN) BTL module
* @param endpoint (IN) BTL addressing information
* @param descriptor (IN) Description of the data to be transferred
*/
int mca_btl_mx_put(
mca_btl_base_module_t* btl,
mca_btl_base_endpoint_t* endpoint,
mca_btl_base_descriptor_t* descriptor)
{
/* mca_btl_mx_module_t* mx_btl = (mca_btl_mx_module_t*) btl; */
mca_btl_mx_frag_t* frag = (mca_btl_mx_frag_t*) descriptor;
frag->endpoint = endpoint;
/* TODO */
return OMPI_ERR_NOT_IMPLEMENTED;
}
/**
* Initiate an asynchronous get.
*
* @param btl (IN) BTL module
* @param endpoint (IN) BTL addressing information
* @param descriptor (IN) Description of the data to be transferred
*
*/
int mca_btl_mx_get(
mca_btl_base_module_t* btl,
mca_btl_base_endpoint_t* endpoint,
mca_btl_base_descriptor_t* descriptor)
{
/* mca_btl_mx_module_t* mx_btl = (mca_btl_mx_module_t*) btl; */
mca_btl_mx_frag_t* frag = (mca_btl_mx_frag_t*) descriptor;
frag->endpoint = endpoint;
/* TODO */
return OMPI_ERR_NOT_IMPLEMENTED;
}
/*
* Cleanup/release module resources.
*/
int mca_btl_mx_finalize(struct mca_btl_base_module_t* btl)
{
mca_btl_mx_module_t* mx_btl = (mca_btl_mx_module_t*) btl;
OBJ_DESTRUCT( &mx_btl->mx_lock );
OBJ_DESTRUCT( &mx_btl->mx_peers );
free(mx_btl);
return OMPI_SUCCESS;
}