Discussion :

[Community Management]

Chers membres du club,

J'ai le plaisir de vous pr�senter ce tutoriel de Dan Levin pour vous apprendre � rendre vos codes plus rapides (performants) avec C++14 et C++17.

L'�criture de codes performants est toujours une t�che difficile. L'application directe des algorithmes th�oriques � purs � n'est pas toujours suffisante dans les architectures du monde r�el.

Lorsqu'on a commenc� � am�liorer la rapidit� de ces algorithmes purs, on se trouve rapidement confront� � un dilemme : certaines impl�mentations s'av�rent relativement rapides sur une architecture, mais effroyablement lentes sur d'autres. Dans le m�me temps, dans certains contextes, une nouvelle impl�mentation va d�passer les performances de la premi�re, mais perdre de la vitesse dans tous les autres.

De nombreuses optimisations, grandes et petites, pour chacune des architectures prises en charge peuvent rapidement faire gonfler notre code et nous faire perdre du temps. Souvent, nous sommes donc ramen�s � choisir entre deux options : un beau code trop lent, ou bien un code rapide mais illisible.

Bonne lecture .



Retrouvez les meilleurs cours et tutoriels pour apprendre la programmation C++

[grunk]

Alors je suis pas expert dans le domaine mais quand je lit �a :

Le code pr�c�dent est �quivalent � ce code, �crit en C++03 ou bien C++11 :

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
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
switch(log2n)
{
case 1:
    add_stage<internal::fft_specialization_t<T, 1, false>::template type>(size, type);
    break;
case 2:
    add_stage<internal::fft_specialization_t<T, 2, false>::template type>(size, type);
    break;
case 3:
    add_stage<internal::fft_specialization_t<T, 3, false>::template type>(size, type);
    break;
case 4:
    add_stage<internal::fft_specialization_t<T, 4, false>::template type>(size, type);
    break;
case 5:
    add_stage<internal::fft_specialization_t<T, 5, false>::template type>(size, type);
    break;
case 6:
    add_stage<internal::fft_specialization_t<T, 6, false>::template type>(size, type);
    break;
case 7:
    add_stage<internal::fft_specialization_t<T, 7, false>::template type>(size, type);
    break;
case 8:
    add_stage<internal::fft_specialization_t<T, 8, false>::template type>(size, type);
    break;
default:
    if(is_even(log2n))
    {
        make_fft(size, type, cbool<true>, ctrue);
        add_stage<internal::fft_reorder_stage_impl_t<T, true>::template type>(size, type);
    }
    else
    {
        make_fft(size, type, cbool<false>, ctrue);
        add_stage<internal::fft_reorder_stage_impl_t<T, false>::template type>(size, type);    
    }
}

Je me dis que j'aurais plut�t fait un truc comme �a :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
if(log2n >= 1 && log2n <= 8) {
    add_stage<internal::fft_specialization_t<T, log2n, false>::template type>(size, type);
} else {
    bool isEven = is_even(log2n);
    make_fft(size, type, cbool<isEven>, ctrue);
    add_stage<internal::fft_reorder_stage_impl_t<T, isEven>::template type>(size, type);
}

Donc soit j'ai pas compris une subtilit� , soit l'auteur original y met un peu de mauvaise fois histoire d'appuyer un peu plus son article

[Luc Hermitte]

log2n est une variable dynamique. Tu ne peux pas l'utiliser directement comme param�tre template sans passer par un dispatching � coups de switch ou autre.

[bacelar]

C'est l'une des diff�rences entre les Template C++ et les g�n�riques JAVA.
Les templates sont compil�s et optimis�s au moment de la compilation.
En JAVA, ce n'est qu'un mod�le de code qui est g�n�r� � la compilation lors de la g�n�ration d'un g�n�rique.

[ternel]

rectification, en java, ce n'est pas un mod�le, c'est une seule classe/fonction, utilisant Object, et l'utilisation est compil�e (en byte code) � grand renfort de cast.

[M�dinoc]

Par contre, en C#...

En revanche, il y a des limitations: Pas de SFINAE, pas de g�n�riques sur des valeurs (seulement des types), etc.