Discussion :

[olivier21c]

Bonjour à toutes et à toutes.

Pour un algorithme de traitement d'informations, je dois appliquer sur un tableau 600x600 un filtre de corrélation 21x21

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
 
int demiTaille = 10;
for(int n=0; n< 600; ++n)
    for(int m=0; m<600; ++m)
    {
        int uBegin = std::max(0, n - demiTaille );
        int uEnd = std::min(600- 1, n + demiTaille );
        int vBegin = std::max(0, m - demiTaille );
        int vEnd = std::min(600- 1, m + demiTaille );
        double temp = 0.0;
        for(int u=uBegin; u<=uEnd; ++u)
            for(int v=vBegin; v<=vEnd; ++v)
                temp += abs(tabInitial[u][v]) * filter[demiTaille + u - n][demiTaille + v - m];
        tabFinal[n][m] = temp;
    }

Le problème est que l'exécution de cette partie dure 0.4 secondes, ce qui est trop long pour mon application.

Est ce que quelqu'un aurait des solutions d'optimisation.

Merci d'avance

[Nhaps]

Bonjour,

est ce que tes conteneurs sont des vectors ?

[olivier21c]

alors au depart oui j'ai utiliser des vector<vector<double>>, mais l'exécution était alors de 4.2s.
donc j'ai essayé avec des double**, et la je passe à 0.4s

je n'ai pas essayer de faire un vector<double> de taille 600x600 par contre...

[pyros]

essaye

Avec un double**, toutes tes données ne sont pas contiguë en mémoire. Avec un vector de taille 600*600 elle le seront et les accès mémoire seront beaucoup plus rapide.

Je te renvois là, ça pourrait t'aider:
http://www.developpez.net/forums/d10...cteur-vecteur/

[Goten]

essaye

Avec un double**, toutes tes données ne sont pas contiguë en mémoire. Avec un vector de taille 600*600 elle le seront et les accès mémoire seront beaucoup plus rapide.

Non, c'est pas garantie en C++98 (par contre toute les implémentations que je connaissent le sont oui )

[r0d]

une idée à tester, bien qu'il y a de grandes chances pour que le compilateur optimise ça lui-même, mais ne sait-on jamais:
- les tests d'arrêt de boucle. Ils sont appelés à chaque itération. Les == et != sont plus rapide que les <, >, <= ou >=

Après, moi je suis sûr que dans ce cas là, ce sera plus rapide avec des vector à une dimension et un iterateur, qu'avec un vector à une dimension et accès avec indice. Certainement pas un gain énorme, mais ce sera toujours ça de pris.

Et puis après, il faut chercher du côté de l'utilisation de threads, si tu as plusieurs cores ou plusieurs processeurs en particulier. Et surtout si tu peux trouver une méthode pour pouvoir permettre cela. Par exemple en découpant ta matrice en sous-matrices et appliquant le filtre dans des processus séparés, ce genre de choses.

Sinon iol doit bien y avoir des libs qui font ce genre de choses déjà non?

[Luc Hermitte]

Non, c'est pas garantie en C++98 (par contre toute les implémentations que je connaissent le sont oui )

La contigüité dans les vecteurs est garantie en C++03.
Pour les sttring, j'ai la flemme de chercher si c'est maintenant assuré dans le C++11.