comment utiliser movntdqa pour éviter la pollution de cache?

Question

Je suis en train d'écrire une fonction memcpy qui ne charge pas la mémoire source dans le cache de cpu. Le but est d'éviter la pollution du cache. La fonction memcpy ci-dessous fonctionne, mais pollue le cache comme le fait le memcpy standard. J'utilise proccesoor P8700 avec express C ++ 2008 visuelle. je vois l'utilisation du cache cpu avec vtune intel.

void memcpy(char *dst,char*src,unsigned size){
    char *dst_end=dst+size;
    while(dst!=dst_end){
        __m128i res = _mm_stream_load_si128((__m128i *)src);
        *((__m128i *)dst)=res;
        src+=16;
        dst+=16;
    }
}

i ont une autre version, qui ont les mêmes résultats -. Œuvres, mais pollue le cache

void memcpy(char *dst,char*src,unsigned size){

        char *dst_end = dst+size;

        __asm{
        mov edi, dst 
        mov edx, dst_end 
        mov esi,src
        inner_start: 
        LFENCE 
      MOVNTDQA xmm0,    [esi ]
      MOVNTDQA xmm1, [esi+16] 
      MOVNTDQA xmm2, [esi+32] 
      MOVNTDQA xmm3, [esi+48] 
      //19. ; Copy data to buffer 
      MOVDQA [edi], xmm0 
      MOVDQA  [edi+16], xmm1 
      MOVDQA  [edi+32], xmm2 
      MOVDQA  [edi+48], xmm3 
    //  25. ; Increment pointers by cache line size and test for end of loop 
      add esi, 040h 
      add edi, 040h 
      cmp edi, edx 
      jne inner_start 


}
}

Mise à jour: il est le programme de test

        void test(int table_size,int num_iter,int item_size){
            char *src_table=alloc_aligned(table_size*item_size);//return value is aligned on 64 bytes
            char *dst=alloc_aligned(item_size); //destination is always the same buffer
            for (int i=0;i<num_iter;i++){
                int location=my_rand()%table_size;
                char *src=src_table+location*item_size;//selecting a different src every time
                memcpy(dst,src,item_size);
            }

        }
main(){
       test(1024*32,1024*1024,1024*32)
}

Answer 1

Je cite Intel :

  

"L'instruction de charge en continu est   destiné à accélérer les transferts de données   à partir du type de mémoire USWC. Pour les autres   types de mémoire tels que cacheable (WB) ou   Uncacheable (UC), l'instruction   se comporte comme un MOVDQA 16 octets typique   instruction de chargement. Cependant, l'avenir   processeurs peuvent utiliser la charge en streaming   instruction pour d'autres types de mémoire   (Comme WB) comme une indication que le   ligne de cache destiné devrait être diffusé en continu   de la mémoire directement sur le noyau tandis que   réduisant au minimum la pollution du cache. "

Cela explique pourquoi le code ne fonctionne pas - la mémoire est de type WB

.