Changeset 4707

Show
Ignore:
Timestamp:
06/12/09 16:30:49 (5 months ago)
Author:
buntinas
Message:

converted all uses of memcpy to the macro MPIU_Memcpy

Location:
mpich2/trunk/src
Files:
64 modified

Legend:

Unmodified
Added
Removed

  • mpich2/trunk/src/include/mpiimpl.h

    r4674 r4707  
    106106#include "mpitypedefs.h" 
    107107 
     108/* This is the default implementation of MPIU_Memcpy.  We define this 
     109   before including mpidpre.h so that it can be used when a device or 
     110   channel can use it if it's overriding MPIU_Memcpy.  */ 
     111static inline void MPIUI_Memcpy(void * restrict dst, const void * restrict src, size_t len) 
     112{ 
     113    memcpy(dst, src, len); 
     114} 
     115 
    108116/* Include definitions from the device which must exist before items in this 
    109117   file (mpiimpl.h) can be defined. mpidpre.h must be included before any 
    … …  
    113121#include "mpidpre.h" 
    114122/* ------------------------------------------------------------------------- */ 
     123 
     124/* Overriding memcpy: 
     125   Devices and channels can override the default implementation of 
     126   MPIU_Memcpy by defining the MPIU_Memcpy macro.  The implementation 
     127   can call MPIUI_Memcpy for the default memcpy implementation.    
     128   Note that MPIU_Memcpy and MPIUI_Memcpy return void rather than a 
     129   pointer to the destination buffer.  This is different from C89 
     130   memcpy. 
     131*/ 
     132#ifndef MPIU_Memcpy 
     133#define MPIU_Memcpy(dst, src, len) MPIUI_Memcpy(dst, src, len) 
     134#endif 
     135#define memcpy(a, b, c) Error_use_MPIU_Memcpy 
     136 
    115137 
    116138#include "mpiimplthread.h" 

  • mpich2/trunk/src/mpe2/src/graphics/contrib/mandel/pm_genproc.c

    r100 r4707  
    444444                                /* get a bigger queue */ 
    445445    if (q->tail < q->head) { 
    446       memcpy( q->r + q->size, q->r, q->tail * sizeof( rect ) ); 
     446      MPIU_Memcpy( q->r + q->size, q->r, q->tail * sizeof( rect ) ); 
    447447                                /* copy over any data that needs to be moved */ 
    448448      q->tail += q->size; 

  • mpich2/trunk/src/mpe2/src/graphics/contrib/mandel/pm_genproc_cleanedup.c

    r100 r4707  
    681681 
    682682    if (q->tail < q->head) { 
    683       memcpy(q->r + q->size, q->r, q->tail * sizeof(rect)); 
     683      MPIU_Memcpy(q->r + q->size, q->r, q->tail * sizeof(rect)); 
    684684 
    685685      q->tail += q->size; 

  • mpich2/trunk/src/mpe2/src/graphics/src/mpe_graphics.c

    r100 r4707  
    12171217      return 1; 
    12181218    } else { 
    1219       memcpy( tmp, listPtr->list, sizeof(int) * listPtr->size / 2 ); 
     1219      MPIU_Memcpy( tmp, listPtr->list, sizeof(int) * listPtr->size / 2 ); 
    12201220      free( listPtr->list ); 
    12211221      listPtr->list = tmp; 

  • mpich2/trunk/src/mpe2/src/logging/src/clog_buffer.c

    r222 r4707  
    823823 
    824824        if ( bytes ) 
    825             memcpy( cargoevt->bytes, bytes, sizeof(CLOG_Str_Bytes_t) ); 
     825            MPIU_Memcpy( cargoevt->bytes, bytes, sizeof(CLOG_Str_Bytes_t) ); 
    826826 
    827827        blkdata->ptr          = cargoevt->end; 
    … …  
    905905        commevt->rank         = comm_rank; 
    906906        commevt->wrank        = world_rank; 
    907         memcpy( commevt->gcomm, guid, CLOG_UUID_SIZE ); 
     907        MPIU_Memcpy( commevt->gcomm, guid, CLOG_UUID_SIZE ); 
    908908        blkdata->ptr          = commevt->end; 
    909909    } 

  • mpich2/trunk/src/mpe2/src/logging/src/clog_cache.c

    r100 r4707  
    449449    /* Save the CLOG record into the CLOG_BlockData_t */ 
    450450    reclen = CLOG_Rec_size( hdr->rectype ); 
    451     memcpy( blkdata->ptr, hdr, reclen ); 
     451    MPIU_Memcpy( blkdata->ptr, hdr, reclen ); 
    452452    blkdata->ptr += reclen; 
    453453} 

  • mpich2/trunk/src/mpe2/src/logging/src/clog_commset.c

    r1013 r4707  
    355355    */ 
    356356    orig_intracommIDs = &intracommIDs_val; 
    357     memcpy( orig_intracommIDs, intracommIDs, sizeof(CLOG_CommIDs_t) ); 
     357    MPIU_Memcpy( orig_intracommIDs, intracommIDs, sizeof(CLOG_CommIDs_t) ); 
    358358 
    359359    /* Set the next available table entry in CLOG_CommSet_t with intercomm */ 
    … …  
    573573 
    574574    if ( comm_world_rank == 0 ) 
    575         memcpy( recv_table, commset->table, recv_table_size ); 
     575        MPIU_Memcpy( recv_table, commset->table, recv_table_size ); 
    576576    PMPI_Bcast( recv_table, recv_table_size, MPI_CHAR, 0, MPI_COMM_WORLD ); 
    577577 
    … …  
    656656    for ( idx = 0; idx < commset->count; idx++ ) { 
    657657        commIDs = &( commset->table[idx] ); 
    658         memcpy( ptr, commIDs->global_ID, CLOG_UUID_SIZE ); 
     658        MPIU_Memcpy( ptr, commIDs->global_ID, CLOG_UUID_SIZE ); 
    659659        ptr += CLOG_UUID_SIZE; 
    660         memcpy( ptr, &(commIDs->local_ID), sizeof(CLOG_CommLID_t) ); 
     660        MPIU_Memcpy( ptr, &(commIDs->local_ID), sizeof(CLOG_CommLID_t) ); 
    661661        ptr += sizeof(CLOG_CommLID_t); 
    662         memcpy( ptr, &(commIDs->kind), sizeof(CLOG_int32_t) ); 
     662        MPIU_Memcpy( ptr, &(commIDs->kind), sizeof(CLOG_int32_t) ); 
    663663        ptr += sizeof(CLOG_int32_t); 
    664664    } 

  • mpich2/trunk/src/mpe2/src/logging/src/clog_merger.c

    r147 r4707  
    283283    /* Save the CLOG record into the sorted buffer */ 
    284284    reclen = CLOG_Rec_size( hdr->rectype ); 
    285     memcpy( sorted_blk->ptr, hdr, reclen ); 
     285    MPIU_Memcpy( sorted_blk->ptr, hdr, reclen ); 
    286286    sorted_blk->ptr += reclen; 
    287287} 

  • mpich2/trunk/src/mpe2/src/logging/src/clog_uuid.c

    r100 r4707  
    8383 
    8484    ptr  = &uuid[0]; 
    85     memcpy( ptr, &random_number, sizeof(CLOG_int32_t) ); 
     85    MPIU_Memcpy( ptr, &random_number, sizeof(CLOG_int32_t) ); 
    8686    ptr += sizeof(CLOG_int32_t); 
    87     memcpy( ptr, &time, sizeof(double) ); 
     87    MPIU_Memcpy( ptr, &time, sizeof(double) ); 
    8888    ptr += sizeof(double); 
    8989    if ( namelen < CLOG_UUID_NAME_SIZE ) { 
    90         memcpy( ptr, processor_name, namelen ); 
     90        MPIU_Memcpy( ptr, processor_name, namelen ); 
    9191        /* pad the rest of uuid with 0 */ 
    9292        ptr += namelen; 
    93         memcpy( ptr, CLOG_UUID_NULL_NAME, CLOG_UUID_NAME_SIZE-namelen ); 
     93        MPIU_Memcpy( ptr, CLOG_UUID_NULL_NAME, CLOG_UUID_NAME_SIZE-namelen ); 
    9494    } 
    9595    else /* if ( namelen >= CLOG_UUID_NAME_SIZE ) */ 
    96         memcpy( ptr, processor_name, CLOG_UUID_NAME_SIZE ); 
     96        MPIU_Memcpy( ptr, processor_name, CLOG_UUID_NAME_SIZE ); 
    9797} 
    9898 
    … …  
    109109 
    110110    ptr  = &uuid[0]; 
    111     memcpy( &random_number, ptr, sizeof(CLOG_int32_t) ); 
     111    MPIU_Memcpy( &random_number, ptr, sizeof(CLOG_int32_t) ); 
    112112    ptr += sizeof(CLOG_int32_t); 
    113     memcpy( &time, ptr, sizeof(double) ); 
     113    MPIU_Memcpy( &time, ptr, sizeof(double) ); 
    114114    ptr += sizeof(double); 
    115     memcpy( &name, ptr, CLOG_UUID_NAME_SIZE ); 
     115    MPIU_Memcpy( &name, ptr, CLOG_UUID_NAME_SIZE ); 
    116116    sprintf( str, i32fmt"-%f-%s", random_number, time, name ); 
    117117} 
    … …  
    132132void CLOG_Uuid_copy( const CLOG_Uuid_t src_uuid, CLOG_Uuid_t dest_uuid ) 
    133133{ 
    134     memcpy( dest_uuid, src_uuid, CLOG_UUID_SIZE ); 
     134    MPIU_Memcpy( dest_uuid, src_uuid, CLOG_UUID_SIZE ); 
    135135} 
    136136 

  • mpich2/trunk/src/mpe2/src/logging/src/mpe_log.c

    r3778 r4707  
    921921#endif 
    922922                vptr = (void *)( (char *) vptr + sizeof( CLOG_int16_t ) ); 
    923                 memcpy( vptr, data, count ); 
     923                MPIU_Memcpy( vptr, data, count ); 
    924924                *position += tot_sz; 
    925925                return MPE_LOG_OK; 
    … …  
    929929            tot_sz = count * 2; 
    930930            if ( *position + tot_sz <= sizeof( MPE_LOG_BYTES ) ) { 
    931                 memcpy( vptr, data, tot_sz ); 
     931                MPIU_Memcpy( vptr, data, tot_sz ); 
    932932#if !defined( WORDS_BIGENDIAN )  
    933933                CLOG_Util_swap_bytes( vptr, 2 , count ); 
    … …  
    942942            tot_sz = count * 4; 
    943943            if ( *position + tot_sz <= sizeof( MPE_LOG_BYTES ) ) { 
    944                 memcpy( vptr, data, tot_sz ); 
     944                MPIU_Memcpy( vptr, data, tot_sz ); 
    945945#if !defined( WORDS_BIGENDIAN ) 
    946946                CLOG_Util_swap_bytes( vptr, 4, count ); 
    … …  
    955955            tot_sz = count * 8; 
    956956            if ( *position + tot_sz <= sizeof( MPE_LOG_BYTES ) ) { 
    957                 memcpy( vptr, data, tot_sz ); 
     957                MPIU_Memcpy( vptr, data, tot_sz ); 
    958958#if !defined( WORDS_BIGENDIAN ) 
    959959                CLOG_Util_swap_bytes( vptr, 8, count ); 

  • mpich2/trunk/src/mpe2/src/logging/src/mpi_null.c

    r217 r4707  
    370370{ 
    371371    if ( sendbuf != recvbuf ) 
    372         memcpy( recvbuf, sendbuf, sendcnt*sendtype ); 
     372        MPIU_Memcpy( recvbuf, sendbuf, sendcnt*sendtype ); 
    373373    return MPI_SUCCESS; 
    374374} 
    … …  
    379379{ 
    380380    if ( sendbuf != recvbuf ) 
    381         memcpy( recvbuf, sendbuf, sendcnt*sendtype ); 
     381        MPIU_Memcpy( recvbuf, sendbuf, sendcnt*sendtype ); 
    382382    return MPI_SUCCESS; 
    383383} 
    … …  
    387387{ 
    388388    if ( sendbuf != recvbuf ) 
    389         memcpy( recvbuf, sendbuf, count*datatype ); 
     389        MPIU_Memcpy( recvbuf, sendbuf, count*datatype ); 
    390390    return MPI_SUCCESS; 
    391391} 
    … …  
    395395{ 
    396396    if ( sendbuf != recvbuf ) 
    397         memcpy( recvbuf, sendbuf, count*datatype ); 
    398     return MPI_SUCCESS; 
    399 } 
     397        MPIU_Memcpy( recvbuf, sendbuf, count*datatype ); 
     398    return MPI_SUCCESS; 
     399} 

  • mpich2/trunk/src/mpe2/src/slog2sdk/trace_rlog/src/rlogutil.c

    r3456 r4707  
    613613    if (pInput == NULL) 
    614614        return -1; 
    615     memcpy(pHeader, &pInput->header, sizeof(RLOG_FILE_HEADER)); 
     615    MPIU_Memcpy(pHeader, &pInput->header, sizeof(RLOG_FILE_HEADER)); 
    616616    return 0; 
    617617} 

  • mpich2/trunk/src/mpe2/src/slog2sdk/trace_rlog/src/trace_input.c

    r3456 r4707  
    4545        return RLOG_FALSE; 
    4646    *length = strlen(str); 
    47     memcpy(&base[*pos], str, *length); 
     47    MPIU_Memcpy(&base[*pos], str, *length); 
    4848    *pos += *length; 
    4949    return RLOG_TRUE; 

  • mpich2/trunk/src/mpe2/src/slog2sdk/trace_sample/src/trace_impl.c

    r100 r4707  
    651651            if ( *legend_pos >= legend_max ) 
    652652                return 21; 
    653             memcpy( &(legend_base[ *legend_pos ]), type->legend, 
     653            MPIU_Memcpy( &(legend_base[ *legend_pos ]), type->legend, 
    654654                    sizeof( char ) * legend_len ); 
    655655            *num_legend  = legend_len; 
    … …  
    665665            if ( *label_pos >= label_max ) 
    666666                return 23; 
    667             memcpy( &(label_base[ *label_pos ]), type->label, 
     667            MPIU_Memcpy( &(label_base[ *label_pos ]), type->label, 
    668668                    sizeof( char ) * label_len ); 
    669669            *num_label  = label_len; 
    … …  
    677677        if ( *method_pos >= method_max ) 
    678678            return 25; 
    679         memcpy( &(method_base[ *method_pos ]), type->methods, 
     679        MPIU_Memcpy( &(method_base[ *method_pos ]), type->methods, 
    680680                sizeof( int ) * type->num_methods ); 
    681681        *num_methods = type->num_methods; 
    … …  
    844844    if ( *coordmap_pos >= coordmap_max ) 
    845845        return 63; 
    846     memcpy( &(coordmap_base[ *coordmap_pos ]), ymap->elems, 
     846    MPIU_Memcpy( &(coordmap_base[ *coordmap_pos ]), ymap->elems, 
    847847            sizeof( int ) * ymap->num_rows * ymap->num_columns ); 
    848848    *coordmap_sz   = ymap->num_rows * ymap->num_columns; 
    … …  
    854854        if ( *method_pos >= method_max ) 
    855855            return 65; 
    856         memcpy( &(method_base[ *method_pos ]), ymap->methods, 
     856        MPIU_Memcpy( &(method_base[ *method_pos ]), ymap->methods, 
    857857                sizeof( int ) * ymap->num_methods ); 
    858858        *num_methods = ymap->num_methods; 
    … …  
    974974        prime->num_info  = *num_bytes; 
    975975        prime->info      = (char *) malloc( prime->num_info * sizeof(char) ); 
    976         memcpy( prime->info, infovals, prime->num_info ); 
     976        MPIU_Memcpy( prime->info, infovals, prime->num_info ); 
    977977#if ! defined( WORDS_BIGENDIAN ) 
    978978        bswp_byteswap( 2, sizeof( int ), prime->info ); 
    … …  
    10161016        if ( *byte_pos >= byte_max ) 
    10171017            return 31; 
    1018         memcpy( &(byte_base[ *byte_pos ]), prime->info, 
     1018        MPIU_Memcpy( &(byte_base[ *byte_pos ]), prime->info, 
    10191019                sizeof( char ) * prime->num_info ); 
    10201020        *num_bytes = prime->num_info; 
    … …  
    10261026    if ( *tcoord_pos >= tcoord_max ) 
    10271027        return 33; 
    1028     memcpy( &(tcoord_base[ *tcoord_pos ]), prime->tcoords, 
     1028    MPIU_Memcpy( &(tcoord_base[ *tcoord_pos ]), prime->tcoords, 
    10291029            sizeof( double ) * prime->num_tcoords ); 
    10301030    *num_tcoords = prime->num_tcoords; 
    … …  
    10351035    if ( *ycoord_pos >= ycoord_max ) 
    10361036        return 35; 
    1037     memcpy( &(ycoord_base[ *ycoord_pos ]), prime->ycoords, 
     1037    MPIU_Memcpy( &(ycoord_base[ *ycoord_pos ]), prime->ycoords, 
    10381038            sizeof( int ) * prime->num_ycoords ); 
    10391039    *num_ycoords = prime->num_ycoords; 
    … …  
    11191119        cmplx->num_info  = *num_bytes; 
    11201120        cmplx->info      = (char *) malloc( cmplx->num_info * sizeof(char) ); 
    1121         memcpy( cmplx->info, infovals, cmplx->num_info ); 
     1121        MPIU_Memcpy( cmplx->info, infovals, cmplx->num_info ); 
    11221122#if ! defined( WORDS_BIGENDIAN ) 
    11231123        bswp_byteswap( 2, sizeof( int ), cmplx->info ); 
    … …  
    11641164        if ( *byte_pos >= byte_max ) 
    11651165            return 41; 
    1166         memcpy( &(byte_base[ *byte_pos ]), cmplx->info, 
     1166        MPIU_Memcpy( &(byte_base[ *byte_pos ]), cmplx->info, 
    11671167                sizeof( char ) * cmplx->num_info ); 
    11681168        *num_bytes = cmplx->num_info; 

  • mpich2/trunk/src/mpe2/src/unused/include/mpe_log_genproc.h

    r100 r4707  
    9595    b->len      += v->len;\ 
    9696    v->dtype    = MPE_Log_INT;\ 
    97     memcpy(v->other,i,n*sizeof(int) ); \ 
     97    MPIU_Memcpy(v->other,i,n*sizeof(int) ); \ 
    9898    MPE_Log_i   += v->len;  } 
    9999 
    … …  
    106106    b->len      += v->len;\ 
    107107    v->dtype    = MPE_Log_CHAR;\ 
    108     memcpy( v->other, str, ln );\ 
     108    MPIU_Memcpy( v->other, str, ln );\ 
    109109    MPE_Log_i   += v->len;} 
    110110 
    … …  
    127127                                /* go to after the block header */ \ 
    128128  } \ 
    129   memcpy (newRecHdr, readRecHdr, readRecHdr->len*sizeof(int)); \ 
     129  MPIU_Memcpy (newRecHdr, readRecHdr, readRecHdr->len*sizeof(int)); \ 
    130130                                /* copy record */ \ 
    131131  newLogBlk->size += readRecHdr->len; /* update block length */ \ 

  • mpich2/trunk/src/mpe2/src/unused/src/mpe_log_genproc.c

    r100 r4707  
    3131 
    3232/* need to put doubles at non-aligned locations */ 
    33 #define MOVEDBL( dest, src ) {memcpy( dest, src, sizeof( double ) );} 
     33#define MOVEDBL( dest, src ) {MPIU_Memcpy( dest, src, sizeof( double ) );} 
    3434 
    3535MPE_Log_BLOCK *MPE_Log_GetBuf (void) 

  • mpich2/trunk/src/mpe2/src/unused/src/mpe_log_merge.c

    r100 r4707  
    148148#endif 
    149149    } 
    150     memcpy( outBuffer->p, inBuffer->p, recLen*sizeof(int) ); 
     150    MPIU_Memcpy( outBuffer->p, inBuffer->p, recLen*sizeof(int) ); 
    151151      /* copy data from inBuffer to outBuffer */ 
    152152    outBuffer->p += recLen; 
    … …  
    155155                                 /* Repack the buffer */ 
    156156    if (recHdr->event != MPE_Log_EVENT_SYNC) { 
    157       memcpy( recordBuf, inBuffer->p, sizeof(MPE_Log_HEADER) ); 
     157      MPIU_Memcpy( recordBuf, inBuffer->p, sizeof(MPE_Log_HEADER) ); 
    158158        /* copy header to temp area */ 
    159159      ((MPE_Log_HEADER *)recordBuf)->len--; 
    160160        /* cut out the procid that was inserted */ 
    161       memcpy( recordBuf + MPE_Log_HEADERSIZE, inBuffer->p + 
     161      MPIU_Memcpy( recordBuf + MPE_Log_HEADERSIZE, inBuffer->p + 
    162162             MPE_Log_HEADERSIZE + 1, 
    163163             (recHdr->len - MPE_Log_HEADERSIZE) * sizeof(int) ); 
    … …  
    292292        /* Reserved header events have all times set to zero */ 
    293293        MPE_Log_ZEROTIME(readHdr); 
    294       memcpy( writePtr, readPtr, sizeof(MPE_Log_HEADER) ); 
     294      MPIU_Memcpy( writePtr, readPtr, sizeof(MPE_Log_HEADER) ); 
    295295                                 /* copy header */ 
    296296      ((MPE_Log_HEADER *)writePtr)->len = readHdr->len + 1; 
    … …  
    298298      writePtr[MPE_Log_HEADERSIZE] = MPE_Log_procid; 
    299299                                 /* insert procid */ 
    300       memcpy( writePtr + MPE_Log_HEADERSIZE + 1, readPtr + MPE_Log_HEADERSIZE,  
     300      MPIU_Memcpy( writePtr + MPE_Log_HEADERSIZE + 1, readPtr + MPE_Log_HEADERSIZE,  
    301301             (readHdr->len - MPE_Log_HEADERSIZE) * sizeof(int) ); 
    302302                                /* copy all the fields */ 

  • mpich2/trunk/src/mpe2/src/wrappers/src/mpe_proff.c

    r4667 r4707  
    185185#endif 
    186186#ifndef HAVE_MPI_STATUS_F2C 
    187 #define MPI_Status_f2c(f_status,c_status) memcpy(c_status,f_status,sizeof(MPI_Status)) 
    188 #define MPI_Status_c2f(c_status,f_status) memcpy(f_status,c_status,sizeof(MPI_Status)) 
     187#define MPI_Status_f2c(f_status,c_status) MPIU_Memcpy(c_status,f_status,sizeof(MPI_Status)) 
     188#define MPI_Status_c2f(c_status,f_status) MPIU_Memcpy(f_status,c_status,sizeof(MPI_Status)) 
    189189#endif 
    190190 

  • mpich2/trunk/src/mpi/coll/helper_fns.c

    r4228 r4707  
    225225    if (sendtype_iscontig && recvtype_iscontig) 
    226226    {     
    227         memcpy(((char *) recvbuf + recvtype_true_lb),  
     227        MPIU_Memcpy(((char *) recvbuf + recvtype_true_lb),  
    228228               ((char *) sendbuf + sendtype_true_lb),  
    229229               copy_sz); 

  • mpich2/trunk/src/mpi/comm/commutil.c

    r4060 r4707  
    508508        MPIR_Init_contextid(); 
    509509    } 
    510     memcpy( local_mask, context_mask, MPIR_MAX_CONTEXT_MASK * sizeof(int) ); 
     510    MPIU_Memcpy( local_mask, context_mask, MPIR_MAX_CONTEXT_MASK * sizeof(int) ); 
    511511 
    512512    /* Note that this is the unthreaded version */ 
    … …  
    597597        } 
    598598        else { 
    599             memcpy( local_mask, context_mask, MPIR_MAX_CONTEXT_MASK * sizeof(int) ); 
     599            MPIU_Memcpy( local_mask, context_mask, MPIR_MAX_CONTEXT_MASK * sizeof(int) ); 
    600600            mask_in_use     = 1; 
    601601            own_mask        = 1; 

  • mpich2/trunk/src/mpi/debugger/tvtest.c

    r3032 r4707  
    320320                             void *data ) 
    321321{ 
    322     memcpy( data, (void *)addr, (size_t) asize ); 
     322    MPIU_Memcpy( data, (void *)addr, (size_t) asize ); 
    323323    return mqs_ok; 
    324324} 
    … …  
    327327                                  void *out_data, int asize ) 
    328328{ 
    329     memcpy( out_data, in_data, asize ); 
     329    MPIU_Memcpy( out_data, in_data, asize ); 
    330330} 
    331331 

  • mpich2/trunk/src/mpi/errhan/errutil.c

    r4674 r4707  
    976976        if (len) 
    977977        { 
    978             memcpy(str, begin, len); 
     978            MPIU_Memcpy(str, begin, len); 
    979979            str += len; 
    980980            maxlen -= len; 

  • mpich2/trunk/src/mpi/pt2pt/bsendutil.c

    r4628 r4707  
    218218 
    219219       We may want to decide here whether we need to pack at all  
    220        or if we can just use (a memcpy) of the buffer. 
     220       or if we can just use (a MPIU_Memcpy) of the buffer. 
    221221    */ 
    222222 
    … …  
    257257            /* We may want to optimize for the special case of 
    258258               either primative or contiguous types, and just 
    259                use memcpy and the provided datatype */ 
     259               use MPIU_Memcpy and the provided datatype */ 
    260260            msg->count = 0; 
    261261            if (dtype != MPI_PACKED) 
    … …  
    266266            else 
    267267            { 
    268                 memcpy(p->msg.msgbuf, buf, count); 
     268                MPIU_Memcpy(p->msg.msgbuf, buf, count); 
    269269                p->msg.count = count; 
    270270            } 

  • mpich2/trunk/src/mpid/ch3/channels/nemesis/nemesis/include/mpid_nem_impl.h

    r4367 r4707  
    1414#include "mpid_nem_atomics.h" 
    1515#include "mpid_nem_defs.h" 
    16 #include "mpid_nem_memdefs.h" 
    1716#include "mpid_nem_fbox.h" 
    1817#include "mpid_nem_nets.h" 

  • mpich2/trunk/src/mpid/ch3/channels/nemesis/nemesis/include/mpid_nem_inline.h

    r4515 r4707  
    159159    } 
    160160#else /*1 */ 
    161     MPID_NEM_MEMCPY (el->pkt.mpich2.payload, buf, size); 
     161    MPIU_Memcpy (el->pkt.mpich2.payload, buf, size); 
    162162#endif /*1 */ 
    163163    DO_PAPI (PAPI_accum_var (PAPI_EventSet, PAPI_vvalues11)); 
    … …  
    273273    { 
    274274        int _iov_len = (*iov)->MPID_IOV_LEN; 
    275         MPID_NEM_MEMCPY (cell_buf, (*iov)->MPID_IOV_BUF, _iov_len); 
     275        MPIU_Memcpy (cell_buf, (*iov)->MPID_IOV_BUF, _iov_len); 
    276276        payload_len -= _iov_len; 
    277277        cell_buf += _iov_len; 
    … …  
    282282    if (*n_iov && payload_len > 0) 
    283283    { 
    284         MPID_NEM_MEMCPY (cell_buf, (*iov)->MPID_IOV_BUF, payload_len); 
     284        MPIU_Memcpy (cell_buf, (*iov)->MPID_IOV_BUF, payload_len); 
    285285        (*iov)->MPID_IOV_BUF = (char *)(*iov)->MPID_IOV_BUF + payload_len; 
    286286        (*iov)->MPID_IOV_LEN -= payload_len; 
    … …  
    396396                payload_32[9] = buf_32[9]; 
    397397            } 
    398             MPID_NEM_MEMCPY ((char *)pbox->cell.pkt.mpich2.payload +sizeof(MPIDI_CH3_Pkt_t), (*iov)[1].MPID_IOV_BUF, (*iov)[1].MPID_IOV_LEN); 
     398            MPIU_Memcpy ((char *)pbox->cell.pkt.mpich2.payload +sizeof(MPIDI_CH3_Pkt_t), (*iov)[1].MPID_IOV_BUF, (*iov)[1].MPID_IOV_LEN); 
    399399            OPA_write_barrier(); 
    400400            pbox->flag.value = 1; 
    … …  
    456456    { 
    457457        int _iov_len = (*iov)->MPID_IOV_LEN; 
    458         MPID_NEM_MEMCPY (cell_buf, (*iov)->MPID_IOV_BUF, _iov_len); 
     458        MPIU_Memcpy (cell_buf, (*iov)->MPID_IOV_BUF, _iov_len); 
    459459        payload_len -= _iov_len; 
    460460        cell_buf += _iov_len; 
    … …  
    465465    if (*n_iov && payload_len > 0) 
    466466    { 
    467         MPID_NEM_MEMCPY (cell_buf, (*iov)->MPID_IOV_BUF, payload_len); 
     467        MPIU_Memcpy (cell_buf, (*iov)->MPID_IOV_BUF, payload_len); 
    468468        (*iov)->MPID_IOV_BUF = (char *)(*iov)->MPID_IOV_BUF + payload_len; 
    469469        (*iov)->MPID_IOV_LEN -= payload_len; 
    … …  
    576576 
    577577            /* copy header */ 
    578             MPID_NEM_MEMCPY((char *)pbox->cell.pkt.mpich2.payload, header, header_sz); 
     578            MPIU_Memcpy((char *)pbox->cell.pkt.mpich2.payload, header, header_sz); 
    579579 
    580580            /* copy data */ 
    … …  
    622622 
    623623    /* copy header */ 
    624     MPID_NEM_MEMCPY(el->pkt.mpich2.payload, header, header_sz); 
     624    MPIU_Memcpy(el->pkt.mpich2.payload, header, header_sz); 
    625625     
    626626    /* copy data */ 

  • mpich2/trunk/src/mpid/ch3/channels/nemesis/nemesis/include/mpid_nem_memdefs.h

    r2927 r4707  
    1111 
    1212#if defined(HAVE_GCC_AND_PENTIUM_ASM) 
    13 #define asm_memcpy(dst, src, n) ({                                                      \ 
    14             const char *p = (char *)(src);                                              \ 
    15             char *q = (char *)(dst);                                                    \ 
    16             size_t nl = (size_t)(n) >> 2;                                               \ 
    17             __asm__ __volatile__ ("cld ; rep ; movsl ; movl %3,%0 ; rep ; movsb"        \ 
    18                                   : "+c" (nl), "+S" (p), "+D" (q)                       \ 
    19                                   : "r" (n & 3) /* : "memory" is this needed?*/);       \ 
    20             (void *)(dst);                                                              \ 
    21         }) 
     13#define asm_memcpy(dst, src, n) do {                                                    \ 
     14        const char *_p = (char *)(src);                                                 \ 
     15        char *_q = (char *)(dst);                                                       \ 
     16        size_t _nl = (size_t)(n) >> 2;                                                  \ 
     17        __asm__ __volatile__ ("cld ; rep ; movsl ; movl %3,%0 ; rep ; movsb"            \ 
     18                              : "+c" (_nl), "+S" (_p), "+D" (_q)                        \ 
     19                              : "r" ((n) & 3) /* : "memory" is this needed?*/);         \ 
     20    } while (0) 
    2221 
    2322/* 
    … …  
    4948 */ 
    5049 
    51 static inline void *nt_memcpy (volatile void *dst, volatile void *src, size_t len) 
     50static inline void nt_memcpy (volatile void *dst, volatile const void *src, size_t len) 
    5251{ 
    53     void *orig_dst = (void *)dst; 
    5452    void *dummy_dst; 
    5553    void *dummy_src; 
    … …  
    193191    n = len & (128 - 1); 
    194192    if (n) 
    195         asm_memcpy (dst, src, n); 
    196      
    197     return orig_dst; 
     193        asm_memcpy (dst, src, n);     
    198194} 
    199195 
    200196#define MPID_NEM_MEMCPY_CROSSOVER (63*1024) 
    201197 
    202 #define MPID_NEM_MEMCPY(a,b,c)  ((((c)) >= MPID_NEM_MEMCPY_CROSSOVER)   \ 
    203                                  ? nt_memcpy (a, b, c)                  \ 
    204                                  : asm_memcpy (a, b, c)) 
     198#define MPIU_Memcpy(a,b,c)  do {                                                                \ 
     199        if (((c)) >= MPID_NEM_MEMCPY_CROSSOVER)                                                 \ 
     200            nt_memcpy (a, b, c);                                                                \ 
     201        else                                                                                    \ 
     202            asm_memcpy (a, b, c);                                                               \ 
     203    } while (0) 
    205204 
    206205#elif 0 && defined(HAVE_GCC_AND_X86_64_ASM) 
    207206 
    208 #define asm_memcpy(dst, src, n) ({                                                              \ 
    209             const char *p = (char *)(src);                                                      \ 
    210             char *q = (char *)(dst);                                                            \ 
    211             size_t nq = n >> 3;                                                                 \ 
    212             __asm__ __volatile__ ("cld ; rep ; movsq ; movl %3,%%ecx ; rep ; movsb"             \ 
    213                                   : "+c" (nq), "+S" (p), "+D" (q)                               \ 
    214                                   : "r" ((uint32_t)(n & 7)) /* : "memory" is this needed? */);  \ 
    215             (void *)(dst);                                                                      \ 
    216         }) 
    217  
    218 static inline void amd64_cpy_nt (volatile void *dst, volatile void *src, size_t n) 
     207#define asm_memcpy(dst, src, n)  do {                                                            \ 
     208        const char *_p = (char *)(src);                                                          \ 
     209        char *_q = (char *)(dst);                                                                \ 
     210        size_t _nq = n >> 3;                                                                     \ 
     211        __asm__ __volatile__ ("cld ; rep ; movsq ; movl %3,%%ecx ; rep ; movsb"                  \ 
     212                              : "+c" (_nq), "+S" (_p), "+D" (_q)                                 \ 
     213                              : "r" ((uint32_t)((n) & 7)) /* : "memory" is this needed? */);     \ 
     214    } while (0) 
     215 
     216static inline void amd64_cpy_nt (volatile void *dst, const volatile void *src, size_t n) 
    219217{ 
    220218    size_t n32 = (n) >> 5; 
    … …  
    250248 
    251249static inline 
    252 void *volatile_memcpy (volatile void *dst, volatile void *src, size_t n) 
     250void volatile_memcpy (volatile void *restrict dst, volatile const void *restrict src, size_t n) 
    253251{ 
    254     return memcpy ((void *)dst, (void *)src, n); 
     252    MPIUI_Memcpy ((void *)dst, (const void *)src, n); 
    255253} 
    256254 
    257255#define MPID_NEM_MEMCPY_CROSSOVER (32*1024) 
    258 #define MPID_NEM_MEMCPY(a,b,c) (((c) >= MPID_NEM_MEMCPY_CROSSOVER) ? amd64_cpy_nt(a, b, c) : volatile_memcpy(a, b, c)) 
     256#define MPIU_Memcpy(a,b,c) do {                 \ 
     257        if ((c) >= MPID_NEM_MEMCPY_CROSSOVER)   \ 
     258            amd64_cpy_nt(a, b, c);              \ 
     259        else                                    \ 
     260            volatile_memcpy(a, b, c);           \ 
     261    } while (0) 
    259262/* #define MPID_NEM_MEMCPY(a,b,c) (((c) < MPID_NEM_MEMCPY_CROSSOVER) ? memcpy(a, b, c) : amd64_cpy_nt(a, b, c)) */ 
    260263/* #define MPID_NEM_MEMCPY(a,b,c) amd64_cpy_nt(a, b, c) */ 
    … …  
    262265 
    263266#else 
    264 #define MPID_NEM_MEMCPY(dst, src, n) do { volatile void *d = (dst); volatile void *s = (src); memcpy((void *)d, (void *)s, n); }while (0) 
     267#define MPIU_Memcpy(dst, src, n) do { volatile void * restrict d = (dst); volatile const void *restrict s = (src); MPIUI_Memcpy((void *)d, (const void *)s, n); }while (0) 
    265268#endif 
    266269 

  • mpich2/trunk/src/mpid/ch3/channels/nemesis/nemesis/include/mpid_nem_pre.h

    r100 r4707  
    1111#include "mpidi_ch3i_nemesis_conf.h" 
    1212#include "mpid_nem_defs.h" 
     13#include "mpid_nem_memdefs.h" 
    1314 
    1415 

  • mpich2/trunk/src/mpid/ch3/channels/nemesis/nemesis/netmod/gm/gm_lmt.c

    r4538 r4707  
    8080        goto error_exit; 
    8181    } 
    82     MPID_NEM_MEMCPY (iov_copy, iov, sizeof (struct iovec) * n_iov); 
     82    MPIU_Memcpy (iov_copy, iov, sizeof (struct iovec) * n_iov); 
    8383    cookie->iov_base = iov_copy; 
    8484    cookie->iov_len = sizeof (struct iovec) * n_iov; 

  • mpich2/trunk/src/mpid/ch3/channels/nemesis/nemesis/netmod/ib/ib_cm.c

    r3763 r4707  
    3131    memset(&list, 0, sizeof(struct ibv_sge)); 
    3232 
    33     memcpy((void *) ((char *) 
     33    MPIU_Memcpy((void *) ((char *) 
    3434                MPID_nem_ib_cm_ctxt_ptr->cm_send_buf + 
    3535                MPID_nem_ib_cm_param_ptr->ud_overhead), 
    … …  
    104104    memset(&init_attr, 0, sizeof(init_attr)); 
    105105 
    106     memcpy(&init_attr, &(MPID_nem_ib_cm_ctxt_ptr->rc_qp_init_attr), 
     106    MPIU_Memcpy(&init_attr, &(MPID_nem_ib_cm_ctxt_ptr->rc_qp_init_attr), 
    107107            sizeof(struct ibv_qp_init_attr)); 
    108108 
    … …  
    124124    memset(&attr, 0, sizeof(attr)); 
    125125 
    126     memcpy(&attr, &(MPID_nem_ib_cm_ctxt_ptr->rc_qp_attr_to_init), 
     126    MPIU_Memcpy(&attr, &(MPID_nem_ib_cm_ctxt_ptr->rc_qp_attr_to_init), 
    127127            sizeof(struct ibv_qp_attr)); 
    128128 
    … …  
    158158    memset(&attr, 0, sizeof(attr)); 
    159159 
    160     memcpy(&attr, &MPID_nem_ib_cm_ctxt_ptr->rc_qp_attr_to_rtr, 
     160    MPIU_Memcpy(&attr, &MPID_nem_ib_cm_ctxt_ptr->rc_qp_attr_to_rtr, 
    161161            sizeof(struct ibv_qp_attr)); 
    162162 
    … …  
    191191    memset(&attr, 0, sizeof(attr)); 
    192192 
    193     memcpy(&attr, &MPID_nem_ib_cm_ctxt_ptr->rc_qp_attr_to_rts, 
     193    MPIU_Memcpy(&attr, &MPID_nem_ib_cm_ctxt_ptr->rc_qp_attr_to_rts, 
    194194            sizeof(struct ibv_qp_attr)); 
    195195 
    … …  
    293293    pending->packet = MPIU_Malloc(sizeof(MPID_nem_ib_cm_packet_t)); 
    294294 
    295     memcpy(&(pending->packet->payload), msg, sizeof(MPID_nem_ib_cm_msg_t)); 
     295    MPIU_Memcpy(&(pending->packet->payload), msg, sizeof(MPID_nem_ib_cm_msg_t)); 
    296296 
    297297fn_exit: 

  • mpich2/trunk/src/mpid/ch3/channels/nemesis/nemesis/netmod/mx/mx_poll.c

    r4515 r4707  
    100100      remote_nic_id = *((uint64_t *)data); 
    101101      remote_endpoint_id = *((uint32_t *)((char *)data+sizeof(uint64_t))); 
    102       memcpy(pg_id,(char *)data+sizeof(uint64_t)+sizeof(uint32_t),length-sizeof(uint64_t)-sizeof(uint32_t)); 
     102      MPIU_Memcpy(pg_id,(char *)data+sizeof(uint64_t)+sizeof(uint32_t),length-sizeof(uint64_t)-sizeof(uint32_t)); 
    103103       
    104104      MPIDI_PG_Find (pg_id, &pg); 
    … …  
    171171        remote_nic_id = *((uint64_t *)data); 
    172172        remote_endpoint_id = *((uint32_t *)((char *)data+sizeof(uint64_t))); 
    173         memcpy(pg_id,(char *)data+sizeof(uint64_t)+sizeof(uint32_t),length-sizeof(uint64_t)-sizeof(uint32_t));    
     173        MPIU_Memcpy(pg_id,(char *)data+sizeof(uint64_t)+sizeof(uint32_t),length-sizeof(uint64_t)-sizeof(uint32_t));    
    174174         
    175175        fprintf(stdout,"[%i]=== NOT NULL VC : Receiver Unex Got infos from  Sender (in data) ..%li %i %s vc is %p\n",  

  • mpich2/trunk/src/mpid/ch3/channels/nemesis/nemesis/netmod/mx/mx_send.c

    r4062 r4707  
    3737 
    3838    NEM_MX_ADI_MATCH(match_info);  
    39     memcpy(&(sreq->dev.pending_pkt),(char *)hdr,sizeof(MPIDI_CH3_PktGeneric_t)); 
     39    MPIU_Memcpy(&(sreq->dev.pending_pkt),(char *)hdr,sizeof(MPIDI_CH3_PktGeneric_t)); 
    4040    mx_iov[0].segment_ptr     = (char *)&(sreq->dev.pending_pkt); 
    4141    mx_iov[0].segment_length  = sizeof(MPIDI_CH3_PktGeneric_t); 
    … …  
    9696    /*fprintf(stdout,"[%i]=== Startcontigmsg  sending  (%lx) to %i... \n",MPID_nem_mem_region.rank,match_info,vc->lpid); */ 
    9797     
    98     memcpy(&(sreq->dev.pending_pkt),(char *)hdr,sizeof(MPIDI_CH3_PktGeneric_t)); 
     98    MPIU_Memcpy(&(sreq->dev.pending_pkt),(char *)hdr,sizeof(MPIDI_CH3_PktGeneric_t)); 
    9999    mx_iov[0].segment_ptr     = (char *)&(sreq->dev.pending_pkt); 
    100100    mx_iov[0].segment_length  = sizeof(MPIDI_CH3_PktGeneric_t);     
    … …  
    153153 
    154154    NEM_MX_ADI_MATCH(match_info);  
    155     memcpy(&(sreq->dev.pending_pkt),(char *)header,sizeof(MPIDI_CH3_PktGeneric_t)); 
     155    MPIU_Memcpy(&(sreq->dev.pending_pkt),(char *)header,sizeof(MPIDI_CH3_PktGeneric_t)); 
    156156    mx_iov[0].segment_ptr     = (char *)&(sreq->dev.pending_pkt); 
    157157    mx_iov[0].segment_length  = sizeof(MPIDI_CH3_PktGeneric_t); 
    … …  
    452452        for(index = last_entry; index < n_iov; index++) 
    453453        { 
    454             memcpy((char *)(sreq->dev.tmpbuf) + offset, iov[index].MPID_IOV_BUF, iov[index].MPID_IOV_LEN); 
     454            MPIU_Memcpy((char *)(sreq->dev.tmpbuf) + offset, iov[index].MPID_IOV_BUF, iov[index].MPID_IOV_LEN); 
    455455            offset += iov[index].MPID_IOV_LEN;       
    456456        }            

  • mpich2/trunk/src/mpid/ch3/channels/nemesis/nemesis/netmod/newmad/newmad_send.c

    r4225 r4707  
    3030    fprintf(stdout,"iSendContig ========> Sending ADI msg  for req %p (match is %lx) \n",sreq,match_info); 
    3131 
    32     memcpy(&(sreq->dev.pending_pkt),(char *)hdr,sizeof(MPIDI_CH3_PktGeneric_t)); 
     32    MPIU_Memcpy(&(sreq->dev.pending_pkt),(char *)hdr,sizeof(MPIDI_CH3_PktGeneric_t)); 
    3333    mad_iov[0].iov_base = (char *)&(sreq->dev.pending_pkt); 
    3434    mad_iov[0].iov_len  = sizeof(MPIDI_CH3_PktGeneric_t); 
    … …  
    8282#endif 
    8383 
    84     memcpy(&(sreq->dev.pending_pkt),(char *)hdr,sizeof(MPIDI_CH3_PktGeneric_t)); 
     84    MPIU_Memcpy(&(sreq->dev.pending_pkt),(char *)hdr,sizeof(MPIDI_CH3_PktGeneric_t)); 
    8585    mad_iov[0].iov_base = (char *)&(sreq->dev.pending_pkt); 
    8686    mad_iov[0].iov_len  = sizeof(MPIDI_CH3_PktGeneric_t); 
    … …  
    139139    fprintf(stdout,"SendNonContig ========> Sending ADI msg  for req %p (match is %lx) \n",sreq,match_info); 
    140140#endif 
    141     memcpy(&(sreq->dev.pending_pkt),(char *)header,sizeof(MPIDI_CH3_PktGeneric_t)); 
     141    MPIU_Memcpy(&(sreq->dev.pending_pkt),(char *)header,sizeof(MPIDI_CH3_PktGeneric_t)); 
    142142    mad_iov[0].iov_base = (char *)&(sreq->dev.pending_pkt); 
    143143    mad_iov[0].iov_len  = sizeof(MPIDI_CH3_PktGeneric_t); 
    … …  
    363363        for(index = last_entry; index < n_iov; index++) 
    364364        { 
    365             memcpy((char *)(sreq->dev.tmpbuf) + offset, iov[index].MPID_IOV_BUF, iov[index].MPID_IOV_LEN); 
     365            MPIU_Memcpy((char *)(sreq->dev.tmpbuf) + offset, iov[index].MPID_IOV_BUF, iov[index].MPID_IOV_LEN); 
    366366            offset += iov[index].MPID_IOV_LEN; 
    367367        } 

  • mpich2/trunk/src/mpid/ch3/channels/nemesis/nemesis/netmod/psm/psm_init.c

    r3763 r4707  
    496496/*         } */ 
    497497 
    498 /*         memcpy(uuid_val, MPID_nem_module_psm_uuid, size-1); */ 
    499 /*         memcpy(uuid_val+size, &zero, 1); */ 
     498/*         MPIU_Memcpy(uuid_val, MPID_nem_module_psm_uuid, size-1); */ 
     499/*         MPIU_Memcpy(uuid_val+size, &zero, 1); */ 
    500500 
    501501/*         for(index = 0;index<size-1;index++) */ 

  • mpich2/trunk/src/mpid/ch3/channels/nemesis/nemesis/netmod/tcp/socksm.c

    r4704 r4707  
    159159 
    160160    MPIU_Assert(0 == index); /* assumed in other parts of this file */ 
    161     MPID_NEM_MEMCPY (&g_sc_tbl[index], &MPID_nem_tcp_g_lstn_sc, sizeof(MPID_nem_tcp_g_lstn_sc)); 
    162     MPID_NEM_MEMCPY (&MPID_nem_tcp_plfd_tbl[index], &MPID_nem_tcp_g_lstn_plfd, sizeof(MPID_nem_tcp_g_lstn_plfd)); 
     161    MPIU_Memcpy (&g_sc_tbl[index], &MPID_nem_tcp_g_lstn_sc, sizeof(MPID_nem_tcp_g_lstn_sc)); 
     162    MPIU_Memcpy (&MPID_nem_tcp_plfd_tbl[index], &MPID_nem_tcp_g_lstn_plfd, sizeof(MPID_nem_tcp_g_lstn_plfd)); 
    163163    MPIU_Assert(MPID_nem_tcp_plfd_tbl[index].fd == g_sc_tbl[index].fd); 
    164164    MPIU_Assert(MPID_nem_tcp_plfd_tbl[index].events == POLLIN); 
    … …  
    211211                         mpi_errno, "expanded pollfd table"); 
    212212 
    213     MPID_NEM_MEMCPY (new_sc_tbl, g_sc_tbl, g_tbl_capacity * sizeof(sockconn_t)); 
    214     MPID_NEM_MEMCPY (new_plfd_tbl, MPID_nem_tcp_plfd_tbl, g_tbl_capacity * sizeof(struct pollfd)); 
     213    MPIU_Memcpy (new_sc_tbl, g_sc_tbl, g_tbl_capacity * sizeof(sockconn_t)); 
     214    MPIU_Memcpy (new_plfd_tbl, MPID_nem_tcp_plfd_tbl, g_tbl_capacity * sizeof(struct pollfd)); 
    215215 
    216216    /* VCs have pointers to entries in the sc table.  These 

  • mpich2/trunk/src/mpid/ch3/channels/nemesis/nemesis/netmod/tcp/tcp_getip.c

    r4096 r4707  
    179179                    myifaddr.type = AF_INET; 
    180180                    myifaddr.len  = 4; 
    181                     memcpy( myifaddr.ifaddr, &addr.s_addr, 4 ); 
     181                    MPIU_Memcpy( myifaddr.ifaddr, &addr.s_addr, 4 ); 
    182182                } 
    183183            } 
    … …  
    186186                myifaddr.type = AF_INET; 
    187187                myifaddr.len  = 4; 
    188                 memcpy( myifaddr.ifaddr, &addr.s_addr, 4 ); 
     188                MPIU_Memcpy( myifaddr.ifaddr, &addr.s_addr, 4 ); 
    189189            } 
    190190        } 

  • mpich2/trunk/src/mpid/ch3/channels/nemesis/nemesis/netmod/tcp/tcp_init.c

    r4530 r4707  
    175175            } 
    176176            else 
    177                 memcpy( ifaddr->ifaddr, info->h_addr_list[0], ifaddr->len ); 
     177                MPIU_Memcpy( ifaddr->ifaddr, info->h_addr_list[0], ifaddr->len ); 
    178178        } 
    179179    } 

  • mpich2/trunk/src/mpid/ch3/channels/nemesis/nemesis/netmod/wintcp/socksm.c

    r4530 r4707  
    128128 
    129129    MPIU_Assert(0 == index); /* assumed in other parts of this file */ 
    130     MPID_NEM_MEMCPY (&g_sc_tbl[index], &MPID_nem_newtcp_module_g_lstn_sc, sizeof(MPID_nem_newtcp_module_g_lstn_sc)); 
     130    MPIU_Memcpy (&g_sc_tbl[index], &MPID_nem_newtcp_module_g_lstn_sc, sizeof(MPID_nem_newtcp_module_g_lstn_sc)); 
    131131 
    132132    mpi_errno = MPIU_SOCKW_Waitset_add_sock(MPID_nem_newtcp_module_waitset_hnd, 
    … …  
    185185                         mpi_errno, "expanded connection table"); 
    186186 
    187     MPID_NEM_MEMCPY (new_sc_tbl, g_sc_tbl, g_sc_tbl_capacity * sizeof(sockconn_t)); 
     187    MPIU_Memcpy (new_sc_tbl, g_sc_tbl, g_sc_tbl_capacity * sizeof(sockconn_t)); 
    188188 
    189189    for(i = 0; i < g_sc_tbl_capacity; i++){ 

  • mpich2/trunk/src/mpid/ch3/channels/nemesis/nemesis/netmod/wintcp/wintcp_init.c

    r4530 r4707  
    221221            } 
    222222            else 
    223                 memcpy( ifaddr->ifaddr, info->h_addr_list[0], ifaddr->len ); 
     223                MPIU_Memcpy( ifaddr->ifaddr, info->h_addr_list[0], ifaddr->len ); 
    224224        } 
    225225    } 
    … …  
    637637                    myifaddr.type = AF_INET; 
    638638                    myifaddr.len  = 4; 
    639                     memcpy( myifaddr.ifaddr, &addr.s_addr, 4 ); 
     639                    MPIU_Memcpy( myifaddr.ifaddr, &addr.s_addr, 4 ); 
    640640                } 
    641641            } 
    … …  
    644644                myifaddr.type = AF_INET; 
    645645                myifaddr.len  = 4; 
    646                 memcpy( myifaddr.ifaddr, &addr.s_addr, 4 ); 
     646                MPIU_Memcpy( myifaddr.ifaddr, &addr.s_addr, 4 ); 
    647647            } 
    648648        } 

  • mpich2/trunk/src/mpid/ch3/channels/nemesis/nemesis/netmod/wintcp/wintcp_lmt.c

    r4037 r4707  
    163163        saddr.sin_family = AF_INET; 
    164164        saddr.sin_port   = htons (r_port); 
    165         MPID_NEM_MEMCPY (&saddr.sin_addr, hp->h_addr, hp->h_length); 
     165        MPIU_Memcpy (&saddr.sin_addr, hp->h_addr, hp->h_length); 
    166166 
    167167        set_sockopts (vc_ch->net.tcp.lmt_desc); 

  • mpich2/trunk/src/mpid/ch3/channels/nemesis/nemesis/src/mpid_nem_lmt.c

    r4411 r4707  
    225225            rreq->ch.lmt_tmp_cookie.MPID_IOV_LEN = rts_pkt->cookie_len; 
    226226         
    227             MPID_NEM_MEMCPY(rreq->ch.lmt_tmp_cookie.MPID_IOV_BUF, data_buf, rts_pkt->cookie_len); 
     227            MPIU_Memcpy(rreq->ch.lmt_tmp_cookie.MPID_IOV_BUF, data_buf, rts_pkt->cookie_len); 
    228228            *buflen = sizeof(MPIDI_CH3_Pkt_t) + rts_pkt->cookie_len; 
    229229            *rreqp = NULL; 

  • mpich2/trunk/src/mpid/ch3/channels/nemesis/nemesis/src/mpid_nem_lmt_shm.c

    r4538 r4707  
    622622            { 
    623623                /* if we're wrapping back to buf 0, then we can copy it directly */ 
    624                 memcpy(((char *)copy_buf->buf[0]) - surfeit, surfeit_ptr, surfeit); 
     624                MPIU_Memcpy(((char *)copy_buf->buf[0]) - surfeit, surfeit_ptr, surfeit); 
    625625 
    626626                OPA_read_write_barrier(); 
    … …  
    630630            { 
    631631                /* otherwise, we need to copy to a tmpbuf first to make sure the src and dest addresses don't overlap */ 
    632                 memcpy(tmpbuf, surfeit_ptr, surfeit); 
    633                 memcpy(((char *)copy_buf->buf[buf_num+1]) - surfeit, tmpbuf, surfeit); 
     632                MPIU_Memcpy(tmpbuf, surfeit_ptr, surfeit); 
     633                MPIU_Memcpy(((char *)copy_buf->buf[buf_num+1]) - surfeit, tmpbuf, surfeit); 
    634634            } 
    635635 

  • mpich2/trunk/src/mpid/ch3/channels/nemesis/nemesis/src/mpid_nem_mpich2.c

    r3093 r4707  
    149149    iov_data_copied = 0; 
    150150    for (i = 0; i < data_n_iov; ++i) { 
    151         MPID_NEM_MEMCPY((char*) sreq->dev.tmpbuf + iov_data_copied, data_iov[i].MPID_IOV_BUF, data_iov[i].MPID_IOV_LEN); 
     151        MPIU_Memcpy((char*) sreq->dev.tmpbuf + iov_data_copied, data_iov[i].MPID_IOV_BUF, data_iov[i].MPID_IOV_LEN); 
    152152        iov_data_copied += data_iov[i].MPID_IOV_LEN; 
    153153    } 

  • mpich2/trunk/src/mpid/ch3/channels/nemesis/nemesis/src/mpid_nem_mpich2_rma.c

    r2927 r4707  
    150150        MPIU_ERR_SETANDJUMP (mpi_errno, MPI_ERR_OTHER, "**winput_oob"); 
    151151 
    152     MPID_NEM_MEMCPY (_d_buf, s_buf, len); 
     152    MPIU_Memcpy (_d_buf, s_buf, len); 
    153153 
    154154 fn_exit: 
    … …  
    184184        { 
    185185            len = (*d_iov)->iov_len; 
    186             MPID_NEM_MEMCPY ((char*)((*d_iov)->iov_base) + diff, (*s_iov)->iov_base, len); 
     186            MPIU_Memcpy ((char*)((*d_iov)->iov_base) + diff, (*s_iov)->iov_base, len); 
    187187 
    188188            (*s_iov)->iov_base = (char *)(*s_iov)->iov_base + len; 
    … …  
    198198        { 
    199199            len = (*s_iov)->iov_len; 
    200             MPID_NEM_MEMCPY ((char*)((*d_iov)->iov_base) + diff, (*s_iov)->iov_base, len); 
     200            MPIU_Memcpy ((char*)((*d_iov)->iov_base) + diff, (*s_iov)->iov_base, len); 
    201201 
    202202            ++(*s_iov); 
    … …  
    209209        { 
    210210            len = (*s_iov)->iov_len; 
    211             MPID_NEM_MEMCPY ((char*)((*d_iov)->iov_base) + diff, (*s_iov)->iov_base, len); 
     211            MPIU_Memcpy ((char*)((*d_iov)->iov_base) + diff, (*s_iov)->iov_base, len); 
    212212 
    213213            ++(*s_iov); 
    … …  
    247247        MPIU_ERR_SETANDJUMP (mpi_errno, MPI_ERR_OTHER, "**winget_oob"); 
    248248 
    249     MPID_NEM_MEMCPY (d_buf, _s_buf, len); 
     249    MPIU_Memcpy (d_buf, _s_buf, len); 
    250250 
    251251 fn_exit: 
    … …  
    281281        { 
    282282            len = (*s_iov)->iov_len; 
    283             MPID_NEM_MEMCPY ((char*)((*d_iov)->iov_base) + diff, (*s_iov)->iov_base, len); 
     283            MPIU_Memcpy ((char*)((*d_iov)->iov_base) + diff, (*s_iov)->iov_base, len); 
    284284 
    285285            (*d_iov)->iov_base = (char *)(*d_iov)->iov_base + len; 
    … …  
    295295        { 
    296296            len = (*d_iov)->iov_len; 
    297             MPID_NEM_MEMCPY ((char*)((*d_iov)->iov_base) + diff, (*s_iov)->iov_base, len); 
     297            MPIU_Memcpy ((char*)((*d_iov)->iov_base) + diff, (*s_iov)->iov_base, len); 
    298298 
    299299            ++(*d_iov); 
    … …  
    306306        { 
    307307            len = (*d_iov)->iov_len; 
    308             MPID_NEM_MEMCPY ((char*)((*d_iov)->iov_base) + diff, (*s_iov)->iov_base, len); 
     308            MPIU_Memcpy ((char*)((*d_iov)->iov_base) + diff, (*s_iov)->iov_base, len); 
    309309 
    310310            ++(*d_iov); 

  • mpich2/trunk/src/mpid/ch3/channels/nemesis/src/ch3_progress.c

    r4629 r4707  
    522522                       ? buflen 
    523523                       : sizeof(MPIDI_CH3_Pkt_t) - vc_ch->pending_pkt_len); 
    524             MPID_NEM_MEMCPY((char *)vc_ch->pending_pkt + vc_ch->pending_pkt_len, buf, copylen); 
     524            MPIU_Memcpy((char *)vc_ch->pending_pkt + vc_ch->pending_pkt_len, buf, copylen); 
    525525            vc_ch->pending_pkt_len += copylen; 
    526526            if (vc_ch->pending_pkt_len < sizeof(MPIDI_CH3_Pkt_t)) 
    … …  
    579579                int iov_len = iov->MPID_IOV_LEN; 
    580580                MPIU_DBG_MSG_D(CH3_CHANNEL, VERBOSE, "        %d\n", iov_len); 
    581                 MPID_NEM_MEMCPY (iov->MPID_IOV_BUF, buf, iov_len); 
     581                MPIU_Memcpy (iov->MPID_IOV_BUF, buf, iov_len); 
    582582 
    583583                buflen -= iov_len; 
    … …  
    592592                { 
    593593                    MPIU_DBG_MSG_D(CH3_CHANNEL, VERBOSE, "        " MPIDI_MSG_SZ_FMT "\n", buflen); 
    594                     MPID_NEM_MEMCPY (iov->MPID_IOV_BUF, buf, buflen); 
     594                    MPIU_Memcpy (iov->MPID_IOV_BUF, buf, buflen); 
    595595                    iov->MPID_IOV_BUF = (void *)((char *)iov->MPID_IOV_BUF + buflen); 
    596596                    iov->MPID_IOV_LEN -= buflen; 

  • mpich2/trunk/src/mpid/ch3/channels/ssm/src/ch3_istartmsgv.c

    r100 r4707  
    2626    sreq->kind = MPID_REQUEST_SEND; \ 
    2727    MPIDI_FUNC_ENTER(MPID_STATE_MEMCPY); \ 
    28     memcpy(sreq->dev.iov, iov, count * sizeof(MPID_IOV)); \ 
     28    MPIU_Memcpy(sreq->dev.iov, iov, count * sizeof(MPID_IOV)); \ 
    2929    MPIDI_FUNC_EXIT(MPID_STATE_MEMCPY); \ 
    3030    /*for (i = 0; i < count; i++) { sreq->dev.iov[i] = iov[i]; }*/ \ 
    3131    if (offset == 0) \ 
    3232    { \ 
    33         /* memcpy(&sreq->dev.pending_pkt, iov[0].MPID_IOV_BUF, iov[0].MPID_IOV_LEN); */ \ 
     33        /* MPIU_Memcpy(&sreq->dev.pending_pkt, iov[0].MPID_IOV_BUF, iov[0].MPID_IOV_LEN); */ \ 
    3434        /*MPIU_Assert(iov[0].MPID_IOV_LEN == sizeof(MPIDI_CH3_Pkt_t));*/ \ 
    3535        sreq->dev.pending_pkt = *(MPIDI_CH3_PktGeneric_t *) iov[0].MPID_IOV_BUF; \ 

  • mpich2/trunk/src/mpid/ch3/src/ch3u_buffer.c

    r100 r4707  
    7575    { 
    7676        MPIDI_FUNC_ENTER(MPID_STATE_MEMCPY); 
    77         memcpy((char *)rbuf + rdt_true_lb, (const char *)sbuf + sdt_true_lb, sdata_sz); 
     77        MPIU_Memcpy((char *)rbuf + rdt_true_lb, (const char *)sbuf + sdt_true_lb, sdata_sz); 
    7878        MPIDI_FUNC_EXIT(MPID_STATE_MEMCPY); 
    7979        *rsz = sdata_sz; 

  • mpich2/trunk/src/mpid/ch3/src/ch3u_handle_recv_pkt.c

    r3296 r4707  
    147147            MPIU_DBG_MSG(CH3_OTHER,VERBOSE,"Copying contiguous data to user buffer"); 
    148148            /* copy data out of the receive buffer */ 
    149             memcpy((char*)(rreq->dev.user_buf) + dt_true_lb, buf, data_sz); 
     149            MPIU_Memcpy((char*)(rreq->dev.user_buf) + dt_true_lb, buf, data_sz); 
    150150            *buflen = data_sz; 
    151151            *complete = TRUE; 
    … …  
    256256    if (rreq->dev.recv_data_sz <= *buflen) 
    257257    { 
    258         memcpy(rreq->dev.tmpbuf, buf, rreq->dev.recv_data_sz); 
     258        MPIU_Memcpy(rreq->dev.tmpbuf, buf, rreq->dev.recv_data_sz); 
    259259        *buflen = rreq->dev.recv_data_sz; 
    260260        rreq->dev.recv_pending_count = 1; 

  • mpich2/trunk/src/mpid/ch3/src/ch3u_request.c

    r4099 r4707  
    246246        iov_data_copied = 0; 
    247247        for (i = 0; i < *iov_n; i++) { 
    248             memcpy((char*) sreq->dev.tmpbuf + iov_data_copied,  
     248            MPIU_Memcpy((char*) sreq->dev.tmpbuf + iov_data_copied,  
    249249                   iov[i].MPID_IOV_BUF, iov[i].MPID_IOV_LEN); 
    250250            iov_data_copied += iov[i].MPID_IOV_LEN; 
    … …  
    606606               (unless configured with --enable-fast) */ 
    607607            MPIDI_FUNC_ENTER(MPID_STATE_MEMCPY); 
    608             memcpy((char *)rreq->dev.user_buf + dt_true_lb, rreq->dev.tmpbuf, 
     608            MPIU_Memcpy((char *)rreq->dev.user_buf + dt_true_lb, rreq->dev.tmpbuf, 
    609609                   unpack_sz); 
    610610            MPIDI_FUNC_EXIT(MPID_STATE_MEMCPY); 

  • mpich2/trunk/src/mpid/ch3/src/ch3u_rma_sync.c

    r4411 r4707  
    526526 
    527527        MPIDI_FUNC_ENTER(MPID_STATE_MEMCPY); 
    528         memcpy(*dataloop, target_dtp->dataloop, target_dtp->dataloop_size); 
     528        MPIU_Memcpy(*dataloop, target_dtp->dataloop, target_dtp->dataloop_size); 
    529529        MPIDI_FUNC_EXIT(MPID_STATE_MEMCPY); 
    530530 
    … …  
    750750 
    751751        MPIDI_FUNC_ENTER(MPID_STATE_MEMCPY); 
    752         memcpy(*dataloop, dtp->dataloop, dtp->dataloop_size); 
     752        MPIU_Memcpy(*dataloop, dtp->dataloop, dtp->dataloop_size); 
    753753        MPIDI_FUNC_EXIT(MPID_STATE_MEMCPY); 
    754754 
    … …  
    22542254        { 
    22552255            /* copy all of dtype_info and dataloop */ 
    2256             memcpy(req->dev.dtype_info, data_buf, sizeof(MPIDI_RMA_dtype_info)); 
    2257             memcpy(req->dev.dataloop, data_buf + sizeof(MPIDI_RMA_dtype_info), put_pkt->dataloop_size); 
     2256            MPIU_Memcpy(req->dev.dtype_info, data_buf, sizeof(MPIDI_RMA_dtype_info)); 
     2257            MPIU_Memcpy(req->dev.dataloop, data_buf + sizeof(MPIDI_RMA_dtype_info), put_pkt->dataloop_size); 
    22582258 
    22592259            *buflen = sizeof(MPIDI_CH3_Pkt_t) + sizeof(MPIDI_RMA_dtype_info) + put_pkt->dataloop_size; 
    … …  
    23932393        { 
    23942394            /* copy all of dtype_info and dataloop */ 
    2395             memcpy(req->dev.dtype_info, data_buf, sizeof(MPIDI_RMA_dtype_info)); 
    2396             memcpy(req->dev.dataloop, data_buf + sizeof(MPIDI_RMA_dtype_info), get_pkt->dataloop_size); 
     2395            MPIU_Memcpy(req->dev.dtype_info, data_buf, sizeof(MPIDI_RMA_dtype_info)); 
     2396            MPIU_Memcpy(req->dev.dataloop, data_buf + sizeof(MPIDI_RMA_dtype_info), get_pkt->dataloop_size); 
    23972397 
    23982398            *buflen = sizeof(MPIDI_CH3_Pkt_t) + sizeof(MPIDI_RMA_dtype_info) + get_pkt->dataloop_size; 
    … …  
    25422542        { 
    25432543            /* copy all of dtype_info and dataloop */ 
    2544             memcpy(req->dev.dtype_info, data_buf, sizeof(MPIDI_RMA_dtype_info)); 
    2545             memcpy(req->dev.dataloop, data_buf + sizeof(MPIDI_RMA_dtype_info), accum_pkt->dataloop_size); 
     2544            MPIU_Memcpy(req->dev.dtype_info, data_buf, sizeof(MPIDI_RMA_dtype_info)); 
     2545            MPIU_Memcpy(req->dev.dataloop, data_buf + sizeof(MPIDI_RMA_dtype_info), accum_pkt->dataloop_size); 
    25462546 
    25472547            *buflen = sizeof(MPIDI_CH3_Pkt_t) + sizeof(MPIDI_RMA_dtype_info) + accum_pkt->dataloop_size; 

  • mpich2/trunk/src/mpid/ch3/util/shm/ch3i_bootstrapq.c

    r100 r4707  
    141141            if (bsmsg_ptr != NULL) 
    142142            { 
    143                 memcpy(bsmsg_ptr->buffer, p->lpData, p->cbData); 
     143                MPIU_Memcpy(bsmsg_ptr->buffer, p->lpData, p->cbData); 
    144144                bsmsg_ptr->length = p->cbData; 
    145145                bsmsg_ptr->next = NULL; 
    … …  
    10191019#endif 
    10201020    MPIDI_FUNC_ENTER(MPID_STATE_MEMCPY); 
    1021     memcpy(msg.data, buffer, length); 
     1021    MPIU_Memcpy(msg.data, buffer, length); 
    10221022    MPIDI_FUNC_EXIT(MPID_STATE_MEMCPY); 
    10231023    MPIU_DBG_PRINTF(("sending message %d on queue %d\n", msg.mtype, queue->id)); 
    … …  
    11461146    } 
    11471147    MPIDI_FUNC_ENTER(MPID_STATE_MEMCPY); 
    1148     memcpy(buffer, msg.data, nb); 
     1148    MPIU_Memcpy(buffer, msg.data, nb); 
    11491149    MPIDI_FUNC_EXIT(MPID_STATE_MEMCPY); 
    11501150    *num_bytes_ptr = nb; 
    … …  
    11701170    { 
    11711171        MPIDI_FUNC_ENTER(MPID_STATE_MEMCPY); 
    1172         memcpy(buffer, msg->buffer, min(length, msg->length)); 
     1172        MPIU_Memcpy(buffer, msg->buffer, min(length, msg->length)); 
    11731173        MPIDI_FUNC_EXIT(MPID_STATE_MEMCPY); 
    11741174        *num_bytes_ptr = min(length, msg->length); 

  • mpich2/trunk/src/mpid/ch3/util/shm/ch3i_shm_bootstrapq.c

    r100 r4707  
    246246                                                  length, index, tag)); 
    247247 
    248             memcpy(q_ptr->msg[index].data, buffer, length); 
     248            MPIU_Memcpy(q_ptr->msg[index].data, buffer, length); 
    249249            q_ptr->msg[index].tag = tag; 
    250250            q_ptr->msg[index].length = length; 
    … …  
    371371                } 
    372372                /* copy the message */ 
    373                 memcpy(buffer, q_ptr->msg[index].data, q_ptr->msg[index].length); 
     373                MPIU_Memcpy(buffer, q_ptr->msg[index].data, q_ptr->msg[index].length); 
    374374                *length = q_ptr->msg[index].length; 
    375375                /* add the node to the free list */ 

  • mpich2/trunk/src/mpid/ch3/util/shmbase/ch3_shm.c

    r4378 r4707  
    9191        writeq->packet[index].num_bytes = length; 
    9292        MPIDI_FUNC_ENTER(MPID_STATE_MEMCPY); 
    93         memcpy(writeq->packet[index].data, buf, length); 
     93        MPIU_Memcpy(writeq->packet[index].data, buf, length); 
    9494        MPIDI_FUNC_EXIT(MPID_STATE_MEMCPY); 
    9595        MPIU_DBG_PRINTF(("shm_write: %d bytes in packet %d\n",  
    … …  
    156156        MPIDI_DBG_PRINTF((60, FCNAME, "writing %d bytes to write_shmq %08p packet[%d]", iov[0].MPID_IOV_LEN + iov[1].MPID_IOV_LEN, writeq, index)); 
    157157        MPIDI_FUNC_ENTER(MPID_STATE_MEMCPY); 
    158         memcpy(writeq->packet[index].data,  
     158        MPIU_Memcpy(writeq->packet[index].data,  
    159159               iov[0].MPID_IOV_BUF, iov[0].MPID_IOV_LEN); 
    160160        MPIDI_FUNC_EXIT(MPID_STATE_MEMCPY); 
    161161        MPIDI_FUNC_ENTER(MPID_STATE_MEMCPY); 
    162         memcpy(&writeq->packet[index].data[iov[0].MPID_IOV_LEN], 
     162        MPIU_Memcpy(&writeq->packet[index].data[iov[0].MPID_IOV_LEN], 
    163163               iov[1].MPID_IOV_BUF, iov[1].MPID_IOV_LEN); 
    164164        MPIDI_FUNC_EXIT(MPID_STATE_MEMCPY); 
    … …  
    199199            MPIDI_DBG_PRINTF((60, FCNAME, "writing %d bytes to write_shmq %08p packet[%d]", iov[i].MPID_IOV_LEN, writeq, index)); 
    200200            MPIDI_FUNC_ENTER(MPID_STATE_MEMCPY); 
    201             memcpy(dest_pos, iov[i].MPID_IOV_BUF, iov[i].MPID_IOV_LEN); 
     201            MPIU_Memcpy(dest_pos, iov[i].MPID_IOV_BUF, iov[i].MPID_IOV_LEN); 
    202202            MPIDI_FUNC_EXIT(MPID_STATE_MEMCPY); 
    203203            MPIU_DBG_PRINTF(("shm_writev: +%d=%d bytes in packet %d\n", iov[i].MPID_IOV_LEN, writeq->packet[index].num_bytes, index)); 
    … …  
    210210            MPIDI_DBG_PRINTF((60, FCNAME, "writing %d bytes to write_shmq %08p packet[%d]", dest_avail, writeq, index)); 
    211211            MPIDI_FUNC_ENTER(MPID_STATE_MEMCPY); 
    212             memcpy(dest_pos, iov[i].MPID_IOV_BUF, dest_avail); 
     212            MPIU_Memcpy(dest_pos, iov[i].MPID_IOV_BUF, dest_avail); 
    213213            MPIDI_FUNC_EXIT(MPID_STATE_MEMCPY); 
    214214            MPIU_DBG_PRINTF(("shm_writev: +%d=%d bytes in packet %d\n", dest_avail, writeq->packet[index].num_bytes, index)); 
    … …  
    232232                MPIDI_DBG_PRINTF((60, FCNAME, "writing %d bytes to write_shmq %08p packet[%d]", num_bytes, writeq, index)); 
    233233                MPIDI_FUNC_ENTER(MPID_STATE_MEMCPY); 
    234                 memcpy(writeq->packet[index].data, cur_pos, num_bytes); 
     234                MPIU_Memcpy(writeq->packet[index].data, cur_pos, num_bytes); 
    235235                MPIDI_FUNC_EXIT(MPID_STATE_MEMCPY); 
    236236                MPIU_DBG_PRINTF(("shm_writev: +%d=%d bytes in packet %d\n", num_bytes, writeq->packet[index].num_bytes, index)); 
    … …  
    426426                        /* copy the received data */ 
    427427                        MPIDI_FUNC_ENTER(MPID_STATE_MEMCPY); 
    428                         memcpy(recv_vcch->read.iov[recv_vcch->read.index].MPID_IOV_BUF, iter_ptr, 
     428                        MPIU_Memcpy(recv_vcch->read.iov[recv_vcch->read.index].MPID_IOV_BUF, iter_ptr, 
    429429                            recv_vcch->read.iov[recv_vcch->read.index].MPID_IOV_LEN); 
    430430                        MPIDI_FUNC_EXIT(MPID_STATE_MEMCPY); 
    … …  
    442442                        /* copy the received data */ 
    443443                        MPIDI_FUNC_ENTER(MPID_STATE_MEMCPY); 
    444                         memcpy(recv_vcch->read.iov[recv_vcch->read.index].MPID_IOV_BUF, iter_ptr, num_bytes); 
     444                        MPIU_Memcpy(recv_vcch->read.iov[recv_vcch->read.index].MPID_IOV_BUF, iter_ptr, num_bytes); 
    445445                        MPIDI_FUNC_EXIT(MPID_STATE_MEMCPY); 
    446446                        MPIU_DBG_PRINTF(("b:shm_read_progress: %d bytes read from packet %d offset %d\n", num_bytes, index, 
    … …  
    506506                    MPIDI_DBG_PRINTF((60, FCNAME, "reading %d bytes from read_shmq %08p packet[%d]", recv_vcch->read.bufflen, shm_ptr, index)); 
    507507                    MPIDI_FUNC_ENTER(MPID_STATE_MEMCPY); 
    508                     memcpy(recv_vcch->read.buffer, mem_ptr, recv_vcch->read.bufflen); 
     508                    MPIU_Memcpy(recv_vcch->read.buffer, mem_ptr, recv_vcch->read.bufflen); 
    509509                    MPIDI_FUNC_EXIT(MPID_STATE_MEMCPY); 
    510510                    recv_vcch->read.total = recv_vcch->read.bufflen; 
    … …  
    518518                    MPIDI_DBG_PRINTF((60, FCNAME, "reading %d bytes from read_shmq %08p packet[%d]", num_bytes, shm_ptr, index)); 
    519519                    MPIDI_FUNC_ENTER(MPID_STATE_MEMCPY); 
    520                     memcpy(recv_vcch->read.buffer, mem_ptr, num_bytes); 
     520                    MPIU_Memcpy(recv_vcch->read.buffer, mem_ptr, num_bytes); 
    521521                    MPIDI_FUNC_EXIT(MPID_STATE_MEMCPY); 
    522522                    recv_vcch->read.total += num_bytes; 
    … …  
    632632       duration of the operation */ 
    633633    MPIDI_FUNC_ENTER(MPID_STATE_MEMCPY); 
    634     memcpy(vcch->read.iov, iov, sizeof(MPID_IOV) * n); 
     634    MPIU_Memcpy(vcch->read.iov, iov, sizeof(MPID_IOV) * n); 
    635635    MPIDI_FUNC_EXIT(MPID_STATE_MEMCPY); 
    636636#else 

  • mpich2/trunk/src/mpid/ch3/util/sock/ch3u_getinterfaces.c

    r1223 r4707  
    140140            } 
    141141            else { 
    142                 memcpy( ifaddr->ifaddr, info->h_addr_list[0], ifaddr->len ); 
     142                MPIU_Memcpy( ifaddr->ifaddr, info->h_addr_list[0], ifaddr->len ); 
    143143#if 0 
    144144                printf( "ifaddr len = %d\n", ifaddr->len ); 
    … …  
    311311                    myifaddr.type = AF_INET; 
    312312                    myifaddr.len  = 4; 
    313                     memcpy( myifaddr.ifaddr, &addr.s_addr, 4 ); 
     313                    MPIU_Memcpy( myifaddr.ifaddr, &addr.s_addr, 4 ); 
    314314                } 
    315315            } 
    … …  
    318318                myifaddr.type = AF_INET; 
    319319                myifaddr.len  = 4; 
    320                 memcpy( myifaddr.ifaddr, &addr.s_addr, 4 ); 
     320                MPIU_Memcpy( myifaddr.ifaddr, &addr.s_addr, 4 ); 
    321321            } 
    322322        } 

  • mpich2/trunk/src/mpid/common/datatype/dataloop/dataloop.c

    r1249 r4707  
    108108 
    109109    /* copy region first */ 
    110     memcpy(dest, src, size); 
     110    DLOOP_Memcpy(dest, src, size); 
    111111 
    112112    /* Calculate difference in starting locations. DLOOP_Dataloop_update() 

  • mpich2/trunk/src/mpid/common/datatype/dataloop/segment_ops.c

    r4536 r4707  
    4141         * used on a memcpy */ 
    4242        MPID_Ensure_Aint_fits_in_pointer((MPI_VOID_PTR_CAST_TO_MPI_AINT (paramp->userbuf)) + rel_off); 
    43         memcpy((char *) paramp->userbuf + rel_off, paramp->streambuf, size); 
     43        DLOOP_Memcpy((char *) paramp->userbuf + rel_off, paramp->streambuf, size); 
    4444    } 
    4545    else { 
    … …  
    4747        /* userbuf is a pointer (not a displacement) since it is being used on a memcpy */ 
    4848        MPID_Ensure_Aint_fits_in_pointer((MPI_VOID_PTR_CAST_TO_MPI_AINT (paramp->userbuf)) + rel_off); 
    49         memcpy(paramp->streambuf, (char *) paramp->userbuf + rel_off, size); 
     49        DLOOP_Memcpy(paramp->streambuf, (char *) paramp->userbuf + rel_off, size); 
    5050    } 
    5151    /* Ensure that pointer increment fits in a pointer */ 
    … …  
    111111        else { 
    112112            for (i=0; i < whole_count; i++) { 
    113                 memcpy(cbufp, paramp->streambuf, ((DLOOP_Offset) blksz) * el_size); 
     113                DLOOP_Memcpy(cbufp, paramp->streambuf, ((DLOOP_Offset) blksz) * el_size); 
    114114                /* Ensure that pointer increment fits in a pointer */ 
    115115                /* streambuf is a pointer (not a displacement) since it is being used for a memory copy */ 
    … …  
    122122            } 
    123123            if (blocks_left) { 
    124                 memcpy(cbufp, paramp->streambuf, ((DLOOP_Offset) blocks_left) * el_size); 
     124                DLOOP_Memcpy(cbufp, paramp->streambuf, ((DLOOP_Offset) blocks_left) * el_size); 
    125125                /* Ensure that pointer increment fits in a pointer */ 
    126126                /* streambuf is a pointer (not a displacement) since 
    … …  
    157157        else { 
    158158            for (i=0; i < whole_count; i++) { 
    159                 memcpy(paramp->streambuf, cbufp, (DLOOP_Offset) blksz * el_size); 
     159                DLOOP_Memcpy(paramp->streambuf, cbufp, (DLOOP_Offset) blksz * el_size); 
    160160                /* Ensure that pointer increment fits in a pointer */ 
    161161                /* streambuf is a pointer (not a displacement) since 
    … …  
    167167            } 
    168168            if (blocks_left) { 
    169                 memcpy(paramp->streambuf, cbufp, (DLOOP_Offset) blocks_left * el_size); 
     169                DLOOP_Memcpy(paramp->streambuf, cbufp, (DLOOP_Offset) blocks_left * el_size); 
    170170                /* Ensure that pointer increment fits in a pointer */ 
    171171                /* streambuf is a pointer (not a displacement) since 
    … …  
    238238        } 
    239239        else { 
    240             memcpy(dest, src, (DLOOP_Offset) blocklen * el_size); 
     240            DLOOP_Memcpy(dest, src, (DLOOP_Offset) blocklen * el_size); 
    241241        } 
    242242 
    … …  
    312312        } 
    313313        else { 
    314             memcpy(dest, src, cur_block_sz * el_size); 
     314            DLOOP_Memcpy(dest, src, cur_block_sz * el_size); 
    315315        } 
    316316 

  • mpich2/trunk/src/mpid/common/datatype/mpid_dataloop.h

    r3497 r4707  
    8383#define DLOOP_Assert MPIU_Assert 
    8484 
     85/* memory copy function */ 
     86#define DLOOP_Memcpy MPIU_Memcpy 
     87 
    8588/* Include dataloop_parts.h at the end to get the rest of the prototypes 
    8689 * and defines, in terms of the prefixes and types above. 

  • mpich2/trunk/src/mpid/common/datatype/mpid_datatype_contents.c

    r3717 r4707  
    8585    /* Fortran90 combiner types do not have a "base" type */ 
    8686    if (nr_types > 0) { 
    87         memcpy(ptr, array_of_types, nr_types * sizeof(MPI_Datatype)); 
     87        MPIU_Memcpy(ptr, array_of_types, nr_types * sizeof(MPI_Datatype)); 
    8888    } 
    8989     
    9090    ptr = ((char *) cp) + struct_sz + types_sz; 
    9191    if (nr_ints > 0) { 
    92         memcpy(ptr, array_of_ints, nr_ints * sizeof(int)); 
     92        MPIU_Memcpy(ptr, array_of_ints, nr_ints * sizeof(int)); 
    9393    } 
    9494 
    9595    ptr = ((char *) cp) + struct_sz + types_sz + ints_sz; 
    9696    if (nr_aints > 0) { 
    97         memcpy(ptr, array_of_aints, nr_aints * sizeof(MPI_Aint)); 
     97        MPIU_Memcpy(ptr, array_of_aints, nr_aints * sizeof(MPI_Aint)); 
    9898    } 
    9999    new_dtp->contents = cp; 
    … …  
    164164 
    165165    ptr = ((char *) cp) + struct_sz + types_sz; 
    166     memcpy(user_ints, ptr, cp->nr_ints * sizeof(int)); 
     166    MPIU_Memcpy(user_ints, ptr, cp->nr_ints * sizeof(int)); 
    167167 
    168168    return; 
    … …  
    204204 
    205205    ptr = ((char *) cp) + struct_sz + types_sz + ints_sz; 
    206     memcpy(user_aints, ptr, cp->nr_aints * sizeof(MPI_Aint)); 
     206    MPIU_Memcpy(user_aints, ptr, cp->nr_aints * sizeof(MPI_Aint)); 
    207207 
    208208    return; 
    … …  
    234234 
    235235    ptr = ((char *) cp) + struct_sz; 
    236     memcpy(user_types, ptr, cp->nr_types * sizeof(MPI_Datatype)); 
     236    MPIU_Memcpy(user_types, ptr, cp->nr_types * sizeof(MPI_Datatype)); 
    237237 
    238238    return; 

  • mpich2/trunk/src/mpid/common/datatype/mpid_ext32_segment.c

    r100 r4707  
    201201    if ((src_el_size == dest_el_size) && (src_el_size == 1)) 
    202202    { 
    203         memcpy(paramp->u.pack.pack_buffer, 
     203        MPIU_Memcpy(paramp->u.pack.pack_buffer, 
    204204               ((char *) bufp) + rel_off, *blocks_p); 
    205205    } 
    … …  
    264264    if ((src_el_size == dest_el_size) && (src_el_size == 1)) 
    265265    { 
    266         memcpy(((char *)bufp) + rel_off, 
     266        MPIU_Memcpy(((char *)bufp) + rel_off, 
    267267               paramp->u.unpack.unpack_buffer, *blocks_p); 
    268268    } 

  • mpich2/trunk/src/pmi/pmi2/simple2pmi.c

    r4369 r4707  
    12591259     
    12601260    MPIU_CHKPMEM_MALLOC(value_p, char *, vallen+1, mpi_errno, "value"); 
    1261     memcpy(value_p, val, vallen); 
     1261    MPIU_Memcpy(value_p, val, vallen); 
    12621262    value_p[vallen] = '\0'; 
    12631263     
    … …  
    13891389        command = MPIU_Malloc(vallen+1); 
    13901390        if (!command) { MPIU_CHKMEM_SETERR(mpi_errno, vallen+1, "command"); goto fn_exit; } 
    1391         memcpy(command, val, vallen); 
     1391        MPIU_Memcpy(command, val, vallen); 
    13921392        val[vallen] = '\0'; 
    13931393 
    … …  
    15651565    MPIU_ERR_CHKANDJUMP1(ret >= PMII_COMMANDLEN_SIZE, mpi_errno, MPI_ERR_OTHER, "**intern", "**intern %s", "Command length won't fit in length buffer"); 
    15661566 
    1567     memcpy(cmdbuf, cmdlenbuf, ret); 
     1567    MPIU_Memcpy(cmdbuf, cmdlenbuf, ret); 
    15681568 
    15691569    printf_d("PMI sending: %s\n", cmdbuf); 
    … …  
    17191719    /* POSIX might define h_addr_list only and node define h_addr */ 
    17201720#ifdef HAVE_H_ADDR_LIST 
    1721     memcpy( (void *)&sa.sin_addr, (void *)hp->h_addr_list[0], hp->h_length); 
     1721    MPIU_Memcpy( (void *)&sa.sin_addr, (void *)hp->h_addr_list[0], hp->h_length); 
    17221722#else 
    1723     memcpy( (void *)&sa.sin_addr, (void *)hp->h_addr, hp->h_length); 
     1723    MPIU_Memcpy( (void *)&sa.sin_addr, (void *)hp->h_addr, hp->h_length); 
    17241724#endif 
    17251725    sa.sin_family = hp->h_addrtype; 

  • mpich2/trunk/src/util/logging/rlog/irlog2rlog.c

    r3456 r4707  
    329329        { 
    330330            /* replace old with new */ 
    331             memcpy(&pIter->state, pState, sizeof(RLOG_STATE)); 
     331            MPIU_Memcpy(&pIter->state, pState, sizeof(RLOG_STATE)); 
    332332            return; 
    333333        } 
    … …  
    336336 
    337337    pIter = (RLOG_State_list*)MPIU_Malloc(sizeof(RLOG_State_list)); 
    338     memcpy(&pIter->state, pState, sizeof(RLOG_STATE)); 
     338    MPIU_Memcpy(&pIter->state, pState, sizeof(RLOG_STATE)); 
    339339    pIter->next = g_pList; 
    340340    g_pList = pIter; 
    … …  
    350350    if (pExt) 
    351351    { 
    352         memcpy(out_filename, filename, pExt-filename); 
     352        MPIU_Memcpy(out_filename, filename, pExt-filename); 
    353353        strcpy(&out_filename[pExt-filename], ".rlog"); 
    354354        MPIU_Msg_printf("out_filename: %s\n", out_filename); 

  • mpich2/trunk/src/util/logging/rlog/irlogutil.c

    r3456 r4707  
    136136        num_valid = (int)(pInput->pEnd - pInput->pCurHeader); 
    137137        if (pInput->pCurHeader != pInput->buffer) 
    138             memcpy(pInput->buffer, pInput->pCurHeader, num_valid); 
     138            MPIU_Memcpy(pInput->buffer, pInput->pCurHeader, num_valid); 
    139139        ReadFileData(pInput->buffer + num_valid, sizeof(RLOG_HEADER) - num_valid, pInput->f); 
    140140        pInput->pCurHeader = pInput->buffer; 
    … …  
    144144 
    145145    /* copy the current header into a temporary variable so the bytes can be manipulated */ 
    146     memcpy(&pInput->header, pInput->pCurHeader, sizeof(RLOG_HEADER)); 
     146    MPIU_Memcpy(&pInput->header, pInput->pCurHeader, sizeof(RLOG_HEADER)); 
    147147    /* 
    148148    CLOGByteSwapDouble(&(header.timestamp), 1); 
    … …  
    155155        num_valid = (int)(pInput->pEnd - pInput->pCurHeader); 
    156156        if (pInput->pCurHeader != pInput->buffer) 
    157             memcpy(pInput->buffer, pInput->pCurHeader, num_valid); 
     157            MPIU_Memcpy(pInput->buffer, pInput->pCurHeader, num_valid); 
    158158        num_read = (int)fread(pInput->buffer + num_valid, 1, RLOG_BUFFSIZE - num_valid, pInput->f); 
    159159        if (num_read == 0) 
    … …  
    178178        break; 
    179179    case RLOG_EVENT_TYPE: 
    180         memcpy(&pInput->record.event, pInput->pCurHeader + sizeof(RLOG_HEADER), sizeof(RLOG_EVENT)); 
     180        MPIU_Memcpy(&pInput->record.event, pInput->pCurHeader + sizeof(RLOG_HEADER), sizeof(RLOG_EVENT)); 
    181181        break; 
    182182    case RLOG_IARROW_TYPE: 
    183         memcpy(&pInput->record.iarrow, pInput->pCurHeader + sizeof(RLOG_HEADER), sizeof(RLOG_IARROW)); 
     183        MPIU_Memcpy(&pInput->record.iarrow, pInput->pCurHeader + sizeof(RLOG_HEADER), sizeof(RLOG_IARROW)); 
    184184        break; 
    185185    case RLOG_STATE_TYPE: 
    186         memcpy(&pInput->record.state, pInput->pCurHeader + sizeof(RLOG_HEADER), sizeof(RLOG_STATE)); 
     186        MPIU_Memcpy(&pInput->record.state, pInput->pCurHeader + sizeof(RLOG_HEADER), sizeof(RLOG_STATE)); 
    187187        break; 
    188188    case RLOG_COMM_TYPE: 
    189         memcpy(&pInput->record.comm, pInput->pCurHeader + sizeof(RLOG_HEADER), sizeof(RLOG_COMM)); 
     189        MPIU_Memcpy(&pInput->record.comm, pInput->pCurHeader + sizeof(RLOG_HEADER), sizeof(RLOG_COMM)); 
    190190        break; 
    191191    default: 
    … …  
    207207 
    208208    /* copy the record into the output buffer */ 
    209     memcpy(pOutput->pCurHeader, pRecord, pRecord->length); 
     209    MPIU_Memcpy(pOutput->pCurHeader, pRecord, pRecord->length); 
    210210    /* advance the current position pointer */ 
    211211    pOutput->pCurHeader = pOutput->pCurHeader + pRecord->length; 

  • mpich2/trunk/src/util/logging/rlog/rlogutil.c

    r3456 r4707  
    615615    if (pInput == NULL) 
    616616        return -1; 
    617     memcpy(pHeader, &pInput->header, sizeof(RLOG_FILE_HEADER)); 
     617    MPIU_Memcpy(pHeader, &pInput->header, sizeof(RLOG_FILE_HEADER)); 
    618618    return 0; 
    619619} 

  • mpich2/trunk/src/util/logging/rlog/trace_input.c

    r3456 r4707  
    4141        return RLOG_FALSE; 
    4242    *length = strlen(str); 
    43     memcpy(&base[*pos], str, *length); 
     43    MPIU_Memcpy(&base[*pos], str, *length); 
    4444    *pos += *length; 
    4545    return RLOG_TRUE; 

  • mpich2/trunk/src/util/mem/trmem.c

    r4567 r4707  
    847847        nsize = size; 
    848848        if (head->size < (unsigned long)nsize) nsize = (int)(head->size); 
    849         memcpy( pnew, p, nsize ); 
     849        MPIU_Memcpy( pnew, p, nsize ); 
    850850        MPIU_trfree( p, lineno, fname ); 
    851851    } 
    … …  
    874874    p = MPIU_trmalloc( len, lineno, (char *)fname ); 
    875875    if (p) { 
    876         memcpy( p, str, len ); 
     876        MPIU_Memcpy( p, str, len ); 
    877877    } 
    878878    return p;