Pfthb

I'm struggling to find a reliable way to get the number of hardware threads on Windows. I am running a Windows 7 Professional SP1 64-bit on a machine with dual CPU Intel Xeon E5-2699 v3 @ 2.30GHz totalizing 36 cores and 72 threads.
I have tried different methods to get the number of cores, and I have found that only two of them seem to work accurately in a 32-bit or 64-bit process. Here are my results:

+------------------------------------------------+----------------+----------------+
| Methods | 32-bit process | 64-bit process |
+------------------------------------------------+----------------+----------------+
| GetSystemInfo->dwNumberOfProcessors | 32 | 36 |
| GetNativeSystemInfo->dwNumberOfProcessors | 36 | 36 |
| GetLogicalProcessorInformation | 36 | 36 |
| GetProcessAffinityMask.processAffinityMask | 32 | 32 |
| GetProcessAffinityMask.systemAffinityMask | 32 | 32 |
| omp_get_num_procs | 32 | 36 |
| getenv("NUMBER_OF_PROCESSORS") | 36 | 36 |
| GetActiveProcessorCount(ALL_PROCESSOR_GROUPS) | 64 | 72 |
| GetMaximumProcessorCount(ALL_PROCESSOR_GROUPS) | 64 | 72 |
| boost::thread::hardware_concurrency() | 32 | 36 |
| Performance counter API | 36 | 36 |
| WMI | 72 | 72 |
| HARDWAREDESCRIPTIONSystemCentralProcessor | 72 | 72 |
+------------------------------------------------+----------------+----------------+

I do not explain why all these functions return different values. The only 2 methods which seem reliable to me is either using WMI (but fairly complicated) or simply to read in the Windows registry the following key: HARDWAREDESCRIPTIONSystemCentralProcessor.

What do you think?
Do you confirm that the WMI and registry key methods are the only reliable methods?

Thanks in advance

The API function that you need is GetLogicalProcessorInformationEx. Since you have more than 64 processors, your processors are grouped. GetLogicalProcessorInformation only reports the processors in the processor group that the thread is currently assigned. You need to use GetLogicalProcessorInformationEx to get past that limitation.

The documentation says:

On systems with more than 64 logical processors, the GetLogicalProcessorInformation function retrieves logical processor information about processors in the processor group to which the calling thread is currently assigned. Use the GetLogicalProcessorInformationEx function to retrieve information about processors in all processor groups on the system.

You can use the CPUID instruction to query the processor directly (platform independent, though since you can't do inline asm in MSVC anymore for some compilers you'll need to use different functions to have access to it). The only downside is that as of a few years ago Intel and AMD handle this instruction differently, and you'll need to do a lot of work to ensure you are reading the information correctly. In fact, not only will you be able to get a core count, but you can get all kinds of processor topology information. Not sure how it works in a VM though if you are using that environment.

Late answer with code:

size_t myHardwareConcurrency()
 size_t concurrency=0;
 DWORD length=0;
 if(GetLogicalProcessorInformationEx(RelationAll,nullptr,&length)!=FALSE)
 return concurrency;
 if(GetLastError()!=ERROR_INSUFFICIENT_BUFFER)
 return concurrency;
 std::unique_ptr<void,void(*)(void*)>buffer(std::malloc(length),std::free);
 if(!buffer)
 return concurrency;
 unsigned char*mem=reinterpret_cast<unsigned char*>(buffer.get());
 if(GetLogicalProcessorInformationEx(RelationAll,reinterpret_cast<PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX>(mem),&length)==false)
 return concurrency;
 for(DWORD i=0;i<length;)
 auto*proc=reinterpret_cast<PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX>(mem+i);
 if(proc->Relationship==RelationProcessorCore)
 for(WORD group=0;group<proc->Processor.GroupCount;++group)
 for(KAFFINITY mask=proc->Processor.GroupMask[group].Mask;mask!=0;mask>>=1)
 concurrency+=mask&1;
 i+=proc->Size;
 return concurrency;

It worked on my dual Xeon gold 6154 with Windows 64 bit system (2 procs * 18 cores/proc * 2 threads/core = 72 threads). The result is 72 both for 32 bit processes and for 64 bit processes.

I do not have access to a system with a 32 bit Windows though.

In case of error, it returns zero like std::thread::hardware_concurrency does.