C++ / Cuda - Template

Bonjour à tous !

J’ai un problème auquel je n’arrive pas à trouver de solution et surtout que je ne parviens pas à comprendre (pour le coup difficile de trouver une solution).

Le principe est plutôt simple, je dispose d’une définition de template et qui contient un thread sur une de ses méthodes. J’ai séparé le tout avec la déclaration template dans un header et les définitions dans un fichier .cu. Il est possible de faire cela si et seulement si, on connait à l’avance les types qui seront utilisés dans le template (voir la fin du fichier .cu).

Voici les codes:
main.cu

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

#include <chrono>
#include <thread>
#include <cuda_runtime.h>
#include "foo.h"

int main(int argc, char **argv)
{
    foo<uchar4> f(make_uchar4(1, 2, 3, 4));
    f.start();
    std::this_thread::sleep_for(std::chrono::seconds(2));
    f.stop();
    return 0;
}

foo.h

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include <thread>

template<typename T>
class foo
{
public:

    foo(T value);

    void start();

    void run();

    void stop();

private:
    T _value;
    std::thread _thread;
    bool _run;
};

#endif //__FOO_H__

foo.cu

 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

#include "foo.h"

#include <iostream>
#include <cuda_runtime.h>

template<typename T>
foo<T>::foo(T value)
{
    _run = false;
    _value = value;
}

template<typename T>
void foo<T>::start()
{
    _run = true;
    _thread = std::thread(&foo<T>::run, this);
}

template<typename T>
void foo<T>::run()
{
    while (_run)
    {
        std::cout << "YOLO ! " << _value.x << std::endl;
    }
}

template<typename T>
void foo<T>::stop()
{
    _run = false;
    if (_thread.joinable()) _thread.join();
}

template class foo<uchar1>;
template class foo<uchar2>;
template class foo<uchar4>;
template class foo<char1>;
template class foo<char2>;
template class foo<char4>;
template class foo<short1>;
template class foo<short2>;
template class foo<short4>;
template class foo<ushort1>;
template class foo<ushort2>;
template class foo<ushort4>;
template class foo<float1>;
template class foo<float2>;
template class foo<float4>;

Il n’y a rien d’extravagant dans ce code ! Cependant impossible de le faire compiler avec Visual Studio 2015 et Cuda 8.0. Si on essaie ce code dans un projet VS 2015 seul (juste des .cpp) et en remplaçant le code cuda par des int / float / double, cela compile sans problème. Perplexe devant ce résultat, j’ai tout de même essayé sur une machine debian avec G++ 5.4 et Cuda 8.0 aucun souci non plus ! L’erreur obtenu est la suivante : error C2292: 'foo<float4>': best case inheritance representation: 'virtual_inheritance' declared but 'single_inheritance' required
pour les différents type définies en fin de foo.cu

Quelqu’un aurait une idée sur la question ? Je suppose qu’il y a une configuration particulière aux projets Cuda sur VS. Bref toute aide est la bienvenue !

Merci à vous !

Salut !

Pour commencer, quand on fait des templates, on met toutes les définitions dans le .h, autrement elles seront introuvables pour les autres unités de compilation  !

Cela étant dit, je n’ai pas de réponse au problème principal.

Hello !

Ma réponse sera probablement stupide mais parles-tu des template class foo<uchar4> etc. ? Je ne suis pas certain de comprendre ta réponse, j’ai fait quelques tests, en compilant séparément et en mettant d’un coté foo dans une bibliothèque et la liant au main.cu. Je n’ai pas eu de problème. Ou alors j’ai mal fait les étapes qui mènent aux potentiels problèmes.

Pour continuer sur le problème j’ai testé en renommant le fichier foo.h en foo.cuh en supposant que si le fichier n’avait pas l’extension voulu et donc que cela ne plaisait pas au parser Cuda si ce n’était pas dans son format de fichier, mais non, rien à changé