"May" writes:
| "Samuel Krempp" a écrit dans
le
| message de news:3f70953b$0$20634$
| > le Tuesday 23 September 2003 20:29, écrivit
:
| > > | #include <cassert>
| > > | double *ptr=&Tab[0].Int;
| > > | assert(sizeof(donnee) % sizeof(double) == 0);
| > > | for (int i=0;i<256;i++,ptr+= sizeof(donnee)/sizeof(double))
| > >
| > > Pourquoi ne pas simplement mettre la taille de Tab utilisée dans sa
| > > déclaration ?
| >
| > parceque je pensais plus à ce 256 et que j'ai copier-collé :)
| >
| > --
| > Sam
|
| Au temps pour moi, c'est effectivement pas 256 dan sla boucle mais 1024
(la
| taille de mon tableau).
|
| A cause de la future utilisation de la MKL, il me faut tester ce que va
| faire la MKL pour copier.
| Pour etre plus claire, j'ai ceci :
|
| struct donne
| {
| double Int;
| double Ext;
| double IntExt;
| };
|
| double Int[1024];
| donne Tab[1024]; //puis a remplacer par std::vector<donne> Tab(1024);
|
| Je veux maintenant copier le tableau Int dans les champs Tab[x].Int
| Mais pour des problemes de performances, je doit utiliser la MKL.
| Or la MKL est codée en C et pas en C++ ou je ne sais trop quoi ....
| Donc sa facon d'acceder a la memoire est par pointeur. Donc exit, les
tests
| (oui oui je teste ce que va faire la MKL) du type :
| for (...)
| {
| Tab[i].Int=1.0;
| }
| ou ptr->Int=1.0;
| Je ne doit pas utiliser l'interface de classe mais un acces memoire
direct.
Là je ne te suis pas. En entrée tu as le tableau « Int » à copier
dans le tableau « Tab », en ne touchant que les champs .Int et le type
« donne » est complet au moment où tu écris ta boucle; c'est bien cela
? Si oui, pourquoi est-ce que ce qui t'a été proposé est exit ?
C'est bien cela. Tout n'est pas "exit".
| Donc pour m'assurer que la MKL copie au bon endroit dans la memoire, il
faut
| lui donner l'offset entre 2 Champs Int dans le tableau Tab (ie
| offset=&(Tab[1].Int)-&(Tab[0].Int))
ne vas pas sur ce terrain et ne te complique pas la vie.
-- Gaby
"May" <May_san45@hotmail.com> writes:
| "Samuel Krempp" <krempp@crans.truc.en.trop.ens-cachan.fr> a écrit dans
le
| message de news:3f70953b$0$20634$626a54ce@news.free.fr...
| > le Tuesday 23 September 2003 20:29, dosreis@cmla.ens-cachan.fr écrivit
:
| > > | #include <cassert>
| > > | double *ptr=&Tab[0].Int;
| > > | assert(sizeof(donnee) % sizeof(double) == 0);
| > > | for (int i=0;i<256;i++,ptr+= sizeof(donnee)/sizeof(double))
| > >
| > > Pourquoi ne pas simplement mettre la taille de Tab utilisée dans sa
| > > déclaration ?
| >
| > parceque je pensais plus à ce 256 et que j'ai copier-collé :)
| >
| > --
| > Sam
|
| Au temps pour moi, c'est effectivement pas 256 dan sla boucle mais 1024
(la
| taille de mon tableau).
|
| A cause de la future utilisation de la MKL, il me faut tester ce que va
| faire la MKL pour copier.
| Pour etre plus claire, j'ai ceci :
|
| struct donne
| {
| double Int;
| double Ext;
| double IntExt;
| };
|
| double Int[1024];
| donne Tab[1024]; //puis a remplacer par std::vector<donne> Tab(1024);
|
| Je veux maintenant copier le tableau Int dans les champs Tab[x].Int
| Mais pour des problemes de performances, je doit utiliser la MKL.
| Or la MKL est codée en C et pas en C++ ou je ne sais trop quoi ....
| Donc sa facon d'acceder a la memoire est par pointeur. Donc exit, les
tests
| (oui oui je teste ce que va faire la MKL) du type :
| for (...)
| {
| Tab[i].Int=1.0;
| }
| ou ptr->Int=1.0;
| Je ne doit pas utiliser l'interface de classe mais un acces memoire
direct.
Là je ne te suis pas. En entrée tu as le tableau « Int » à copier
dans le tableau « Tab », en ne touchant que les champs .Int et le type
« donne » est complet au moment où tu écris ta boucle; c'est bien cela
? Si oui, pourquoi est-ce que ce qui t'a été proposé est exit ?
C'est bien cela. Tout n'est pas "exit".
| Donc pour m'assurer que la MKL copie au bon endroit dans la memoire, il
faut
| lui donner l'offset entre 2 Champs Int dans le tableau Tab (ie
| offset=&(Tab[1].Int)-&(Tab[0].Int))
ne vas pas sur ce terrain et ne te complique pas la vie.
-- Gaby
"May" writes:
| "Samuel Krempp" a écrit dans
le
| message de news:3f70953b$0$20634$
| > le Tuesday 23 September 2003 20:29, écrivit
:
| > > | #include <cassert>
| > > | double *ptr=&Tab[0].Int;
| > > | assert(sizeof(donnee) % sizeof(double) == 0);
| > > | for (int i=0;i<256;i++,ptr+= sizeof(donnee)/sizeof(double))
| > >
| > > Pourquoi ne pas simplement mettre la taille de Tab utilisée dans sa
| > > déclaration ?
| >
| > parceque je pensais plus à ce 256 et que j'ai copier-collé :)
| >
| > --
| > Sam
|
| Au temps pour moi, c'est effectivement pas 256 dan sla boucle mais 1024
(la
| taille de mon tableau).
|
| A cause de la future utilisation de la MKL, il me faut tester ce que va
| faire la MKL pour copier.
| Pour etre plus claire, j'ai ceci :
|
| struct donne
| {
| double Int;
| double Ext;
| double IntExt;
| };
|
| double Int[1024];
| donne Tab[1024]; //puis a remplacer par std::vector<donne> Tab(1024);
|
| Je veux maintenant copier le tableau Int dans les champs Tab[x].Int
| Mais pour des problemes de performances, je doit utiliser la MKL.
| Or la MKL est codée en C et pas en C++ ou je ne sais trop quoi ....
| Donc sa facon d'acceder a la memoire est par pointeur. Donc exit, les
tests
| (oui oui je teste ce que va faire la MKL) du type :
| for (...)
| {
| Tab[i].Int=1.0;
| }
| ou ptr->Int=1.0;
| Je ne doit pas utiliser l'interface de classe mais un acces memoire
direct.
Là je ne te suis pas. En entrée tu as le tableau « Int » à copier
dans le tableau « Tab », en ne touchant que les champs .Int et le type
« donne » est complet au moment où tu écris ta boucle; c'est bien cela
? Si oui, pourquoi est-ce que ce qui t'a été proposé est exit ?
C'est bien cela. Tout n'est pas "exit".
| Donc pour m'assurer que la MKL copie au bon endroit dans la memoire, il
faut
| lui donner l'offset entre 2 Champs Int dans le tableau Tab (ie
| offset=&(Tab[1].Int)-&(Tab[0].Int))
ne vas pas sur ce terrain et ne te complique pas la vie.
-- Gaby
Mais je ne peux pas utiliser les accesseurs ->Int et .Int.
En fait je cherche, dans un premier temps, à faire comme ce que ferai la
MKL, c'est a dire à n'utiliser que des pointeurs et pas d'acces aux
données de la structure par ses champs (.Int .Ext .IntExt).
Car dans un deuxieme temps, j'aimerai utiliser la MKL mais il faut pour
cela que j'arrive a determiner un offset memoire entre chaque champ "Int"
de chaque objet "donne" du tableau Tab.
donc en gros si j'arrive à acceder a chaque champ Int de mon tableau avec
ce que ma proposé Samuel Krempp, alors c'est que je peux utiliser la MKL
pour faire une copie.
Si les données ne sont pas contigües et que l'offset
(entre 2 champ Int) change au cours du tableau, alors je ne pourrais pas
utiliser la MKL qui est trés nettement plus rapide qu'une boucle for.
Je ne cherche pas a programmer lisible et beau, j'ai besoin de performance
car c'est un passage critique dans mon appli... Je fait du traitement de
l'image et seules les perfs comptent (enfin presque)
Mais je ne peux pas utiliser les accesseurs ->Int et .Int.
En fait je cherche, dans un premier temps, à faire comme ce que ferai la
MKL, c'est a dire à n'utiliser que des pointeurs et pas d'acces aux
données de la structure par ses champs (.Int .Ext .IntExt).
Car dans un deuxieme temps, j'aimerai utiliser la MKL mais il faut pour
cela que j'arrive a determiner un offset memoire entre chaque champ "Int"
de chaque objet "donne" du tableau Tab.
donc en gros si j'arrive à acceder a chaque champ Int de mon tableau avec
ce que ma proposé Samuel Krempp, alors c'est que je peux utiliser la MKL
pour faire une copie.
Si les données ne sont pas contigües et que l'offset
(entre 2 champ Int) change au cours du tableau, alors je ne pourrais pas
utiliser la MKL qui est trés nettement plus rapide qu'une boucle for.
Je ne cherche pas a programmer lisible et beau, j'ai besoin de performance
car c'est un passage critique dans mon appli... Je fait du traitement de
l'image et seules les perfs comptent (enfin presque)
Mais je ne peux pas utiliser les accesseurs ->Int et .Int.
En fait je cherche, dans un premier temps, à faire comme ce que ferai la
MKL, c'est a dire à n'utiliser que des pointeurs et pas d'acces aux
données de la structure par ses champs (.Int .Ext .IntExt).
Car dans un deuxieme temps, j'aimerai utiliser la MKL mais il faut pour
cela que j'arrive a determiner un offset memoire entre chaque champ "Int"
de chaque objet "donne" du tableau Tab.
donc en gros si j'arrive à acceder a chaque champ Int de mon tableau avec
ce que ma proposé Samuel Krempp, alors c'est que je peux utiliser la MKL
pour faire une copie.
Si les données ne sont pas contigües et que l'offset
(entre 2 champ Int) change au cours du tableau, alors je ne pourrais pas
utiliser la MKL qui est trés nettement plus rapide qu'une boucle for.
Je ne cherche pas a programmer lisible et beau, j'ai besoin de performance
car c'est un passage critique dans mon appli... Je fait du traitement de
l'image et seules les perfs comptent (enfin presque)
"May" writes:
[...]
| > | Je veux maintenant copier le tableau Int dans les champs Tab[x].Int
| > | Mais pour des problemes de performances, je doit utiliser la MKL.
| > | Or la MKL est codée en C et pas en C++ ou je ne sais trop quoi ....
| > | Donc sa facon d'acceder a la memoire est par pointeur. Donc exit,
les
| tests
| > | (oui oui je teste ce que va faire la MKL) du type :
| > | for (...)
| > | {
| > | Tab[i].Int=1.0;
| > | }
| > | ou ptr->Int=1.0;
| > | Je ne doit pas utiliser l'interface de classe mais un acces memoire
| direct.
| >
| > Là je ne te suis pas. En entrée tu as le tableau « Int » à copier
| > dans le tableau « Tab », en ne touchant que les champs .Int et le type
| > « donne » est complet au moment où tu écris ta boucle; c'est bien cela
| > ? Si oui, pourquoi est-ce que ce qui t'a été proposé est exit ?
| >
| C'est bien cela. Tout n'est pas "exit".
| Mais je ne peux pas utiliser les accesseurs ->Int et .Int.
c'est bien là je ne comprends pas pourquoi les accesseurs ->Int et
.Int ne peuvent pas être utilisés. Ton MKL, il a bien la structure
donne comme présentés ci-haut ?
La MKL n'est pas une librairie C++. Les structures, elle connait pôô.
| En fait je cherche, dans un premier temps, à faire comme ce que ferai la
| MKL, c'est a dire à n'utiliser que des pointeurs et pas d'acces aux
données
| de la structure par ses champs (.Int .Ext .IntExt).
| Car dans un deuxieme temps, j'aimerai utiliser la MKL mais il faut pour
cela
| que j'arrive a determiner un offset memoire entre chaque champ "Int" de
| chaque objet "donne" du tableau Tab.
|
| donc en gros si j'arrive à acceder a chaque champ Int de mon tableau
avec ce
| que ma proposé Samuel Krempp, alors c'est que je peux utiliser la MKL
pour
| faire une copie.
il manque un connecteur ici. Quelle est l'API du machin MKL qui faitt
la copie ?
| Si les données ne sont pas contigües et que l'offset (entre
| 2 champ Int) change au cours du tableau, alors je ne pourrais pas
utiliser
| la MKL qui est trés nettement plus rapide qu'une boucle for.
je crois qu'aller sur le terrain de l'offset compliquera la tâche
inutilement.
non c 'est obligatoire
| Je ne cherche pas a programmer lisible et beau, j'ai besoin de
performance
| car c'est un passage critique dans mon appli... Je fait du traitement de
| l'image et seules les perfs comptent (enfin presque)
Je comprends que tu cherches la perf -- et dans ma jeunesse, dans le
labo où j'ai été formé, j'ai eu a regarder et écrire certains codes
pour le traitement d'image. Globablement, l'impression que j'ai gardé
de cette pratique est qu'on croit souvent à tord que performant
implique nécessairement pas beau, et surtout pas portable
(hein, Samy, que penses-tu du code produit et utilisé par xxxxxve ? ;-)
ouais mais c'est quand meme ma boucle principale, j'aimerai que tout y soit
-- Gaby
"May" <May_san45@hotmail.com> writes:
[...]
| > | Je veux maintenant copier le tableau Int dans les champs Tab[x].Int
| > | Mais pour des problemes de performances, je doit utiliser la MKL.
| > | Or la MKL est codée en C et pas en C++ ou je ne sais trop quoi ....
| > | Donc sa facon d'acceder a la memoire est par pointeur. Donc exit,
les
| tests
| > | (oui oui je teste ce que va faire la MKL) du type :
| > | for (...)
| > | {
| > | Tab[i].Int=1.0;
| > | }
| > | ou ptr->Int=1.0;
| > | Je ne doit pas utiliser l'interface de classe mais un acces memoire
| direct.
| >
| > Là je ne te suis pas. En entrée tu as le tableau « Int » à copier
| > dans le tableau « Tab », en ne touchant que les champs .Int et le type
| > « donne » est complet au moment où tu écris ta boucle; c'est bien cela
| > ? Si oui, pourquoi est-ce que ce qui t'a été proposé est exit ?
| >
| C'est bien cela. Tout n'est pas "exit".
| Mais je ne peux pas utiliser les accesseurs ->Int et .Int.
c'est bien là je ne comprends pas pourquoi les accesseurs ->Int et
.Int ne peuvent pas être utilisés. Ton MKL, il a bien la structure
donne comme présentés ci-haut ?
La MKL n'est pas une librairie C++. Les structures, elle connait pôô.
| En fait je cherche, dans un premier temps, à faire comme ce que ferai la
| MKL, c'est a dire à n'utiliser que des pointeurs et pas d'acces aux
données
| de la structure par ses champs (.Int .Ext .IntExt).
| Car dans un deuxieme temps, j'aimerai utiliser la MKL mais il faut pour
cela
| que j'arrive a determiner un offset memoire entre chaque champ "Int" de
| chaque objet "donne" du tableau Tab.
|
| donc en gros si j'arrive à acceder a chaque champ Int de mon tableau
avec ce
| que ma proposé Samuel Krempp, alors c'est que je peux utiliser la MKL
pour
| faire une copie.
il manque un connecteur ici. Quelle est l'API du machin MKL qui faitt
la copie ?
| Si les données ne sont pas contigües et que l'offset (entre
| 2 champ Int) change au cours du tableau, alors je ne pourrais pas
utiliser
| la MKL qui est trés nettement plus rapide qu'une boucle for.
je crois qu'aller sur le terrain de l'offset compliquera la tâche
inutilement.
non c 'est obligatoire
| Je ne cherche pas a programmer lisible et beau, j'ai besoin de
performance
| car c'est un passage critique dans mon appli... Je fait du traitement de
| l'image et seules les perfs comptent (enfin presque)
Je comprends que tu cherches la perf -- et dans ma jeunesse, dans le
labo où j'ai été formé, j'ai eu a regarder et écrire certains codes
pour le traitement d'image. Globablement, l'impression que j'ai gardé
de cette pratique est qu'on croit souvent à tord que performant
implique nécessairement pas beau, et surtout pas portable
(hein, Samy, que penses-tu du code produit et utilisé par xxxxxve ? ;-)
ouais mais c'est quand meme ma boucle principale, j'aimerai que tout y soit
-- Gaby
"May" writes:
[...]
| > | Je veux maintenant copier le tableau Int dans les champs Tab[x].Int
| > | Mais pour des problemes de performances, je doit utiliser la MKL.
| > | Or la MKL est codée en C et pas en C++ ou je ne sais trop quoi ....
| > | Donc sa facon d'acceder a la memoire est par pointeur. Donc exit,
les
| tests
| > | (oui oui je teste ce que va faire la MKL) du type :
| > | for (...)
| > | {
| > | Tab[i].Int=1.0;
| > | }
| > | ou ptr->Int=1.0;
| > | Je ne doit pas utiliser l'interface de classe mais un acces memoire
| direct.
| >
| > Là je ne te suis pas. En entrée tu as le tableau « Int » à copier
| > dans le tableau « Tab », en ne touchant que les champs .Int et le type
| > « donne » est complet au moment où tu écris ta boucle; c'est bien cela
| > ? Si oui, pourquoi est-ce que ce qui t'a été proposé est exit ?
| >
| C'est bien cela. Tout n'est pas "exit".
| Mais je ne peux pas utiliser les accesseurs ->Int et .Int.
c'est bien là je ne comprends pas pourquoi les accesseurs ->Int et
.Int ne peuvent pas être utilisés. Ton MKL, il a bien la structure
donne comme présentés ci-haut ?
La MKL n'est pas une librairie C++. Les structures, elle connait pôô.
| En fait je cherche, dans un premier temps, à faire comme ce que ferai la
| MKL, c'est a dire à n'utiliser que des pointeurs et pas d'acces aux
données
| de la structure par ses champs (.Int .Ext .IntExt).
| Car dans un deuxieme temps, j'aimerai utiliser la MKL mais il faut pour
cela
| que j'arrive a determiner un offset memoire entre chaque champ "Int" de
| chaque objet "donne" du tableau Tab.
|
| donc en gros si j'arrive à acceder a chaque champ Int de mon tableau
avec ce
| que ma proposé Samuel Krempp, alors c'est que je peux utiliser la MKL
pour
| faire une copie.
il manque un connecteur ici. Quelle est l'API du machin MKL qui faitt
la copie ?
| Si les données ne sont pas contigües et que l'offset (entre
| 2 champ Int) change au cours du tableau, alors je ne pourrais pas
utiliser
| la MKL qui est trés nettement plus rapide qu'une boucle for.
je crois qu'aller sur le terrain de l'offset compliquera la tâche
inutilement.
non c 'est obligatoire
| Je ne cherche pas a programmer lisible et beau, j'ai besoin de
performance
| car c'est un passage critique dans mon appli... Je fait du traitement de
| l'image et seules les perfs comptent (enfin presque)
Je comprends que tu cherches la perf -- et dans ma jeunesse, dans le
labo où j'ai été formé, j'ai eu a regarder et écrire certains codes
pour le traitement d'image. Globablement, l'impression que j'ai gardé
de cette pratique est qu'on croit souvent à tord que performant
implique nécessairement pas beau, et surtout pas portable
(hein, Samy, que penses-tu du code produit et utilisé par xxxxxve ? ;-)
ouais mais c'est quand meme ma boucle principale, j'aimerai que tout y soit
-- Gaby
le Wednesday 24 September 2003 15:09, écrivit :Mais je ne peux pas utiliser les accesseurs ->Int et .Int.
En fait je cherche, dans un premier temps, à faire comme ce que ferai la
MKL, c'est a dire à n'utiliser que des pointeurs et pas d'acces aux
données de la structure par ses champs (.Int .Ext .IntExt).
Car dans un deuxieme temps, j'aimerai utiliser la MKL mais il faut pour
cela que j'arrive a determiner un offset memoire entre chaque champ
"Int"
de chaque objet "donne" du tableau Tab.
d'accord, et bien pour cela la structure Donnee que j'ai indiqué
fonctionne
(en utilisant comme offset sizeof(Donnee)/sizeof(double))
Laisse cependant au début de ton code pour vérifier que tout va bien :
assert(sizeof(Donnee) % sizeof(double) ==0);
comme ça si ça ne marche pas comme prévu, ça se verra.donc en gros si j'arrive à acceder a chaque champ Int de mon tableau
avec
ce que ma proposé Samuel Krempp, alors c'est que je peux utiliser la MKL
pour faire une copie.
oui, c'est bien le cas, ce que j'ai proposé est bon, et ça te permet
d'utiliser la MKL.Si les données ne sont pas contigües et que l'offset
(entre 2 champ Int) change au cours du tableau, alors je ne pourrais pas
utiliser la MKL qui est trés nettement plus rapide qu'une boucle for.
tu peux utiliser plusieurs sortes de tableaux qui garantissent la
contigüité
et la technique fonctionne. précisément :
std::vector<double> Tab;
double Tab[1024];
double * Tab = new double[1024];
dans chaque cas la même boucle marchera.
Je ne cherche pas a programmer lisible et beau, j'ai besoin de
performance
car c'est un passage critique dans mon appli... Je fait du traitement de
l'image et seules les perfs comptent (enfin presque)
ah tiens ! et dans quel labo travailles-tu ?
--
Sam
le Wednesday 24 September 2003 15:09, May_san45@hotmail.com écrivit :
Mais je ne peux pas utiliser les accesseurs ->Int et .Int.
En fait je cherche, dans un premier temps, à faire comme ce que ferai la
MKL, c'est a dire à n'utiliser que des pointeurs et pas d'acces aux
données de la structure par ses champs (.Int .Ext .IntExt).
Car dans un deuxieme temps, j'aimerai utiliser la MKL mais il faut pour
cela que j'arrive a determiner un offset memoire entre chaque champ
"Int"
de chaque objet "donne" du tableau Tab.
d'accord, et bien pour cela la structure Donnee que j'ai indiqué
fonctionne
(en utilisant comme offset sizeof(Donnee)/sizeof(double))
Laisse cependant au début de ton code pour vérifier que tout va bien :
assert(sizeof(Donnee) % sizeof(double) ==0);
comme ça si ça ne marche pas comme prévu, ça se verra.
donc en gros si j'arrive à acceder a chaque champ Int de mon tableau
avec
ce que ma proposé Samuel Krempp, alors c'est que je peux utiliser la MKL
pour faire une copie.
oui, c'est bien le cas, ce que j'ai proposé est bon, et ça te permet
d'utiliser la MKL.
Si les données ne sont pas contigües et que l'offset
(entre 2 champ Int) change au cours du tableau, alors je ne pourrais pas
utiliser la MKL qui est trés nettement plus rapide qu'une boucle for.
tu peux utiliser plusieurs sortes de tableaux qui garantissent la
contigüité
et la technique fonctionne. précisément :
std::vector<double> Tab;
double Tab[1024];
double * Tab = new double[1024];
dans chaque cas la même boucle marchera.
Je ne cherche pas a programmer lisible et beau, j'ai besoin de
performance
car c'est un passage critique dans mon appli... Je fait du traitement de
l'image et seules les perfs comptent (enfin presque)
ah tiens ! et dans quel labo travailles-tu ?
--
Sam
le Wednesday 24 September 2003 15:09, écrivit :Mais je ne peux pas utiliser les accesseurs ->Int et .Int.
En fait je cherche, dans un premier temps, à faire comme ce que ferai la
MKL, c'est a dire à n'utiliser que des pointeurs et pas d'acces aux
données de la structure par ses champs (.Int .Ext .IntExt).
Car dans un deuxieme temps, j'aimerai utiliser la MKL mais il faut pour
cela que j'arrive a determiner un offset memoire entre chaque champ
"Int"
de chaque objet "donne" du tableau Tab.
d'accord, et bien pour cela la structure Donnee que j'ai indiqué
fonctionne
(en utilisant comme offset sizeof(Donnee)/sizeof(double))
Laisse cependant au début de ton code pour vérifier que tout va bien :
assert(sizeof(Donnee) % sizeof(double) ==0);
comme ça si ça ne marche pas comme prévu, ça se verra.donc en gros si j'arrive à acceder a chaque champ Int de mon tableau
avec
ce que ma proposé Samuel Krempp, alors c'est que je peux utiliser la MKL
pour faire une copie.
oui, c'est bien le cas, ce que j'ai proposé est bon, et ça te permet
d'utiliser la MKL.Si les données ne sont pas contigües et que l'offset
(entre 2 champ Int) change au cours du tableau, alors je ne pourrais pas
utiliser la MKL qui est trés nettement plus rapide qu'une boucle for.
tu peux utiliser plusieurs sortes de tableaux qui garantissent la
contigüité
et la technique fonctionne. précisément :
std::vector<double> Tab;
double Tab[1024];
double * Tab = new double[1024];
dans chaque cas la même boucle marchera.
Je ne cherche pas a programmer lisible et beau, j'ai besoin de
performance
car c'est un passage critique dans mon appli... Je fait du traitement de
l'image et seules les perfs comptent (enfin presque)
ah tiens ! et dans quel labo travailles-tu ?
--
Sam
"May" writes:
| Le labo Odyssee de l'INRIA.
de Sophia Antipolis donc ? Pourquoi ne vas-tu pas discuter avec Théo ?
-- Gaby
"May" <May_san45@hotmail.com> writes:
| Le labo Odyssee de l'INRIA.
de Sophia Antipolis donc ? Pourquoi ne vas-tu pas discuter avec Théo ?
-- Gaby
"May" writes:
| Le labo Odyssee de l'INRIA.
de Sophia Antipolis donc ? Pourquoi ne vas-tu pas discuter avec Théo ?
-- Gaby
"Gabriel Dos Reis" a écrit dans le
message de news:"May" writes:"Samuel Krempp" a écrit
dans le message de news:3f70953b$0$20634$le Tuesday 23 September 2003 20:29,
écrivit#include <cassert>
double *ptr=&Tab[0].Int;
assert(sizeof(donnee) % sizeof(double) == 0);
for (int i=0;i<256;i++,ptr+= sizeof(donnee)/sizeof(double))
Pourquoi ne pas simplement mettre la taille de Tab utilisée dans
sa déclaration ?
parceque je pensais plus à ce 256 et que j'ai copier-collé :)
--
Sam
Au temps pour moi, c'est effectivement pas 256 dan sla boucle mais
1024 (la taille de mon tableau).
A cause de la future utilisation de la MKL, il me faut tester ce
que va faire la MKL pour copier.
Pour etre plus claire, j'ai ceci :
struct donne
{
double Int;
double Ext;
double IntExt;
};
double Int[1024];
donne Tab[1024]; //puis a remplacer par std::vector<donne>
Tab(1024);
Je veux maintenant copier le tableau Int dans les champs Tab[x].Int
Mais pour des problemes de performances, je doit utiliser la MKL.
Or la MKL est codée en C et pas en C++ ou je ne sais trop quoi ....
Donc sa facon d'acceder a la memoire est par pointeur.
Le code que l'on t'a montré est parfaitement valide en C : Les structures
Mais je ne peux pas utiliser les accesseurs ->Int et .Int.
En fait je cherche, dans un premier temps, à faire comme ce que ferai
la MKL, c'est a dire à n'utiliser que des pointeurs et pas d'acces
aux données de la structure par ses champs (.Int .Ext .IntExt).
Je ne cherche pas a programmer lisible et beau, j'ai besoin de
performance car c'est un passage critique dans mon appli... Je fait
du traitement de l'image et seules les perfs comptent (enfin presque)
Sauf que là, le code par arithmétique de pointeur "à la main" ou par les
"Gabriel Dos Reis" <dosreis@cmla.ens-cachan.fr> a écrit dans le
message de news:fl3cem1idc.fsf@sel.cmla.ens-cachan.fr...
"May" <May_san45@hotmail.com> writes:
"Samuel Krempp" <krempp@crans.truc.en.trop.ens-cachan.fr> a écrit
dans le message de news:3f70953b$0$20634$626a54ce@news.free.fr...
le Tuesday 23 September 2003 20:29, dosreis@cmla.ens-cachan.fr
écrivit
#include <cassert>
double *ptr=&Tab[0].Int;
assert(sizeof(donnee) % sizeof(double) == 0);
for (int i=0;i<256;i++,ptr+= sizeof(donnee)/sizeof(double))
Pourquoi ne pas simplement mettre la taille de Tab utilisée dans
sa déclaration ?
parceque je pensais plus à ce 256 et que j'ai copier-collé :)
--
Sam
Au temps pour moi, c'est effectivement pas 256 dan sla boucle mais
1024 (la taille de mon tableau).
A cause de la future utilisation de la MKL, il me faut tester ce
que va faire la MKL pour copier.
Pour etre plus claire, j'ai ceci :
struct donne
{
double Int;
double Ext;
double IntExt;
};
double Int[1024];
donne Tab[1024]; //puis a remplacer par std::vector<donne>
Tab(1024);
Je veux maintenant copier le tableau Int dans les champs Tab[x].Int
Mais pour des problemes de performances, je doit utiliser la MKL.
Or la MKL est codée en C et pas en C++ ou je ne sais trop quoi ....
Donc sa facon d'acceder a la memoire est par pointeur.
Le code que l'on t'a montré est parfaitement valide en C : Les structures
Mais je ne peux pas utiliser les accesseurs ->Int et .Int.
En fait je cherche, dans un premier temps, à faire comme ce que ferai
la MKL, c'est a dire à n'utiliser que des pointeurs et pas d'acces
aux données de la structure par ses champs (.Int .Ext .IntExt).
Je ne cherche pas a programmer lisible et beau, j'ai besoin de
performance car c'est un passage critique dans mon appli... Je fait
du traitement de l'image et seules les perfs comptent (enfin presque)
Sauf que là, le code par arithmétique de pointeur "à la main" ou par les
"Gabriel Dos Reis" a écrit dans le
message de news:"May" writes:"Samuel Krempp" a écrit
dans le message de news:3f70953b$0$20634$le Tuesday 23 September 2003 20:29,
écrivit#include <cassert>
double *ptr=&Tab[0].Int;
assert(sizeof(donnee) % sizeof(double) == 0);
for (int i=0;i<256;i++,ptr+= sizeof(donnee)/sizeof(double))
Pourquoi ne pas simplement mettre la taille de Tab utilisée dans
sa déclaration ?
parceque je pensais plus à ce 256 et que j'ai copier-collé :)
--
Sam
Au temps pour moi, c'est effectivement pas 256 dan sla boucle mais
1024 (la taille de mon tableau).
A cause de la future utilisation de la MKL, il me faut tester ce
que va faire la MKL pour copier.
Pour etre plus claire, j'ai ceci :
struct donne
{
double Int;
double Ext;
double IntExt;
};
double Int[1024];
donne Tab[1024]; //puis a remplacer par std::vector<donne>
Tab(1024);
Je veux maintenant copier le tableau Int dans les champs Tab[x].Int
Mais pour des problemes de performances, je doit utiliser la MKL.
Or la MKL est codée en C et pas en C++ ou je ne sais trop quoi ....
Donc sa facon d'acceder a la memoire est par pointeur.
Le code que l'on t'a montré est parfaitement valide en C : Les structures
Mais je ne peux pas utiliser les accesseurs ->Int et .Int.
En fait je cherche, dans un premier temps, à faire comme ce que ferai
la MKL, c'est a dire à n'utiliser que des pointeurs et pas d'acces
aux données de la structure par ses champs (.Int .Ext .IntExt).
Je ne cherche pas a programmer lisible et beau, j'ai besoin de
performance car c'est un passage critique dans mon appli... Je fait
du traitement de l'image et seules les perfs comptent (enfin presque)
Sauf que là, le code par arithmétique de pointeur "à la main" ou par les
