Enormes fuites mémoires

**blueLight** · 03/03/2020, 17h00

Bonjour,
Il semblerait que les fuites mémoires que j'ai viennent du chargement des textures.
Pour gagner en temps de chargement, j'ai threadé leur chargements.
Je n'arrive pas à comprendre comment ce bout de code peut générer beaucoup de fuites mémoire, pourriez vous m'aider ?

Code :

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

1
2
3
4
5
6
7
8
9
template <typename C>
    static void SafeDeleteD3Dobject(C& pointer)
    {
        if (pointer > 0x0000000000000000)
        {
            pointer->Release();
            pointer = nullptr;
        }
    }

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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
DWORD WINAPI D3D11Rendering::texturesLoading(LPVOID lpParam)
{
 
	LoadingThreadsParameters* parameters = (LoadingThreadsParameters*)lpParam;
 
	for (unsigned short i = parameters->beginning; i <= parameters->end; i++)
	{
		string textureName(objectsData[i].textureName);
 
		//_ASSERT(i != 236);
 
		if (textureName.length() > 1)
		{
 
 
			string textureDirectory("./Assets/Textures/");
 
			textureName.replace(textureName.length() - 4, 4, ".jpg");
 
			string textureFilePath = textureDirectory + textureName;
 
			// Load the texture and initialize an ID3D11Texture2D object.
			HRESULT result = D3DX11CreateTextureFromFile(deviceDX11, textureFilePath.c_str(), NULL, NULL, (ID3D11Resource **)&textureData[i], NULL);
 
 
			D3D11_SHADER_RESOURCE_VIEW_DESC shaderResourceViewDesc;
 
			// Fill in the D3D11_SHADER_RESOURCE_VIEW_DESC structure.
			shaderResourceViewDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;// textureDesc.Format;
			shaderResourceViewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
			shaderResourceViewDesc.Texture2D.MostDetailedMip = 0;
			shaderResourceViewDesc.Texture2D.MipLevels = 1;
 
			textureSRV.resize(Loader3ds::nbObj+1);
			normalMapSRV.resize(Loader3ds::nbObj + 1);
 
			// Create the shader resource view.
			HRESULT hResult = deviceDX11->CreateShaderResourceView((ID3D11Resource*)textureData[i], &shaderResourceViewDesc, &textureSRV[i]);
 
			textureData[i]->Release();
			textureData[i] = NULL;
 
			if (strstr(objectsData[i].textureName, "SKY")!=0)
				backgroundIndex = i;
 
			//Loading of the normal maps
			if ( ( strstr(textureFilePath.c_str(), "backgroun") == 0 ) /*|| (strstr(textureFilePath.c_str(), "badTree") == 0 )*/)
			{
				string textureDirectory("./Assets/Textures/");
 
				textureName.replace(textureName.length() - 4, 4, "");
 
				string textureFilePath = textureDirectory + textureName;
 
				textureFilePath += string("_NormalMap.png");
 
				// Load the texture and initialize an ID3D11Texture2D object.
				HRESULT result = D3DX11CreateTextureFromFile(deviceDX11, textureFilePath.c_str(), NULL, NULL, (ID3D11Resource**)&normalMapTexture[i], NULL);
 
 
				D3D11_SHADER_RESOURCE_VIEW_DESC shaderResourceViewDesc;
 
				// Fill in the D3D11_SHADER_RESOURCE_VIEW_DESC structure.
				shaderResourceViewDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;// textureDesc.Format;
				shaderResourceViewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
				shaderResourceViewDesc.Texture2D.MostDetailedMip = 0;
				shaderResourceViewDesc.Texture2D.MipLevels = 1;
 
				//textureSRV.resize(Loader3ds::nbObj + 1);
				//normalMapSRV.resize(Loader3ds::nbObj + 1);
 
				// Create the shader resource view.
				HRESULT hResult = deviceDX11->CreateShaderResourceView((ID3D11Resource*)normalMapTexture[i], &shaderResourceViewDesc, &normalMapSRV[i]);
 
// 				normalMapTexture[i]->Release();
// 				normalMapTexture[i] = NULL;
				MemoryUtilities::SafeDeleteD3Dobject(normalMapTexture[i]);
			}
 
		}
	}
	_CrtDumpMemoryLeaks();
	/*MemoryUtilities::SafeDelete(lpParam);
	MemoryUtilities::SafeDelete(parameters);*/
	return 0;
}
 
void D3D11Rendering::parallelizeTextureLoading()
{
	LoadingThreadsParameters loadingThreadsParameters0;
	LoadingThreadsParameters loadingThreadsParameters1;
	LoadingThreadsParameters loadingThreadsParameters2;
	LoadingThreadsParameters loadingThreadsParameters3;
	LoadingThreadsParameters loadingThreadsParameters4;
	LoadingThreadsParameters loadingThreadsParameters5;
	LoadingThreadsParameters loadingThreadsParameters6;
	LoadingThreadsParameters loadingThreadsParameters7;
 
	SetThreadPriority(handleLoadingTexturesThread[0], THREAD_PRIORITY_TIME_CRITICAL);
 
	SetThreadPriority(handleLoadingTexturesThread[1], THREAD_PRIORITY_TIME_CRITICAL);
 
	SetThreadPriority(handleLoadingTexturesThread[2], THREAD_PRIORITY_TIME_CRITICAL);
 
	SetThreadPriority(handleLoadingTexturesThread[3], THREAD_PRIORITY_TIME_CRITICAL);
 
	SetThreadPriority(handleLoadingTexturesThread[4], THREAD_PRIORITY_TIME_CRITICAL);
 
	SetThreadPriority(handleLoadingTexturesThread[5], THREAD_PRIORITY_TIME_CRITICAL);
 
	SetThreadPriority(handleLoadingTexturesThread[6], THREAD_PRIORITY_TIME_CRITICAL);
 
	SetThreadPriority(handleLoadingTexturesThread[7], THREAD_PRIORITY_TIME_CRITICAL);
 
	loadingThreadsParameters0.beginning = 0;
	loadingThreadsParameters0.end = nbObj / 8;
 
	handleLoadingTexturesThread[0] = CreateThread(
		NULL,                   // default security attributes
		0,                      // use default stack size  
		&D3D11Rendering::texturesLoading,       // thread function name
		&loadingThreadsParameters0,          // argument to thread function 
		0,                      // use default creation flags 
		0);
 
	loadingThreadsParameters1.beginning = (nbObj / 8)+1;
	loadingThreadsParameters1.end = (nbObj/8)*2;
 
	handleLoadingTexturesThread[1] = CreateThread(
		NULL,                   // default security attributes
		0,                      // use default stack size  
		&D3D11Rendering::texturesLoading,       // thread function name
		&loadingThreadsParameters1,          // argument to thread function 
		0,                      // use default creation flags 
		0);
 
	loadingThreadsParameters2.beginning = ((nbObj / 8) * 2)+1;
	loadingThreadsParameters2.end = (nbObj / 8) * 3;
 
	handleLoadingTexturesThread[2] = CreateThread(
		NULL,                   // default security attributes
		0,                      // use default stack size  
		&D3D11Rendering::texturesLoading,       // thread function name
		&loadingThreadsParameters2,          // argument to thread function 
		0,                      // use default creation flags 
		0);
 
	loadingThreadsParameters3.beginning = ((nbObj / 8) * 3) +1 ;
	loadingThreadsParameters3.end = (nbObj / 8) * 4;
 
	handleLoadingTexturesThread[3] = CreateThread(
		NULL,                   // default security attributes
		0,                      // use default stack size  
		&D3D11Rendering::texturesLoading,       // thread function name
		&loadingThreadsParameters3,          // argument to thread function 
		0,                      // use default creation flags 
		0);
 
	loadingThreadsParameters4.beginning = ((nbObj / 8) * 4)+1;
	loadingThreadsParameters4.end = (nbObj / 8) * 5;
 
	handleLoadingTexturesThread[4] = CreateThread(
		NULL,                   // default security attributes
		0,                      // use default stack size  
		&D3D11Rendering::texturesLoading,       // thread function name
		&loadingThreadsParameters4,          // argument to thread function 
		0,                      // use default creation flags 
		0);
 
	loadingThreadsParameters5.beginning = ((nbObj / 8) * 5)+1;
	loadingThreadsParameters5.end = (nbObj / 8) * 6;
 
	handleLoadingTexturesThread[5] = CreateThread(
		NULL,                   // default security attributes
		0,                      // use default stack size  
		&D3D11Rendering::texturesLoading,       // thread function name
		&loadingThreadsParameters5,          // argument to thread function 
		0,                      // use default creation flags 
		0);
 
	loadingThreadsParameters6.beginning = ((nbObj / 8) * 6)+1;
	loadingThreadsParameters6.end = (nbObj / 8) * 7;
 
	handleLoadingTexturesThread[6] = CreateThread(
		NULL,                   // default security attributes
		0,                      // use default stack size  
		&D3D11Rendering::texturesLoading,       // thread function name
		&loadingThreadsParameters6,          // argument to thread function 
		0,                      // use default creation flags 
		0);
 
	loadingThreadsParameters7.beginning = ((nbObj / 8) * 7)+1;
	loadingThreadsParameters7.end = (nbObj);
 
	handleLoadingTexturesThread[7] = CreateThread(
		NULL,                   // default security attributes
		0,                      // use default stack size  
		&D3D11Rendering::texturesLoading,       // thread function name
		&loadingThreadsParameters7,          // argument to thread function 
		0,                      // use default creation flags 
		0);
 
	WaitForMultipleObjects(8, handleLoadingTexturesThread, TRUE, INFINITE);
 
	CloseHandle(handleLoadingTexturesThread[0]);
	CloseHandle(handleLoadingTexturesThread[1]);
	CloseHandle(handleLoadingTexturesThread[2]);
	CloseHandle(handleLoadingTexturesThread[3]);
	CloseHandle(handleLoadingTexturesThread[4]);
	CloseHandle(handleLoadingTexturesThread[5]);
	CloseHandle(handleLoadingTexturesThread[6]);
	CloseHandle(handleLoadingTexturesThread[7]);
}

**Kannagi** · 03/03/2020, 19h47

Si tu charge tes textures , mais que tu ne le libere pas en RAM , c'est normal

**blueLight** · 03/03/2020, 21h35

Je les libère avec SafeDeleteD3Dobject et l'appel à Release dans le code.

**LittleWhite** · 07/03/2020, 19h59

Bonjour,

En effet, ce n'est pas simple de trouver une fuite de mémoire par la simple lecture de code, d'autant plus lorsque vous semblez faire ce qu'il faut.
Du coup, je vais poser les questions (possiblement inutiles

) que j'ai eu en tête à la première lecture :

comment faites-vous pour savoir qu'il y a fuite de mémoire ?
avez-vous penser à l'utiliser d'un outil spécifique à la détection des fuites (je pense à valgrind, Dr Memory ou similaire). Peut être aussi Pix, peux vous aider

**blueLight** · 09/03/2020, 15h42

Je regarde la taille de l'exécutable dans le gestionnaire des tâches. Mon application est un jeu et lorsque je charge le niveau suivant la taille de l'exécutable passe de 300 Mo à 2 ou 3 Go puis avec le niveau suivant à 5 Go.
J'ai utilisé Intel Inspector mais il ne m'est pas d'un grand secours. Je pense que les plus grosses fuites viennent des textures mais Intel Inspector ne m'indique rien là dessus.

**blueLight** · 10/03/2020, 15h57

J'ai trouvé d'où vient la source du leak, elle vient de la variable "normalMapTexture" que j'ai besoin de libérer au fur et à mesure, j'utilise des ComPtr, j'ai essayé la méthode Release et Reset(), et rien ne marche.
Auriez vous une idée de comment je peux libérer cette variable ?

**LittleWhite** · 10/03/2020, 17h52

Bonjour,

Pourquoi des ComPtr ?
Sinon, je ne vois pas de Release, sur les ComPtr (doc).

**blueLight** · 10/03/2020, 20h22

Parce que ce sont des smart pointers, on m'a suggéré ça, je me suis dit que ça devait être une bonnes idée.

**LittleWhite** · 10/03/2020, 21h00

De mon côté, je pense qu'il est maintenant préférable d'utiliser ce qui a été introduit dans le standard C++ (à partir de C++11), c'est-à-dire : std::unique_ptr et std::shared_ptr.
En tout cas, même avec les ComPtr vous ne devriez pas avoir de tel problème. Vous devriez donc vérifiez si vous passez autant de fois dans la création de vos ressources, que dans la fonction de suppression de celles-ci (vérifiable avec un compteur statique, par exemple).
Aussi, vous devriez vérifier s'il n'y a pas une référence résiduelle à ces pointeurs, empêchant donc leur suppression.

**blueLight** · 10/03/2020, 21h42

Merci, je vais regarder ça.

**blueLight** · 12/03/2020, 11h12

J'ai regardé et le programme passe 1 fois dans le constructeur et 1 fois dans le destructeur, mais il ne semble pas libérer la mémoire du tout même en y passant.
Comment je peux libérer certaines variables si il y a une référence résiduelle ? ( j'en suspecte une )

**LittleWhite** · 12/03/2020, 11h25

Vous pouvez toujours lui prendre le pointeur contenu dans le ComPtr et le libérer vous même (et lui faire perdre la propriété du pointeur aussi). Mais bon, y a de grande chance que cela pète plus tard (car le ComPtr pourrait vouloir libérer la ressource, quand le compteur de référence tombe à 0).

**blueLight** · 12/03/2020, 14h47

Je viens de penser à un problème : la boucle de rendu est une boucle infinie qui a besoin de certaines de mes variables qui causent un memory leak.
Le hic c'est que je n'arrive pas à quitter cette boucle :

Code :

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

1
2
while (exitThread == false)
	{...}

Je mets ensuite exitThread à true mais son exécution continue.
Connaissez vous une méthode efficace pour arrêter un thread de ce genre ?
Pensez vous que c'est ce thread qui en ne s'arrêtant pas empêche la libération des ressources qu'il utilise ?

**LittleWhite** · 12/03/2020, 16h19

Possible que la variable exitThread ne soit pas partagée entre les threads (c'est-à-dire, une variable locale à chaque thread). Sinon, cela veut dire qu'il y a autre chose de bloquant dans la boucle.

**blueLight** · 12/03/2020, 17h52

ExitThread est une variable static. Pensez vous que le mot clé volatile serait la solution pour cette variable ?

**Bousk** · 12/03/2020, 19h04

C'est une variable static à quoi ? La classe ? La fonction ? L'unité de compilation ?

**blueLight** · 12/03/2020, 19h21

Elle est static à la classe.
J'ai essayé avec le mot clé volatile et exitThread change bien de valeur, mais le thread de la boucle d'affichage ne se termine jamais quand même.

Cette instruction ne se termine jamais et le programme est bloqué dessus :

Code :

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

WaitForSingleObject(handleRenderingThread, INFINITE);

**blueLight** · 12/03/2020, 19h34

Le thread est celui-ci :

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
DWORD WINAPI D3D11Rendering::renderingThread(LPVOID lpParam)
{
 
 
	while (D3D11Rendering::exitThread == false)
	{
 
 
		GBuffer();
 
		downsamplingPass();
 
		glowEffect.extractingColorPass();
 
		glowEffect.horizontalBlur();
 
		glowEffect.verticalBlur();
 
		LightingPass();
 
		glowEffect.blendGlowAndScene();
 
		updateRendering();
 
		HRESULT hresult = deferredContext->FinishCommandList(TRUE, commandList.GetAddressOf());
 
		deviceContext->ExecuteCommandList(commandList.Get(), FALSE);
		swapChain->Present(SYNC_60_FPS,0);
		commandList->Release();//to avoid memory leaks
 
		if (D3D11Rendering::exitThread == true)
		{
			return 2;
		}
		/*if (exitThread == true)
		{
			DWORD exitCode;
			if (0 != GetExitCodeThread(handleRenderingThread, &exitCode))
			{
				ExitThread(exitCode);
				MessageBox(D3D11Rendering::hwnd, NULL, "thread end", NULL);
			}
		}*/
 
 
	}
 
 
	return 2;
}