C++

Manipulation d'expression par templates : la vengeance

Recherche :

Mot : Pseudo : Filtrer
Page : 1 2 Page Suivante Page Précédente Bas de page
Auteur	Sujet : Manipulation d'expression par templates : la vengeance

Joel F

Real men use unique_ptr

bon, mon générateur de code arithmétique optimisé Altivec par template marche.
Il me reste neanmoins un gros probleme.

Pour une expression du style :

R = (a+b)/(a*b);

mon générateur produit 2 chargements de la variable a et deux de la variable b :

Code :

vector float t1,t2,t3,t4;
t1 = vec_ld(0,a.begin);
t2 = vec_ld(0,b.begin);
t3 = vec_ld(0,a.begin);
t4 = vec_ld(0,b.begin);
//calcul
vec_madd( vec_add(t1,t2), vec_re(vec_madd(t3,t4,zero)),zero);

au lieu de :

Code :

vector char t1,t2;
t1 = vec_ld(0,a.begin);
t2 = vec_ld(0,b.begin);
//calcul
vec_madd( vec_add(t1,t2), vec_re(vec_madd(t1,t2,zero)),zero);

Moralité : 50% de perf en - que prevu.

Question :
En utilisant une technique d'expressions template ou dérivée, comment arrivez a ne generer qu'un chargement par occurence d'une variable dans les expressions ?

Plus geenralement comment 'flagé' des objets comme etant utilisé et ceci au moment de la compilation ?

Cf mes aures posts sur mes classes d'expressions pour les details. Je posterais un exemple minimaliste de code plus tard.

EIT : arf j'ai acheté un nouveau clavier

Message édité par Joel F le 04-09-2003 à 16:58:47

Publicité

LetoII

Le dormeur doit se réveiller

Je pense pas que tu puisse le faire dans un cadre général, tu va pouvoir optimiser ça pour des opérateurs particuliers ou des suites d'opérateurs particulières (du style a+b*c a+b+c ...)

---------------
Le Tyran

Taz

bisounours-codeur

c'est peut etre con, mais moi j'aurais fait

(x+y)/(u*v) renvoie une Expression+/*. cette expression contient des références

après tu as

uneFonction(Expression+/* e) // contructeur, conversion, membre
{
if(&e.x == &e.u and &e.y==&e.v)
{
version spécialisée
}
else
{
version générique
}
}

après je pense pas que tu puisse avoir quelque chose au moment de la compilation

Joel F

Real men use unique_ptr

ok ... bonc je vais etre obligé de me taper xxx fonction spar cas particuliers.
c'est ce que je commencait a craindre ...

LetoII

Le dormeur doit se réveiller

Joel F a écrit :

ok ... bonc je vais etre obligé de me taper xxx fonction spar cas particuliers.
c'est ce que je commencait a craindre ...

Ben ouaip, après tu peux peut être te limiter aux cas les plus fréquants, c à toi de voir

---------------
Le Tyran

Joel F

Real men use unique_ptr

la solution que j'ai actuellement pass pr des variables muettes :

Code :

eve::var<1> x;
eve::var<2> y;
r = apply( (x+y)/(x*y),a,b);

ca marche mais c moche
donc retour a la case parser/lexer avant compilation ...

LetoII

Le dormeur doit se réveiller

et un truc du genre
(la syntaxe c peut être pas ça, ça fait 3 mois que j'ai pas touché un template, j'ai des absences [:ddr555] )

Code :

template<boolean test> toto f(const titi &, const titi &,);
template<const titi &a, const titi &b> toto g()
{
return f<&a == &b>(a,b);
}

Tu spécialise f de façon a pas charger 2 fois la même var en mémoire. Ca pourrait pas marcher? J'ai rien pour tester ici et je sais même pas si ça peut s'adapter à ton cas d'ailleur [:ddr555]

---------------
Le Tyran

ACut

Une piste. Y a des techniques assez intéressantes à découvrir dans la doc de Spirit. Par exemple sur l'utilisation de foncteurs conjugués avec le parsing: http://www.boost.org/libs/spirit/doc/functional.html

---------------
NOUVEAU! Le guide de l'édition en version ebook : http://marcautret.free.fr/autret/150q-ebook/

Taz

bisounours-codeur

ACut a écrit :

je lui ai déjà conseillé y a longtemps, mais il s'entête

Taz

bisounours-codeur

Leto > [:xp1700]

Publicité

Taz

bisounours-codeur

Joel F > sinon, si tu veux eviter les tests comme ça, tu peux tenter des bidouiller des wrappers pour référence, tu te fais une fonction qui fait fusionner les alias que tu appelles à chaque fois qu'il faut. soit tu la fais binaire et tu l'appelles (n-1) fois (gaffe à l'implémentation) ou alors avec une liste template ( à coup de cons) (ou de boost::tuple)

Message édité par Taz le 04-09-2003 à 15:14:11

LetoII

Le dormeur doit se réveiller

Taz a écrit :

Leto > [:xp1700]

Ca veut dire quoi ça, je me suis complétement planté ou c super génial? Non par ce que avec toi je me méfie, et vu que je suis absolument pas sûr de ce que j'ai écrit... :whistle:

Message édité par LetoII le 04-09-2003 à 14:00:24

---------------
Le Tyran

Taz

bisounours-codeur

Joel F ?

LetoII

Le dormeur doit se réveiller

Taz a écrit :

Joel F ?

Soit il bosse, soit il est rentré chez lui

---------------
Le Tyran

ACut

...soit il est mort.
C'est une hypothèse qu'on formule rarement mais il est déjà arrivé qu'elle se vérifie.

---------------
NOUVEAU! Le guide de l'édition en version ebook : http://marcautret.free.fr/autret/150q-ebook/

LetoII

Le dormeur doit se réveiller

ACut a écrit :

...soit il est mort.
C'est une hypothèse qu'on formule rarement mais il est déjà arrivé qu'elle se vérifie.

Ouai mais là ça serait con il m'a pas encore mis sur son testament :whistle:

---------------
Le Tyran

Joel F

Real men use unique_ptr

Je suis pas mort, j'etais en reunion

@Leto : je crois aps qu ca marche &a c connu que a l'execution pas a la compilation.

@Taz : hmmm des precisions ?? la je comprends pas tout

Joel F

Real men use unique_ptr

Taz a écrit :

je lui ai déjà conseillé y a longtemps, mais il s'entête

:??: :??:

je veux bien mais ou dois je mettre mon code altivec si je recod epas mes foncteurs a la main ??

Taz

bisounours-codeur

sur ? moi je te dis juste, que le fastidieux, c'est de taper du code à chaque fois pour vérifier qui est qui. si tu wrappes tes références et que dans chaque fonction tu unique ( tuple <shared_ptr <Reference> > > ) ou un truc du genre, t'as moyen de trouver un traitement générique pour éliminer les alias.

Joel F

Real men use unique_ptr

Taz a écrit :

Justement sur ces wrappers de references ... en quoi ca va m'aider

Taz

bisounours-codeur

ben comment tu veux faire ? tu peux pas affecter des références entre elles ?

LetoII

Le dormeur doit se réveiller

Joel F a écrit :

Je suis pas mort, j'etais en reunion

@Leto : je crois aps qu ca marche &a c connu que a l'execution pas a la compilation.

Ben tu remplace par un opérateur == de ton cru :whistle:

---------------
Le Tyran

Joel F

Real men use unique_ptr

Taz a écrit :

ben comment tu veux faire ? tu peux pas affecter des références entre elles ?

y a un quiproquo la non [:taimp]
?? :??:

Taz

bisounours-codeur

template<typename T>
class refWrapper
{
struct ref
{
T &r;

ref(T &i)
: r(i)
{}

private:
ref& operator=(const ref & );
ref(const ref & );

};

boost::shared_ptr<ref> rp;

public:

explicit refWrapper(T &r)
: rp( new ref(r) )
{}

refWrapper(const refWrapper &other)
: rp( other.rp )
{}

refWrapper& operator=(const refWrapper &other)
{
if(this != &other)
{
this->rp = other.rp;
}

return *this;
}

T& operator*()
{
return this->rp->r;
}

};
tu fais une daube comme ça

et apres, vu que tes références sont vers des objets de même type, tu dois avoir un moyen sympa de faire la chose

void f( truc &a, truc &b)
{
refWrapper aa(a);
refWrapper bb(b);

if(aa == bb) // tiens je l'ai pas ecris celui la
{
aa = bb;
}

call(*aa, *bb);
}

après tu peux faire un truc avec template, 1 par classe n-aire de fonction avec un tuple de refWrapper de longueur N, et tu bricoles les tests, comme ça à chaque fois

void fxwrapper( arg0, arg2, arg3, n-1)
{
tuple < ... > t(arg0, ..., argn-1)
unique(t);
fx(*t.get<0)>, ... t.get<n-1>());
}

mais peut etre je divague
mais peut etre je divague

Message édité par Taz le 04-09-2003 à 17:17:19

Taz

bisounours-codeur

je crois que je me suis complètement égaré dans mes pensées là. surtout sur la fin ...

Taz

bisounours-codeur

Taz a écrit :

je crois que je me suis complètement égaré dans mes pensées là. surtout sur la fin ...

en fait j'en reviens au meme point qu'au début: soit des trucs anonymes, soit tu te cognes des spécialisation pour les cas favorables

edit: bon, j'ai fait nimp comme jamais, mais au moins j'ai réfléchi

Message édité par Taz le 04-09-2003 à 17:20:35

Joel F

Real men use unique_ptr

bon merci quand même ...
ca fait 1 mois qu eje suis le nez dedans et je m'en sort ps ...
je crois que je vais reprendre le probleme calmement plu stard ..

j'ai autrement de quoi m'occupé d'ici la

Taz

bisounours-codeur

de toutes façons, y aura du code à dupliquer en fonction de l'usage, le tout c'est de trouver la meilleur manière générique pour que l'appel soit élégant et que ça soit pas chiant à écrire

Taz

bisounours-codeur

attends, le problème il est bien là

t1 = vec_ld(0,a.begin);
t2 = vec_ld(0,b.begin);
t3 = vec_ld(0,a.begin);
t4 = vec_ld(0,b.begin);

masi transformer en

t1 = vec_ld(0,a.begin);
t2 = vec_ld(0,b.begin);
t3 = t1
t4 = t2

ça serait bon?

Joel F

Real men use unique_ptr

oui c les vec_ld qui coutent cher.

blackgoddess

vive le troll !

spécialiser un template ca veut bien dire lui ajouter des membres qui ne fonctionnent que pour un type particulier ?

par exemple au lieu d'écrire

Code :

template<class T>
montemplate<T>::membre(T var)
{
//
}

écrire

Code :

template<class T>
montemplate<T>::membre(int var)
{
//
}

Message édité par blackgoddess le 04-09-2003 à 18:05:29

---------------
-( BlackGoddess )-

Joel F

Real men use unique_ptr

Presque :

Code :

template<class T>
template::membre(T var)
{
//
}

écrire

Code :

template<>
template::membre<int>(int var)
{
//
}

est la bonne syntaxe

(et le rapport avec la choucroute :??: )

Message édité par Joel F le 04-09-2003 à 18:06:03

blackgoddess

vive le troll !

d'accord, merci

---------------
-( BlackGoddess )-

blackgoddess

vive le troll !

bin dsl, je m'ecarte du sujet, taz a parlé de spécialisation, je comprenais pas, je demande ici plutot que d'ouvrir un nouveau topic

---------------
-( BlackGoddess )-

Taz

bisounours-codeur

Code :

#include <iostream>
#include <boost/shared_ptr.hpp>
#include <boost/tuple/tuple.hpp>
struct Vector
{};
struct LoadedVectorHandle
{
Vector *v;
LoadedVectorHandle(Vector *vv = 0)
: v(vv)
{}
};
LoadedVectorHandle load(Vector &v)
{
return LoadedVectorHandle(&v);
};
class UniqueLoader
{
struct Shared
{
Vector &v;
LoadedVectorHandle lvh;
bool loaded;
Shared(Vector &vv)
: v(vv), loaded(false)
{}
};
boost::shared_ptr< Shared> rep;
public:
UniqueLoader(Vector &v)
: rep( new Shared(v) )
{}
UniqueLoader(const UniqueLoader &other)
: rep( other.rep )
{}
UniqueLoader& operator=(const UniqueLoader &other)
{
if(this != &other)
{
this->rep = other.rep;
}
return *this;
}
LoadedVectorHandle load()
{
if(!this->rep->loaded)
{
this->rep->lvh = ::load(this->rep->v);
this->rep->loaded=true;
std::cout << "loaded " << static_cast<void*>(&this->rep->v) << '\n';
}
return this->rep->lvh;
}
Vector* operator*()
{
return &this->rep->v;
}
};
void compute(LoadedVectorHandle a, LoadedVectorHandle b, LoadedVectorHandle c)
{
std::cout << "compute "
<< static_cast<void*>(a.v) << ' '
<< static_cast<void*>(b.v) << ' '
<< static_cast<void*>(c.v) << '\n';
}
void computeWrapper(Vector &a, Vector &b, Vector &c)
{
std::cout << "computeWrapper "
<< static_cast<void*>(&a) << ' '
<< static_cast<void*>(&b) << ' '
<< static_cast<void*>(&c) << '\n';
boost::tuple< UniqueLoader, UniqueLoader, UniqueLoader > args(a, b, c);
if( *args.get<0>() == *args.get<1>() )
{
args.get<0>() = args.get<1>();
}
if( *args.get<0>() == *args.get<2>() )
{
args.get<0>() = args.get<2>();
}
if( *args.get<1>() == *args.get<2>() )
{
args.get<1>() = args.get<2>();
}
compute( args.get<0>().load(), args.get<1>().load(), args.get<2>().load() );
std::cout << std::endl;
}
int main()
{
Vector a, b, c;
computeWrapper(a, b, c);
computeWrapper(a, a, b);
computeWrapper(a, a, a);
}

Message édité par Taz le 04-09-2003 à 18:32:53

Joel F

Real men use unique_ptr

hmm je vois la chose ...

qss expiclations qd même

Taz

bisounours-codeur

mis a jour . regarde l'affichage. l'idée est bete. tes différents paramtères peuvent en fait aliaser des variables communes. dans mon truc, un Vector est transformé en LVH une fois chargé avec load, le but étant de ne pas charger inutilement 2 fois le meme Vector. je refrabrique cette aliasing avec des UniqueLoader à base de shared_ptr qui partage un Vector, un lvh et un drapeau pour savoir si load a été appelé. ensuite j'ai mis tout ça dans mon tuple (je sais pas pourquoi, mais je pense qu'il doit y avoir un moyen de généraliser peut etre, et puis je peux appeler les constructeurs avec, mais bon, on pourrait faire avec des variables ou autres, j'y reviens), je farfouille mon tuple pour recréer les alias, c'est à dire, faire les affectations pour que les UL partagent les implémentations quand nécessaire.

ensuite, reste plus qu'a UL::load qui load s'il le faut et renvoie un LVH

l'affichage est concluant

pour les tuples, je pense que ya moyen de métaprogrammer tout ça, de manière d'exprimer l'opération d'alias sur un tuple de N éléments en fonctions de l'opération sur un tuple de N-1 éléments

Taz

bisounours-codeur

Code :

static inline void Unique2(boost::tuple<UniqueLoader, UniqueLoader> t)
{
if( *t.get<0>() == *t.get<1>() )
{
t.get<0>() = t.get<1>();
}
}
static inline void Unique3(boost::tuple<UniqueLoader, UniqueLoader, UniqueLoader> t)
{
Unique2( boost::make_tuple(t.get<0>(), t.get<1>()) );
Unique2( boost::make_tuple(t.get<0>(), t.get<2>()) );
Unique2( boost::make_tuple(t.get<1>(), t.get<2>()) );
}
static inline void Unique4(boost::tuple<UniqueLoader, UniqueLoader, UniqueLoader, UniqueLoader> t)
{
Unique3( boost::make_tuple(t.get<0>(), t.get<1>(), t.get<2>()) );
Unique3( boost::make_tuple(t.get<0>(), t.get<1>(), t.get<3>()) );
Unique3( boost::make_tuple(t.get<0>(), t.get<2>(), t.get<3>()) );
Unique3( boost::make_tuple(t.get<1>(), t.get<2>(), t.get<3>()) );
}

Code :

boost::tuple< UniqueLoader, UniqueLoader, UniqueLoader > args(a, b, c);
UniqueLoader::Unique3(args);

ça marche (pas testé le 4, mais l'idée est là)
les UniqueLoader supporte parfaitement l'affecation, donc y a pas de problèmes si tout ce passe par copie, puisque les implémentations sont partagées. j'ai pas fait à coup de référence et de boost::tie, par ce que c'est plus long à écrire. attention avec boost::tuple, y a des surprises, voir la doc

on doit pouvoir faire par template pour avoir des jolis numéros <3>, mais gaffe encore à la manipulation des tuple, il faudra donc faire

template<typename Tuple, unsigned N> etc

Message édité par Taz le 04-09-2003 à 19:07:28

Joel F

Real men use unique_ptr

[:taimp] nickel !!!

Evidemment moi, j'ai besoin de gerer tout les UniqueLoader pour 1 a N argument et remplacer les load par mes vec_ld !!!

Je teste tous ca et je te dit si ca marche

:jap: big merci

Joel F

Real men use unique_ptr

Bon :

CA MARCHE !

J'ai testé pour deux, trois et quatre arguments et le gain est de bien 35%. Je suis pas a 50% de plus bicose les tests et le fait que j'ai pas MPT les tuples mais c deja encourageant

MERCI !!!!

Publicité

Page : 1 2

Page Suivante

Page Précédente

Haut de page

FORUM HardWare.fr

Programmation

C++

Manipulation d'expression par templates : la vengeance

Sujets relatifs
[CSS] height d'un div reglé par expression	[C] Question sur les union et gestion de priorités dans une expression
expression reguliere	[JS] Regular expression
templates de formulaires pour PHP	Manipulation de string c++
[Meta-prog] Les templates-Expressions	Spécialisation des templates
PHP expression reguliere help	Expression Reguliere ... Où est le problème ?
Plus de sujets relatifs à : Manipulation d'expression par templates : la vengeance

Page générée en 0.168 secondes