Je suis en train d'optimiser ce code c en utilisant la boucle 4 voies

Question

Qu'est-ce que le déroulement, je suis en train de faire est de prendre ce code C et d'optimiser à l'aide d'une technique appelée boucle déroulage, mais dans ce cas je veux utiliser quatre déroulement de la boucle. Maintenant, je comprends la technique et je comprends le concept que je ne sais pas comment l'appliquer à ce code. Dois-je ajouter des variables supplémentaires? Dois-je avoir du code après chaque boucle ou juste à la fin de toutes les boucles? Ce code est un code de bloc 8x8 traitant de prendre des pixels et de le faire pivoter de 90 degrés dans le sens contraire des aiguilles d'une montre. Toute aide serait grandement appréciée. Je vous remercie.

/* 
* rotate8 - rotate with 8x8 blocking 
*/ 

char rotate8_descr[] = "rotate8: rotate with 8x8 blocking"; 

void rotate8(int dim, pixel *src, pixel *dst) 
{ 

int i, j, ii, jj; 

for(ii = 0; ii < dim; ii += 8) 
     for(jj = 0; jj < dim; jj += 8) 
       for (i = ii; i < ii + 8; i++) 
        for (j = jj; j < jj + 8; j++) 
         dst[RIDX(dim-1-j, i, dim)] = src[RIDX(i, j, dim)]; 
} 

Answer 1

Vous pouvez remplacer la boucle interne avec 8 lignes de code explicites

  dst[RIDX(dim-1-jj, i, dim)] = src[RIDX(i, jj, dim)]; 
      dst[RIDX(dim-1-(jj+1), i, dim)] = src[RIDX(i, (jj+1), dim)]; 
      ... 
      dst[RIDX(dim-1-(jj+7), i, dim)] = src[RIDX(i, (jj+7), dim)]; 

si vous remplacez la variable de boucle en écrivant explicitement une ligne pour chaque valeur qu'il faut.

Maintenant, vous pouvez répéter que, pour les 8 valeurs de la boucle suivante, vous aurez 8 x 8 lignes de code, et ainsi de suite.

Comme autre chose qu'un exercice de compréhension, cela semble assez inutile pour moi, compilateurs font ce genre de choses vraiment efficace, ils vont optimiser où il est logique. Rouler à la main produit rarement un code optimal.

Answer 2

 
gcc -funrull-loops 

Vous ne devriez pas vous déroulez boucles à moins que GCC ne peut le faire (voir l'assemblage) et vous avez prouvé à l'aide d'un profileur que vous devez accélérer cette partie du code.

Ce code exemple, vous avez l'air d'un candidat idéal pour déroulage de boucle automatique.

D'autres drapeaux utiles:

 
-O3       // turns on a lot of optimizations (almost all) 
-ftree-vectorize -msse2  // vectorizes automatically some loops 

Answer 3

je voulais dire le profil - mais je l'ai fait moi-même. La partie surprenante est - la boucle interne effectue le plus rapidement avec exactement votre disposition - le dérouler à la main est en fait plus lent.

Cependant - le vrai attrape est la macro RIDX. La commutation de la disposition de la mémoire et la commutation des boucles externes ont un impact significatif de .

Voilà ma version la plus rapide avec indentation pour montrer où elle diffère de votre version. La macro RIDX est supposée être telle que définie.

#define RIDX(x,y,d) (x+(y)*(d)) 
typedef unsigned char pixel; 
void rotate8(int dim, pixel *src, pixel *dst) 
{ 
    int i, j, ii, jj; 
     for(jj = 0; jj < dim; jj += 8) 
    for(ii = 0; ii < dim; ii += 8) 
       for (i = ii; i < ii + 8; i++) 
        for (j = jj; j < jj + 8; j++) 
         dst[RIDX(dim-1-j, i, dim)] = src[RIDX(i, j, dim)]; 
} 

... leçon apprise: :-) Toujours profil

Answer 4

http://www.relisoft.com/book/lang/pointer/2ptrarr.html

Si votre compilateur ne peut pas optimiser la version lisible, maintenable de l'algorithme, et vous devez doubler comme un compilateur humain - achetez un nouveau compilateur! Personne ne peut plus se permettre les compilateurs humains. Alors, ayez pitié de vous et de vos collègues programmeurs qui devront regarder votre code.