ports/openmpi
ports/openmpi
1
1
Форкнуть 0
Код Релизы Активность

Finally the convertor export a convenience function to allow a consistent

Просмотр исходного кода 
computation of the current location on the pack/unpack process. This can
be used both for retrieving the pointer to the first byte (in the special
case of the cached RDMA protocol) and for getting the current
position (for the pipelined protocol).

I modified all BTLs, but most of them are still untested.

This commit was SVN r14180.
Этот коммит содержится в:
George Bosilca 2007-03-30 22:02:45 +00:00
родитель 8f4f992bfc
Коммит 1cb26e3b9c
19 изменённых файлов: 74 добавлений и 81 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

12
ompi/datatype/convertor.c
Просмотреть файл

@ -235,12 +235,12 @@ int32_t ompi_convertor_pack( ompi_convertor_t* pConv,
* use the bConverted to manage the conversion.
*/
uint32_t i;
char* base_pointer;
unsigned char* base_pointer;
size_t pending_length = pConv->local_size - pConv->bConverted;
*max_data = pending_length;
base_pointer = pConv->pBaseBuf + pConv->bConverted +
pConv->use_desc->desc[pConv->use_desc->used].end_loop.first_elem_disp;
ompi_convertor_get_current_pointer( pConv, (void**)&base_pointer );
for( i = 0; i < *out_size; i++ ) {
if( iov[i].iov_len >= pending_length ) {
goto complete_contiguous_data_pack;
@ -282,12 +282,12 @@ int32_t ompi_convertor_unpack( ompi_convertor_t* pConv,
* use the bConverted to manage the conversion.
*/
uint32_t i;
char* base_pointer;
unsigned char* base_pointer;
size_t pending_length = pConv->local_size - pConv->bConverted;
*max_data = pending_length;
base_pointer = pConv->pBaseBuf + pConv->bConverted +
pConv->use_desc->desc[pConv->use_desc->used].end_loop.first_elem_disp;
ompi_convertor_get_current_pointer( pConv, (void**)&base_pointer );
for( i = 0; i < *out_size; i++ ) {
if( iov[i].iov_len >= pending_length ) {
goto complete_contiguous_data_unpack;

17
ompi/datatype/convertor.h
Просмотреть файл

@ -84,7 +84,7 @@ struct ompi_convertor_t {
const struct ompi_datatype_t* pDesc; /**< the datatype description associated with the convertor */
const struct dt_type_desc* use_desc; /**< the version used by the convertor (normal or optimized) */
uint32_t count; /**< the total number of full datatype elements */
char* pBaseBuf; /**< initial buffer as supplied by the user */
unsigned char* pBaseBuf; /**< initial buffer as supplied by the user */
dt_stack_t* pStack; /**< the local stack for the actual conversion */
uint32_t stack_size; /**< size of the allocated stack */
convertor_advance_fct_t fAdvance; /**< pointer to the pack/unpack functions */
@ -187,6 +187,19 @@ ompi_convertor_get_unpacked_size( const ompi_convertor_t* pConv,
*pSize = pConv->remote_size;
}
/**
* Return the current absolute position of the next pack/unpack. This function is
* mostly useful for contiguous datatypes, when we need to get the pointer to the
* contiguous piece of memory.
*/
static inline void
ompi_convertor_get_current_pointer( const ompi_convertor_t* pConv,
void** position )
{
unsigned char* base = pConv->pBaseBuf + pConv->bConverted + pConv->pDesc->true_lb;
*position = (void*)base;
}
/**
* Basic convertor initialization. This is performed for all types of convertors,
* but is the only thing required for convertors working on contiguous or
@ -196,7 +209,7 @@ ompi_convertor_get_unpacked_size( const ompi_convertor_t* pConv,
{ \
/* Compute the local in advance */ \
convertor->local_size = count * datatype->size; \
convertor->pBaseBuf = (char*)pUserBuf; \
convertor->pBaseBuf = (unsigned char*)pUserBuf; \
convertor->count = count; \
\
/* Grab the datatype part of the flags */ \

6
ompi/datatype/datatype_pack.c
Просмотреть файл

@ -56,7 +56,7 @@ ompi_pack_homogeneous_contig_function( ompi_convertor_t* pConv,
size_t* max_data )
{
dt_stack_t* pStack = pConv->pStack;
char *source_base = NULL;
unsigned char *source_base = NULL;
uint32_t iov_count;
size_t length = pConv->local_size - pConv->bConverted, initial_amount = pConv->bConverted;
ptrdiff_t initial_displ = pConv->use_desc->desc[pConv->use_desc->used].end_loop.first_elem_disp;
@ -103,7 +103,7 @@ ompi_pack_homogeneous_contig_with_gaps_function( ompi_convertor_t* pConv,
{
const ompi_datatype_t* pData = pConv->pDesc;
dt_stack_t* pStack = pConv->pStack;
char *user_memory, *packed_buffer;
unsigned char *user_memory, *packed_buffer;
uint32_t i, index, iov_count;
size_t max_allowed, total_bytes_converted = 0;
ptrdiff_t extent;
@ -254,7 +254,7 @@ ompi_generic_simple_pack_function( ompi_convertor_t* pConvertor,
dt_elem_desc_t* description;
dt_elem_desc_t* pElem;
const ompi_datatype_t *pData = pConvertor->pDesc;
char *source_base, *destination;
unsigned char *source_base, *destination;
size_t iov_len_local;
uint32_t iov_count;

12
ompi/datatype/datatype_pack.h
Просмотреть файл

@ -16,14 +16,14 @@
static inline void pack_predefined_data( ompi_convertor_t* CONVERTOR,
dt_elem_desc_t* ELEM,
uint32_t* COUNT,
char** SOURCE,
char** DESTINATION,
unsigned char** SOURCE,
unsigned char** DESTINATION,
size_t* SPACE )
{
uint32_t _copy_count = *(COUNT);
size_t _copy_blength;
ddt_elem_desc_t* _elem = &((ELEM)->elem);
char* _source = (*SOURCE) + _elem->disp;
unsigned char* _source = (*SOURCE) + _elem->disp;
_copy_blength = ompi_ddt_basicDatatypes[_elem->common.type]->size;
if( (_copy_count * _copy_blength) > *(SPACE) ) {
@ -62,13 +62,13 @@ static inline void pack_predefined_data( ompi_convertor_t* CONVERTOR,
static inline void pack_contiguous_loop( ompi_convertor_t* CONVERTOR,
dt_elem_desc_t* ELEM,
uint32_t* COUNT,
char** SOURCE,
char** DESTINATION,
unsigned char** SOURCE,
unsigned char** DESTINATION,
size_t* SPACE )
{
ddt_loop_desc_t *_loop = (ddt_loop_desc_t*)(ELEM);
ddt_endloop_desc_t* _end_loop = (ddt_endloop_desc_t*)((ELEM) + _loop->items);
char* _source = (*SOURCE) + _end_loop->first_elem_disp;
unsigned char* _source = (*SOURCE) + _end_loop->first_elem_disp;
uint32_t _copy_loops = *(COUNT);
uint32_t _i;

18
ompi/datatype/datatype_unpack.c
Просмотреть файл

@ -186,7 +186,7 @@ ompi_unpack_homogeneous_contig_function( ompi_convertor_t* pConv,
size_t* max_data )
{
const ompi_datatype_t *pData = pConv->pDesc;
char *user_memory, *packed_buffer;
unsigned char *user_memory, *packed_buffer;
uint32_t iov_count, i;
size_t bConverted, remaining, length, initial_bytes_converted = pConv->bConverted;
dt_stack_t* stack = pConv->pStack;
@ -196,7 +196,7 @@ ompi_unpack_homogeneous_contig_function( ompi_convertor_t* pConv,
DO_DEBUG( opal_output( 0, "unpack_homogeneous_contig( pBaseBuf %p, iov_count %d )\n",
pConv->pBaseBuf, *out_size ); );
for( iov_count = 0; iov_count < (*out_size); iov_count++ ) {
packed_buffer = (char*)iov[iov_count].iov_base;
packed_buffer = (unsigned char*)iov[iov_count].iov_base;
remaining = pConv->local_size - pConv->bConverted;
if( remaining > (uint32_t)iov[iov_count].iov_len )
remaining = iov[iov_count].iov_len;
@ -284,13 +284,13 @@ ompi_unpack_homogeneous_contig_function( ompi_convertor_t* pConv,
*/
static inline uint32_t
ompi_unpack_partial_datatype( ompi_convertor_t* pConvertor, dt_elem_desc_t* pElem,
char* partial_data,
unsigned char* partial_data,
ptrdiff_t start_position, ptrdiff_t end_position,
char** user_buffer )
unsigned char** user_buffer )
{
char unused_byte = 0x7F, saved_data[16];
char temporary[16], *temporary_buffer = temporary;
char* real_data = *user_buffer + pElem->elem.disp;
unsigned char temporary[16], *temporary_buffer = temporary;
unsigned char* real_data = *user_buffer + pElem->elem.disp;
uint32_t i, length, count_desc = 1;
size_t data_length = ompi_ddt_basicDatatypes[pElem->elem.common.type]->size;
@ -356,7 +356,7 @@ ompi_generic_simple_unpack_function( ompi_convertor_t* pConvertor,
dt_elem_desc_t* description;
dt_elem_desc_t* pElem;
const ompi_datatype_t *pData = pConvertor->pDesc;
char *user_memory_base, *packed_buffer;
unsigned char *user_memory_base, *packed_buffer;
size_t iov_len_local;
uint32_t iov_count;
@ -421,7 +421,7 @@ ompi_generic_simple_unpack_function( ompi_convertor_t* pConvertor,
type = pElem->elem.common.type;
assert( type < DT_MAX_PREDEFINED );
if( 0 != iov_len_local ) {
char* temp = user_memory_base;
unsigned char* temp = user_memory_base;
/* We have some partial data here. Let's copy it into the convertor
* and keep it hot until the next round.
*/
@ -440,7 +440,7 @@ ompi_generic_simple_unpack_function( ompi_convertor_t* pConvertor,
if( DT_END_LOOP == pElem->elem.common.type ) { /* end of the current loop */
DO_DEBUG( opal_output( 0, "unpack end_loop count %d stack_pos %d pos_desc %d disp %ld space %lu\n",
(int)pStack->count, pConvertor->stack_pos, pos_desc,
(long)pStack->disp, (unsigned long)iov_len_local ); );
(long)pStack->disp, (unsigned long)iov_len_local ); );
if( --(pStack->count) == 0 ) { /* end of loop */
if( pConvertor->stack_pos == 0 ) {
/* Force the conversion to stop by lowering the number of iovecs. */

14
ompi/datatype/datatype_unpack.h
Просмотреть файл

@ -16,14 +16,14 @@
static inline void unpack_predefined_data( ompi_convertor_t* CONVERTOR, /* the convertor */
dt_elem_desc_t* ELEM, /* the element description */
uint32_t* COUNT, /* the number of elements */
char** SOURCE, /* the source pointer */
char** DESTINATION, /* the destination pointer */
unsigned char** SOURCE, /* the source pointer */
unsigned char** DESTINATION, /* the destination pointer */
size_t* SPACE ) /* the space in the destination buffer */
{
uint32_t _copy_count = *(COUNT);
size_t _copy_blength;
size_t _copy_blength;
ddt_elem_desc_t* _elem = &((ELEM)->elem);
char* _destination = (*DESTINATION) + _elem->disp;
unsigned char* _destination = (*DESTINATION) + _elem->disp;
_copy_blength = ompi_ddt_basicDatatypes[_elem->common.type]->size;
if( (_copy_count * _copy_blength) > *(SPACE) ) {
@ -62,13 +62,13 @@ static inline void unpack_predefined_data( ompi_convertor_t* CONVERTOR, /* the c
static inline void unpack_contiguous_loop( ompi_convertor_t* CONVERTOR,
dt_elem_desc_t* ELEM,
uint32_t* COUNT,
char** SOURCE,
char** DESTINATION,
unsigned char** SOURCE,
unsigned char** DESTINATION,
size_t* SPACE )
{
ddt_loop_desc_t *_loop = (ddt_loop_desc_t*)(ELEM);
ddt_endloop_desc_t* _end_loop = (ddt_endloop_desc_t*)((ELEM) + _loop->items);
char* _destination = (*DESTINATION) + _end_loop->first_elem_disp;
unsigned char* _destination = (*DESTINATION) + _end_loop->first_elem_disp;
uint32_t _copy_loops = *(COUNT);
uint32_t _i;

4
ompi/datatype/dt_optimize.c
Просмотреть файл

@ -279,8 +279,8 @@ int32_t ompi_ddt_commit( ompi_datatype_t** data )
dt_elem_desc_t* pElem = pData->desc.desc;
index = GET_FIRST_NON_LOOP( pElem );
assert( pData->desc.desc[index].elem.common.flags & DT_FLAG_DATA );
first_elem_disp = pData->desc.desc[index].elem.disp;
assert( pElem[index].elem.common.flags & DT_FLAG_DATA );
first_elem_disp = pElem[index].elem.disp;
}
/* let's add a fake element at the end just to avoid useless comparaisons

8
ompi/datatype/position.c
Просмотреть файл

@ -49,11 +49,11 @@ extern int ompi_position_debug;
static inline void position_predefined_data( ompi_convertor_t* CONVERTOR,
dt_elem_desc_t* ELEM,
uint32_t* COUNT,
char** POINTER,
unsigned char** POINTER,
size_t* SPACE )
{
uint32_t _copy_count = *(COUNT);
size_t _copy_blength;
size_t _copy_blength;
ddt_elem_desc_t* _elem = &((ELEM)->elem);
_copy_blength = ompi_ddt_basicDatatypes[_elem->common.type]->size;
@ -73,7 +73,7 @@ static inline void position_predefined_data( ompi_convertor_t* CONVERTOR,
static inline void position_contiguous_loop( ompi_convertor_t* CONVERTOR,
dt_elem_desc_t* ELEM,
uint32_t* COUNT,
char** POINTER,
unsigned char** POINTER,
size_t* SPACE )
{
ddt_loop_desc_t *_loop = (ddt_loop_desc_t*)(ELEM);
@ -105,7 +105,7 @@ int ompi_convertor_generic_simple_position( ompi_convertor_t* pConvertor,
uint16_t type; /* type at current position */
dt_elem_desc_t* description = pConvertor->use_desc->desc;
dt_elem_desc_t* pElem;
char *base_pointer = pConvertor->pBaseBuf;
unsigned char *base_pointer = pConvertor->pBaseBuf;
size_t iov_len_local;
ptrdiff_t extent = pConvertor->pDesc->ub - pConvertor->pDesc->lb;

4
ompi/mca/btl/gm/btl_gm.c
Просмотреть файл

@ -387,7 +387,6 @@ mca_btl_base_descriptor_t* mca_btl_gm_prepare_dst(
#if (OMPI_MCA_BTL_GM_HAVE_RDMA_GET || OMPI_MCA_BTL_GM_HAVE_RDMA_PUT)
mca_btl_gm_frag_t* frag;
mca_mpool_base_module_t* mpool = btl->btl_mpool;
ptrdiff_t lb;
int rc;
MCA_BTL_GM_FRAG_ALLOC_USER(btl, frag, rc);
@ -400,7 +399,6 @@ mca_btl_base_descriptor_t* mca_btl_gm_prepare_dst(
*/
frag->type = MCA_BTL_GM_PUT;
ompi_ddt_type_lb(convertor->pDesc, &lb);
/*
* we don't know that this is for a PUT,
* but it doesn't matter.. they belong
@ -409,7 +407,7 @@ mca_btl_base_descriptor_t* mca_btl_gm_prepare_dst(
frag->type = MCA_BTL_GM_PUT;
frag->segment.seg_len = *size;
frag->segment.seg_addr.pval = convertor->pBaseBuf + lb + convertor->bConverted;
ompi_convertor_get_current_pointer( convertor, (void**)&(frag->segment.seg_addr.pval) );
frag->base.des_src = NULL;
frag->base.des_src_cnt = 0;

12
ompi/mca/btl/mvapi/btl_mvapi.c
Просмотреть файл

@ -397,7 +397,6 @@ mca_btl_base_descriptor_t* mca_btl_mvapi_prepare_dst(
mca_btl_mvapi_module_t* mvapi_btl;
mca_btl_mvapi_frag_t* frag;
mca_btl_mvapi_reg_t *mvapi_reg;
ptrdiff_t lb;
int rc;
mvapi_btl = (mca_btl_mvapi_module_t*) btl;
@ -408,9 +407,8 @@ mca_btl_base_descriptor_t* mca_btl_mvapi_prepare_dst(
return NULL;
}
ompi_ddt_type_lb(convertor->pDesc, &lb);
frag->segment.seg_len = *size;
frag->segment.seg_addr.pval = convertor->pBaseBuf + lb + convertor->bConverted;
frag->segment.seg_len = *size;
ompi_convertor_get_current_pointer( convertor, (void**)&(frag->segment.seg_addr.pval) );
frag->base.des_flags = 0;
if(NULL == registration) {
@ -418,10 +416,10 @@ mca_btl_base_descriptor_t* mca_btl_mvapi_prepare_dst(
* ourselves
*/
rc = btl->btl_mpool->mpool_register(btl->btl_mpool,
frag->segment.seg_addr.pval, *size, 0, &registration);
frag->segment.seg_addr.pval, *size, 0, &registration);
if(OMPI_SUCCESS != rc || NULL == registration) {
BTL_ERROR(("mpool_register(%p,%lu) failed: base %p lb %lu offset %lu",
frag->segment.seg_addr.pval, *size, convertor->pBaseBuf, lb, convertor->bConverted));
BTL_ERROR(("mpool_register(%p,%lu) failed: base %p offset %lu",
frag->segment.seg_addr.pval, *size, convertor->pBaseBuf, convertor->bConverted));
MCA_BTL_IB_FRAG_RETURN(btl, frag);
return NULL;
}

2
ompi/mca/btl/mx/btl_mx.c
Просмотреть файл

@ -305,7 +305,7 @@ mca_btl_base_descriptor_t* mca_btl_mx_prepare_dst( struct mca_btl_base_module_t*
}
frag->segment[0].seg_len = *size;
frag->segment[0].seg_addr.pval = convertor->pBaseBuf + convertor->bConverted;
ompi_convertor_get_current_pointer( convertor, (void**)&(frag->segment.seg_addr.pval) );
frag->segment[0].seg_key.key64 = (uint64_t)(intptr_t)frag;
mx_segment.segment_ptr = frag->segment[0].seg_addr.pval;

5
ompi/mca/btl/openib/btl_openib.c
Просмотреть файл

@ -547,7 +547,6 @@ mca_btl_base_descriptor_t* mca_btl_openib_prepare_dst(
mca_btl_openib_frag_t *frag;
mca_btl_openib_reg_t *openib_reg;
int rc;
ptrdiff_t lb;
openib_btl = (mca_btl_openib_module_t*)btl;
@ -556,9 +555,7 @@ mca_btl_base_descriptor_t* mca_btl_openib_prepare_dst(
return NULL;
}
ompi_ddt_type_lb(convertor->pDesc, &lb);
frag->segment.seg_addr.pval = convertor->pBaseBuf + lb +
convertor->bConverted;
ompi_convertor_get_current_pointer( convertor, (void**)&(frag->segment.seg_addr.pval) );
if(NULL == registration){
/* we didn't get a memory registration passed in, so we have to

4
ompi/mca/btl/portals/btl_portals.c
Просмотреть файл

@ -431,7 +431,6 @@ mca_btl_portals_prepare_dst(struct mca_btl_base_module_t* btl_base,
ptl_md_t md;
ptl_handle_me_t me_h;
int ret;
ptrdiff_t lb;
assert(&mca_btl_portals_module == (mca_btl_portals_module_t*) btl_base);
@ -448,9 +447,8 @@ mca_btl_portals_prepare_dst(struct mca_btl_base_module_t* btl_base,
return NULL;
}
ompi_ddt_type_lb(convertor->pDesc, &lb);
frag->segments[0].seg_len = *size;
frag->segments[0].seg_addr.pval = convertor->pBaseBuf + lb + convertor->bConverted;
ompi_convertor_get_current_pointer( convertor, (void**)&(frag->segment.seg_addr.pval) );
frag->segments[0].seg_key.key64 =
OPAL_THREAD_ADD64(&(mca_btl_portals_module.portals_rdma_key), 1);
frag->base.des_src = NULL;

4
ompi/mca/btl/self/btl_self.c
Просмотреть файл

@ -277,7 +277,6 @@ struct mca_btl_base_descriptor_t* mca_btl_self_prepare_dst(
{
mca_btl_self_frag_t* frag;
size_t max_data = *size;
ptrdiff_t lb;
int rc;
MCA_BTL_SELF_FRAG_ALLOC_RDMA(frag, rc);
@ -286,8 +285,7 @@ struct mca_btl_base_descriptor_t* mca_btl_self_prepare_dst(
}
/* setup descriptor to point directly to user buffer */
ompi_ddt_type_lb( convertor->pDesc, &lb );
frag->segment.seg_addr.pval = (unsigned char*)convertor->pBaseBuf + lb + convertor->bConverted;
ompi_convertor_get_current_pointer( convertor, (void**)&(frag->segment.seg_addr.pval) );
frag->segment.seg_len = reserve + max_data;
frag->segment.seg_key.key64 = (uint64_t)(intptr_t)convertor;
frag->base.des_dst = &frag->segment;

4
ompi/mca/btl/tcp/btl_tcp.c
Просмотреть файл

@ -340,7 +340,6 @@ mca_btl_base_descriptor_t* mca_btl_tcp_prepare_dst(
size_t* size)
{
mca_btl_tcp_frag_t* frag;
ptrdiff_t lb;
int rc;
MCA_BTL_TCP_FRAG_ALLOC_USER(frag, rc);
@ -348,9 +347,8 @@ mca_btl_base_descriptor_t* mca_btl_tcp_prepare_dst(
return NULL;
}
ompi_ddt_type_lb(convertor->pDesc, &lb);
frag->segments->seg_len = *size;
frag->segments->seg_addr.pval = convertor->pBaseBuf + lb + convertor->bConverted;
ompi_convertor_get_current_pointer( convertor, (void**)&(frag->segments->seg_addr.pval) );
frag->base.des_src = NULL;
frag->base.des_src_cnt = 0;

2
ompi/mca/btl/template/btl_template.c
Просмотреть файл

@ -323,7 +323,7 @@ mca_btl_base_descriptor_t* mca_btl_template_prepare_dst(
}
frag->segment.seg_len = *size;
frag->segment.seg_addr.pval = convertor->pBaseBuf + convertor->bConverted;
ompi_convertor_get_current_pointer( convertor, (void**)&(frag->segment.seg_addr.pval) );
frag->base.des_src = NULL;
frag->base.des_src_cnt = 0;

4
ompi/mca/btl/udapl/btl_udapl.c
Просмотреть файл

@ -674,7 +674,6 @@ mca_btl_base_descriptor_t* mca_btl_udapl_prepare_dst(
size_t* size)
{
mca_btl_udapl_frag_t* frag;
ptrdiff_t lb;
int rc;
MCA_BTL_UDAPL_FRAG_ALLOC_USER(btl, frag, rc);
@ -682,9 +681,8 @@ mca_btl_base_descriptor_t* mca_btl_udapl_prepare_dst(
return NULL;
}
ompi_ddt_type_lb(convertor->pDesc, &lb);
frag->segment.seg_len = *size;
frag->segment.seg_addr.pval = convertor->pBaseBuf + lb + convertor->bConverted;
ompi_convertor_get_current_pointer( convertor, (void**)&(frag->segment.seg_addr.pval) );
if(NULL == registration) {
/* didn't get a memory registration passed in, so must

15
ompi/mca/pml/ob1/pml_ob1_recvreq.c
Просмотреть файл

@ -247,16 +247,13 @@ static int mca_pml_ob1_recv_request_ack(
if(ompi_convertor_need_buffers(&recvreq->req_recv.req_convertor) == 0 &&
hdr->hdr_match.hdr_common.hdr_flags & MCA_PML_OB1_HDR_FLAGS_CONTIG) {
char *base;
ptrdiff_t lb;
ompi_ddt_type_lb(recvreq->req_recv.req_convertor.pDesc, &lb);
base = recvreq->req_recv.req_convertor.pBaseBuf + lb;
unsigned char *base;
ompi_convertor_get_current_pointer( &recvreq->req_recv.req_convertor, (void**)&(base) );
recvreq->req_rdma_cnt = mca_pml_ob1_rdma_btls(
bml_endpoint,
(unsigned char*) base,
recvreq->req_recv.req_bytes_packed,
recvreq->req_rdma);
recvreq->req_rdma_cnt = mca_pml_ob1_rdma_btls( bml_endpoint,
base,
recvreq->req_recv.req_bytes_packed,
recvreq->req_rdma );
/* memory is already registered on both sides */
if (hdr->hdr_match.hdr_common.hdr_flags & MCA_PML_OB1_HDR_FLAGS_PIN &&

8
ompi/mca/pml/ob1/pml_ob1_sendreq.h
Просмотреть файл

@ -286,14 +286,12 @@ static inline int mca_pml_ob1_send_request_start_btl(
rc = mca_pml_ob1_send_request_start_buffered(sendreq, bml_btl, size);
} else if
(ompi_convertor_need_buffers(&sendreq->req_send.req_convertor) == false) {
char *base;
ptrdiff_t lb;
ompi_ddt_type_lb(sendreq->req_send.req_convertor.pDesc, &lb);
base = sendreq->req_send.req_convertor.pBaseBuf + lb;
unsigned char *base;
ompi_convertor_get_current_pointer( &sendreq->req_send.req_convertor, (void**)&base );
if( 0 != (sendreq->req_rdma_cnt = (uint32_t)mca_pml_ob1_rdma_btls(
sendreq->req_endpoint,
(unsigned char*) base,
base,
sendreq->req_send.req_bytes_packed,
sendreq->req_rdma))) {
rc = mca_pml_ob1_send_request_start_rdma(sendreq, bml_btl,