CACHE_TYPE ProcessorInfo::GetCacheType(int level, CACHE_TYPE cacheType)
{
CACHE_TYPE cache_type = ctNone;
DWORD buffer_size = 0;
DWORD i = 0;
SYSTEM_LOGICAL_PROCESSOR_INFORMATION * buffer = 0;
GetLogicalProcessorInformation(0, &buffer_size);
buffer = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION *)malloc(buffer_size);
GetLogicalProcessorInformation(&buffer[0], &buffer_size);
for (i = 0; i != buffer_size / sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION); ++i)
{
if (buffer[i].Relationship == RelationCache && buffer[i].Cache.Level == level) {
if(buffer[i].Cache.Type == CacheUnified)
cache_type = ctUnified;
else if(buffer[i].Cache.Type == CacheData)
cache_type = ctData;
else if(buffer[i].Cache.Type == CacheInstruction)
cache_type = ctInstruction;
break;
}
}
free(buffer);
return cache_type;
}
SystemInfo::SystemInfo()
{
#ifdef _MSC_VER
SYSTEM_INFO info;
GetSystemInfo(&info);
m_nPageSize=info.dwPageSize;
m_nCpuCount=info.dwNumberOfProcessors;
size_t line_size = 0;
DWORD buffer_size = 0;
DWORD i = 0;
SYSTEM_LOGICAL_PROCESSOR_INFORMATION * buffer = 0;
GetLogicalProcessorInformation(0, &buffer_size);
buffer = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION *)malloc(buffer_size);
GetLogicalProcessorInformation(&buffer[0], &buffer_size);
for (i = 0; i != buffer_size / sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION); ++i)
{
if (buffer[i].Relationship == RelationCache && buffer[i].Cache.Level == 1)
{
line_size = buffer[i].Cache.LineSize;
break;
}
}
free(buffer);
m_nCacheLine=(int)line_size;
#endif
update();
}
static void os_get_cores_internal(void)
{
PSYSTEM_LOGICAL_PROCESSOR_INFORMATION info = NULL, temp = NULL;
DWORD len = 0;
if (core_count_initialized)
return;
core_count_initialized = true;
GetLogicalProcessorInformation(info, &len);
if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
return;
info = malloc(len);
if (GetLogicalProcessorInformation(info, &len)) {
DWORD num = len / sizeof(*info);
temp = info;
for (DWORD i = 0; i < num; i++) {
if (temp->Relationship == RelationProcessorCore) {
ULONG_PTR mask = temp->ProcessorMask;
physical_cores++;
logical_cores += num_logical_cores(mask);
}
temp++;
}
}
free(info);
}
size_t host_cache_line_size()
{
size_t line_size = 0;
#if defined(_WIN32)
DWORD buffer_size = 0;
DWORD i = 0;
SYSTEM_LOGICAL_PROCESSOR_INFORMATION * buffer = 0;
GetLogicalProcessorInformation(0, &buffer_size);
buffer = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION *)malloc(buffer_size);
GetLogicalProcessorInformation(&buffer[0], &buffer_size);
for (i = 0; i != buffer_size / sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION); ++i) {
if (buffer[i].Relationship == RelationCache && buffer[i].Cache.Level == 1) {
line_size = buffer[i].Cache.LineSize;
break;
}
}
free(buffer);
#elif defined(__linux__)
long sysconf_line_size = sysconf(_SC_LEVEL1_DCACHE_LINESIZE);
if(sysconf_line_size != -1)
line_size = sysconf_line_size;
#elif defined(__APPLE__)
size_t sizeof_line_size = sizeof(line_size);
sysctlbyname("hw.cachelinesize", &line_size, &sizeof_line_size, 0, 0);
#endif
if(line_size > 0)
return line_size;
else
return DEFAULT_CACHE_LINE_SIZE;
}
bool
AutoSystemInfo::InitPhysicalProcessorCount()
{
DWORD size = 0;
DWORD countPhysicalProcessor = 0;
PSYSTEM_LOGICAL_PROCESSOR_INFORMATION pBufferCurrent;
PSYSTEM_LOGICAL_PROCESSOR_INFORMATION pBufferStart;
BOOL bResult;
Assert(!this->initialized);
// Initialize physical processor to number of logical processors.
// If anything below fails, we still need an approximate value
this->dwNumberOfPhysicalProcessors = this->dwNumberOfProcessors;
bResult = GetLogicalProcessorInformation(NULL, &size);
if (bResult || GetLastError() != ERROR_INSUFFICIENT_BUFFER || !size)
{
return false;
}
DWORD count = (size) / sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION);
if (size != count * sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION))
{
Assert(false);
return false;
}
pBufferCurrent = pBufferStart = NoCheckHeapNewArray(SYSTEM_LOGICAL_PROCESSOR_INFORMATION, (size_t)count);
if (!pBufferCurrent)
{
return false;
}
bResult = GetLogicalProcessorInformation(pBufferCurrent, &size);
if (!bResult)
{
return false;
}
while (pBufferCurrent < (pBufferStart + count))
{
if (pBufferCurrent->Relationship == RelationProcessorCore)
{
countPhysicalProcessor++;
}
pBufferCurrent++;
}
NoCheckHeapDeleteArray(count, pBufferStart);
this->dwNumberOfPhysicalProcessors = countPhysicalProcessor;
return true;
}
tt_result_t tt_platform_cpu_num_load(OUT tt_u32_t *cpu_num)
{
PSYSTEM_LOGICAL_PROCESSOR_INFORMATION info = NULL;
DWORD info_len = 0;
PSYSTEM_LOGICAL_PROCESSOR_INFORMATION cur_info = NULL;
tt_u32_t cur_len = 0;
tt_result_t result = TT_FAIL;
tt_u32_t __cpu_num = 0;
// get info
if (!((GetLogicalProcessorInformation(info, &info_len) == FALSE) &&
(GetLastError() == ERROR_INSUFFICIENT_BUFFER))) {
return TT_FAIL;
}
info = (PSYSTEM_LOGICAL_PROCESSOR_INFORMATION)malloc(info_len);
if (info == NULL) {
return TT_FAIL;
}
if (!GetLogicalProcessorInformation(info, &info_len)) {
free(info);
return TT_FAIL;
}
// enumerate info
if (tt_g_numa_node_id != TT_NUMA_NODE_ID_UNSPECIFIED) {
cur_info = info;
while (cur_len < info_len) {
// count all logical cpus with specified numa node id
if ((cur_info->Relationship == RelationNumaNode) &&
(cur_info->NumaNode.NodeNumber == tt_g_numa_node_id)) {
__cpu_num += __mask_1num(cur_info->ProcessorMask);
}
++cur_info;
cur_len += sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION);
}
} else {
cur_info = info;
while (cur_len < info_len) {
// count all logical cpus of all cpu cores
if (cur_info->Relationship == RelationProcessorCore) {
__cpu_num += __mask_1num(cur_info->ProcessorMask);
}
++cur_info;
cur_len += sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION);
}
}
free(info);
if (__cpu_num > 0) {
*cpu_num = __cpu_num;
return TT_SUCCESS;
} else {
return TT_FAIL;
}
}
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();
}
bool GetProcessorCoreCount(u32& coreCount)
{
PSYSTEM_LOGICAL_PROCESSOR_INFORMATION buffer = NULL;
DWORD bufferByteCount = 0;
GetLogicalProcessorInformation(buffer, &bufferByteCount);
if(GetLastError() != ERROR_INSUFFICIENT_BUFFER)
{
return false;
}
buffer = (PSYSTEM_LOGICAL_PROCESSOR_INFORMATION)malloc((size_t)bufferByteCount);
if(buffer == NULL)
{
return false;
}
if(GetLogicalProcessorInformation(buffer, &bufferByteCount) == FALSE)
{
free(buffer);
return false;
}
u32 count = 0;
const size_t elementCount = (size_t)bufferByteCount / sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION);
for(size_t i = 0; i < elementCount; ++i)
{
if(buffer[i].Relationship == RelationProcessorCore)
{
++count;
}
}
free(buffer);
if(count == 0)
{
return false;
}
coreCount = count;
return true;
}
int cache_line_size() {
int line_size = 0;
DWORD buffer_size = 0;
DWORD i = 0;
SYSTEM_LOGICAL_PROCESSOR_INFORMATION * buffer = 0;
GetLogicalProcessorInformation(0, &buffer_size);
buffer = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION *)malloc(buffer_size);
GetLogicalProcessorInformation(&buffer[0], &buffer_size);
for (i = 0; i != buffer_size / sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION); ++i) {
if (buffer[i].Relationship == RelationCache && buffer[i].Cache.Level == 1) {
line_size = buffer[i].Cache.LineSize;
break;
}
}
free(buffer);
return line_size;
}
int __cpu_cache_line_size()
{
PSYSTEM_LOGICAL_PROCESSOR_INFORMATION info = NULL;
DWORD info_len = 0;
PSYSTEM_LOGICAL_PROCESSOR_INFORMATION cur_info = NULL;
tt_u32_t cur_len = 0;
int __cache_line_size = -1;
// get info
if (!((GetLogicalProcessorInformation(info, &info_len) == FALSE) &&
(GetLastError() == ERROR_INSUFFICIENT_BUFFER))) {
return -1;
}
info = (PSYSTEM_LOGICAL_PROCESSOR_INFORMATION)malloc(info_len);
if (info == NULL) {
return -1;
}
if (!GetLogicalProcessorInformation(info, &info_len)) {
free(info);
return -1;
}
// enumerate info
cur_info = info;
while (cur_len < info_len) {
if (cur_info->Relationship == RelationCache) {
CACHE_DESCRIPTOR *cache = &cur_info->Cache;
if ((cache->Level == 1) &&
((cache->Type == CacheData) || (cache->Type == CacheUnified))) {
__cache_line_size = cur_info->Cache.LineSize;
break;
// would there be cpus with different cache line size?
}
}
++cur_info;
cur_len += sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION);
}
free(info);
return __cache_line_size;
}
bool ProcessorInfo::HasCacheLevel(int level, CACHE_TYPE cacheType)
{
DWORD buffer_size = 0;
DWORD i = 0;
SYSTEM_LOGICAL_PROCESSOR_INFORMATION * buffer = 0;
GetLogicalProcessorInformation(0, &buffer_size);
buffer = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION *)malloc(buffer_size);
GetLogicalProcessorInformation(&buffer[0], &buffer_size);
for (i = 0; i != buffer_size / sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION); ++i)
{
if (buffer[i].Relationship == RelationCache && buffer[i].Cache.Level == level)
{
if(buffer[i].Cache.Size > 0)
return true;
}
}
free(buffer);
return false;
}
U32 ProcessorInfo::GetCacheSize(int level, CACHE_TYPE cacheType)
{
U32 szCache = 0;
DWORD buffer_size = 0;
DWORD i = 0;
SYSTEM_LOGICAL_PROCESSOR_INFORMATION * buffer = 0;
GetLogicalProcessorInformation(0, &buffer_size);
buffer = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION *)malloc(buffer_size);
GetLogicalProcessorInformation(&buffer[0], &buffer_size);
for (i = 0; i != buffer_size / sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION); ++i)
{
if (buffer[i].Relationship == RelationCache && buffer[i].Cache.Level == level) {
szCache = buffer[i].Cache.Size;
break;
}
}
free(buffer);
return szCache;
}
tt_result_t __check_numa_node_id(tt_u32_t node_id)
{
PSYSTEM_LOGICAL_PROCESSOR_INFORMATION info = NULL;
DWORD info_len = 0;
PSYSTEM_LOGICAL_PROCESSOR_INFORMATION cur_info = NULL;
tt_u32_t cur_len = 0;
tt_result_t result = TT_FAIL;
// get info
if (!((GetLogicalProcessorInformation(info, &info_len) == FALSE) &&
(GetLastError() == ERROR_INSUFFICIENT_BUFFER))) {
return TT_FAIL;
}
info = (PSYSTEM_LOGICAL_PROCESSOR_INFORMATION)malloc(info_len);
if (info == NULL) {
return TT_FAIL;
}
if (!GetLogicalProcessorInformation(info, &info_len)) {
free(info);
return TT_FAIL;
}
// enumerate info
cur_info = info;
while (cur_len < info_len) {
if (cur_info->Relationship == RelationNumaNode) {
if (cur_info->NumaNode.NodeNumber == node_id) {
result = TT_SUCCESS;
break;
}
}
++cur_info;
cur_len += sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION);
}
free(info);
return result;
}
//=============================================================================
uint ThreadLogicalProcessorCount ()
{
DWORD numStructs = 0;
GetLogicalProcessorInformation(null, &numStructs);
SYSTEM_LOGICAL_PROCESSOR_INFORMATION * infos = new SYSTEM_LOGICAL_PROCESSOR_INFORMATION[numStructs];
GetLogicalProcessorInformation(infos, &numStructs);
uint numLogicProcs = 0;
SYSTEM_LOGICAL_PROCESSOR_INFORMATION * ptr = infos;
SYSTEM_LOGICAL_PROCESSOR_INFORMATION * end = ptr + numStructs;
for ( ; ptr < end; ++ptr )
{
if ( ptr->Relationship != RelationProcessorCore)
continue;
numLogicProcs += Math::BitCount(uint64_t(ptr->ProcessorMask));
}
delete[] infos;
return numLogicProcs;
}
static orxINLINE orxU32 orxMemory_CacheLineSize()
{
SYSTEM_LOGICAL_PROCESSOR_INFORMATION *astProcessorInfoList;
orxU32 u32InfoListSize = 0, u32Result = orxMEMORY_KU32_DEFAULT_CACHE_LINE_SIZE, i, u32Number;
/* Requests total size of processors info */
GetLogicalProcessorInformation(0, (PDWORD)&u32InfoListSize);
/* Allocates info list */
astProcessorInfoList = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION *)orxMemory_Allocate(u32InfoListSize, orxMEMORY_TYPE_TEMP);
/* Gets processors info */
GetLogicalProcessorInformation(astProcessorInfoList, (PDWORD)&u32InfoListSize);
/* For all processor info */
for(i = 0, u32Number = u32InfoListSize / sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION);
i < u32Number;
i++)
{
/* Found first level cache info? */
if((astProcessorInfoList[i].Relationship == RelationCache)
&& (astProcessorInfoList[i].Cache.Level == 1))
{
/* Updates result */
u32Result = astProcessorInfoList[i].Cache.LineSize;
break;
}
}
/* Frees info list */
orxMemory_Free(astProcessorInfoList);
/* Done! */
return u32Result;
}
