Discussion :

[Thauglor]

Bonjour a tous...

Voila je dois remplacer une librairie qui me fait ce calcul, mais j'ai un temps de calcul bien supérieur au leur. Je voulais savoir si quelqu'un a des idées d'optimisation qui pourrait diminuer cet écart de temps de calcul (2 à 3 fois supérieur que ce qu'il est possible de faire).

Pour le contexte, c'est l'extraction d'une coupe 2D dans un volume 3D.

J'ai calculé un vecteur de déplacement équivalent au déplacement entre deux pixels. 1 Sur l'axe des X l'autre sur l'axe des Y. a chaque itération (et donc a chaque pixel) j'effectue mon déplacement, regarde le voxels qui contient le point et en extrait la données.

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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
int CVolume::RasterizeSliceNearest(void* aiSlice,
							const double* adOrigVOL, 
							const double* adVectorDepVOL,
							const double* adResVOL, 
							const int iNbWidthVIEW, 
							const int iNbHeightVIEW,	
							const int iValMinVOL)
{
	double adCurPosVOL[3];
	double adOrigPosVOL[3];
	double adVectorPosVOLX[3];
	double adVectorPosVOLY[3];
	int aiVoxelVOL[3];
	short* aiVolumeTemp;
	unsigned char* acVolumeTemp;
	int iPos=0;
 
	for(int k = 0 ; k<3;k++)
	{
		adOrigPosVOL[k] = adOrigVOL[k]/adResVOL[k];
		adVectorPosVOLX[k] = adVectorDepVOL[k]/adResVOL[k];
		adVectorPosVOLY[k] = adVectorDepVOL[k+3]/adResVOL[k];
	}
 
	aiVolumeTemp = (short*)m_aiPixelsValue;
	for(int i=0; i<iNbHeightVIEW;i++)
	{
		adOrigPosVOL[0]+=adVectorPosVOLY[0];
		adOrigPosVOL[1]+=adVectorPosVOLY[1];
		adOrigPosVOL[2]+=adVectorPosVOLY[2];
		adCurPosVOL[0] = adOrigPosVOL[0];
		adCurPosVOL[1] = adOrigPosVOL[1];
		adCurPosVOL[2] = adOrigPosVOL[2];
		for(int j=0;j<iNbWidthVIEW;j++)
		{
			adCurPosVOL[0] += adVectorPosVOLX[0];
			adCurPosVOL[1] += adVectorPosVOLX[1];
			adCurPosVOL[2] += adVectorPosVOLX[2];
			aiVoxelVOL[0] = (int)adCurPosVOL[0];
			aiVoxelVOL[1] = (int)adCurPosVOL[1];
			aiVoxelVOL[2] = (int)adCurPosVOL[2];
			if(adCurPosVOL[0]>=0&&adCurPosVOL[1]>=0&&adCurPosVOL[2]>=0
					&&aiVoxelVOL[0]<GetVolDimWidth()&&aiVoxelVOL[1]<GetVolDimHeight()&&aiVoxelVOL[2]<GetVolDimDepth())
			{
				((short*)aiSlice)[iPos] = (short)aiVolumeTemp[aiVoxelVOL[0]+m_aiDecalInWidthPos[aiVoxelVOL[1]]+m_aiDecalInWidthHeightPos[aiVoxelVOL[2]]];//Aislice est de type void * (tableau à 1 dimension)
//m_aiDecalInWidthHeightPos contient les déplacement de mon tableau
 
			}
			else
			{
				((short*)aiSlice)[iPos] = (short)iValMinVOL;
			}
			iPos++;
		}
	}
return 0;
}

[white_tentacle]

Une idée comme ça, c'est de sortir de ta boucle toutes les opérations qui ne dépendent ni de i, ni de j (toutes celles qui ne dépendent pas de ipos en fait).

Ca devrait largement améliorer tes performances .

[Thauglor]

a savoir lesquelles? car je pense les avoir toute enlevées.

En fait je me sers de mes boucles également pour ajouter chaque composante de mon vecteur. je ne peux sortir ce calcul de mes boucles.

C'est plus un problème de syntaxe ( stockage et accès de données) je pense car niveau algorithmique itérative je pense avoir fait le tour

[camboui]

Les appels à GetVolDimWidth(), GetVolDimHeight() et GetVolDimDepth() peuvent être sortis de la boucle.

[Thauglor]

c'est des fonctions inline

Code :

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

inline int GetVolDimWidth(void){return m_aiVolDim[0];};

dans le doute j'ai remplacé les appels à ces fonctions par les

m_aiVolDim[0] correspondant... Toujours trop de temps de calcul

[camboui]

Calcul parallèle -> MMX, SSE, assembleur, etc...

[white_tentacle]

Effectivement, j'ai regardé un peu vite, pas évident de sortir des choses de la boucle.

Tu peux tenter ceci :

Code :

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

1
2
3
4
5
6
7
int CVolume::RasterizeSliceNearest(void* aiSlice,
							const double* __restricted__ adOrigVOL, 
							const double* __restricted__ adVectorDepVOL,
							const double* __restricted__ adResVOL, 
							const int iNbWidthVIEW, 
							const int iNbHeightVIEW,	
							const int iValMinVOL)

(plus tout à fait sûr de la position du __restricted__, ne marche qu'avec gcc, pour visual il y a un autre mot clé je crois). Ton optimiseur devrait pouvoir optimiser un peu plus. Ca n'explique toutefois pas un x3.

Sinon, mettre le m_aiVolDim[x] dans une variable de pile plutôt que dans le tableau peut aider (dépend du volume de données --> la variable se trouvera sur la pile ou dans un registre plutôt que dans ta ram, ça peut potentiellement réduire le nombre de page faults et augmenter les perfs).