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

macros to compute checksum while moving data

Просмотр исходного кода 
This commit was SVN r9278.
Этот коммит содержится в:
Tim Woodall 2006-03-14 19:33:27 +00:00
родитель 92c5e26758
Коммит 0b366e912c
7 изменённых файлов: 64 добавлений и 54 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

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

@ -86,6 +86,9 @@ inline int32_t ompi_convertor_pack( ompi_convertor_t* pConv,
size_t* max_data, int32_t* freeAfter ) size_t* max_data, int32_t* freeAfter )
{ {
pConv->checksum = 1; pConv->checksum = 1;
pConv->csum_ui1 = 0;
pConv->csum_ui2 = 0;
/* protect against over packing data */ /* protect against over packing data */
if( pConv->flags & CONVERTOR_COMPLETED ) { if( pConv->flags & CONVERTOR_COMPLETED ) {
iov[0].iov_len = 0; iov[0].iov_len = 0;
@ -107,6 +110,9 @@ inline int32_t ompi_convertor_unpack( ompi_convertor_t* pConv,
size_t* max_data, int32_t* freeAfter ) size_t* max_data, int32_t* freeAfter )
{ {
pConv->checksum = 1; pConv->checksum = 1;
pConv->csum_ui1 = 0;
pConv->csum_ui2 = 0;
/* protect against over unpacking data */ /* protect against over unpacking data */
if( pConv->flags & CONVERTOR_COMPLETED ) { if( pConv->flags & CONVERTOR_COMPLETED ) {
iov[0].iov_len = 0; iov[0].iov_len = 0;

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

@ -94,6 +94,8 @@ struct ompi_convertor_t {
uint32_t stack_pos; /**< the actual position on the stack */ uint32_t stack_pos; /**< the actual position on the stack */
size_t bConverted; /**< # of bytes already converted */ size_t bConverted; /**< # of bytes already converted */
uint32_t checksum; /**< checksum computed by pack/unpack operation */ uint32_t checksum; /**< checksum computed by pack/unpack operation */
uint32_t csum_ui1; /**< partial checksum computed by pack/unpack operation */
uint32_t csum_ui2; /**< partial checksum computed by pack/unpack operation */
char pending[16]; /**< bytes pending from the last conversion */ char pending[16]; /**< bytes pending from the last conversion */
uint32_t pending_length; /**< # bytes pending ... */ uint32_t pending_length; /**< # bytes pending ... */
dt_stack_t static_stack[DT_STATIC_STACK_SIZE]; /**< local stack for small datatypes */ dt_stack_t static_stack[DT_STATIC_STACK_SIZE]; /**< local stack for small datatypes */

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

@ -251,6 +251,7 @@ do { \
memcpy( (DST), (SRC), (BLENGTH) ); \ memcpy( (DST), (SRC), (BLENGTH) ); \
} while (0) } while (0)
#if OMPI_ENABLE_DEBUG #if OMPI_ENABLE_DEBUG
OMPI_DECLSPEC int ompi_ddt_safeguard_pointer_debug_breakpoint( const void* actual_ptr, int length, OMPI_DECLSPEC int ompi_ddt_safeguard_pointer_debug_breakpoint( const void* actual_ptr, int length,
const void* initial_ptr, const void* initial_ptr,
@ -291,7 +292,33 @@ static inline int GET_FIRST_NON_LOOP( const dt_elem_desc_t* _pElem )
/* Please set it to one if you want data checksum. The current implementation /* Please set it to one if you want data checksum. The current implementation
* use ADLER32 algorithm. * use ADLER32 algorithm.
*/ */
#define OMPI_REQUIRE_DATA_VALIDATION 0 #define OMPI_REQUIRE_DATA_VALIDATION 0
#include "opal/util/crc.h"
#define MEMCPY_CSUM( DST, SRC, BLENGTH, CONVERTOR ) \
do { \
/*opal_output( 0, "memcpy dest = %p src = %p length = %d\n", (void*)(DST), (void*)(SRC), (int)(BLENGTH) ); */\
(CONVERTOR)->checksum += opal_bcopy_uicsum_partial( (SRC), (DST), (BLENGTH), (BLENGTH), &(CONVERTOR)->csum_ui1, &(CONVERTOR)->csum_ui2 ); \
} while (0)
#define COMPUTE_CSUM( SRC, BLENGTH, CONVERTOR ) \
do { \
/*opal_output( 0, "memcpy dest = %p src = %p length = %d\n", (void*)(DST), (void*)(SRC), (int)(BLENGTH) ); */\
(CONVERTOR)->checksum += opal_uicsum_partial( (SRC), (BLENGTH), &(CONVERTOR)->csum_ui1, &(CONVERTOR)->csum_ui2 ); \
} while (0)
#else
#define MEMCPY_CSUM( DST, SRC, BLENGTH, CONVERTOR ) \
do { \
/*opal_output( 0, "memcpy dest = %p src = %p length = %d\n", (void*)(DST), (void*)(SRC), (int)(BLENGTH) ); */\
memcpy( (DST), (SRC), (BLENGTH) ); \
} while (0)
#define COMPUTE_CSUM( SRC, BLENGTH, CONVERTOR )
#endif
/* ADLER_NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */ /* ADLER_NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */
#define ADLER_NMAX 5551 #define ADLER_NMAX 5551

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

@ -234,7 +234,7 @@ int ompi_convertor_pack_homogeneous_with_memcpy( ompi_convertor_t* pConv,
for( i = 0; i < last_count; i++ ) { for( i = 0; i < last_count; i++ ) {
OMPI_DDT_SAFEGUARD_POINTER( pConv->pBaseBuf + lastDisp, end_loop->size, OMPI_DDT_SAFEGUARD_POINTER( pConv->pBaseBuf + lastDisp, end_loop->size,
pConv->pBaseBuf, pData, pConv->count ); pConv->pBaseBuf, pData, pConv->count );
MEMCPY( pDestBuf, pConv->pBaseBuf + lastDisp, end_loop->size ); MEMCPY_CSUM( pDestBuf, pConv->pBaseBuf + lastDisp, end_loop->size, pConv );
pDestBuf += end_loop->size; /* size of the contiguous data */ pDestBuf += end_loop->size; /* size of the contiguous data */
lastDisp += pElems[pos_desc].loop.extent; lastDisp += pElems[pos_desc].loop.extent;
} }
@ -268,7 +268,7 @@ int ompi_convertor_pack_homogeneous_with_memcpy( ompi_convertor_t* pConv,
} }
OMPI_DDT_SAFEGUARD_POINTER( pConv->pBaseBuf + lastDisp, last_count, OMPI_DDT_SAFEGUARD_POINTER( pConv->pBaseBuf + lastDisp, last_count,
pConv->pBaseBuf, pData, pConv->count ); pConv->pBaseBuf, pData, pConv->count );
MEMCPY( pDestBuf, pConv->pBaseBuf + lastDisp, last_count ); MEMCPY_CSUM( pDestBuf, pConv->pBaseBuf + lastDisp, last_count, pConv );
bConverted += last_blength; bConverted += last_blength;
space -= last_blength; space -= last_blength;
pDestBuf += last_blength; pDestBuf += last_blength;
@ -281,7 +281,7 @@ int ompi_convertor_pack_homogeneous_with_memcpy( ompi_convertor_t* pConv,
if( last_count != 0 ) { /* save the internal state */ if( last_count != 0 ) { /* save the internal state */
OMPI_DDT_SAFEGUARD_POINTER( pConv->pBaseBuf + lastDisp, last_count, OMPI_DDT_SAFEGUARD_POINTER( pConv->pBaseBuf + lastDisp, last_count,
pConv->pBaseBuf, pData, pConv->count ); pConv->pBaseBuf, pData, pConv->count );
MEMCPY( pDestBuf, pConv->pBaseBuf + lastDisp, last_count ); MEMCPY_CSUM( pDestBuf, pConv->pBaseBuf + lastDisp, last_count, pConv );
bConverted += last_count; bConverted += last_count;
lastDisp += last_count; lastDisp += last_count;
} }
@ -363,6 +363,7 @@ int ompi_convertor_pack_no_conversion( ompi_convertor_t* pConv,
saveLength = 0; saveLength = 0;
iov_pos++; iov_pos++;
space_on_iovec = 0; space_on_iovec = 0;
COMPUTE_CSUM( iov[iov_pos].iov_base, iov[iov_pos].iov_len, pConv );
/* let's go out of here */ /* let's go out of here */
} else { } else {
uint32_t copy_length = saveLength; uint32_t copy_length = saveLength;
@ -373,7 +374,7 @@ int ompi_convertor_pack_no_conversion( ompi_convertor_t* pConv,
pConv->pBaseBuf, pData, pConv->count ); pConv->pBaseBuf, pData, pConv->count );
DO_DEBUG( opal_output( 0, "1. memcpy( %p, %p, %ld ) bConverted %ld space %ld pConv->bConverted %ld\n", destination, source, DO_DEBUG( opal_output( 0, "1. memcpy( %p, %p, %ld ) bConverted %ld space %ld pConv->bConverted %ld\n", destination, source,
copy_length, bConverted, space_on_iovec, pConv->bConverted ); ); copy_length, bConverted, space_on_iovec, pConv->bConverted ); );
MEMCPY( destination, source, copy_length ); MEMCPY_CSUM( destination, source, copy_length, pConv );
source += copy_length; source += copy_length;
destination += copy_length; destination += copy_length;
bConverted += copy_length; bConverted += copy_length;
@ -433,7 +434,7 @@ int ompi_convertor_pack_no_conversion( ompi_convertor_t* pConv,
pConv->pBaseBuf, pData, pConv->count ); pConv->pBaseBuf, pData, pConv->count );
DO_DEBUG (opal_output( 0, "2. memcpy( %p, %p, %ld )\n", destination, pConv->pBaseBuf + lastDisp, DO_DEBUG (opal_output( 0, "2. memcpy( %p, %p, %ld )\n", destination, pConv->pBaseBuf + lastDisp,
end_loop->size ); ); end_loop->size ); );
MEMCPY( destination, pConv->pBaseBuf + lastDisp, end_loop->size ); MEMCPY_CSUM( destination, pConv->pBaseBuf + lastDisp, end_loop->size, pConv );
lastDisp += pElems[pos_desc].loop.extent; lastDisp += pElems[pos_desc].loop.extent;
destination += end_loop->size; destination += end_loop->size;
} }
@ -516,7 +517,7 @@ int ompi_convertor_pack_no_conversion( ompi_convertor_t* pConv,
pConv->pBaseBuf, pData, pConv->count ); pConv->pBaseBuf, pData, pConv->count );
DO_DEBUG( opal_output( 0, "3. memcpy( %p, %p, %ld ) bConverted %ld space %ld pConv->bConverted %ld\n", destination, source, DO_DEBUG( opal_output( 0, "3. memcpy( %p, %p, %ld ) bConverted %ld space %ld pConv->bConverted %ld\n", destination, source,
saveLength, bConverted, space_on_iovec, pConv->bConverted ); ); saveLength, bConverted, space_on_iovec, pConv->bConverted ); );
MEMCPY( destination, source, saveLength ); MEMCPY_CSUM( destination, source, saveLength, pConv );
destination += saveLength; destination += saveLength;
/* update the pack counters values */ /* update the pack counters values */
bConverted += saveLength; bConverted += saveLength;
@ -531,7 +532,7 @@ int ompi_convertor_pack_no_conversion( ompi_convertor_t* pConv,
pConv->pBaseBuf, pData, pConv->count ); pConv->pBaseBuf, pData, pConv->count );
DO_DEBUG( opal_output( 0, "4. memcpy( %p, %p, %ld ) bConverted %ld space %ld pConv->bConverted %ld\n", destination, source, DO_DEBUG( opal_output( 0, "4. memcpy( %p, %p, %ld ) bConverted %ld space %ld pConv->bConverted %ld\n", destination, source,
space_on_iovec, bConverted, space_on_iovec, pConv->bConverted ); ); space_on_iovec, bConverted, space_on_iovec, pConv->bConverted ); );
MEMCPY( destination, source, space_on_iovec ); MEMCPY_CSUM( destination, source, space_on_iovec, pConv );
/* let's prepare for the next round. As I keep trace of the amount that I still /* let's prepare for the next round. As I keep trace of the amount that I still
* have to pack, the next time when I came here, I'll try to append something. * have to pack, the next time when I came here, I'll try to append something.
* If I already fill-up the amount of data required by the upper level, I will * If I already fill-up the amount of data required by the upper level, I will
@ -609,21 +610,16 @@ ompi_convertor_pack_no_conv_contig( ompi_convertor_t* pConv,
+ pStack[0].disp + pStack[1].disp); + pStack[0].disp + pStack[1].disp);
if( iov[iov_count].iov_base == NULL ) { if( iov[iov_count].iov_base == NULL ) {
iov[iov_count].iov_base = source_base; iov[iov_count].iov_base = source_base;
COMPUTE_CSUM( iov[iov_count].iov_base, iov[iov_count].iov_len, pConv );
} else { } else {
/* contiguous data just memcpy the smallest data in the user buffer */ /* contiguous data just memcpy the smallest data in the user buffer */
OMPI_DDT_SAFEGUARD_POINTER( source_base, iov[iov_count].iov_len, OMPI_DDT_SAFEGUARD_POINTER( source_base, iov[iov_count].iov_len,
pConv->pBaseBuf, pConv->pDesc, pConv->count ); pConv->pBaseBuf, pConv->pDesc, pConv->count );
MEMCPY( iov[iov_count].iov_base, source_base, iov[iov_count].iov_len); MEMCPY_CSUM( iov[iov_count].iov_base, source_base, iov[iov_count].iov_len, pConv );
} }
length -= iov[iov_count].iov_len; length -= iov[iov_count].iov_len;
pConv->bConverted += iov[iov_count].iov_len; pConv->bConverted += iov[iov_count].iov_len;
pStack[0].disp += iov[iov_count].iov_len; pStack[0].disp += iov[iov_count].iov_len;
/* We compute the checksum if we have to. But we will store the temporary
* values in the a and b variables, and only at the end take in account the
* value of the convertor checksum.
*/
COMPUTE_SPECIFIC_CHECKSUM( iov[iov_count].iov_base, iov[iov_count].iov_len,
pConv->checksum );
} }
/* update the return value */ /* update the return value */
@ -679,6 +675,7 @@ ompi_convertor_pack_no_conv_contig_with_gaps( ompi_convertor_t* pConv,
total_bytes_converted += pStack[1].count; total_bytes_converted += pStack[1].count;
pStack[1].disp = 0; /* reset it for the next round */ pStack[1].disp = 0; /* reset it for the next round */
pStack[1].count = pData->size; pStack[1].count = pData->size;
COMPUTE_CSUM( iov[index].iov_base, iov[index].iov_len, pConv );
} }
*out_size = iov_count + index; *out_size = iov_count + index;
pConv->bConverted += total_bytes_converted; pConv->bConverted += total_bytes_converted;
@ -697,11 +694,13 @@ ompi_convertor_pack_no_conv_contig_with_gaps( ompi_convertor_t* pConv,
iov[index].iov_len = max_allowed; iov[index].iov_len = max_allowed;
max_allowed = 0; max_allowed = 0;
printf( "%s:%d Possible problem here\n", __FILE__, __LINE__ ); printf( "%s:%d Possible problem here\n", __FILE__, __LINE__ );
COMPUTE_CSUM( iov[index].iov_base, iov[index].iov_len, pConv );
break; break;
} else { } else {
iov[index].iov_base = user_memory; iov[index].iov_base = user_memory;
iov[index].iov_len = pData->size; iov[index].iov_len = pData->size;
user_memory += extent; user_memory += extent;
COMPUTE_CSUM( iov[index].iov_base, iov[index].iov_len, pConv );
} }
max_allowed -= iov[index].iov_len; max_allowed -= iov[index].iov_len;
total_bytes_converted += iov[index].iov_len; total_bytes_converted += iov[index].iov_len;
@ -733,7 +732,7 @@ ompi_convertor_pack_no_conv_contig_with_gaps( ompi_convertor_t* pConv,
if( done != 0 ) { /* still some data to copy from the last time */ if( done != 0 ) { /* still some data to copy from the last time */
done = pData->size - done; done = pData->size - done;
OMPI_DDT_SAFEGUARD_POINTER( user_memory, done, pConv->pBaseBuf, pData, pConv->count ); OMPI_DDT_SAFEGUARD_POINTER( user_memory, done, pConv->pBaseBuf, pData, pConv->count );
MEMCPY( packed_buffer, user_memory, done ); MEMCPY_CSUM( packed_buffer, user_memory, done, pConv );
packed_buffer += done; packed_buffer += done;
max_allowed -= done; max_allowed -= done;
i++; /* just to compute the correct source pointer */ i++; /* just to compute the correct source pointer */
@ -744,7 +743,7 @@ ompi_convertor_pack_no_conv_contig_with_gaps( ompi_convertor_t* pConv,
if( counter > pConv->count ) counter = pConv->count; if( counter > pConv->count ) counter = pConv->count;
for( i = 0; i < counter; i++ ) { for( i = 0; i < counter; i++ ) {
OMPI_DDT_SAFEGUARD_POINTER( user_memory, pData->size, pConv->pBaseBuf, pData, pConv->count ); OMPI_DDT_SAFEGUARD_POINTER( user_memory, pData->size, pConv->pBaseBuf, pData, pConv->count );
MEMCPY( packed_buffer, user_memory, pData->size ); MEMCPY_CSUM( packed_buffer, user_memory, pData->size, pConv );
packed_buffer+= pData->size; packed_buffer+= pData->size;
user_memory += extent; user_memory += extent;
} }
@ -757,12 +756,6 @@ ompi_convertor_pack_no_conv_contig_with_gaps( ompi_convertor_t* pConv,
* it's supposed to be useless from now. * it's supposed to be useless from now.
*/ */
user_memory = pConv->pBaseBuf + pStack[0].disp; user_memory = pConv->pBaseBuf + pStack[0].disp;
/* We compute the checksum if we have to. But we will store the temporary
* values in the a and b variables, and only at the end take in account the
* value of the convertor checksum.
*/
COMPUTE_SPECIFIC_CHECKSUM( iov[iov_count].iov_base, iov[iov_count].iov_len,
pConv->checksum );
} }
*max_data = total_bytes_converted; *max_data = total_bytes_converted;
pConv->bConverted += total_bytes_converted; pConv->bConverted += total_bytes_converted;

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

@ -236,7 +236,7 @@ static int ompi_convertor_unpack_homogeneous( ompi_convertor_t* pConv,
OMPI_DDT_SAFEGUARD_POINTER( pConv->pBaseBuf + lastDisp, end_loop->size, OMPI_DDT_SAFEGUARD_POINTER( pConv->pBaseBuf + lastDisp, end_loop->size,
pConv->pBaseBuf, pData, pConv->count ); pConv->pBaseBuf, pData, pConv->count );
/*opal_output( 0, "3. memcpy %p, %p, %d", pConv->pBaseBuf + lastDisp, pSrcBuf, end_loop->size );*/ /*opal_output( 0, "3. memcpy %p, %p, %d", pConv->pBaseBuf + lastDisp, pSrcBuf, end_loop->size );*/
MEMCPY( pConv->pBaseBuf + lastDisp, pSrcBuf, end_loop->size ); MEMCPY_CSUM( pConv->pBaseBuf + lastDisp, pSrcBuf, end_loop->size, pConv );
pSrcBuf += end_loop->size; pSrcBuf += end_loop->size;
lastDisp += pElems[pos_desc].loop.extent; lastDisp += pElems[pos_desc].loop.extent;
} }
@ -273,7 +273,7 @@ static int ompi_convertor_unpack_homogeneous( ompi_convertor_t* pConv,
OMPI_DDT_SAFEGUARD_POINTER( pConv->pBaseBuf + lastDisp, last_blength, OMPI_DDT_SAFEGUARD_POINTER( pConv->pBaseBuf + lastDisp, last_blength,
pConv->pBaseBuf, pData, pConv->count ); pConv->pBaseBuf, pData, pConv->count );
/*opal_output( 0, "1. memcpy %p, %p, %d -> %d", pConv->pBaseBuf + lastDisp, pSrcBuf, last_blength, bConverted );*/ /*opal_output( 0, "1. memcpy %p, %p, %d -> %d", pConv->pBaseBuf + lastDisp, pSrcBuf, last_blength, bConverted );*/
MEMCPY( pConv->pBaseBuf + lastDisp, pSrcBuf, last_blength ); MEMCPY_CSUM( pConv->pBaseBuf + lastDisp, pSrcBuf, last_blength, pConv );
bConverted += last_blength; bConverted += last_blength;
space -= last_blength; space -= last_blength;
pSrcBuf += last_blength; pSrcBuf += last_blength;
@ -285,7 +285,7 @@ static int ompi_convertor_unpack_homogeneous( ompi_convertor_t* pConv,
OMPI_DDT_SAFEGUARD_POINTER( pConv->pBaseBuf + lastDisp, last_blength, OMPI_DDT_SAFEGUARD_POINTER( pConv->pBaseBuf + lastDisp, last_blength,
pConv->pBaseBuf, pData, pConv->count ); pConv->pBaseBuf, pData, pConv->count );
/*opal_output( 0, "2. memcpy %p, %p, %d", pConv->pBaseBuf + lastDisp, pSrcBuf, last_blength );*/ /*opal_output( 0, "2. memcpy %p, %p, %d", pConv->pBaseBuf + lastDisp, pSrcBuf, last_blength );*/
MEMCPY( pConv->pBaseBuf + lastDisp, pSrcBuf, last_blength ); MEMCPY_CSUM( pConv->pBaseBuf + lastDisp, pSrcBuf, last_blength, pConv );
lastDisp += pElems[pos_desc].elem.extent; lastDisp += pElems[pos_desc].elem.extent;
pSrcBuf += basic_type->size; pSrcBuf += basic_type->size;
} }
@ -301,7 +301,7 @@ static int ompi_convertor_unpack_homogeneous( ompi_convertor_t* pConv,
/* update corresponding the the datatype length */ /* update corresponding the the datatype length */
OMPI_DDT_SAFEGUARD_POINTER( pConv->pBaseBuf + lastDisp, last_blength, OMPI_DDT_SAFEGUARD_POINTER( pConv->pBaseBuf + lastDisp, last_blength,
pConv->pBaseBuf, pData, pConv->count ); pConv->pBaseBuf, pData, pConv->count );
MEMCPY( pConv->pBaseBuf + lastDisp, pSrcBuf, last_blength ); MEMCPY_CSUM( pConv->pBaseBuf + lastDisp, pSrcBuf, last_blength, pConv );
/*opal_output( 0, "1. memcpy %p, %p, %d -> %d", pConv->pBaseBuf + lastDisp, pSrcBuf, last_blength, bConverted );*/ /*opal_output( 0, "1. memcpy %p, %p, %d -> %d", pConv->pBaseBuf + lastDisp, pSrcBuf, last_blength, bConverted );*/
bConverted += last_blength; bConverted += last_blength;
lastDisp += last_blength; lastDisp += last_blength;
@ -351,7 +351,7 @@ static int ompi_convertor_unpack_homogeneous_contig( ompi_convertor_t* pConv,
pConv->pBaseBuf, pData, pConv->count ); pConv->pBaseBuf, pData, pConv->count );
/*opal_output( 0, "1. unpack contig dest %p src %p length %d\n", /*opal_output( 0, "1. unpack contig dest %p src %p length %d\n",
user_memory, packed_buffer, remaining );*/ user_memory, packed_buffer, remaining );*/
MEMCPY( user_memory, packed_buffer, remaining); MEMCPY_CSUM( user_memory, packed_buffer, remaining, pConv );
} else { } else {
user_memory += stack->disp; user_memory += stack->disp;
@ -363,7 +363,7 @@ static int ompi_convertor_unpack_homogeneous_contig( ompi_convertor_t* pConv,
pData, pConv->count ); pData, pConv->count );
/*opal_output( 0, "1. unpack dest %p src %p length %d\n", /*opal_output( 0, "1. unpack dest %p src %p length %d\n",
user_memory, packed_buffer, length );*/ user_memory, packed_buffer, length );*/
MEMCPY( user_memory, packed_buffer, length ); MEMCPY_CSUM( user_memory, packed_buffer, length, pConv );
packed_buffer += length; packed_buffer += length;
user_memory += (extent - (pData->size - length)); user_memory += (extent - (pData->size - length));
remaining -= length; remaining -= length;
@ -373,7 +373,7 @@ static int ompi_convertor_unpack_homogeneous_contig( ompi_convertor_t* pConv,
pData, pConv->count ); pData, pConv->count );
/*opal_output( 0, "2. unpack dest %p src %p length %d\n", /*opal_output( 0, "2. unpack dest %p src %p length %d\n",
user_memory, packed_buffer, pData->size );*/ user_memory, packed_buffer, pData->size );*/
MEMCPY( user_memory, packed_buffer, pData->size ); MEMCPY_CSUM( user_memory, packed_buffer, pData->size, pConv );
packed_buffer += pData->size; packed_buffer += pData->size;
user_memory += extent; user_memory += extent;
remaining -= pData->size; remaining -= pData->size;
@ -384,18 +384,12 @@ static int ompi_convertor_unpack_homogeneous_contig( ompi_convertor_t* pConv,
pData, pConv->count ); pData, pConv->count );
/*opal_output( 0, "3. unpack dest %p src %p length %d\n", /*opal_output( 0, "3. unpack dest %p src %p length %d\n",
user_memory, packed_buffer, remaining );*/ user_memory, packed_buffer, remaining );*/
MEMCPY( user_memory, packed_buffer, remaining ); MEMCPY_CSUM( user_memory, packed_buffer, remaining, pConv );
user_memory += remaining; user_memory += remaining;
} }
stack->disp = user_memory - pData->true_lb - pConv->pBaseBuf; /* save the position */ stack->disp = user_memory - pData->true_lb - pConv->pBaseBuf; /* save the position */
} }
pConv->bConverted += bConverted; pConv->bConverted += bConverted;
/* We compute the checksum if we have to. But we will store the temporary
* values in the a and b variables, and only at the end take in account the
* value of the convertor checksum.
*/
COMPUTE_SPECIFIC_CHECKSUM( iov[iov_count].iov_base, iov[iov_count].iov_len,
pConv->checksum );
} }
*out_size = iov_count; *out_size = iov_count;
*max_data = (pConv->bConverted - initial_bytes_converted); *max_data = (pConv->bConverted - initial_bytes_converted);

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

@ -78,7 +78,7 @@ static inline void pack_predefined_data( ompi_convertor_t* CONVERTOR,
(CONVERTOR)->pDesc, (CONVERTOR)->count ); (CONVERTOR)->pDesc, (CONVERTOR)->count );
DO_DEBUG( opal_output( 0, "pack 1. memcpy( %p, %p, %ld ) => space %d\n", DO_DEBUG( opal_output( 0, "pack 1. memcpy( %p, %p, %ld ) => space %d\n",
*(DESTINATION), _source, _copy_blength, *(SPACE) ); ); *(DESTINATION), _source, _copy_blength, *(SPACE) ); );
MEMCPY( *(DESTINATION), _source, _copy_blength ); MEMCPY_CSUM( *(DESTINATION), _source, _copy_blength, (CONVERTOR) );
_source += _copy_blength; _source += _copy_blength;
*(DESTINATION) += _copy_blength; *(DESTINATION) += _copy_blength;
} else { } else {
@ -88,7 +88,7 @@ static inline void pack_predefined_data( ompi_convertor_t* CONVERTOR,
(CONVERTOR)->pDesc, (CONVERTOR)->count ); (CONVERTOR)->pDesc, (CONVERTOR)->count );
DO_DEBUG( opal_output( 0, "pack 2. memcpy( %p, %p, %ld ) => space %d\n", DO_DEBUG( opal_output( 0, "pack 2. memcpy( %p, %p, %ld ) => space %d\n",
*(DESTINATION), _source, _copy_blength, *(SPACE) - (_i * _copy_blength) ); ); *(DESTINATION), _source, _copy_blength, *(SPACE) - (_i * _copy_blength) ); );
MEMCPY( *(DESTINATION), _source, _copy_blength ); MEMCPY_CSUM( *(DESTINATION), _source, _copy_blength, (CONVERTOR) );
*(DESTINATION) += _copy_blength; *(DESTINATION) += _copy_blength;
_source += _elem->extent; _source += _elem->extent;
} }
@ -119,7 +119,7 @@ static inline void pack_contiguous_loop( ompi_convertor_t* CONVERTOR,
(CONVERTOR)->pDesc, (CONVERTOR)->count ); (CONVERTOR)->pDesc, (CONVERTOR)->count );
DO_DEBUG( opal_output( 0, "pack 3. memcpy( %p, %p, %ld ) => space %ld\n", DO_DEBUG( opal_output( 0, "pack 3. memcpy( %p, %p, %ld ) => space %ld\n",
*(DESTINATION), _source, _end_loop->size, *(SPACE) - _i * _end_loop->size ); ); *(DESTINATION), _source, _end_loop->size, *(SPACE) - _i * _end_loop->size ); );
MEMCPY( *(DESTINATION), _source, _end_loop->size ); MEMCPY_CSUM( *(DESTINATION), _source, _end_loop->size, (CONVERTOR) );
*(DESTINATION) += _end_loop->size; *(DESTINATION) += _end_loop->size;
_source += _loop->extent; _source += _loop->extent;
} }
@ -265,12 +265,6 @@ int ompi_convertor_generic_simple_pack( ompi_convertor_t* pConvertor,
iov[iov_count].iov_len -= iov_len_local; /* update the amount of valid data */ iov[iov_count].iov_len -= iov_len_local; /* update the amount of valid data */
total_packed += iov[iov_count].iov_len; total_packed += iov[iov_count].iov_len;
pConvertor->bConverted += iov[iov_count].iov_len; /* update the already converted bytes */ pConvertor->bConverted += iov[iov_count].iov_len; /* update the already converted bytes */
/* We compute the checksum if we have to. But we will store the temporary
* values in the a and b variables, and only at the end take in account the
* value of the convertor checksum.
*/
COMPUTE_SPECIFIC_CHECKSUM( iov[iov_count].iov_base, iov[iov_count].iov_len,
pConvertor->checksum );
} }
*max_data = total_packed; *max_data = total_packed;
*out_size = iov_count; *out_size = iov_count;

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

@ -70,7 +70,7 @@ static inline void unpack_predefined_data( ompi_convertor_t* CONVERTOR, /* the c
(CONVERTOR)->pDesc, (CONVERTOR)->count ); (CONVERTOR)->pDesc, (CONVERTOR)->count );
DO_DEBUG( opal_output( 0, "unpack 1. memcpy( %p, %p, %ld ) => space %d\n", DO_DEBUG( opal_output( 0, "unpack 1. memcpy( %p, %p, %ld ) => space %d\n",
_destination, *(SOURCE), _copy_blength, *(SPACE) ); ); _destination, *(SOURCE), _copy_blength, *(SPACE) ); );
MEMCPY( _destination, *(SOURCE), _copy_blength ); MEMCPY_CSUM( _destination, *(SOURCE), _copy_blength, (CONVERTOR) );
*(SOURCE) += _copy_blength; *(SOURCE) += _copy_blength;
_destination += _copy_blength; _destination += _copy_blength;
} else { } else {
@ -80,7 +80,7 @@ static inline void unpack_predefined_data( ompi_convertor_t* CONVERTOR, /* the c
(CONVERTOR)->pDesc, (CONVERTOR)->count ); (CONVERTOR)->pDesc, (CONVERTOR)->count );
DO_DEBUG( opal_output( 0, "unpack 2. memcpy( %p, %p, %ld ) => space %d\n", DO_DEBUG( opal_output( 0, "unpack 2. memcpy( %p, %p, %ld ) => space %d\n",
_destination, *(SOURCE), _copy_blength, *(SPACE) - (_i * _copy_blength) ); ); _destination, *(SOURCE), _copy_blength, *(SPACE) - (_i * _copy_blength) ); );
MEMCPY( _destination, *(SOURCE), _copy_blength ); MEMCPY_CSUM( _destination, *(SOURCE), _copy_blength, (CONVERTOR) );
*(SOURCE) += _copy_blength; *(SOURCE) += _copy_blength;
_destination += _elem->extent; _destination += _elem->extent;
} }
@ -111,7 +111,7 @@ static inline void unpack_contiguous_loop( ompi_convertor_t* CONVERTOR,
(CONVERTOR)->pDesc, (CONVERTOR)->count ); (CONVERTOR)->pDesc, (CONVERTOR)->count );
DO_DEBUG( opal_output( 0, "unpack 3. memcpy( %p, %p, %ld ) => space %ld\n", DO_DEBUG( opal_output( 0, "unpack 3. memcpy( %p, %p, %ld ) => space %ld\n",
_destination, *(SOURCE), _end_loop->size, *(SPACE) - _i * _end_loop->size ); ); _destination, *(SOURCE), _end_loop->size, *(SPACE) - _i * _end_loop->size ); );
MEMCPY( _destination, *(SOURCE), _end_loop->size ); MEMCPY_CSUM( _destination, *(SOURCE), _end_loop->size, (CONVERTOR) );
*(SOURCE) += _end_loop->size; *(SOURCE) += _end_loop->size;
_destination += _loop->extent; _destination += _loop->extent;
} }
@ -280,12 +280,6 @@ int ompi_convertor_generic_simple_unpack( ompi_convertor_t* pConvertor,
iov[iov_count].iov_len -= iov_len_local; /* update the amount of valid data */ iov[iov_count].iov_len -= iov_len_local; /* update the amount of valid data */
total_unpacked += iov[iov_count].iov_len; total_unpacked += iov[iov_count].iov_len;
pConvertor->bConverted += iov[iov_count].iov_len; /* update the already converted bytes */ pConvertor->bConverted += iov[iov_count].iov_len; /* update the already converted bytes */
/* We compute the checksum if we have to. But we will store the temporary
* values in the a and b variables, and only at the end take in account the
* value of the convertor checksum.
*/
COMPUTE_SPECIFIC_CHECKSUM( iov[iov_count].iov_base, iov[iov_count].iov_len,
pConvertor->checksum );
} }
*max_data = total_unpacked; *max_data = total_unpacked;
*out_size = iov_count; *out_size = iov_count;