static std::pair<int, int> GetLogicalProcessorInfoHelper()
{
std::pair<int, int> empty= std::make_pair(0, 0);
GetLogicalProcessorInformationFn get_lpi=
reinterpret_cast<GetLogicalProcessorInformationFn>(
::GetProcAddress(GetModuleHandle(_T("kernel32")), "GetLogicalProcessorInformation"));
if (get_lpi == 0)
return empty;
DWORD length= 0;
if (get_lpi(0, &length) != 0 || GetLastError() != ERROR_INSUFFICIENT_BUFFER || length == 0)
return empty;
std::vector<BYTE> buffer(length);
SYSTEM_LOGICAL_PROCESSOR_INFORMATION* info= reinterpret_cast<SYSTEM_LOGICAL_PROCESSOR_INFORMATION*>(&buffer[0]);
if (get_lpi(info, &length) == 0)
return empty;
int cores= 0;
int logical_cores= 0;
const size_t count= length / sizeof(*info);
for (size_t i= 0; i < count; ++i)
if (info[i].Relationship == RelationProcessorCore)
{
++cores;
// A hyperthreaded core supplies more than one logical processor
logical_cores += CountSetBits(info[i].ProcessorMask);
}
return std::make_pair(cores, logical_cores);
}
void STDCALL OSInit()
{
timeBeginPeriod(1);
TIMECAPS chi;
timeGetDevCaps(&chi, sizeof(chi));
GetSystemInfo(&si);
osVersionInfo.dwOSVersionInfoSize = sizeof(osVersionInfo);
GetVersionEx(&osVersionInfo);
if (OSGetVersion() == 8)
bWindows8 = TRUE;
QueryPerformanceFrequency(&clockFreq);
QueryPerformanceCounter(&startTime);
startTick = GetTickCount();
prevElapsedTime = 0;
PSYSTEM_LOGICAL_PROCESSOR_INFORMATION pInfo = NULL, pTemp = NULL;
DWORD dwLen = 0;
if(!GetLogicalProcessorInformation(pInfo, &dwLen))
{
if(GetLastError() == ERROR_INSUFFICIENT_BUFFER)
{
pInfo = (PSYSTEM_LOGICAL_PROCESSOR_INFORMATION)malloc(dwLen);
if(GetLogicalProcessorInformation(pInfo, &dwLen))
{
pTemp = pInfo;
DWORD dwNum = dwLen/sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION);
coreCount = 0;
logicalCores = 0;
for(UINT i=0; i<dwNum; i++)
{
if(pTemp->Relationship == RelationProcessorCore)
{
coreCount++;
logicalCores += CountSetBits(pTemp->ProcessorMask);
}
pTemp++;
}
}
free(pInfo);
}
}
hProfilerMutex = OSCreateMutex();
}
int CheckBitFlipps(int a,int b){
int c=a^b;
/*
int count=0;
while(c){
c=c&(c-1);
count++;
}
return count;
*/
return CountSetBits(c);
}
bool CCPUDesc::ProcessGetCacheInfo()
{
LPFN_GLPI glpi;
bool done = false;
PSYSTEM_LOGICAL_PROCESSOR_INFORMATION buffer = NULL;
PSYSTEM_LOGICAL_PROCESSOR_INFORMATION ptr = NULL;
DWORD returnLength = 0;
DWORD byteOffset = 0;
PCACHE_DESCRIPTOR Cache;
glpi = (LPFN_GLPI) GetProcAddress(
GetModuleHandle(TEXT("kernel32")),
"GetLogicalProcessorInformation");
if (NULL == glpi)
{
//_tprintf(TEXT("\nGetLogicalProcessorInformation is not supported.\n"));
return FALSE;
}
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)
{
//_tprintf(TEXT("\nError: Allocation failure\n"));
return false;
}
}
else
{
// _tprintf(TEXT("\nError %d\n"), GetLastError());
return false;
}
}
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.
m_numaNodeCount++;
break;
case RelationProcessorCore:
m_processorCoreCount++;
// A hyperthreaded core supplies more than one logical processor.
m_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)
{
m_processorL1CacheCount++;
m_processorL1CacheSize += Cache->Size;
}
else if (Cache->Level == 2)
{
m_processorL2CacheCount++;
m_processorL2CacheSize += Cache->Size;
}
else if (Cache->Level == 3)
{
m_processorL3CacheCount++;
m_processorL3CacheSize += Cache->Size;
}
break;
case RelationProcessorPackage:
// Logical processors share a physical package.
m_processorPackageCount++;
break;
default:
//_tprintf(TEXT("\nError: Unsupported LOGICAL_PROCESSOR_RELATIONSHIP value.\n"));
break;
}
byteOffset += sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION);
ptr++;
}
free(buffer);
return true;
}
int TCOD_sys_get_num_cores() {
#ifdef TCOD_WINDOWS
// what a crap !!! works only on xp sp3 & vista
typedef enum _PROCESSOR_CACHE_TYPE {
CacheUnified,
CacheInstruction,
CacheData,
CacheTrace
} PROCESSOR_CACHE_TYPE;
typedef struct _CACHE_DESCRIPTOR {
BYTE Level;
BYTE Associativity;
WORD LineSize;
DWORD Size;
PROCESSOR_CACHE_TYPE Type;
} CACHE_DESCRIPTOR,
*PCACHE_DESCRIPTOR;
typedef enum _LOGICAL_PROCESSOR_RELATIONSHIP {
RelationProcessorCore,
RelationNumaNode,
RelationCache,
RelationProcessorPackage
} LOGICAL_PROCESSOR_RELATIONSHIP;
typedef struct _SYSTEM_LOGICAL_PROCESSOR_INFORMATION {
ULONG_PTR ProcessorMask;
LOGICAL_PROCESSOR_RELATIONSHIP Relationship;
union {
struct {
BYTE Flags;
} ProcessorCore;
struct {
DWORD NodeNumber;
} NumaNode;
CACHE_DESCRIPTOR Cache;
ULONGLONG Reserved[2];
} ;
} SYSTEM_LOGICAL_PROCESSOR_INFORMATION,
*PSYSTEM_LOGICAL_PROCESSOR_INFORMATION;
typedef BOOL (WINAPI *LPFN_GLPI)(
PSYSTEM_LOGICAL_PROCESSOR_INFORMATION,
PDWORD);
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 byteOffset = 0;
glpi = (LPFN_GLPI) GetProcAddress(
GetModuleHandle(TEXT("kernel32")),
"GetLogicalProcessorInformation");
if (! glpi) {
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) {
return 1;
}
} else {
return 1;
}
} else {
done = TRUE;
}
}
ptr = buffer;
while (byteOffset + sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION) <= returnLength) {
switch (ptr->Relationship) {
case RelationProcessorCore:
// A hyperthreaded core supplies more than one logical processor.
logicalProcessorCount += CountSetBits(ptr->ProcessorMask);
break;
default: break;
}
byteOffset += sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION);
ptr++;
}
free(buffer);
return logicalProcessorCount;
#else
return sysconf(_SC_NPROCESSORS_ONLN);
#endif
}