Discussion :

[Atharendil]

Bonjour,

j'ai une fonction qui permet d'afficher des sprites sur un écran que je dois optimiser pour gagner le moindre temps processeur. J'ai déjà modifié certaines choses qui peuvent accélérer le temps d'éxecution.

Voilà le code de la fonction :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
inline void DisplaySprite(int * x, int * y, Sprite* pSprite){
unsigned int i;
unsigned int j;
 
 
const sp_h = pSprite->h;
const sp_w = pSprite->w;
 
unsigned int offset = (*x)+(*y)*W;
 
for (i=0; i<sp_h; i++)
	for(j=0; j<sp_w; j++)
		screen[offset + j + i*W] = pSprite->Im[j + i*sp_w];

La structure Sprite étant :

Code :

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

1
2
3
4
5
6
 
struct Sprite{
	int h;
	int w;
	char* Im;
}

Auriez-vous des idées quant à ce qui resterait à faire pour améliorer la fonction et augmenter la rapidité d'exécution ?

[Emmanuel Delahaye]

Bonjour,

j'ai une fonction qui permet d'afficher des sprites sur un écran que je dois optimiser pour gagner le moindre temps processeur. J'ai déjà modifié certaines choses qui peuvent accélérer le temps d'éxecution.

Voilà le code de la fonction :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
inline void DisplaySprite(int * x, int * y, Sprite* pSprite){
unsigned int i;
unsigned int j;
 
 
const sp_h = pSprite->h;
const sp_w = pSprite->w;
 
unsigned int offset = (*x)+(*y)*W;
 
for (i=0; i<sp_h; i++)
	for(j=0; j<sp_w; j++)
		screen[offset + j + i*W] = pSprite->Im[j + i*sp_w];

La structure Sprite étant :

Code :

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

1
2
3
4
5
6
 
struct Sprite{
	int h;
	int w;
	char* Im;
}

Auriez-vous des idées quant à ce qui resterait à faire pour améliorer la fonction et augmenter la rapidité d'exécution ?

Pourquoi les pointeurs x et y ?

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
 
inline void DisplaySprite(int const x, int const y, Sprite const * pSprite)
{
   int const sp_h = pSprite->h;
   int const sp_w = pSprite->w;
 
   unsigned int const offset = x + y * W;
 
   unsigned int i;
 
   for (i = 0; i < sp_h; i++)
   {
      /* precalculs */
      unsigned const i_w = i*W;
      unsigned const i_sp_w = i*sp_w;
      unsigned int j;
      for (j = 0; j < sp_w; j++)
      {   
         screen[offset + j + i_w] = pSprite->Im[j + i_sp_w];
      }
   }
}

Je ne crois pas pouvoir faire mieux...

[Jean-Marc.Bourguet]

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
inline void DisplaySprite(int * x, int * y, Sprite* pSprite){
unsigned int i;
unsigned int j;
 
 
const sp_h = pSprite->h;
const sp_w = pSprite->w;
 
unsigned int offset = (*x)+(*y)*W;
 
for (i=0; i<sp_h; i++)
	for(j=0; j<sp_w; j++)
		screen[offset + j + i*W] = pSprite->Im[j + i*sp_w];

La structure Sprite étant :

Code :

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

1
2
3
4
5
6
 
struct Sprite{
	int h;
	int w;
	char* Im;
}

Auriez-vous des idées quant à ce qui resterait à faire pour améliorer la fonction et augmenter la rapidité d'exécution ?

screen, c'est un char* aussi je suppose?

La boucle intérieure, c'est dans ce cas un

Code :

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

memcpy(screen+offset+i*W, pSprite->Im+i*sp_w, sp_w);

Après, on peut éviter une partie des multiplications:

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
inline void DisplaySprite(int * x, int * y, Sprite* pSprite){
unsigned int i;
unsigned int j;
 
 
const sp_h = pSprite->h;
const sp_w = pSprite->w;
 
unsigned int offset = (*x)+(*y)*W;
 
char* dst = screen+offset;
char* src = pSprite->Im
for (i=0; i<sp_h; i++) {
   memcpy(dst, src, sp_w);
   dst += W;
   src += sp_w;
}

Mais il faudrait vraisemblablement ajouter du code pour permettre au sprite de se rapprocher des bords... et ce genre de transformations est à la portée des optimiseurs. Il n'est donc pas sûr que ce soit un gain.

[Atharendil]

Merci à vous deux, je n'aurais pas pensé à toutes ces optimisations.

screen, c'est un char* aussi je suppose?

Oui, screen est un char* comme l'Im de la structure Sprite, chaque octet correspondant à un pixel.

Pourquoi les pointeurs x et y ?

J'ai utilisé un passage des paramètres x et y par référence pour éviter une copie des int passés en paramètre, qui aurait été plus gourmande en ressource. Pas grand chose, c'est vrai, mais j'essaie d'obtenir le code le plus optimisé qui soit

[Jean-Marc.Bourguet]

J'ai utilisé un passage des paramètres x et y par référence pour éviter une copie des int passés en paramètre, qui aurait été plus gourmande en ressource. Pas grand chose, c'est vrai, mais j'essaie d'obtenir le code le plus optimisé qui soit

Tu as mesuré? Sur quelle architecture? Je ne connais aucune architecture sur laquelle a priori passer un pointeur par valeur puis faire une indirection est plus couteux que de passer un int par valeur et je n'arrive même pas à imaginer comment une telle machine pourrait être concue. De plus, si je peux imaginer des machines pour lesquelles la pression sur l'allocation de registre favoriserait parfois ce genre de transformation, je n'en connais pas.

[ram-0000]

J'ai utilisé un passage des paramètres x et y par référence pour éviter une copie des int passés en paramètre, qui aurait été plus gourmande en ressource. Pas grand chose, c'est vrai, mais j'essaie d'obtenir le code le plus optimisé qui soit

Donc tu passes un pointeur (une référence est un pointeur masqué) sur ces int au lieu de passer leurs valeurs.

Dans ta fonction appelée, il faut donc déréférencer tes pointeurs pour obtenir la valeur.

Je ne suis pas sûr que cela soit une bonne idée

[Emmanuel Delahaye]

J'ai utilisé un passage des paramètres x et y par référence pour éviter une copie des int passés en paramètre, qui aurait été plus gourmande en ressource. Pas grand chose, c'est vrai, mais j'essaie d'obtenir le code le plus optimisé qui soit

Etant donné que tu as demandé un 'inline', c'est un peu absurde. Avec un passage par valeur directe, le code généré en inline peut être simplifié facilement par l'optimiseur. Avec un passage par l'adresse de l'int, c'est beaucoup moins sûr... Il faudrait voir le code généré.

[orfix]

J'ai utilisé un passage des paramètres x et y par référence pour éviter une copie des int passés en paramètre, qui aurait été plus gourmande en ressource <...>

En C il y a que des passages par valeur ! et peut-être que chez toi sizeof(int)==sizeof(int*) , donc pas vraiment de gain sur ce coup, pire peut être avec le déréférencement des pointeurs pour accéder aux valeurs comme l'a signalé ram-0000

[Atharendil]

Yep, my mistake... ne m'y connaissant pas tellement en optimisation, j'avais lu un tutoriel qui donnait plusieurs méthodes et parlait justement du passage par référence plutôt que par valeur.

Ca doit être approprié dans certains cas, mais pas dans le cas des int et s'il y a déréférencement. J'ai donc remis un passage par valeur pour x et y.

Merci à tous