Discussion :

[uriotcea]

Bonjour,

J'ai un bi processeur, mais quand j'utilise le code suivant proposé par windows je ne trouve pas mon second processeur (voir image)



Alors que le code mode donne:

GetLogicalProcessorInformation results:
Number of NUMA nodes: 1
Number of physical processor sockets: 1
Number of processor cores: 20
Number of logical processors: 40
Number of processor L1/L2/L3 caches: 40/20/1

Merci d'avance de votre aide

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
 
typedef BOOL (WINAPI *LPFN_GLPI)(
    PSYSTEM_LOGICAL_PROCESSOR_INFORMATION,
    PDWORD);
 
 
// Helper function to count set bits in the processor mask.
DWORD CountSetBits(ULONG_PTR bitMask)
{
    DWORD LSHIFT = sizeof(ULONG_PTR)*8 - 1;
    DWORD bitSetCount = 0;
    ULONG_PTR bitTest = (ULONG_PTR)1 << LSHIFT;
    DWORD i;
 
    for (i = 0; i <= LSHIFT; ++i)
    {
        bitSetCount += ((bitMask & bitTest)?1:0);
        bitTest/=2;
    }
 
    return bitSetCount;
}
 
int _tmain ()
{
    LPFN_GLPI glpi;
    BOOL done = FALSE;
    PSYSTEM_LOGICAL_PROCESSOR_INFORMATION buffer = NULL;
    PSYSTEM_LOGICAL_PROCESSOR_INFORMATION ptr = NULL;
    DWORD returnLength = 0;
    DWORD logicalProcessorCount = 0;
    DWORD numaNodeCount = 0;
    DWORD processorCoreCount = 0;
    DWORD processorL1CacheCount = 0;
    DWORD processorL2CacheCount = 0;
    DWORD processorL3CacheCount = 0;
    DWORD processorPackageCount = 0;
    DWORD byteOffset = 0;
    PCACHE_DESCRIPTOR Cache;
 
    glpi = (LPFN_GLPI) GetProcAddress(
                            GetModuleHandle(TEXT("kernel32")),
                            "GetLogicalProcessorInformation");
    if (NULL == glpi)
    {
        printf("\nGetLogicalProcessorInformation is not supported.\n");
        return (1);
    }
 
    while (!done)
    {
        DWORD rc = glpi(buffer, &returnLength);
 
        if (FALSE == rc)
        {
            if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
            {
                if (buffer)
                    free(buffer);
 
                buffer = (PSYSTEM_LOGICAL_PROCESSOR_INFORMATION)malloc(
                        returnLength);
 
                if (NULL == buffer)
                {
                    printf("\nError: Allocation failure\n");
                    return (2);
                }
            }
            else
            {
                printf("\nError %d\n", GetLastError());
                return (3);
            }
        }
        else
        {
            done = TRUE;
        }
    }
 
    ptr = buffer;
 
    while (byteOffset + sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION) <= returnLength)
    {
        switch (ptr->Relationship)
        {
        case RelationNumaNode:
            // Non-NUMA systems report a single record of this type.
            numaNodeCount++;
            break;
 
        case RelationProcessorCore:
            processorCoreCount++;
 
            // A hyperthreaded core supplies more than one logical processor.
            logicalProcessorCount += CountSetBits(ptr->ProcessorMask);
            break;
 
        case RelationCache:
            // Cache data is in ptr->Cache, one CACHE_DESCRIPTOR structure for each cache.
            Cache = &ptr->Cache;
            if (Cache->Level == 1)
            {
                processorL1CacheCount++;
            }
            else if (Cache->Level == 2)
            {
                processorL2CacheCount++;
            }
            else if (Cache->Level == 3)
            {
                processorL3CacheCount++;
            }
            break;
 
        case RelationProcessorPackage:
            // Logical processors share a physical package.
            processorPackageCount++;
            break;
 
        default:
            printf("\nError: Unsupported LOGICAL_PROCESSOR_RELATIONSHIP value.\n");
            break;
        }
        byteOffset += sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION);
        ptr++;
    }
 
    printf("\nGetLogicalProcessorInformation results:\n");
    printf("Number of NUMA nodes: %d\n",
            numaNodeCount);
    printf("Number of physical processor sockets: %d\n",
            processorPackageCount);
    printf("Number of processor cores: %d\n",
            processorCoreCount);
    printf("Number of logical processors: %d\n",
            logicalProcessorCount);
    printf("Number of processor L1/L2/L3 caches: %d/%d/%d\n",
            processorL1CacheCount,
            processorL2CacheCount,
            processorL3CacheCount);
 
    free(buffer);
 
    return 0;
}

[Kannagi]

Quel rapport avec le C++ ?
(et même ton code , c'est du C et non du C++ ).

[Bousk]

J'ai travaillé sur un code identique il y a quelques jours mais sans multiprocessor. Je m'attendrais à ce que ce soit le truc Numa qui donne le nombre de processeurs ?
Sinon je ne sais pas quel API fournirait ça, et Google est assez avare en information...
Par contre oui l'exemple fourni est en C et franchement médiocre.
Tu peux appeler directement GetLogicalProcessorInformationEx, pas besoin de getprocaddress etc.
Pour le buffer, un std::vector<uint8_t> fait l'affaire et remplace très bien le malloc.

Peut-être qu'avec GetLogicalProcessorInformationEx et RelationAll tu auras de meilleurs résultats.
https://devblogs.microsoft.com/oldne...028-00/?p=2823

[uriotcea]

Bonjour,

Merci de votre suggestion, malheureusement visiblement mon compilateur GCC (4.7.1) est visiblement trop vieux parce qu'il ne reconnait par GetLogicalProcessorInformationEX.

Mon Qt (5.4.1) doit l'être aussi parce que la fonction QThread::idealThreadCount() répond 40 au lieu des 80 attendus

[dragonjoker59]

Pour compter le nombre de coeurs logiques, j'utilise ça :

Code :

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

1
2
3
4
5
6
7
 
uint32_t getCoreCount()
{
	SYSTEM_INFO sysinfo = { 0 };
	::GetSystemInfo( &sysinfo );
	return uint32_t( sysinfo.dwNumberOfProcessors );
}

[uriotcea]

Bonjour,

Oui essayé ca aussi sans plus de résultats probants

[Mat.M]

Merci de votre suggestion, malheureusement visiblement mon compilateur GCC (4.7.1) est visiblement trop vieux parce qu'il ne reconnait par GetLogicalProcessorInformationEX.

Je pense qu'il est vivement préférable d'utiliser la dernière version de Visual Studio.
Après si ces API windows sont compliquées à utiliser avec Qt faire une dll à part qui appelle ces API windows

[uriotcea]

Bonjour,
Je n'utilise pas du tout visual studio et je préfère poursuivre avec GNU gcc. Cela dit, les API Windows ne sont absolument pas compliquées à utiliser avec Q, ce n'est pas le souci. Je suis tout de même surpris qu'il n'existe pas de méthode même avec un gcc ancien de détecter le nombre de processeur. Les machine bi-pro existe depuis des décennies.