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