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;
}