Discussion :

[AuraHxC]

Bonjour tout le monde !!!

Je vous explique rapidement ce que je fais : J'ai donc pour l'instant un kernel qui s'occupe d'un rayon, qui le fait avancer, lorsqu'il coupe un voxel, il accumule la couleur pas à pas à travers le voxel, lorsqu'il arrive à la fin du voxel le kernel s'arrête et je lance ce kernel de manière parallèle autant que je peux en lancer (donc beaucoup de rayon en même temps).

Mais il existe d'autre voxel derrière le premier voxel parcouru par un kernel et donc d'autre couleur a accumuler.

Donc mon idée était de faire un lancer de kernel de manière "itérative", le premier kernel fait ce que je viens de décrire mais à la fin de son parcours il sauvegarde la position du rayon et la couleur accumulé jusque là puis un nouveau kernel est lancé en prenant la position du rayon et la couleur accumulé par le précédent kernel et refait la même chose etc...

Mais je ne sais pas trop comment faire pour lancer des kernels de manière "itérative" et permettre le partage d'information entre ceux ci.

Je mets un petit schéma pour mieux expliquer. Donc le but est de pouvoir lancer une multitude de kernel en parallèle (comme je le fais déjà) mais qui eux même lorsqu'il s'arrête lance un autre kernel en lui transmettant deux valeurs : position du rayon (pour reprendre où l'ancien kernel c'est arrêté) et la couleur jusque là accumulé.
Un bloc de kernel "itératif" s'arrêtera lorsqu'il n'y a plus de voxel à parcourir ou alors que l'opacité est égale ou supérieur à 1.

Voilà j'espère être assez clair si non vous n'hésitez pas a me poser des questions.

Merci d'avance

[AuraHxC]

Je vais reformuler mon problème car peut être n'est il pas assez clair.
En fait ce que j'aimerais faire c'est : J'ai un kernel de taille suivante :
Nombre de blocs : 32x32
Nombre de threads par blocs : 16x16

A chaque fin d'exécution d'un thread, j'aimerais sauvegarder deux valeurs qui pourront être lu par un autre kernel du même type qui sera lancé après l'arrêt total du kernel précédent.

En gros j'ai un seul kernel qui fait son affaire, chaque thread dans ce kernel fait son taf et sauvegarde les deux données.

Je relance le même kernel, je veux qu'il puisse charger les données enregistrés juste avant.

Mais pour faire ceci, je ne sais pas quel type de mémoire je dois utiliser et comment faire exactement.

Si je suis toujours pas clair, j'essaierais de faire encore mieux.

[Letinono]

Hello,

Merci pour ton second message, le premier n'était effectivement pas très clair

Pour faire ce que tu veux faire, il te suffit d'utiliser la mémoire globale.
Chaque thread va calculer les X valeurs et tu les stocks dans X tableaux à 1 dimension stocké en mémoire globale.

Quand tu relances ton kernel, chaque threads va reprendre la valeur qui lui est associé dans chaque tableau.

[AuraHxC]

Merci pour ta réponse mais j'avais trouvé mon bonheur et maintenant j'ai fini ce que je voulais faire
Mais merci quand même !!!