Discussion :

[Eldrick]

Bonjour,

Je développe un logiciel sous Windows qui réalise de multiples captures d'écrans par seconde. J'ai besoin de lancer plusieurs instances de ce logiciel, cependant, cela diminue grandement les performances - de mon logiciel et de Windows lui-même.
Étant une opération single thread, je ne comprends pas pourquoi lancer 4 applications, par exemple, diminue les performances sur un processeur qui possède 4 cœurs/8 threads ?
Donc, je me suis dit que peut-être Windows faisait s'exécuter les applications dans le même cœur/thread. J'ai essayé de régler l'affinité des processus à des cœurs différents, mais cela n'affecte pas du tout les performances, ni en bien, ni en mal, ce que je ne comprends encore moins.

J'ai reproduis un code exemple de mon problème:

Code C++ :

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
#include <iostream>
#include <windows.h>
#include <atlimage.h>
#include <string>
#include <time.h>
 
using namespace std;
 
void ScreenShot(int left, int top, int sizex, int sizey, string output);
 
int main()
{
	int t, i;
 
	/////////////////////
	clock_t startTime = clock();
	clock_t testTime;
	clock_t timePassed;
	double secondsPassed;
	/////////////////////
 
	while (1 == 1)
	{
		startTime = clock();
 
		ScreenShot(0, 0, 200, 200, "");
 
 
		/////////////////////
		testTime = clock();
		timePassed = testTime - startTime;
		secondsPassed = timePassed / (double)CLOCKS_PER_SEC;
		/////////////////////
 
		cout << secondsPassed << endl;
	}
 
	system("pause");
	return 0;
}
 
void ScreenShot(int left, int top, int sizex, int sizey, string output)
{
	HDC hScreenDC = CreateDC("DISPLAY", NULL, NULL, NULL);
	HDC hMemoryDC = CreateCompatibleDC(hScreenDC);
	HBITMAP hBitmap_Global = CreateCompatibleBitmap(hScreenDC, sizex, sizey);
 
	/////////////////////////////////////////////////////
 
	SelectObject(hMemoryDC, hBitmap_Global);
	BitBlt(hMemoryDC, 0, 0, sizex, sizey, hScreenDC, left, top, SRCCOPY);
 
	////////////////////////////////////////////
	// img manipulation and saving here
	////////////////////////////////////////////
 
	///////////////////////////////////////////////
 
	DeleteObject(hBitmap_Global);
	DeleteDC(hMemoryDC);
	DeleteDC(hScreenDC);
 
	return;
}

si je lance 1 fois ce programme sur un i7-7700, une capture d'écran est faite toutes les 0.016 secondes par l'application
si je lance 8 fois ce programme sur un i7-7700, une capture d'écran est faite toutes les 0.133 secondes par l'application
si je lance 8 fois ce programme sur un ryzen 9 3950x, une capture d'écran est faite toutes les 0.133 secondes par l'application
Changer l'affinité ne change rien dans aucun des cas.

Quelqu'un peut-il m'éclairer sur ce qui ce passe réellement?
Merci

[kaitlyn]

Bonjour,

Je ne sais pas si std::clock() (<ctime>) est fiable pour mesurer la performance d'un code sur windows, car cette fonction mesure le temps horloge. Il faudrait voir peut-être du côté temps cpu (GetProcessTimes() (win32)), ou utiliser un compteur haute performance, haute résolution (std::chrono::high_resolution_clock (<chrono>) / QueryPerformanceCounter() (win32)).

Ensuite, dans ScreenShot(), il y a beaucoup d'appels système avec constructions et destructions d'objets. En déplaçant tout ça dans main() et passer les données via une structure en const ref, devrait occasionner moins de bouchons au niveau de l'OS.

[Eldrick]

Meme si std::clock n est pas fiable a 100%, le code fait ramer un ryzen 3950x.. ce qui n est pas normal.

Ensuite, dans ScreenShot(), il y a beaucoup d'appels système avec constructions et destructions d'objets. En déplaçant tout ça dans main() et passer les données via une structure en const ref, devrait occasionner moins de bouchons au niveau de l'OS.

Oui j avais essayer ca, j ai exactement les meme resultats

[kaitlyn]

Place un SwitchToThread() juste après ta fonction BitBlt() et vois ce que ça donne.
Autre possibilité, synchroniser tes processus, par exemple avec un mutex nommé
(CreateMutex(): WaitForSingleObject();BitBlt();ReleaseMutex()).