Discussion :

[Invité]

Le message d'erreur n'est pas complet.
A quoi correspond "std::vector<unsigned int>" dans la ligne de code que tu donnes ?

A un vecteur d'unsigned int, en fait, ce sont toutes les positions des premiers sommet pour chaque face.

PS : je viens seulement de comprendre en fait il faut une constante, une carte graphique possède combien de mémoire cache en général ? (En gros, je peux stocker combien de vertex à la fois ?)

[mintho carmo]

A un vecteur d'unsigned int, en fait, ce sont toutes les positions des premiers sommet pour chaque face.

Merci... On recommence.
A quelle variable correspond ce type ? Dans la ligne de code que tu donnes, tu utilises baseVertices.size() (le size_type probablement du message d'erreur) et nbVerticesPerFaces (un unsigned int). Donc d'ou vient le "std::vector<unsigned int>" donné dans le message d'erreur ?
(dit autrement, le message d'erreur ne semble pas correspondre a la ligne de code que tu donnes)

PS : je viens seulement de comprendre en fait il faut une constante, une carte graphique possède combien de mémoire cache en général ? (En gros, je peux stocker combien de vertex à la fois ?)

Tu confonds (encore) mémoire cache et mémoire du GPU. La première : quelques ko, la seconde en général au moins 1 Go (sauf probablement sur embarqué).

[mintho carmo]

Et qu'est ce qui doit etre constant ???

[Invité]

Et qu'est ce qui doit etre constant ???

Ca ne compilait pas car le troisième paramètre de cette fonction devait être un litéral constant :

Code cpp :

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

1
2
3
4
 
err = clqueue.enqueueNDRangeKernel(clkvertexShader,
                                                    cl::NullRange, <s>cl::NDRange(baseVertices.size() * nbVerticesPerFaces</s> 1024),
                                                    cl::NDRange(1, 1), NULL, &event);

Mais que fait cette fonction exactement, je ne suis pas sûr de bien la comprendre, la seule chose que j'ai compris est qu'elle réserve un espace mémoire (workgroup) utilisé par tout les threads, et chaque thread utilise un espace mémoire appelé work-item, et ça fait ainsi comme une sorte de tableau, mais, comment parcourir ce tableau afin de récupérer les bons ids ?

Par exemple cl::NDRange me génère un thread id par appel au kernel que je récupère avec get_global_id, NDRange(0, 4) va me générer deux thread id qui vont de 0 à 4 alors ?

Au sinon voici le code que j'ai pour le moment, qui utilise un thread par vertex, mais, je ne sais pas si je le laisse ainsi ou si j'utilise un thread par face plutôt, ça, ça dépendra beaucoup des performances de ma machine.

Voici le code que j'ai en ce moment :

Code cpp :

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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
 
#pragma OPENCL EXTENSION cl_khr_byte_addressable_store : enable
//Multiply two 4*4 matrices.
float16 multMat (float16 matA, float16 matB) {
    float16 matC;        
    for (int x = 0; x < 4; ++x) {
	for (int y = 0; y < 4; ++y) {
            float value = 0;
	    for (int k = 0; k < 4; ++k) {
		float elementA = matA[y * 4 + k];
                float elementB = matB[k * 4 + x];
		value += elementA * elementB;
	    }
	    matC[y * 4 + x] = value;		
        }
    }
    return matC;
}
//Multiply a 4*4 matrix with a vec4.
float4 multVec (float16 matA, float4 vecB) {
   float4 vecC;
   for (int i = 0; i < 4; ++i) {
        float value = 0;
	for (int j = 0; j < 4; ++j) {
             value += vecB[j] * matA[i][j];
	}
	vecC[i] = value;
   }
   return vecC;
}
//Transpose a 4*4 matrix.
float16 transpose(float16 matA) {
	float16 matT
	for (int i = 0; i < 4; ++i) {        	
		for (int j = 0; j < 4; ++j) {
			matT[i][j] = matA[j][i];
		}
	}
	return matT;
}
//Convert vertex position from object space toviewport space.
__kernel void vertexShader(__global float* vPosX, __global float* vPosY, __global float* vPosZ, __global float* vPosW,
                           __global unsigned int* vColRed, __global unsigned int* vColBlue, __global unsigned int* vColGreen, 				   __global unsigned int* vColAlpha, __global int* vTCU, __global int* vTCV, 
			   __global unsigned int* indices,  __global unsigned int numIndices, __global unsigned int* baseIndices, 
			   __global unsigned int* baseVertices,  __global unsigned int* nbVerticesPerFaces, __global float* transfMatrices, 				   __global float16 projMatrix, __global float16 viewMatrix, __global float16 viewportMatrix, 
			   __global int nbVertices) {
        size_t tid = get_global_id(0);
	if (tid < nbVertices) {		
		int instanceID = tid / nbVerticesPerFace;
		float16 transfMatrix;
		float4 position = (float4) (vPosX[indices[tid]], vPosY[indices[tid]], vPosZ[indices[tid]], vPosW[indices[tid]]);
		for (int i = 0; i < 16; i++) {
		    transfMatrix[i] = transfMatrices[instanceID*16+i];
		}					
		float4 worldcoords = multVec(transfMatrix, position);
		float4 viewcoords = multVec(viewMatrix, worldcoords);
                float4 clipcoords = multVec(projMatrix, viewcoords);
		float4 ndcCoords = clipcoords / clipcoords.w;
		position = multVec(viewportMatrix, ndcCoords);
		vPosX[tid] = abs(position.x);
                vPosY[tid] = abs(position.y);
                vPosZ[tid] = abs(position.z);
                vPosW[tid] = position.w; 
	}
 
}

[mintho carmo]

Ca ne compilait pas car le troisième paramètre de cette fonction devait être un litéral constant

Le 3ème paramètre est juste un cl_uint passé par valeur. Tu n'es pas obligé de passer une littérale (heureusement).
(cours de C++ débutant)

Mais que fait cette fonction exactement, je ne suis pas sûr de bien la comprendre, la seule chose que j'ai compris est qu'elle réserve un espace mémoire (workgroup) utilisé par tout les threads, et chaque thread utilise un espace mémoire appelé work-item, et ça fait ainsi comme une sorte de tableau, mais, comment parcourir ce tableau afin de récupérer les bons ids ?

Par exemple cl::NDRange me génère un thread id par appel au kernel que je récupère avec get_global_id, NDRange(0, 4) va me générer deux thread id qui vont de 0 à 4 alors ?

Ouch.
Tu utilises quel cours ou livre pour étudier OpenCL ?
Tu mélanges complètement les concepts, n'utilises pas correctement les termes techniques.
Tu vas faire n'importe quoi si tu n'étudies pas sérieusement les choses.

Au sinon voici le code que j'ai pour le moment, qui utilise un thread par vertex, mais, je ne sais pas si je le laisse ainsi ou si j'utilise un thread par face plutôt, ça, ça dépendra beaucoup des performances de ma machine.

L'équivalent OpenGL dépend du stage dans le pipeline :
- un thread par géométrie dans les geometry shader et tesselation shader
- un thread par vertex dans le vertex shader
- un thread pas pixel dans le fragment/pixel shader
Donc tout dépend de ce que tu veux faire

[Iradrille]

- un thread pas pixel dans le fragment/pixel shader

Je croyais que c'était un thread par fragment, avec un fragment = 4 (valeur fixe ? dépendante du matériel ?) pixels ?

[LittleWhite]

Oui Iradrille, c'est un thread par fragment (d'ailleurs on devrait dire fragment shader) et le nombre de pixel géré par fragment dépend du matériel.
Mais bon, on peux résumer/extrapoler en disant un thread par pixel, car au final, nous voyons (dans le pixel shader/thread) que le pixel (et non le fragment) et c'est la carte graphique qui split le fragment, si jamais il y a deux pixels n'ayant pas les mêmes couleurs (genre, sur les bordures de mesh).

[Invité]

Ou se trouvent les messages d'erreur de compilation pour les fichiers .cl ?

PS : Il me faudrait un bouquin ou quelque chose du genre sur openCL car là, ça devient compliqué. :/