[Performance] Image RGB et GrayScale

Version imprimable

10/09/2008, 19h34
poukill

[Performance] Image RGB et GrayScale

Bonjour à tous,

J'aurai voulu quantifier la perte de performance entre une image RGBA (3 channels + couche alpha) et une image GrayScale (un seul canal) dans des algorithmes.
Est-ce 3 fois plus lent en RGB? 4 fois plus lent?
Ou bien est-ce que ça dépend du processeur (mise en cache, alignement, etc...) ou de l'OS (32, 64 bits)

J'avoue ne vraiment pas avoir d'idées sur le sujet. Merci d'éclairer ma lanterne ! ;)
10/09/2008, 20h51
yan

Ben es ce que les opération sur int (RGBA) est plus longue que sur char(GrayScale)???

Tout depend de ce que tu fait.
Pour additionner ce sera proche, pour gérer de l'alpha ça sera plus long.
Quels type de traitement fait tu?
11/09/2008, 07h43
poukill
Mes traitements sont très différents d'une fonction à l'autre, mais globalement je touche pas trop à l'alpha.
Quelques exemples:
- Parcours d'images avec recherche de maximum/moyenne
- Multiplication de l'image par une constante
- Soustraction d'une image par rapport à une autre
Les fonctions plus avancées se décomposant toujours en une somme d'opérations plus simple...

Tu penses que pour des traitements simples comme soustraire une image à une autre les performances vont être quasi identique? Pourtant il faudra bien itérer sur les 3 composantes RGB, c'est plus long non? :koi:

:merci:
11/09/2008, 10h05
yan

Citation:

Envoyé par poukill

Tu penses que pour des traitements simples comme soustraire une image à une autre les performances vont être quasi identique? Pourtant il faudra bien itérer sur les 3 composantes RGB, c'est plus long non? :koi:

Je pense que ce ne sera pas 3 fois.
De ce que je comprend, ce qui prend surtout du temps dans le traitement d'image ce sont les boucles (préférer une seul boucle pour parcourir tout les pixels) et les accès mémoire(préférer de la mémoire contigüe).
Ceci sera très proche pour les deux types d'images.

Donc ce qui reste est le temps de ton traitement par pixel. Je ne pense pas qu'une recherche de maximum ou moyenne pour du rgb soit 3 fois plus longue que pour GrayScale. Le compilo y ferra surement des optimisations.

Tu devrais poser la question sur le forum de traitement d'image, tu auras surement de meilleur avis ;)
http://www.developpez.net/forums/f64...ement-dimages/
11/09/2008, 13h22
Frifron

tout depend si tu fais tes opération au pixel sur les composantes couleurs (4 opérations sur 8 bits par pixels en RGBA) ou sur la couleur en elle même (1 opération sur 32 bits). Si c'est sur la couleur en elle même, les perf seront plus ou moins identiques car la boucle fera la même longueur (ce sera juste des opérations sur 32 bits au lieu de 8 bits -> a voir les différences de perfs niveau hardware). Par contre si c'est sur chaque composante couleur séparément, la ta boucle sera 4 fois plus longue avec des opérations sur 8 bits donc ton algo prendra 4 fois plus de temps.

Après niveau rendu, une chose est sur la gestion de l'alpha le ralenti de facon significative car tu a les opérations de blending qui s'ajoute.
11/09/2008, 17h00
poukill
Merci à vous pour vos réponses.
On pourrait assimiler:
- une image RGB à un std::vector <RGBValue> ( 3 * 8 bits)
- une image GrayScale à un vector<unsigned short> (16 bits)
Je pensais que du coup on est obligé d'itérer sur les 3 composantes au lieu d'une sur la greyscale et qu'on a une perte de temps assez importante...

J'entends pas mal de gens autour de moi dire effectivement que un algo simple appliqué sur une image RGB sera à peine plus lent que sur une GrayScale.
Je pense que je vais écrire quelques benchmarks dès que possible pour mettre un début à ce débat. Y'a rien de mieux que l'expérience non ? :lol:

:merci:
11/09/2008, 19h04
Frifron
Citation:
Envoyé par poukill

Merci à vous pour vos réponses.
On pourrait assimiler:

une image RGB à un std::vector <RGBValue> ( 3 * 8 bits)
une image GrayScale à un vector<unsigned short> (16 bits)
Seulement si ton image RGB est en 8 bits par couches et ton gray scale en 16 bits. En regle général le grayscale sera plutot en 8 bits.

Pour en revenir a la rapidité d'une opération entre grayscale et image RGB, ca depend vraiment de l'opération. Pour les opérations que tu cites tu devra travailler sur chacune des composantes indépendamment, ce sera donc 3 fois plus lent.

Par exemple pour trouver la moyenne entre 2 couleurs, mettons en RGBA (FF,00,00,FF) et (00,00,FF,FF), la moyenne que tu cherche sera naturellement (7F,00,7F,FF). Si tu travailles sur la couleur en entier tu va te retrouver avec (0xFF0000FF + 0x0000FFFF) >> 1 = 0x7F08087F qui n'est pas le résultat recherché. Donc pour ce cas la, ca va te prendre plus de temps en effet.

Par contre si tu travaille sur une composante uniquement. Par exemple rajouter du vert, la ca sera a peu pret identique en temps que de rajouter du gris dans un image grayscale.

Ou un autre exemple passer une image en négatif, il suffit d'inverser les bits de toute la couleur (même sur toute l'image en fait). Donc la tu travaille sur la couleur et non plus sur la composante, donc performance plus ou moins équivalentes aussi. [EDIT]Mais dans ce cas tu peux optimisé en travaillant sur 32bits par exemple, donc le grayscale sera encore une fois plus rapide car moins de données a traiter. Donc c'est un mauvais exemple

Donc, oui le traitement d'image RGB prend en général plus de temps que celui en grayscale. Ce qui est logique dans la mesure ou il y a 3 canaux. Mais encore une fois, tout dépend du format d'image et de l'opération
11/09/2008, 19h12
yan

Citation:

Envoyé par Frifron

Pour en revenir a la rapidité d'une opération entre grayscale et image RGB, ca depend vraiment de l'opération. Pour les opérations que tu cites tu devra travailler sur chacune des composantes indépendamment, ce sera donc 3 fois plus lent.

Perso, je ne périrai pas dessus. Le compilo peut certainement faire des chose pour optimiser.
Y as plus qu'un petit bench a faire pour vérifier
11/09/2008, 19h26
Frifron

D'accord, mais le compilo ne va pas te changer la complexité de l'algo. Une opération par pixel va être linéaire. Tu multiplies par 3 le nombre de données sur lesquelles réaliser l'opération, bah le temps de calcul sera multiplié par 3

code

Code:

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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
#include <iostream>
#include <vector>
#include <list>
#include <deque>
#include <set>
#include <algorithm>
#include <ctime>
#include <cmath>
using namespace std;
const int num =1000;
template<typename T>
struct image
{
    image(int hh,int ww)
    :h(hh),w(ww),buffer(hh*ww)
    {};
    int h;
    int w;
    vector<T> buffer;
};
 
struct pix
{
    pix():r(0),g(0),b(0)
    {};
 
    pix(char rr,char gg,char bb)
    :r(rr),g(gg),b(bb)
    {}
 
    char r;
    char g;
    char b;
    pix& operator*=(int a)
    {
        r*=a;
        g*=a;
        b*=a;
           return *this;
    }
};
 
struct gen
{
    char operator()()
    {
        return rand()%256+1;
    }
};
 
struct genpix
{
    pix operator()()
    {
        pix p;
        p.r = rand()%256+1;
        p.g = rand()%256+1;
        p.b = rand()%256+1;
        return p;
    }
 
};
template <typename T>
struct multiplie
{
    multiplie(int aa):a(aa){};
    void operator()(T & pix)
    {
        pix*=a;
 
    }
    int a;
};
 
 
struct MIN
{
    MIN():min(255){};
    void operator()(char pix)
    {
        if (pix<min) min = pix;
    }
    char min;
};
 
struct MINPIX
{
    MINPIX()
    :min(255,255,255)
    {};
    void operator()(const pix & pix)
    {
        if (pix.r<min.r) min.r = pix.r;
        if (pix.g<min.g) min.g = pix.g;
        if (pix.b<min.b) min.b = pix.b;
    }
    pix min;
};
int main(int argc, char* argv[])
{
srand(clock());
   image<char> img(1000,1000);
   std::generate
       (
           img.buffer.begin(),
           img.buffer.end(),
           gen()
       );
   image<pix>  imgRGB(1000,1000);
    std::generate
       (
           imgRGB.buffer.begin(),
           imgRGB.buffer.end(),
           genpix()
       );
 
 
    while(1)
    {
    clock_t t0 = clock();
 
    for (int i =0;i<num;++i)
    {
        std::for_each
            (
                img.buffer.begin(),
                img.buffer.end(),
                multiplie<char>(2)
             );
    }
    double tempA = double(clock()-t0)/num;
    std::cout<<"************MULTIPLICATION**************" <<std::endl;
    std::cout<<"grayscale""  "<<tempA <<std::endl;
 
    t0 = clock();
    for (int i =0;i<num;++i)
    {
        std::for_each
            (
                imgRGB.buffer.begin(),
                imgRGB.buffer.end(),
                multiplie<pix>(2)
             );
    }
    double tempB = double(clock()-t0)/num;
    std::cout<<"rgb"<<"  "<<tempB <<std::endl;
 
    std::cout<<"rgb/grayscale"<<" "<<100*(tempB/tempA)<<"%"<<std::endl;
 
    t0 = clock();
    int min;
    for (int i =0;i<num;++i)
    {
        min = std::for_each
            (
                img.buffer.begin(),
                img.buffer.end(),
                MIN()
             ).min;
    }
    tempA = double(clock()-t0)/num;
    std::cout<<"************MIN**************" <<std::endl;
    std::cout<<"grayscale""  "<<tempA <<std::endl;
 
    t0 = clock();
    pix minpix;
    for (int i =0;i<num;++i)
    {
       minpix = std::for_each
            (
                imgRGB.buffer.begin(),
                imgRGB.buffer.end(),
                MINPIX()
             ).min;
    }
    tempB = double(clock()-t0)/num;
    std::cout<<"rgb "<<minpix.r<<"  "<<minpix.g<<"  "<<minpix.b<<"  "<<tempB <<std::endl;
 
    std::cout<<"B/A"<<" "<<100*(tempB/tempA)<<"%"<<std::endl;
    }
 
	return 0;
}

sous visual :
multiplication : rapport de 211%
recherche du min : rapport de 450% (ca je m'y attendais pas)

sous mingw :
multiplication : identique
recherche du min : rapport de 339%

[edit]
j'ai utilisé des char au lieu des unsigned char mais les résultat sont pareil.

11/09/2008, 20h30
millie

Pour certains types d'opérateurs, il est possible de multithreadé par canaux les opérateurs. (chaque thread s'occupe d'un canal ce qui réduit donc en général bien le temps sur les quad-core)

Maintenant, il faut voir aussi le type d'opération. Si ça prend 1ms pour du mono canal ou 3ms pour du RGB, c'est pas la fin du monde (sauf si tu fais l'opération 100 fois par seconde). Si c'est 10 sec pour du mono ou du 30 sec pour du RGB, là il faut se poser des questions.

En Java, sur un quad-core, avec mes algorithmes, j'ai un temps équivalent pour du RGB ou du Gray.

EDIT : J'avais également fait de tests dans le temps en C++ sur des Solaris quadri-processeur, ça réduisait bien le temps.

On arrive tout de même a des perf bien inferieure en RGB. De plus tu ne testes pas l'overflow sur la multiplication. Je l'ai rajouté et on passe à un ratio de 290% (VISUAL).
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 struct multiplie { multiplie(int aa):a(aa){}; void operator()(unsigned char& pix) { pix = std::min(255,pix * a); } int a; }; struct multipliePIX { multipliePIX(int aa):a(aa){}; void operator()(pix& pix) { pix.r = std::min(255,pix.r * a); pix.g = std::min(255,pix.g * a); pix.b = std::min(255,pix.b * a); } int a; };
Quand tu dis "identique" sous mingw ca veut dire identique a visual ou 100% ? Et ca donne quoi avec le seuil ?

11/09/2008, 21h29
yan

Citation:

Envoyé par Frifron

On arrive tout de même a des perf bien inferieure en RGB.

Bien sur. Rien n'est magique. Je voulais juste dire que le compilo peut faire des chose qui réduise l'écart.

Citation:

Envoyé par Frifron

De plus tu ne testes pas l'overflow sur la multiplication. Je l'ai rajouté et on arrive à un ratio de 308% (VISUAL)

c'est pour cela que j'avais la multiplication et le min. Histoire de pas tout mélanger.

Enfin de toute facon un produit en traitement de l'image c'est plutot sur une echelle de 0 a 1 donc en fait ca donne plutot ca :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 struct multiplie { multiplie(int aa):a(aa){}; void operator()(unsigned char& pix) { pix = (pix * a) / 255; } int a; }; struct multipliePIX { multipliePIX(int aa):a(aa){}; void operator()(pix& pix) { pix.r = (pix.r * a) / 255; pix.g = (pix.g * a) / 255; pix.b = (pix.b * a) / 255; } int a; };
Avec ca on a du 299%. Les opti ici sont négligeables. Mais en effet pour certaines opérations le compilo optimisera ce qui descendra en dessous des 3 fois plus lent. Par ailleurs pour d'autres (ton min par exemple) on se retrouve avec des opérations qui prennent plus de 3x le temps. Donc on peut tout de même affirmer que les opérations au pixel sur du RGB sont plus lentes en rêgles générale. Après la solutions du multithread peut en effet amoindrir considérablement le différence dans le cas de proc multi core.

12/09/2008, 10h36
Sylvain Togni

Et si l'image en niveaux de gris rentre dans le cache mais pas l'image RGB, c'est pas un facteur 3 qu'il risque d'y avoir mais plutôt un facteur 10 ou 20.

Citation:

Envoyé par millie

Pour certains types d'opérateurs, il est possible de multithreadé par canaux les opérateurs. (chaque thread s'occupe d'un canal ce qui réduit donc en général bien le temps sur les quad-core)

OK d'accord...

Citation:

Envoyé par millie

Maintenant, il faut voir aussi le type d'opération. Si ça prend 1ms pour du mono canal ou 3ms pour du RGB, c'est pas la fin du monde (sauf si tu fais l'opération 100 fois par seconde). Si c'est 10 sec pour du mono ou du 30 sec pour du RGB, là il faut se poser des questions.

La, pas d'accord... enfin du moins pour mon application. Je travaille sur du temps reel et donc 1ms et 3 ms pour moi il y a un monde... ;)

Citation:

Envoyé par Mongaulois

code

Code:

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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
#include <iostream>
#include <vector>
#include <list>
#include <deque>
#include <set>
#include <algorithm>
#include <ctime>
#include <cmath>
using namespace std;
const int num =1000;
template<typename T>
struct image
{
    image(int hh,int ww)
    :h(hh),w(ww),buffer(hh*ww)
    {};
    int h;
    int w;
    vector<T> buffer;
};
 
struct pix
{
    pix():r(0),g(0),b(0)
    {};
 
    pix(char rr,char gg,char bb)
    :r(rr),g(gg),b(bb)
    {}
 
    char r;
    char g;
    char b;
    pix& operator*=(int a)
    {
        r*=a;
        g*=a;
        b*=a;
           return *this;
    }
};
 
struct gen
{
    char operator()()
    {
        return rand()%256+1;
    }
};
 
struct genpix
{
    pix operator()()
    {
        pix p;
        p.r = rand()%256+1;
        p.g = rand()%256+1;
        p.b = rand()%256+1;
        return p;
    }
 
};
template <typename T>
struct multiplie
{
    multiplie(int aa):a(aa){};
    void operator()(T & pix)
    {
        pix*=a;
 
    }
    int a;
};
 
 
struct MIN
{
    MIN():min(255){};
    void operator()(char pix)
    {
        if (pix<min) min = pix;
    }
    char min;
};
 
struct MINPIX
{
    MINPIX()
    :min(255,255,255)
    {};
    void operator()(const pix & pix)
    {
        if (pix.r<min.r) min.r = pix.r;
        if (pix.g<min.g) min.g = pix.g;
        if (pix.b<min.b) min.b = pix.b;
    }
    pix min;
};
int main(int argc, char* argv[])
{
srand(clock());
   image<char> img(1000,1000);
   std::generate
       (
           img.buffer.begin(),
           img.buffer.end(),
           gen()
       );
   image<pix>  imgRGB(1000,1000);
    std::generate
       (
           imgRGB.buffer.begin(),
           imgRGB.buffer.end(),
           genpix()
       );
 
 
    while(1)
    {
    clock_t t0 = clock();
 
    for (int i =0;i<num;++i)
    {
        std::for_each
            (
                img.buffer.begin(),
                img.buffer.end(),
                multiplie<char>(2)
             );
    }
    double tempA = double(clock()-t0)/num;
    std::cout<<"************MULTIPLICATION**************" <<std::endl;
    std::cout<<"grayscale""  "<<tempA <<std::endl;
 
    t0 = clock();
    for (int i =0;i<num;++i)
    {
        std::for_each
            (
                imgRGB.buffer.begin(),
                imgRGB.buffer.end(),
                multiplie<pix>(2)
             );
    }
    double tempB = double(clock()-t0)/num;
    std::cout<<"rgb"<<"  "<<tempB <<std::endl;
 
    std::cout<<"rgb/grayscale"<<" "<<100*(tempB/tempA)<<"%"<<std::endl;
 
    t0 = clock();
    int min;
    for (int i =0;i<num;++i)
    {
        min = std::for_each
            (
                img.buffer.begin(),
                img.buffer.end(),
                MIN()
             ).min;
    }
    tempA = double(clock()-t0)/num;
    std::cout<<"************MIN**************" <<std::endl;
    std::cout<<"grayscale""  "<<tempA <<std::endl;
 
    t0 = clock();
    pix minpix;
    for (int i =0;i<num;++i)
    {
       minpix = std::for_each
            (
                imgRGB.buffer.begin(),
                imgRGB.buffer.end(),
                MINPIX()
             ).min;
    }
    tempB = double(clock()-t0)/num;
    std::cout<<"rgb "<<minpix.r<<"  "<<minpix.g<<"  "<<minpix.b<<"  "<<tempB <<std::endl;
 
    std::cout<<"B/A"<<" "<<100*(tempB/tempA)<<"%"<<std::endl;
    }
 
	return 0;
}

Merci Mongaulois pour ce bench. Je vais essayer de le tester la semaine prochaine avec mes algos. je vous tiens au courant..

:merci: a tous !!! :king:

12/09/2008, 10h40
millie

Citation:

Envoyé par poukill

La, pas d'accord... enfin du moins pour mon application. Je travaille sur du temps reel et donc 1ms et 3 ms pour moi il y a un monde... ;)

Le problème pour des temps aussi court, c'est que tu perds bien quelques millisecondes à créer les threads, donc tu ne gagnes pas forcement de temps avec l'histoire des mes threads. Après, c'est quel genre de temps réel ? Est-ce qu'il est possible de mettre en cache des résultats ?
12/09/2008, 11h00
ram-0000

Citation:

Envoyé par millie

Le problème pour des temps aussi court, c'est que tu perds bien quelques millisecondes à créer les threads

En général, en temps réel, les threads sont créés au début (lors de la phase d'allocation des ressources du programme) et ensuite, ils sont gérés par un pool de threads auquel on demande une tâche.

Il n'y a plus de création supplémentaire de thread et il n'y a pas non plus de destruction des threads (à part peut être à la fin du programme pour autant qu'il ait une fin).
12/09/2008, 11h04
millie

Citation:

Envoyé par ram-0000

En général, en temps réel, les threads sont créés au début (lors de la phase d'allocation des ressources du programme) et ensuite, ils sont gérés par un pool de threads auquel on demande une tâche.

Par contre là, je ne sais pas trop le comportement que ça peut avoir car s'il y a trop de thread et qui sont déjà dans un pool (chaque thread est associé à un coeur du processeur une fois pour toute).

Quand on recréait par exemple 3 threads pour les trois canaux, l'OS va essayer de répartir les threads sur les coeurs les moins occupés ce qui permet d'avoir en général les 3 threads sur des coeurs différents (donc là ça roule).
Si tous les threads sont crées depuis le début, j'ai l'impression qu'il est plus probable de choisir des threads dans la pool qui sont associé à un même coeur (dans ce cas, il n'y a pas de gain de performance).

Enfin, je dis ça, mais je ne sais pas trop quel va être le comportement dans un cas comme ça :?

Bon je viens de passer deux trois heures à bencher... ET là c'est le drame...
Autant en char ou unsigned char, le RGB est pas trop pénalisé.
Autant en float le RGB est méchamment ralenti!!!

Voici le code de Mongaulois que j'ai templaté pour pouvoir changer plus facilement dans le main le type de données à prendre : float, unsigned char, unsigned short...

Code:

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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
 
#include <iostream>
#include <vector>
#include <list>
#include <deque>
#include <set>
#include <algorithm>
#include <ctime>
#include <cmath>
#include <limits>
using namespace std;
const int num =1000;
 
template<typename T>
struct Image
{
	typedef T value_type;
 
    Image(int hh,int ww)
    :h(hh),w(ww),buffer(hh*ww)
    {}
    int h;
    int w;
    vector<T> buffer;
};
 
template <typename T>
struct RGB
{
    RGB():r(0),g(0),b(0)
    {};
 
    RGB(T rr,T gg,T bb)
    :r(rr),g(gg),b(bb)
	{}
 
    T r;
    T g;
    T b;
 
	template <typename TYPE>
    RGB& operator*=(TYPE a)
    {
        r*=a;
        g*=a;
        b*=a;
        return *this;
    }
};
 
template <typename T>
struct Gen
{
	T operator()()
    {
		return static_cast<T> ((rand() * 1.0)/RAND_MAX * std::numeric_limits<T>::max() ) ;
    }
};
 
template <typename T>
struct GenRGB
{
    RGB<T> operator()()
    {
        RGB<T> p;
		p.r = static_cast<T> ((rand() * 1.0)/RAND_MAX * std::numeric_limits<T>::max() ) ;
        p.g = static_cast<T> ((rand() * 1.0)/RAND_MAX * std::numeric_limits<T>::max() ) ;
		p.b = static_cast<T> ((rand() * 1.0)/RAND_MAX * std::numeric_limits<T>::max() ) ;
        return p;
    }
 
};
template <typename T>
struct Multiplie
{
    Multiplie(T aa):a(aa){};
 
	template <typename TYPE>
    void operator()(TYPE & RGB)
    {
        RGB *= a;
    }
    T a;
};
 
 
template <typename T>
struct MIN
{
	typedef T value_type;
 
    MIN():min(255){};
    void operator()(T RGB)
    {
        if (RGB<min) min = RGB;
    }
    T min;
};
 
template <typename T>
struct MINRGB
{
    MINRGB()
    :min(255,255,255)
    {}
    void operator()(const RGB<T> & RGB)
    {
        if (RGB.r<min.r) min.r = RGB.r;
        if (RGB.g<min.g) min.g = RGB.g;
        if (RGB.b<min.b) min.b = RGB.b;
    }
    RGB<T> min;
};
 
 
 
 
int main(int argc, unsigned char* argv[])
{	
	typedef unsigned short  TYPE_GRAYSCALE;
	typedef float			TYPE_RGB;
 
 
	// GENERATION DES IMAGES ...
	srand(clock());
	Image<TYPE_GRAYSCALE> img(200,200);
	std::generate
	   (
		   img.buffer.begin(),
		   img.buffer.end(),
		   Gen<TYPE_GRAYSCALE>()
	   );
	Image<RGB<TYPE_RGB>>  imgRGB(200,200);
	std::generate
	   (
		   imgRGB.buffer.begin(),
		   imgRGB.buffer.end(),
		   GenRGB<TYPE_RGB>()
	   );
 
	// FIN GENERATION
 
 
    while(1)
    {
		clock_t t0 = clock();
 
		for (int i =0;i<num;++i)
		{
			std::for_each
				(
					img.buffer.begin(),
					img.buffer.end(),
					Multiplie<TYPE_GRAYSCALE>(2)
				 );
		}
		double tempA = double(clock()-t0)/num;
		std::cout<<"************MULTIPLICATION**************" <<std::endl;
		std::cout<<"grayscale""  "<<tempA <<std::endl;
 
		t0 = clock();
		for (int i =0;i<num;++i)
		{
			//std::cout << i << endl;
			std::for_each
				(
					imgRGB.buffer.begin(),
					imgRGB.buffer.end(),
					Multiplie<TYPE_RGB>(2)
				 );
		}
		double tempB = double(clock()-t0)/num;
		std::cout<<"rgb"<<"  "<<tempB <<std::endl;
 
		std::cout<<"rgb/grayscale"<<" "<<100*(tempB/tempA)<<"%"<<std::endl;
 
		t0 = clock();
		int min;
		for (int i =0;i<num;++i)
		{
			min = std::for_each
				(
					img.buffer.begin(),
					img.buffer.end(),
					MIN<TYPE_GRAYSCALE>()
				 ).min;
		}
		tempA = double(clock()-t0)/num;
		std::cout<<"************MIN**************" <<std::endl;
		std::cout<<"grayscale""  "<<tempA <<std::endl;
 
		t0 = clock();
		RGB<TYPE_RGB> minRGB;
		for (int i =0;i<num;++i)
		{
		   minRGB = std::for_each
				(
					imgRGB.buffer.begin(),
					imgRGB.buffer.end(),
					MINRGB<TYPE_RGB>()
				 ).min;
		}
		tempB = double(clock()-t0)/num;
		std::cout<<"rgb "<<minRGB.r<<"  "<<minRGB.g<<"  "<<minRGB.b<<"  "<<tempB <<std::endl;
 
		std::cout<<"B/A"<<" "<<100*(tempB/tempA)<<"%"<<std::endl;
    }
 
	return 0;
}

Mais tout de même, pourquoi cette performance nulle en float? Mise en cache pas suffisante??? 8O

12/09/2008, 15h27
yan

Citation:

Envoyé par poukill

Mais tout de même, pourquoi cette performance nulle en float? Mise en cache pas suffisante??? 8O

EN faite y as un petit problème dans mon code... Lors de la multiplication fait num fois, y as de forte chance que tout les float devienne infinie et les type entier à zéro. Et le cas des inf est un cas particulier qui il me semble plomb les résultats....
Il faudrait régénérer les pixels de l'image avant chaque traitement...

Voila
je ne pense pas m'être trompé.
J'ai par contre viré le std::numeric_limits<T>::max() car avec les float tu as trés souvent un inf aprés la multiplication.

Si je ne me suis pas gouré, ça devrait fortement te rassurer (multiplication parfois plus rapide en rgb :roll:)
Par contre l'écart n'est pas constant, mais j'ai une machine de merde au taf

Code:

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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
#include <iostream>
#include <vector>
#include <list>
#include <deque>
#include <set>
#include <algorithm>
#include <ctime>
#include <cmath>
#include <limits>
using namespace std;
const int num =1000;
 
template<typename T>
struct Image
{
	typedef T value_type;
 
    Image(int hh,int ww)
    :h(hh),w(ww),buffer(hh*ww)
    {}
    int h;
    int w;
    vector<T> buffer;
};
 
template <typename T>
struct RGB
{
    RGB():r(0),g(0),b(0)
    {};
 
    RGB(T rr,T gg,T bb)
    :r(rr),g(gg),b(bb)
	{}
 
    T r;
    T g;
    T b;
 
	template <typename TYPE>
    RGB& operator*=(TYPE a)
    {
        r*=a;
        g*=a;
        b*=a;
        return *this;
    }
};
 
template <typename T>
struct Gen
{
	T operator()()
    {
		return static_cast<T> ((rand() * 1.0)/RAND_MAX * 1024 ) ;
    }
};
 
template <typename T>
struct GenRGB
{
    RGB<T> operator()()
    {
        RGB<T> p;
		p.r = static_cast<T> ((rand() * 1.0)/RAND_MAX * 1024) ;
        p.g = static_cast<T> ((rand() * 1.0)/RAND_MAX * 1024 ) ;
		p.b = static_cast<T> ((rand() * 1.0)/RAND_MAX * 1024 ) ;
        return p;
    }
 
};
template <typename T>
struct Multiplie
{
    Multiplie(T aa):a(aa){};
 
	template <typename TYPE>
    void operator()(TYPE & RGB)
    {
        RGB *= a;
    }
    T a;
};
 
 
template <typename T>
struct MIN
{
	typedef T value_type;
 
    MIN():min(255){};
    void operator()(T RGB)
    {
        if (RGB<min) min = RGB;
    }
    T min;
};
 
template <typename T>
struct MINRGB
{
    MINRGB()
    :min(255,255,255)
    {}
    void operator()(const RGB<T> & RGB)
    {
        if (RGB.r<min.r) min.r = RGB.r;
        if (RGB.g<min.g) min.g = RGB.g;
        if (RGB.b<min.b) min.b = RGB.b;
    }
    RGB<T> min;
};
 
 
 
 
int main(int argc, unsigned char* argv[])
{	
	typedef unsigned short  TYPE_GRAYSCALE;
	typedef float			TYPE_RGB;
 
 
	// GENERATION DES IMAGES ...
	srand(clock());
    Image<TYPE_GRAYSCALE> img(256,256);
	Image<RGB<TYPE_RGB>>  imgRGB(256,256);
 
 
	// FIN GENERATION
 
 
    while(1)
    {
 
	    clock_t tSomme(0);
		for (int i =0;i<num;++i)
		{
 
	        std::generate
	        (
		    img.buffer.begin(),
		    img.buffer.end(),
		    Gen<TYPE_GRAYSCALE>()
	        );
 
            clock_t t0 = clock();
			std::for_each
				(
					img.buffer.begin(),
					img.buffer.end(),
					Multiplie<double>(3.5)
				 );
            tSomme+=clock()-t0;
		}
		double tempA = double(tSomme)/num;
		std::cout<<"************MULTIPLICATION**************" <<std::endl;
		std::cout<<"grayscale""  "<<tempA <<std::endl;
 
        tSomme =0;
		for (int i =0;i<num;++i)
		{
 
	    std::generate
	       (
		       imgRGB.buffer.begin(),
		       imgRGB.buffer.end(),
		       GenRGB<TYPE_RGB>()
	       );
         clock_t t0 = clock();
			std::for_each
				(
					imgRGB.buffer.begin(),
					imgRGB.buffer.end(),
					Multiplie<double>(3.5)
				 );
         tSomme+=clock()-t0;
		}
		double tempB = double(tSomme)/num;
		std::cout<<"rgb"<<"  "<<tempB <<std::endl;
 
		std::cout<<"rgb/grayscale"<<" "<<100*(tempB/tempA)<<"%"<<std::endl;
 
        tSomme =0;
		int min;
		for (int i =0;i<num;++i)
		{
	        std::generate
	        (
		    img.buffer.begin(),
		    img.buffer.end(),
		    Gen<TYPE_GRAYSCALE>()
	        );
 
            clock_t t0 = clock();
			min = std::for_each
				(
					img.buffer.begin(),
					img.buffer.end(),
					MIN<TYPE_GRAYSCALE>()
				 ).min;
            tSomme+=clock()-t0;
		}
		tempA = double(tSomme)/num;
		std::cout<<"************MIN**************" <<std::endl;
		std::cout<<"grayscale""  "<<tempA <<std::endl;
 
		tSomme =0;
		RGB<TYPE_RGB> minRGB;
		for (int i =0;i<num;++i)
		{
	    std::generate
	       (
		       imgRGB.buffer.begin(),
		       imgRGB.buffer.end(),
		       GenRGB<TYPE_RGB>()
	       );
           clock_t t0 = clock();
		   minRGB = std::for_each
				(
					imgRGB.buffer.begin(),
					imgRGB.buffer.end(),
					MINRGB<TYPE_RGB>()
				 ).min;
           tSomme+=clock()-t0;
		}
		tempB = double(tSomme)/num;
		std::cout<<"rgb "<<minRGB.r<<"  "<<minRGB.g<<"  "<<minRGB.b<<"  "<<tempB <<std::endl;
 
		std::cout<<"B/A"<<" "<<100*(tempB/tempA)<<"%"<<std::endl;
    }
 
	return 0;
}

edit sur le code.
Tu t'était planté sur les parametre de Multiplie... d'ailleur je ne comprend pas comment il as pu convertir un double en RGB :koi:

12/09/2008, 15h54
yan

petite astuce sous visual pour gagné en rgb sur le min. Tu vire la récupération du min. Tu aura un temp = 0 :yaisse2: il est trop fort le compilo, il as vue que l'on ne faisait rien et il as virée le foreach
12/09/2008, 16h29
poukill

Citation:

Envoyé par Mongaulois

Tu t'était planté sur les parametre de Multiplie... d'ailleur je ne comprend pas comment il as pu convertir un double en RGB :koi:

??? il a jamais eu besoin de convertir en RGB ! le multiplie prend en paremetre un float ou bien un entier... Et la structure RGB a deja un operateur pour multiplier par quelquechose...
pas de souci non??? :koi:

Citation:

Envoyé par poukill

??? il a jamais eu besoin de convertir en RGB ! le multiplie prend en paremetre un float ou bien un entier... Et la structure RGB a deja un operateur pour multiplier par quelquechose...
pas de souci non??? :koi:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 template <typename T> struct Multiplie { Multiplie(T aa):a(aa){}; template <typename TYPE> void operator()(TYPE & RGB) { RGB *= a; } T a; }; Multiplie<TYPE_RGB>(2)
donc a et aa sont des RGB et donc tu initialise aa avec 2

[edit]
j'ai dit n'importe quoi... j'ai confondu RGB et TYPE_RGB

12/09/2008, 16h56
poukill
Non a et aa sont des ENTIERS !
Dans le code :
Code:

1 2 std::for_each ( img.buffer.begin(), img.buffer.end(), Multiplie<TYPE_RGB>(2) );
a et aa seront de TYPE_RGB donc des float dans mon exemple...

Et multiplier par un foat, ma structure RGB sait faire !!! ;)

EDIT : OK no pb mon code etait peut etre pas super clair... ;)
12/09/2008, 17h04
yan

Si il n'y as pas d'erreur,en gros,
je gagne en moyenne 50% avec rgb par rapport au grayscale.
Comme quoi.

Pour le min, c'est un peu n'importe quoi comme bench... Il faudrait que pour chaque iteration que les trois plan RGB soi identique à l'image greayscale pour la même iteration. Il recherche ainsi la même chose au même endroit.

Re,

Si, il y a erreur... :P
Ton Multiplie prend en parametre template toujours un double, ce qui penalise bcp le GreyScale !:D
En mettant bien unsigned short dans les deux, on gagne un facteur 15...
Et on retrouve bien le greyscale plus rapide et le RGB plus lent avec 200 a 300 % en moyenne...

Code mis a jour :

Code:

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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
 
#include <iostream>
#include <vector>
#include <list>
#include <deque>
#include <set>
#include <algorithm>
#include <ctime>
#include <cmath>
#include <limits>
using namespace std;
const int num =1000;
 
template<typename T>
struct Image
{
	typedef T value_type;
 
    Image(int hh,int ww)
    :h(hh),w(ww),buffer(hh*ww)
    {}
    int h;
    int w;
    vector<T> buffer;
};
 
template <typename T>
struct RGB
{
    RGB():r(0),g(0),b(0)
    {};
 
    RGB(T rr,T gg,T bb)
    :r(rr),g(gg),b(bb)
	{}
 
    T r;
    T g;
    T b;
 
	template <typename TYPE>
    RGB& operator*=(TYPE a)
    {
        r*=a;
        g*=a;
        b*=a;
        return *this;
    }
};
 
template <typename T>
struct Gen
{
	T operator()()
    {
		return static_cast<T> ((rand() * 1.0)/RAND_MAX * 1024 ) ;
    }
};
 
template <typename T>
struct GenRGB
{
    RGB<T> operator()()
    {
        RGB<T> p;
		p.r = static_cast<T> ((rand() * 1.0)/RAND_MAX * 1024) ;
        p.g = static_cast<T> ((rand() * 1.0)/RAND_MAX * 1024 ) ;
		p.b = static_cast<T> ((rand() * 1.0)/RAND_MAX * 1024 ) ;
        return p;
    }
 
};
template <typename T>
struct Multiplie
{
    Multiplie(T aa):a(aa){};
 
	template <typename TYPE>
    void operator()(TYPE & RGB)
    {
        RGB *= a;
    }
    T a;
};
 
 
template <typename T>
struct MIN
{
	typedef T value_type;
 
    MIN():min(255){};
    void operator()(T RGB)
    {
        if (RGB<min) min = RGB;
    }
    T min;
};
 
template <typename T>
struct MINRGB
{
    MINRGB()
    :min(255,255,255)
    {}
    void operator()(const RGB<T> & RGB)
    {
        if (RGB.r<min.r) min.r = RGB.r;
        if (RGB.g<min.g) min.g = RGB.g;
        if (RGB.b<min.b) min.b = RGB.b;
    }
    RGB<T> min;
};
 
 
 
 
int main(int argc, unsigned char* argv[])
{	
	typedef unsigned short  TYPE_GRAYSCALE;
	typedef float			TYPE_RGB;
 
 
	// GENERATION DES IMAGES ...
	srand(clock());
    Image<TYPE_GRAYSCALE> img(256,256);
	Image<RGB<TYPE_RGB>>  imgRGB(256,256);
 
 
	// FIN GENERATION
 
 
    while(1)
    {
 
	    clock_t tSomme(0);
		for (int i =0;i<num;++i)
		{
 
	        std::generate
	        (
		    img.buffer.begin(),
		    img.buffer.end(),
		    Gen<TYPE_GRAYSCALE>()
	        );
 
            clock_t t0 = clock();
			std::for_each
				(
					img.buffer.begin(),
					img.buffer.end(),
					Multiplie<TYPE_GRAYSCALE>(3.5)
				 );
            tSomme+=clock()-t0;
		}
		double tempA = double(tSomme)/num;
		std::cout<<"************MULTIPLICATION**************" <<std::endl;
		std::cout<<"grayscale""  "<<tempA <<std::endl;
 
        tSomme =0;
		for (int i =0;i<num;++i)
		{
 
	    std::generate
	       (
		       imgRGB.buffer.begin(),
		       imgRGB.buffer.end(),
		       GenRGB<TYPE_RGB>()
	       );
         clock_t t0 = clock();
			std::for_each
				(
					imgRGB.buffer.begin(),
					imgRGB.buffer.end(),
					Multiplie<TYPE_RGB>(3.5)
				 );
         tSomme+=clock()-t0;
		}
		double tempB = double(tSomme)/num;
		std::cout<<"rgb"<<"  "<<tempB <<std::endl;
 
		std::cout<<"rgb/grayscale"<<" "<<100*(tempB/tempA)<<"%"<<std::endl;
 
        tSomme =0;
		int min;
		for (int i =0;i<num;++i)
		{
	        std::generate
	        (
		    img.buffer.begin(),
		    img.buffer.end(),
		    Gen<TYPE_GRAYSCALE>()
	        );
 
            clock_t t0 = clock();
			min = std::for_each
				(
					img.buffer.begin(),
					img.buffer.end(),
					MIN<TYPE_GRAYSCALE>()
				 ).min;
            tSomme+=clock()-t0;
		}
		tempA = double(tSomme)/num;
		std::cout<<"************MIN**************" <<std::endl;
		std::cout<<"grayscale""  "<<tempA <<std::endl;
 
		tSomme =0;
		RGB<TYPE_RGB> minRGB;
		for (int i =0;i<num;++i)
		{
	    std::generate
	       (
		       imgRGB.buffer.begin(),
		       imgRGB.buffer.end(),
		       GenRGB<TYPE_RGB>()
	       );
           clock_t t0 = clock();
		   minRGB = std::for_each
				(
					imgRGB.buffer.begin(),
					imgRGB.buffer.end(),
					MINRGB<TYPE_RGB>()
				 ).min;
           tSomme+=clock()-t0;
		}
		tempB = double(tSomme)/num;
		std::cout<<"rgb "<<minRGB.r<<"  "<<minRGB.g<<"  "<<minRGB.b<<"  "<<tempB <<std::endl;
 
		std::cout<<"B/A"<<" "<<100*(tempB/tempA)<<"%"<<std::endl;
    }
 
	return 0;
}

12/09/2008, 17h13
yan

Citation:

Envoyé par poukill

Re,

Si, il y a erreur... :P
Ton Multiplie prend en parametre template toujours un double, ce qui penalise bcp le GreyScale !:D
En mettant bien unsigned short dans les deux, on gagne un facteur 15...
Et on retrouve bien le greyscale plus rapide et le RGB plus lent avec 200 a 300 % en moyenne...

Ok. Le problème si tu utilise des unsigned short, tu ne peut multiplier que par des entiers. Puis la tu as le problème inverse pour le rgb. Il est ralentie par la convertion.
Donc tout dépend de ce que tu veut faire ;)
12/09/2008, 17h15
yan

si tu met TYPE_GRAYSCALE pour GRAYSCALE et TYPE_RGB pour RGB, tu es en dessous des 200% voir même plustôt vers 115%
12/09/2008, 17h50
screetch

threading + sse2 > micro optimisations.

regarde du coté de Intel Thread Building Blocks
13/09/2008, 10h07
poukill

Citation:

Envoyé par Mongaulois

Ok. Le problème si tu utilise des unsigned short, tu ne peut multiplier que par des entiers. Puis la tu as le problème inverse pour le rgb. Il est ralentie par la conversion.
Donc tout dépend de ce que tu veut faire ;)

Ca c'est clair... Je ne peux multiplier que par des entiers pour les unsigned short.
Par contre les RGB étant de base en float dans mon application, le Muliplie<float> ne le ralentira pas. On va dire qu'on est en optimum dans les 2 cas, mais qu'on est dans un cas restreint pour le GreyScale (pas pouvoir mulitplier par un float c'est quand même emmerdant).
C'est là qu'on voit que la conversion est quand même pénalisante...

Citation:

Envoyé par screetch

threading + sse2 > micro optimisations.

regarde du coté de Intel Thread Building Blocks

Merci du tuyau. Utilisant une bibliothèque externe commerciale, je ne pense pas pouvoir m'en servir. Le bench que je fais aujourd'hui, c'est pour simuler des performances là où je n'ai pas le code source en optimisant au maximum. J'ai des données GreyScale entier sur 16 bits, et le fournisseur (la lib) ne prend que du RGBA float. Je voudrai donc quantifier cette "perte" pour éventuellement coder tout moi même si je juge que ça ne tiendra pas le temps réel qui m'est imposé... ;)

J'ai une autre question. Est-ce qu'on pourrait vraiment améliorer ce bench? Je veux dire, une image à base de pointeurs only. Une structure RGB avec un tableau C...

Merci encore pour votre aide ! :)
13/09/2008, 10h11
yan

Citation:

Envoyé par poukill

J'ai une autre question. Est-ce qu'on pourrait vraiment améliorer ce bench? Je veux dire, une image à base de pointeurs only. Une structure RGB avec un tableau C...

C'est à dire?
13/09/2008, 10h26
poukill
J'en sais rien... C'est juste pour pas me retrouver à montrer un bench mal optimisé au concepteur de la bibliothèque, qui va me rire au nez en me disant que tout ça ne veut rien dire...
Je pensais à un truc du genre:
Code:

1 2 3 4 5 6 7 8 9 10 struct ImageRGB { ImageRGB(int hh,int ww) :h(hh),w(ww), buffer(new float[hh*ww*3]) {} ~ImageRGB() {delete buffer;} int h; int w; float *buffer; };
13/09/2008, 11h03
yan

Citation:

Envoyé par poukill

J'en sais rien... C'est juste pour pas me retrouver à montrer un bench mal optimisé au concepteur de la bibliothèque, qui va me rire au nez en me disant que tout ça ne veut rien dire...
Je pensais à un truc du genre:

Ben on utilise un vector et on parcoure avec les algo donc c'est pareil.
Aprés tu pourrais aussi
- aligné la mémoire utilisé. Peut peut être améliorer un peu
- chercher comment optimiser le cache
- Peut être optimizer ton traitement dû fait que c'est des entier
- utiliser l'opérateur [] pour faire du filtrage par exemple
- accéder sous forme de pointeur en partant de &buffer[0]
- Visual pro et gcc 4.x implémente OpenMP. Tu pourrais t'en servir pour paralléliser une boucle.
- dérouler un peu la boucle principale .Genre 4 par 4 Mais je croie que le compilo le fait déjà.
- déroule les boucles utiliser pour le filtrage.
- utiliser du SSE
- TBB pour utiliser leur vector aligné et leur algorithm
- Peut être GIL de Boost

Après si tu veut être rigoureux, il faudrait la même image sur les deux versions. Si tu montre que tu as un énorme gain, il ne pourra rien dire.

Y as aussi une chose pour le filtrage sur le pentium, mais j'ai pas encore tout compris
http://www.developpez.net/forums/d53...acces-memoire/

je pense que le plus gros gain c'est par SSE2 qui te permettra de faire 4 operations flottantes par "operation". du coup ca peut etre des flottants 32 bits, et donc des RGBA flottants. le plus rapide serait en gros comme tu l'as ecrit, puis :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 struct ImageRGB { ImageRGB(int hh,int ww) :h(hh),w(ww), buffer(new float[hh*ww*3]) {} ~ImageRGB() {delete buffer;} int h; int w; float *buffer; //must be aligned on 16 bytes void multiply(float val) { __m128 by = _mm_set_ps1(val); __m128* buffer ? this->buffer; for(size_t = 0; t < w*h/4; i+=4, buffer+=4) { _mm_prefetch(buffer+256); buffer[0] = _mm_mul_ps(buffer[0], by); buffer[1] = _mm_mul_ps(buffer[1], by); buffer[2] = _mm_mul_ps(buffer[2], by); buffer[3] = _mm_mul_ps(buffer[3], by); } } };
Si les images sont grosses ca vaut le coup d'utiliser TBB, sinon c'est inutile, le temps de dispatcher les taches serait superieur au temps d'execution.

14/09/2008, 10h14
screetch

c'est aussi un bon moment pour utiliser, sur le code le plus simple possible (donc exit les foncteurs et autres decompositions en pixels minuscules) le simulateur de pipeline deAMD Code Analyst qui te permettra de comparer et de voir les eventues problemes CPU (cache miss, STLF etc)

Citation:

Envoyé par Mongaulois

Ben on utilise un vector et on parcoure avec les algo donc c'est pareil.
Aprés tu pourrais aussi
- aligné la mémoire utilisé. Peut peut être améliorer un peu
- chercher comment optimiser le cache
- Peut être optimizer ton traitement dû fait que c'est des entier
- utiliser l'opérateur [] pour faire du filtrage par exemple
- accéder sous forme de pointeur en partant de &buffer[0]
- Visual pro et gcc 4.x implémente OpenMP. Tu pourrais t'en servir pour paralléliser une boucle.
- dérouler un peu la boucle principale .Genre 4 par 4 Mais je croie que le compilo le fait déjà.
- déroule les boucles utiliser pour le filtrage.
- utiliser du SSE
- TBB pour utiliser leur vector aligné et leur algorithm
- Peut être GIL de Boost

Après si tu veut être rigoureux, il faudrait la même image sur les deux versions. Si tu montre que tu as un énorme gain, il ne pourra rien dire.

Y as aussi une chose pour le filtrage sur le pentium, mais j'ai pas encore tout compris
http://www.developpez.net/forums/d53...acces-memoire/

Merci Mongaulois pour ces précisions.
De mon côté il faut savoir que mes images sont plutôt petites (300 * 300 à 1000 * 1000). Par contre, j'en ai beaucoup (50 par secondes) !! ;)
Je vais regarder TBB et openMP, mais je doute que sur des images si petites...
Citation:
Envoyé par screetch
je pense que le plus gros gain c'est par SSE2 qui te permettra de faire 4 operations flottantes par "operation". du coup ca peut etre des flottants 32 bits, et donc des RGBA flottants. le plus rapide serait en gros comme tu l'as ecrit, puis :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 struct ImageRGB { ImageRGB(int hh,int ww) :h(hh),w(ww), buffer(new float[hh*ww*3]) {} ~ImageRGB() {delete buffer;} int h; int w; float *buffer; //must be aligned on 16 bytes void multiply(float val) { __m128 by = _mm_set_ps1(val); __m128* buffer ? this->buffer; for(size_t = 0; t < w*h/4; i+=4, buffer+=4) { _mm_prefetch(buffer+256); buffer[0] = _mm_mul_ps(buffer[0], by); buffer[1] = _mm_mul_ps(buffer[1], by); buffer[2] = _mm_mul_ps(buffer[2], by); buffer[3] = _mm_mul_ps(buffer[3], by); } } };
Si les images sont grosses ca vaut le coup d'utiliser TBB, sinon c'est inutile, le temps de dispatcher les taches serait superieur au temps d'execution.
OK. L'utilisation de SSE2 et d'alignement forcé ne risque pas d'être dépendant d'une plateforme cible? Je veux dire par là que je souhaite que mon code soit vraiment portable (au moins Linux et Windows) et pas trop dépendant du type de processeur car ça change beaucoup d'un PC à l'autre.

Poukill.

15/09/2008, 10h15
screetch

a 50 images par secondes ca peut etre plus simple de dispatcher lesi mags sur deux processeurs, pour que chacun travaille a 25 mages par seconde. dans le cas d'un dual core.

le SSE2 est disponible seulement a partir de pentium 4 je crois, et athlon XP, je dirai qu'a l'heure actuelle 95% des CPU de PC de bureaux l'ont. l'alignement necessaire est le meme, ce n'est pas un gros probleme.

SSE2 c'est les processeurs de 2001