void main() {
    char *buf1,*buf2;
    static const int size=32*1024*1024;
    
    buf1=(char *) malloc(2*size);
    buf2=buf1+size;

    DWORD t1,t2,t3;

    t1=timeGetTime();
    memcpy(buf1,buf2,size);
    t2=timeGetTime();
    for(int i=0; i<size; i++) buf2[i]=buf1[i];
    t3=timeGetTime();

    free(buf1);

    printf("t2-t1=%.3f\nt3-t2=%.3f",(t2-t1)/1000.0f,(t3-t2)/1000.0f);
}

      p=buf2;
    q=buf1;
    for(int i=0; i<size; i++) *p++=*q++;

    asm {
        mov esi,buf1
        mov edi,buf2
        mov ecx,size/4
        cld
        rep movsd 
    }

;;;     p=(long *) buf2;
;;;     q=(long *) buf1;
;;;     for(int i=0; i<size/4; i++) *p++=*q++;

        xor       edx, edx                                      ;27.10
        ALIGN     4
                                ; LOE edx ecx ebx esi edi
.B1.6:                          ; Preds .B1.6 .B1.5
        mov       eax, DWORD PTR [ecx]                          ;27.36
        mov       DWORD PTR [ebx], eax                          ;27.31
        mov       eax, DWORD PTR [ecx+4]                        ;27.36
        mov       DWORD PTR [ebx+4], eax                        ;27.31
        mov       eax, DWORD PTR [ecx+8]                        ;27.36
        mov       DWORD PTR [ebx+8], eax                        ;27.31
        mov       eax, DWORD PTR [ecx+12]                       ;27.36
        mov       DWORD PTR [ebx+12], eax                       ;27.31
        add       ecx, 16                                       ;27.36
        add       ebx, 16                                       ;27.31
        add       edx, 4                                        ;27.25
        cmp       edx, 8388608                                  ;27.2
        jl        .B1.6         ; Prob 99%                      ;27.2

// ==================================================================
// 
// FUNCTION :  SSEmemcpy()
// 
// * Description :
//     fast copy with mmx sse - faster than memcpy in 3-4 times
// 
// * Author : [Vadim VuDZ]
// 
// * Returns : [void] - nothing
// 
// * Function parameters : 
// [to]   - pointer to destination
// [from] - pointer to source
// [sz]   - lenght of [from]
// 
// ==================================================================

void SSEmemcpy(void * to, const void * from, unsigned int sz){
                // check for correct values
                if (!to || !from || !sz) {
#ifdef  DEBUG
                                OutputDebugString("SSEmemcpy: Incorrect parameters!\n");
#endif
                                return;
                }

                // Check for SSE
                if (!_IsSSE) {
                                MMXmemcpy(to, from, sz);
                                return;
                }

                int ne32 = sz % 32;
                int szz = sz - ne32;

                if (szz != 0){
                                __asm
                                {
                                               pusha;
                                               mov esi, from;
                                               mov ecx, szz;
                                               prefetcht0 [esi + ecx - 32];                // preload first 32 bytes
                                               mov edi, to;
                                               shr ecx, 3;            // devide on 8
_l_p3:                     movq mm0, [esi + ecx * 8 - 8];      
                                               movq mm1, [esi + ecx * 8 - 16];
                                               movq mm2, [esi + ecx * 8 - 24];
                                               movq mm3, [esi + ecx * 8 - 32];
                                               prefetcht0 [esi + ecx * 8 - 64];// preload next 32 bytes
                                               movntq [edi + ecx * 8 - 8], mm0;
                                               movntq [edi + ecx * 8 - 16], mm1;
                                               movntq [edi + ecx * 8 - 24], mm2;
                                               movntq [edi + ecx * 8 - 32], mm3;
                                               sub ecx, 4;
                                               jnz _l_p3;
                                               popa;
                                }
                                __asm emms; // set fpu registers free
                }

                // check for full copy
                memcpy((char*)to + sz - (ne32), (char*)from + sz - (ne32), ne32);
}

  for(int i=0,i<size;i++) dest[i]=src[i];

AD>>  for(int i=0,i<size;i++) dest[i]=src[i];
AD>>

#include <memory.h>
#include <iostream>

const int size = 256;

// Ф-я используется для подавления оптимизации
// Без неё из кода будет вырезано всё, что не связано с volatile
char calc(const char * data)
{
  char result = 0;
  for (int i = 0; i < size; i++) result += data[i];
  return result;
}


int main(int argc, char* argv[])
{
  const char src[size] = {0};
  char dst1[size], dst2[size];
  volatile char dstv[size];
  
  for (int i = 0; i < size; i++) dst1[i] = src[i];
  
  memcpy(dst2, src, size);
  
  for (int i = 0; i < size; i++) dstv[i] = src[i];
  
  std::cout << calc(dst1)+calc(dst2) << "\n";
}

...
; for (int i = 0; i < size; i++) dst1[i] = src[i];
    mov    ecx, 64                    ; 00000040H
    lea    esi, DWORD PTR _src$[esp+1040]
    lea    edi, DWORD PTR _dst1$[esp+1040]
    rep movsd
; memcpy(dst2, src, size);
    mov    ecx, 64                    ; 00000040H
    lea    esi, DWORD PTR _src$[esp+1040]
    lea    edi, DWORD PTR _dst2$[esp+1040]
    rep movsd
; for (int i = 0; i < size; i++) dstv[i] = src[i];
    xor    eax, eax
    npad    13
$L8472:
    mov    cl, BYTE PTR _src$[esp+eax+1040]
    mov    BYTE PTR _dstv$[esp+eax+1040], cl
    inc    eax
    cmp    eax, 256                ; 00000100H
    jl    SHORT $L8472
...

for (int i = 0; i < size; i++) dst1[i] = src[i];

memcpy(dst2, src, size);

for (int i = 0; i < size; i++) dstv[i] = src[i];

AD>>>  for(int i=0,i<size;i++) dest[i]=src[i];
AD>>>

dst[0] = src[0] ;
dst[1] = src[1] ;
dst[2] = src[2] ;
dst[3] = src[3] ;
...
dst[size-1] = src[size-1] ;

/* main.cpp */ 

#include <iostream>

using namespace std;

/* main() */ 

int main()
 {
  char mem[10]={'a','b'};
  
  char *dst=mem+2;
  const char *src=mem;
  size_t size=8;

#if 1
  
  for(size_t i=0; i<size ;i++) dst[i]=src[i]; // печатает ababababab
  
#else

  memcpy(dst,src,size); //  у меня печатает abab, у тебя может форматнуть винчестер

#endif  
  
  cout.write(mem,10) << endl ;
  
  return 0;
 }

Ш>>dst[0] = src[0] ;
Ш>>dst[1] = src[1] ;
Ш>>dst[2] = src[2] ;
Ш>>dst[3] = src[3] ;
Ш>>...
Ш>>dst[size-1] = src[size-1] ;
Ш>>

AD>С этим я, пожалуй, соглашусь

; 11   :   char mem[10]={'a','b'};

    mov    al, 97                    ; 00000061H
    push    esi
    xor    edx, edx
    mov    DWORD PTR _mem$[esp+18], edx
    mov    cl, 98                    ; 00000062H
    mov    DWORD PTR _mem$[esp+22], edx
    push    edi
    mov    BYTE PTR _mem$[esp+20], al

; 12   :   
; 13   :   char *dst=mem+2;
; 14   :   const char *src=mem;
; 15   :   size_t size=8;
; 16   : 
; 17   : #if 1
; 18   :   
; 19   :   for(size_t i=0; i<size ;i++) dst[i]=src[i];

    mov    BYTE PTR _mem$[esp+22], al
    mov    BYTE PTR _mem$[esp+24], al
    mov    BYTE PTR _mem$[esp+26], al
    mov    BYTE PTR _mem$[esp+28], al

; 20   :   
; 21   : #else
; 22   : 
; 23   :   memcpy(dst,src,size);
; 24   : 
; 25   : #endif  
; 26   :   
; 27   :   cout.write(mem,10) << endl ;

    push    10                    ; 0000000aH
    lea    eax, DWORD PTR _mem$[esp+24]
    mov    BYTE PTR _mem$[esp+25], cl
    mov    BYTE PTR _mem$[esp+27], cl
    mov    BYTE PTR _mem$[esp+29], cl
    mov    BYTE PTR _mem$[esp+31], cl
    mov    BYTE PTR _mem$[esp+33], cl

; 11   :   char mem[10]={'a','b'};

    xor    eax, eax
    mov    DWORD PTR _mem$[esp+14], eax
    push    esi
    mov    BYTE PTR _mem$[esp+16], 97        ; 00000061H
    mov    BYTE PTR _mem$[esp+17], 98        ; 00000062H

; 12   :   
; 13   :   char *dst=mem+2;
; 14   :   const char *src=mem;
; 15   :   size_t size=8;
; 16   : 
; 17   : #if 0
; 18   :   
; 19   :   for(size_t i=0; i<size ;i++) dst[i]=src[i];
; 20   :   
; 21   : #else
; 22   : 
; 23   :   memcpy(dst,src,size);

    mov    ecx, DWORD PTR _mem$[esp+16]
    mov    DWORD PTR _mem$[esp+22], eax
    mov    DWORD PTR _mem$[esp+18], ecx
    mov    edx, DWORD PTR _mem$[esp+20]

; 24   : 
; 25   : #endif  
; 26   :   
; 27   :   cout.write(mem,10) << endl ;

    push    10                    ; 0000000aH
    lea    eax, DWORD PTR _mem$[esp+20]
    push    eax
    mov    ecx, OFFSET FLAT:?cout@std@@3V?$basic_ostream@DU?$char_traits@D@std@@@1@A
    mov    DWORD PTR _mem$[esp+30], edx