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.