Discussion :

[Matthieu76]

Bonjour, j'ai un petit soucis de pointer :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
void truc()
{
    int* hh = (int*)malloc(sizeof(int));
    *hh = 42;
    cout << "address : " << &hh << endl;
    initializeTest(hh);
}
 
void initializeTest(int* h)
{
    cout << "address : " << &h << endl;
}

Dans cette exemple, mes 2 adresses sont différentes. Comment cela ce fait-il ?
Ça fais maintenant plusieurs années que je code en C++ mais là j'ai l'impression de ne pas avoir compris un truc basique (je me sens nul)

[koala01]

Salut,

En fait, c'est pour une raison tout à fait idiote: il faut bien que l'adresse mémoire représentée par ton pointeur soit accessible au travers... d'une variable ( qui sera, typiquement, d'un type numérique, entier sans doute non signé, composé de suffisamment de bits que pour pouvoir représenter "n'importe quelle adresse accessible sur le système cible").

Or, en dehors du nom (qui n'est en définitive utile que pour l'humain) et de sa valeur, une variable est principalement identifiée par... son adresse mémoire.

Et, quand on transmet un pointeur, on évite la copie de l'élément sous-jacent (de ce qui se trouve à l'adresse mémoire indiquée par le pointeur), mais on fait bel et bien un copie de... la variable qui est qualifiée de "pointeur" (pour etre précis : de la variable qui représente l'adresse mémoire).

Du coup, il est tout à fait normal que, si tu prend l'adresse mémoire d'un pointeur représentant une même adresse mémoire dans deux fonctions différentes, tu obtiennes effectivement deux adresses différentes, vu qu'il s'agit bel et bien de deux variables différentes.
Mais, généralement, on s'en fout pas mal, car, comme je l'ai dit, il s'agit de variables d'un type primitif entier, et donc, dont la création est très rapide et ne demande que très peu de ressources. Ce qui nous intéresse surtout, c'est que les deux variables nous indiquent la même adresse mémoire à laquelle aller chercher l'objet du type qui nous intéresse

En rerprenant ton code, mais en supprimant la demande de l'adresse mémoire de ton pointeur, on se rend en effet compte que l'adresse vers laquelle pointent tes deux pointeurs est parfaitement identique, et c'est généralement ce qui compte ;p

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
void truc()
{
    int* hh = (int*)malloc(sizeof(int));
    *hh = 42;
    cout << "address : " << hh << endl;
    initializeTest(hh);
}
 
void initializeTest(int* h)
{
    cout << "address : " << h << endl;
}

Mais, ceci dit, c'est la raison pour laquelle C fait une utilisation intensive des pointeurs de pointeurs ( Type **), de manière à nous permettre de disposer de... l'adresse mémoire à laquelle nous trouverons une information dont nous savons qu'il s'agit... de l'adresse mémoire à laquelle nous trouverons l'élément du type qui nous intéresse; par exemple, lorsqu'il s'agit de "réallouer" de la mémoire à un objet existant

[Matthieu76]

Ok, merci pour tes expliquations mais du coup j'ai encore une question.
Peux-tu m'aider pour ce qui suit ? (je suis un peu perdu)

Voici mon vrai problème :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
void truc() {
    int* hh = (int*)malloc(sizeof(int));
    int* dd;
    int* result = (int*)malloc(sizeof(int));
    *result = 99;
    *hh = 42;
    cudaMalloc((void**)&dd, 1*sizeof(int));
    cudaMemcpy(dd, hh, sizeof(int), cudaMemcpyHostToDevice);
    cudaMemcpy(result, dd, sizeof(int), cudaMemcpyDeviceToHost);
    cout << *hh << endl;
    cout << *result << endl;
}

Dans ce cas hh a bien été recopié dans result.

Par contre ça ne fonctionne pas quand je met ce code dans une fonction :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
void truc() {
    int* hh = (int*)malloc(sizeof(int));
    int* dd;
    int* result = (int*)malloc(sizeof(int));
    *result = 99;
    *hh = 42;
 
    initializeTEST(hh, dd, result);
 
    cout << *hh << endl;
    cout << *result << endl;
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
void initializeTEST(int* h, int* d, int* res) {
    cudaMalloc((void**)&d, 1*sizeof(int));
    cudaMemcpy(d, h, sizeof(int), cudaMemcpyHostToDevice);
    cudaMemcpy(h, res, sizeof(int), cudaMemcpyDeviceToHost);
}

[Matthieu76]

HA HA !!

Je viens de remarqué que j'ai inversé res et h.
Bon bah c'est bon, ça devrait fonctionner correctement maintenant ^^

[Bktero]

Au passage, pourquoi faire des malloc() en C++ ?

[Bousk]

Pourquoi faire des malloc tout court, quand la variable est totalement interne à la fonction ?
Ou alors c'est un programme dont le but est juste de générer une fuite mémoire ?

[koala01]

HA HA !!

Je viens de remarqué que j'ai inversé res et h.
Bon bah c'est bon, ça devrait fonctionner correctement maintenant ^^

C'est la raison pour laquelle il est important de choisir des noms explicites pour les variables. La règle peut être adaptée en disant que, plus une variable "vit" longtemps, plus son nom doit être explicite : si tu n'a qu'un compteur qui ne sert que dans une boucle (ce que tout compteur devrait faire), tu peut te contenter de le nommer i ou cpt.

Mais autrement, tu aurais sans doute remarqué bien plus vite le problème si tu avais utilise les termes host et destination (par exemple, car c'est ce que tu veux indiquer me semble-t-il) au lieu des nom h et dd, qui ne disent absolument rien de l'intérêt des variables

[koala01]

Pourquoi faire des malloc tout court, quand la variable est totalement interne à la fonction ?
Ou alors c'est un programme dont le but est juste de générer une fuite mémoire ?

il est possible de faire preuve de "pensée positive" et de se dire que Matthieu76 a présenté un code minimal compilant exposant le problème, mais basé sur un code bien plus complexe, pour lequel l'allocation dynamique peut s'avérer utile.

D'autant plus qu'il est visiblement question de travailler avec Cuda, qui impose peut-être ses propres besoins

[Bousk]

Tout à fait d'accord avec toi koala, mais ayant affaire à un débutant, il n'est pas rare - voire plutôt commun - de voir des malloc/new partout sans raison (parce que la fonction attend un pointeur et que c'est le seul/plus rapide moyen qu'ils connaissent pour en avoir un, l'utilisation de & n'est pas facile à appréhender, preuve avec le problème initial) donc le doute subsiste, et pas dans le sens où tu l'entends.
Et quand bien même, un code minimal devrait inclure les free/delete et ça donne une meilleure impression de savoir ce que l'on écrit

[koala01]

Nous sommes bien d'accord! C'est bien pour cela que j'ai parlé de pensée positive

[Matthieu76]

Merci de vos réponses,
Ce bout de code est juste là pour tester car vu que ça ne fonctionnait pas sur ma grosse fonction, j'ai tester avec du code plus simple pour plus facilement trouvé le problème, d'où le nom des variables
Le but final étant de copier une structure dans la mémoire du GPU pour pouvoir accélérer mes calculs.

D'ailleurs dans ma fonction d'initialisation je doit impérativement retourner le pointeur d, si je ne le récupère pas comme ça, il ne sera pas modifier. J'aurais surement dû faire un passage par référence de mon pointeur mais là c'est un peu compliqué pour moi. D’habitude je ne n'utilise que très rarement des pointeurs, j'utilise des vecteurs et je passe tout par référence.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
int* initializeTEST(int* h, int* d)
{
    cudaMalloc((void**)&d, 1*sizeof(int));
    cudaMemcpy(d, h, sizeof(int), cudaMemcpyHostToDevice);
    return d;
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
void returnTEST(int* d, int* res)
{
    cudaMemcpy(res, d, sizeof(int), cudaMemcpyDeviceToHost);
}

[Bousk]

Utiliser des vector au lieu de pointeur est une bonne pratique. Si t'oublie de le retourner, ou déplacer il libèrera la mémoire.

[Matthieu76]

Merci pour l'astuce mais c'est déjà ce que je fais sur mon code CPU par contre sur mon code GPU je ne peux pas car je dois faire des vecteurs de vecteurs de tailles différentes et il est impossible de faire ça en cuda.
Du coup j'ai quelques pointeurs et j'utilise des fonctions pour aller chercher la valeur que je souhaite à partir de mon pointeur.

Ça me donne un truc du genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
inline
void setWeightInHiddenLayers(network* nn, const int &l, const int &n, const int &w, const float &v)
{
    nn->weightsInHiddenLayers[(l-1) * nn->numberOfNeuronInHiddenLayer * nn->numberOfNeuronInHiddenLayer +
                             n * nn->numberOfNeuronInHiddenLayer + w] = v;
}