Discussion :

[Fooshi]

Bonjour,
j'ai lu que l'utilisation des memcpy pour des données inferieures à 8 octets etaient pas top.

je souhaiterais donc changer mes lignes de copie de memoire qui sont sur 2 et 4 octets :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

memcpy(start_msg + msg_len, &protocol_version, sizeof(uint32_t));

comme ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
uint32_t len = sizeof(uint32_t);
while (--len > 0)
{
*(start_msg + len + msg_len) = *(protocol_version + len);
}

Cette syntaxe est elle bonne et à votre avis y en a t'il une meilleure ?
Merci d'avance ?

[dtrosset]

Bonjour,

AMHA, avant de vouloir remplacer une ligne de code très parlante par cinq lignes pour lesquelles il faut réfléchir avant de comprendre ce qu'elles font, il faudrait mesurer. Oui, mesurer si appeler memcpy fait vraiment perdre du temps.

Les compilateurs de nos jours sont suffisemment bien foutus pour optimiser tout seuls ces fonctions de base comme memcpy.

La meilleure syntaxe, c'est celle qui se lit facilement et qui ne demande pas à réfléchir pour comprendre ce qui se passe.

Didier

[Vincent Rogier]

en effet, il vaut mieux faire des tests avant !

les implémentations de memcpy diffèrent selon les compilos et les architectures. Généralement codées en assembleur, les différentes version peuvent utiliser des instructions SS2 sous Inte. De plus au sein des implémentations des distinctions sont faites en fonction de la taille et des scénarios différents sont alors appliqués. Etc....

Donc, avant de vouloir faire mieux que le compilo ou le processeur, soit sur que c'est justifié et que ca vaut le coup.

Faits donc des tests et tu pourra en juger par toi même

[valefor]

Et au pire tu peux créer une fonction my_memcpy dans laquelle tu écris

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
void *my_memcpy(void *dest, const void *src, size_t n)
{
  if(n <=sizeof(uint32_t))
  {
    while (--n >= 0)  /* <- tu as oublie le 'egal' */
    {
      *((uint8_t *)dest + n) = *((uint8_t *)src + n);
    }
  else
  {
    memcpy(dest, src, n);
  }
}

Mais il y a quand même toutes les chances pour que le codeur de la fonction memcpy pour ta cible ait déjà pensé à cela.

Attention dans ton exemple tu as oublié le égal dans la boucle et il faut que les deux pointeurs start_message et &protocol_version soient des pointeurs sur un octet.

[Fooshi]

Je suis plutot d'accord avec vous au niveau de l'optimisation du compilateur, mais bon, mise a part que j'ai vu qu'il etais preferable d'eviter des copies des memcpy pour <8 octets, mon chef de projet ne veut pas de memcpy dans mon code.

@valefor : effectivement pour le cast mais on aurais pu mettre aussi (char *)

J'ai modifié mon code comme ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
int cpy_len = sizeof(uint32_t);
 
uint32_t protocol_version = htonl(sql_conn->pversion);
		while (--cpy_len >= 0)
		{
			*((uint32_t *)start_msg + cpy_len) = *((uint32_t *)&protocol_version + cpy_len);
		}

et ca fonctionne nickel

[Fooshi]

J'ai ajouté une fonction dans mon code pour remplacer tous les memcpy, comme me l'a conseillé valefor :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
void
sql_copy_data ( void * dest, void * src, int n )
{
	if (n <= sizeof(uint32_t))
	{
		while (--n >= 0)
		{
			*((char *)dest + n) = *((char *)src + n);
		}
	}
	else
	{
		memcpy(dest, src, n);
	}
}