Discussion :

[progfou]

Normalement sur ARM on s'intéresse plus à la taille du code qu'à la performance.

Il est vrai que la taille de code a une influence non négligeable sur les performances, mais ta phrase, en soi, ne veut pas dire grand chose...
Si on te lit au 1er degré, on comprend qu'il ne ser(virai)t à rien d'optimiser, si ce n'est en taille ?
On peut faire un code très lent et tout petit nettement moins rapide qu'un code plus gros (je pense à une boucle, au hasard ).

[Charlemagne]

Je peux utiliser des mots de 64 bits (pas 128), dans ce cas précis, comment t'y prendrais-tu pour le faire ?

Sous Windows/Linux, y'a un fichier <xmmintrin.h> à inclure. Vérifie s'il n'en existe pas un semblable sous ton système.
Après tu peux peut-être faire un truc du genre:

Code :

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

std::copy((const __m64*)pX1,(const __m64*)pX2,(__m64*)pY)

et éventuellement t'inspirer d'une version perso de copy:

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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
template<class InIt, class OutIt>
inline OutIt copyn(size_t n, InIt in, OutIt out)
{
  for (; n>=UNROLL_SIZE; n-=UNROLL_SIZE) 
  { 
    *out=*in; 
#if UNROLL_SIZE>1    
    *++out=*++in;
#endif 
#if UNROLL_SIZE>2       
    *++out=*++in;
#endif 
#if UNROLL_SIZE>3       
    *++out=*++in;
#endif 
#if UNROLL_SIZE>4       
    *++out=*++in;
#endif 
#if UNROLL_SIZE>5       
    *++out=*++in;
#endif 
#if UNROLL_SIZE>6      
    *++out=*++in;
#endif 
#if UNROLL_SIZE>7       
    *++out=*++in;
#endif    
    ++in; ++out;
  } 
 
#if UNROLL_SIZE>1    
  switch (n)
  {
#if UNROLL_SIZE>7
    case 7: *out++=*in++;
    case 6: *out++=*in++;
    case 5: *out++=*in++;
    case 4: *out++=*in++;
#endif
#if UNROLL_SIZE>3
    case 3: *out++=*in++;
    case 2: *out++=*in++;
#endif
    case 1: *out++=*in++;
  }
#endif
  return ++out;
}

[progfou]

J'ai une version qui s'appelle <mmintrin.h>.

[Charlemagne]

C'est bien <mmintrin.h>.
Je me suis trompé, car <xmmintrin.h> est en fait pour SSE.

A propos MMX a un truc plutôt génant, on ne peut peut pas utiliser les calculs flottant en même temps. Et il faut réinitialiser les registres au passage de l'un à l'autre (je sais plus dans quel sens, peut-être même dans les 2).
Renseigne toi sur l'instruction _mm_empty.

[progfou]

J'ai continué mon investigation (j'avais un peu lâché l'affaire jusque là ), et je me rends compte que je peux spécialiser mes memcpy !
En effet, je connais la taille et le type des opérandes pour la plupart des cas.

Est-il possible d'en faire un template ?
Je dirais oui.
Si oui ( ) est-ce que cela peut me permettre de virer des if et des boucles ?
Là encore, je dirais oui...

[progfou]

Petite précision: j'ai essayé de spécialiser uniquement la taille, dans le cas où il y a 16 char à copier :

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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
template<>
__inline
void memcpytemplate<16>(void *dst, void *src)
{
	char *pcDst = (char *)dst;
	char const *pcSrc = (char const *)src;
 
	int IntDst = reinterpret_cast<int>(dst);
	int IntSrc = reinterpret_cast<int>(src);
 
	unsigned int iModulo;
	// test for same alignment
	if (((iModulo=(IntSrc & 0x03)) ^ (IntDst & 0x03))==0)
	{
		// byte count needed to align 32 bit
		//unsigned int iAlignCount=(4-iModulo) & 0x03;
		//	// head copy
		//	
		//	while (iAlignCount--)
		//		*pcDst++ = *pcSrc++;
 
		switch((4-iModulo) & 0x03)
		{
			case 3: *pcDst++ = *pcSrc++;
			case 2: *pcDst++ = *pcSrc++;
			case 1: *pcDst++ = *pcSrc++;
			default: break;
		}
 
			int	*lpDst = (int *)pcDst;
			int const *lpSrc = (int const *)pcSrc;
			// Copy the 16 words
			*lpDst++ = *lpSrc++;
			*lpDst++ = *lpSrc++;
			*lpDst++ = *lpSrc++;
			*lpDst++ = *lpSrc++;
 
	}
}

Edit: Est-ce que ça fonctionnera à tous les coups ?
Car ça a l'air de passer pour moi, mais c'est peut-être un coup de chance...

[loufoque]

Est-il possible d'en faire un template ?

ça s'appelle std::copy