Alignement de l'adresse source et de destination dans memcpy

Question

Je souhaite écrire un code memcpy qui copie mot par mot au lieu de byte by byte pour augmenter la vitesse. (Bien que j'ai besoin de faire un peu d'octet par octet pour les derniers octets ou quelques octets). Je veux donc que mon adresse source et destination soit correctement alignée. J'ai vu la mise en œuvre de memcpy dans la glibc https://fossies.org/dox/glibc-2.22/string_2memcpy_8c_source.html il ne alignement que pour l'adresse de destination. Mais même si l'adresse de la source n'est pas correctement alignée, cela entraînera une erreur de bus (la vérification de l'alignement est activée dans mon CPU). Je ne suis pas sûr de savoir comment aligner correctement la source et la destination. Parce que si j'essaie d'aligner la source en copiant quelques octets par octet par octet, cela changera aussi l'adresse de destination, donc d'abord l'adresse de destination qui a été alignée d'abord correctement pourrait ne pas être correctement alignée maintenant. Alors est-il possible d'aligner les deux? Aidez-moi, s'il vous plaît.

void memcpy(void *dst, void *src,int size) 
{ 
    if(size >= 8) 
    { 
    while(size/8) /* code will give sigbus error if src = 0x10003 and dst = 0x100000 */ 
    { 
     *((double*)dst)++ = *((double*)src)++; 
     size = size - 8; 
    } 
    } 

    while(size--) 
    { 
    *((char*)dst)++ = *((char*)src)++; 
    } 
} 

Answer 1

... donc tout d'abord l'adresse de destination qui a été aligné dans un premier temps bien pourrait ne pas être aligné correctement maintenant. Alors, y a-t-il un moyen d'aligner les deux?

J'ai trouvé cet article sur l'optimisation des memcpy que je crois discute de ce que vous essayez de faire en longueur ... (voir lien ci-dessous exemple de code)

modifié GNU algorithme:

void * memcpy(void * dst, void const * src, size_t len) 
{ 
    long * plDst = (long *) dst; 
    long const * plSrc = (long const *) src; 

    if (!(src & 0xFFFFFFFC) && !(dst & 0xFFFFFFFC)) 
    { 
     while (len >= 4) 
    { 
      *plDst++ = *plSrc++; 
      len -= 4; 
     } 
    } 

    char * pcDst = (char *) plDst; 
    char const * pcDst = (char const *) plSrc; 

    while (len--) 
    { 
     *pcDst++ = *pcSrc++; 
    } 

    return (dst); 
} 

ThisLa variation de l'algorithme GNU modifié utilise le calcul pour ajuster le désalignement d'adresse.

Answer 2

Avec le code de memoire glibc que vous avez inclus, il n'y a aucun moyen d'appeler la fonction sans que la mémoire soit déjà alignée. Si vous deviez écrire le vôtre, comme je le vois, il y a deux alignements possibles pour le memcpy:

1) Les deux tampons sont décalés d'une même limite de quatre octets, ou les deux sont déjà sur une limite de quatre octets. (src % 4 == dst % 4) Dans ce cas, la copie octet par octet des premiers octets, puis l'alignement de l'adresse de destination uniquement est correct.

2) Les tampons ne sont pas tous les deux sur la même frontière. (src % 4 != dst % 4) Dans ce cas, afin de copier d'un alignement à l'autre, un mot à la fois, le processeur devrait suivre un processus similaire à celui ci-dessous:

Load the new word 
Split it into an upper half and lower half. 
Shift the upper half down 
Shift the lower half up 
Add the upper half the previous lower half. 
Store the combined copy to memory 
Repeat 

Je ne suis pas sûr que ce serait plus rapide que de simplement copier octet par octet. Halfword-by-halfword peut être plus rapide si l'architecture de votre processeur le permet et que les deux tampons sont alignés sur le demi-mot, bien que la plupart des implémentations memcpy que j'ai vues sur les architectures supportent déjà.