Discussion :

[kris1980]

J'ai besoin de réaliser une conversion d'un "long long unsigned int" stocké en little endian vers du big endian.

J'ai développé plusieurs méthodes de conversion en C/C++, cependant les performances ne sont pas exceptionnelles.
J'aimerai savoir si injecter de l'assembleur dans du C/C++ pourrait m'aider à augmenter les performances ?

Merci

PS : J’utilise la distribution MinGW.

[droggo]

Jai,

J'ai besoin de réaliser une conversion d'un "long long unsigned int" stocké en little endian vers du big endian.

J'ai développé plusieurs méthodes de conversion en C/C++, cependant les performances ne sont pas exceptionnelles.
J'aimerai savoir si injecter de l'assembleur dans du C/C++ pourrait m'aider à augmenter les performances ?

Merci

PS : J’utilise la distribution MinGW.

Ça dépend évidemment de ton code en C.

Comme j'ai égaré ma boule de cristal...

[Blustuff]

L'assembleur peut aider par des instructions spécifiques, comme les rotations qui ne sont a prori pas ou peu utilisé par les compilateurs, en tout cas, pas sous ordre du codeur.

[dapounet]

L'instruction bswap permet de faire ça, elle prend un registre 32 bits ou 64 bits comme opérande.

[kris1980]

Je me suis inspiré de codes sur internet et voici mes pauvres tentatives sachant que si ma façon de mesurer est bonne la plus rapide et la 1er.

1)

Code :

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

1
2
3
4
5
6
7
8
9
 
#define SWAP_INT32(x) ( (((x)>>24) & 0x000000FFL) \
                      | (((x)>>8)  & 0x0000FF00L) \
                      | (((x)<<8)  & 0x00FF0000L) \
                      | (((x)<<24) & 0xFF000000L) )
 
#define SWAP_INT64(x) (((long long unsigned int) \
                       ((unsigned int)SWAP_INT32((unsigned int)((x<<32) >> 32))) << 32) \
                       |(unsigned int)SWAP_INT32((unsigned int)(x>>32) ))

2)

Code :

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

1
2
3
4
5
6
7
8
9
 
#define SWAP_INT64(x) ( (((x)>>56) & 0x00000000000000FFLL) \
                      | (((x)>>40) & 0x000000000000FF00LL) \
                      | (((x)>>24) & 0x0000000000FF0000LL) \
                      | (((x)>>8)  & 0x00000000FF000000LL) \
                      | (((x)<<8)  & 0x000000FF00000000LL) \
                      | (((x)<<24) & 0x0000FF0000000000LL) \
                      | (((x)<<40) & 0x00FF000000000000LL) \
                      | (((x)<<56) & 0xFF00000000000000LL) )

3)

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
16
17
18
19
20
21
22
23
24
 
void swap_int64(void* x)
{
  ((unsigned char*)x)[0] = ((unsigned char*)x)[7];
  ((unsigned char*)x)[1] = ((unsigned char*)x)[6];
  ((unsigned char*)x)[2] = ((unsigned char*)x)[5];
  ((unsigned char*)x)[3] = ((unsigned char*)x)[4];
  ((unsigned char*)x)[4] = ((unsigned char*)x)[3];
  ((unsigned char*)x)[5] = ((unsigned char*)x)[2];
  ((unsigned char*)x)[6] = ((unsigned char*)x)[1];
  ((unsigned char*)x)[7] = ((unsigned char*)x)[0];
}
 
inline void inline_swap_int64(void* x)
{
  ((unsigned char*)x)[0] = ((unsigned char*)x)[7];
  ((unsigned char*)x)[1] = ((unsigned char*)x)[6];
  ((unsigned char*)x)[2] = ((unsigned char*)x)[5];
  ((unsigned char*)x)[3] = ((unsigned char*)x)[4];
  ((unsigned char*)x)[4] = ((unsigned char*)x)[3];
  ((unsigned char*)x)[5] = ((unsigned char*)x)[2];
  ((unsigned char*)x)[6] = ((unsigned char*)x)[1];
  ((unsigned char*)x)[7] = ((unsigned char*)x)[0];
}

4)

Code :

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

1
2
3
4
5
6
7
8
 
#define bswap(cb){                             \
        register char   c;                      \
        c = ((unsigned char*)cb)[0]; ((unsigned char*)cb)[0] = ((unsigned char*)cb)[3]; ((unsigned char*)cb)[3] = c;    \
        c = ((unsigned char*)cb)[1]; ((unsigned char*)cb)[1] = ((unsigned char*)cb)[2]; ((unsigned char*)cb)[2] = c;    \
        c = ((unsigned char*)cb)[4]; ((unsigned char*)cb)[4] = ((unsigned char*)cb)[7]; ((unsigned char*)cb)[7] = c;    \
        c = ((unsigned char*)cb)[5]; ((unsigned char*)cb)[5] = ((unsigned char*)cb)[6]; ((unsigned char*)cb)[6] = c;    \
}

Je n'ai que de vieux souvenirs d'école du 68000, Si quelqu'un peut m'aider à réaliser ce petit bout de code assembleur sous MinGW... çà serait cool

[Smortex]

Salut!

D'un point de vue portabilité, il peut être mieux de se cantoner à du code C et utiliser sys/endian.h... Mais si les conversions sont effectivement le goulot d'étranglement pour le traitement des données, alors ok, essayons de voir ce qu'on peut faire

Tout d'abord, l'algo 3 est faux... a <= b puis b <= a; ... ça n'inverse pas a et b...

En mettant cet algo de côté, le plus lent est certainement 4 a cause des manipulations sur des octets seulement et tout ce qui va avec. 1 et 2 doivent être kiff kiff...

Si ça ne suffit pas, dans machine/endian.h, tu as des macros en asm pour faire ces inversions de variables, par exemple:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#define __word_swap_int_var(x) \
__extension__ ({ register __uint32_t __X = (x); \
   __asm ("rorl $16, %0" : "+r" (__X)); \
   __X; })
 
#define __byte_swap_int_var(x) \
__extension__ ({ register __uint32_t __X = (x); \
   __asm ("bswap %0" : "+r" (__X)); \
   __X; })
 
#define __byte_swap_word_var(x) \
__extension__ ({ register __uint16_t __X = (x); \
   __asm ("xchgb %h0, %b0" : "+q" (__X)); \
   __X; })

A regarder

[dapounet]

Donc pour convertir une variable en 32 bits :

Code :

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

1
2
mov eax, variable
bswap eax

Pour une variable 64 bits sur un processeur 64 bits :

Code :

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

1
2
mov rax, variable
bswap rax

Pour du 64 bits sur un processeur 32 bits, je propose :

Code :

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

1
2
3
4
5
mov ecx, ebx
mov edx, eax
 
bswap ecx
bswap edx

(avec la variable à inverser dans EAX:EBX, le résultat est dans ECX:EDX)

Même chose sans utiliser ECX:EDX, mais avec une instruction en plus :

Code :

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

1
2
3
4
5
6
xor eax, ebx
xor ebx, eax
xor eax, ebx
 
bswap eax
bswap ebx

Edit : Si tu utilises GCC il faudra sûrement convertir en syntaxe AT&T mais ça ne devrait pas être compliqué.

[kris1980]

Mea culpa, Le code N°3 est carrement faux...
J'ai une envie terrible de modifier mon post

Les macros __word_swap_int_var, __byte_swap_int_var, byte_swap_word_var n'existe pas dans la distribution MinGW.

Certaine personne conseille de copier le fichier endians.h de Cygwin dans le répertoire include de MinGW.

Cependant j'ai inclus le code directement dans mon source de test:

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
16
17
18
19
 
#define __word_swap_int_var(x) \
__extension__ ({ register unsigned int __X = (x); \
   __asm ("rorl $16, %0" : "+r" (__X)); \
   __X; })
 
#define __byte_swap_int_var(x) \
__extension__ ({ register unsigned int __X = (x); \
   __asm ("bswap %0" : "+r" (__X)); \
   __X; })
 
#define __byte_swap_word_var(x) \
__extension__ ({ register __uint16_t __X = (x); \
   __asm ("xchgb %h0, %b0" : "+q" (__X)); \
   __X; })
 
#define SWAP_INT64_4(x) (((long long unsigned int) \
                      ((unsigned int)__byte_swap_int_var((unsigned int)((x<<32) >> 32))) << 32) \
                      |(unsigned int)__byte_swap_int_var((unsigned int)(x>>32) ))

Pour info le Code N°2 est quasiment aussi lent que le N°4.
Le code N°1 va deux fois plus vite que le N°2.

Voici ma première fonction en assembleur x86

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
16
17
18
19
 
# swap_uint64.s
.data
.align 2
 
.global _swap_uint64
_swap_uint64:
  pushl %ebp  
  movl %esp, %ebp
 
  movl 12(%ebp), %eax
  movl 8(%ebp), %edx
 
  bswap %eax
  bswap %edx
 
  movl %ebp,%esp  
  popl %ebp
  ret

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
16
17
 
// swap_uint64.h
#ifndef __SWAP_UINT64_H__
#define __SWAP_UINT64_H__
 
#ifdef __cplusplus
extern "C"
{
#endif
 
extern long long unsigned int swap_uint64(long long unsigned int llui);
 
#ifdef __cplusplus
}
#endif
 
#endif

Qu'en pensez vous ?

J'ai un gain de 60% par rapport à la meilleure macro (code N°1)
Mais elle est moins performante que SWAP_INT64_4......

Est-il possible d'améliorer encore les performances ?
(J'utilise un processeur et un OS 32 Bits )

Que pensez vous que je puisse gagner en transformant cette fonction en procédure ?

Merci

[dapounet]

A mon avis ce serait plus performant de mettre les quelques instructions en assembleur inline que d'appeler une fonction en utilisant la pile et tout ça.
Je crois que l'instruction "movl %ebp,%esp" à la fin ne sert à rien puisque ESP n'est pas modifié dans la fonction.